Author projects and Registry content in Code

Code connects the model you are editing to local Library, Template, Solution, and pretrained Model projects, installed packages, and Registry content. Three work areas make those connections explicit:

• Projects opens local source, interface previews and development checks.
• Dependencies connects model imports to their required packages and runtime.
• Registry discovers reusable work and prepares your own publications.

Each area has its own working tab and navigation history. Moving between them retains project drafts, selections and publication context within the model session. Model imports remain readable in the browser; local project operations and publishing use the desktop's native CLI integration. Browser Projects and Registry explain that requirement and link back to Dependencies.

Local source projects

In Code → Projects, choose Open source project and select the artifact's root folder. Code recognizes exactly one of grid-extension.json (Library), grid-template.json (Template), grid-domain-pack.json (Solution), or grid-model.json (pretrained Model). The matching manifest opens first. Edit its text files, Grid modules (.gs), interfaces, contracts, and fixtures. Malformed JSON remains editable for repair; ambiguous roots are rejected. Binary assets and model weights are not text editors.

For proposed TEAM and PROCESS source, Code highlights the core coordination words and uses compiler-selected completion choices. An ASK target suggests participants; a value expression suggests its visible data; RUN and plan construction suggest process and team names. Loop carries stay inside their iteration, and independent requests cannot see one another's results. This support requires retained, completely parsed declarations; malformed process syntax can withhold suggestions. Process rename and product Start remain unavailable. A completion suggestion is not execution approval. Save file checks the last-read file digest: an external edit produces a conflict while retaining your draft. Reload from disk explicitly discards that draft; Refresh files refreshes the inventory without replacing drafts.

Open another project retains the current project in a tab. Up to twelve projects retain their drafts, selected files, file filters and editor history. Use the arrow keys, Home or End in the tab strip. Reopening a folder selects its existing tab. Save or reload drafts and finish active work before closing a tab. Drafts are retained within the model session, not after model exit or app restart.

Undo/Redo applies to the current source file. On macOS, the native Edit menu, Command+Z and Command+Shift+Z follow the focused Code editor's history after switching files or projects. Other text controls retain native editing behavior. In the model editor, macOS Control+Shift+M toggles Tab navigation out of Monaco; Command+Shift+M opens Problems. Tab can then reach tools and the split divider, whose arrow keys resize the groups.

New project tab offers Library, Solution, and Template creation. Libraries use the CLI's ten language profiles; compiled profiles require their language toolchains and may download dependencies. Solutions take a lowercase ID, label, and version and start with a Grid module, a model template, and executable smoke tests. Templates take a canonical lowercase publisher/name, label and version, and start with main.grid, a README and catalog metadata in grid-template.json. Template creation is local native authoring using Core’s manifest contract; it does not require a CLI scaffolding command or a signing key. Choose a new destination folder for any kind. Creation reports output and supports Stop and recovery within the current app session. Failed or stopped creation may leave files; a new attempt does not overwrite an existing folder. Creation output remains with the opened project.

For Libraries, save drafts before Validate project or Inspect project runtime fit. These inspect disk contents through the existing CLI. A successful inspection does not run exports, install the package or prove that later disk edits are safe.

If a Library project has grid-extension.dev.json, Prepare development run shows its declared configuration. Build & test runs once; Start watch repeats the declared development cycle as saved files change. These commands can execute local tools and update artifacts, manifests and bindings. Output and Stop belong to the originating project; return to its tab to observe the latest job status. Stopping does not roll back files already written.

Preview a project interface with model values

Open a .jsx or .tsx file and choose Preview surface to connect its draft to an editable surface in the current model. The preview uses that surface's saved configuration and live bindings. Typing updates the preview without saving the file or changing the model. Grid JSX types and model-binding completions use the same authoring support as Surface studio. Inspect element reveals a rendered element in the file; preview diagnostics navigate to their source. Incomplete JSX retains the last successful render until repaired.

Pause preview releases the renderer and its subscriptions while retaining file edits. The selected surface and preview state belong to that file and model session. Switching to another model does not inherit the link.

Save file updates the local project only. Review in Surface studio stages an independent model source draft, using the model version shown by the preview as its baseline. Existing surface drafts, pending writes, or model source edits must be resolved first. Review the staged draft and use the studio's existing Apply action to update the model. Subsequent edits to either copy remain independent; this is an explicit handoff, not two-way file synchronization.

Preview permits local interface controls but withholds model writes, jobs, connectors, app navigation and publication actions. It honors the deployment's custom UI trust policy. JSX runs through the existing trusted in-process renderer; this preview does not add a security sandbox or a multi-file JSX package bundler.

Develop a Solution

A created Solution opens its grid-domain-pack.json and related source files. Creation validates the generated files; it does not execute the Solution's tests. After editing and saving source, use Synchronize hashes to update the declared artifact hashes in the manifest and related metadata. This changes local files and does not run tests. Reload changed metadata from disk before editing it; saving a stale copy is refused by the normal conflict check.

Run Solution tests compiles the declared modules and model templates and executes conformance assertions and qualification cases through the existing CLI and Grid runtime. Stale artifact hashes produce a failure until explicitly synchronized. The completed result reports compiled modules/templates, conformance models, executed assertions, and passed/total qualification cases. Failures keep their output available and do not display a successful result. Results describe that run; later source edits require another run.

Save all drafts before either action. Work continues while you navigate Code; return to its project to see output or choose Stop Solution operation. Stopping preserves files already written and does not claim completed tests. These actions neither publish the Solution nor activate it in the current model. Active work and unsaved drafts prevent new publication preparation for that root.

Template file checks

Save your drafts, then choose Check Template files to compare the manifest’s declared hashes and sizes with the files on disk. The report identifies changed files without modifying them. Synchronize hashes updates those declared hashes and sizes in grid-template.json; its open editor receives the saved manifest. It does not add or remove files from publication. To include a new file, add its entry to the manifest explicitly.

Checks cover binary assets as well as editable text. Missing files, empty files, symlinks, invalid paths and byte-budget violations stop the operation. Checks read at most 64 MiB per file and 256 MiB across the declared file list. A manifest changed since admission is retained rather than overwritten. Synchronization rechecks observed files before saving, but later external edits still require a new check. Drafts appearing during the operation stay intact and require review.

The report describes saved files, not model behavior. Checking or synchronizing does not compile, execute, sign, install or publish the Template. Publication preparation independently validates the declared graph through the existing CLI.

Move between source and publication

Use Review publication on an opened project to select that exact folder in Registry preparation. Save its drafts and finish active development first. This handoff reads the manifest; it does not sign, execute tests, or publish. An invalid manifest remains in the editor for repair. Runtime inspection and extension development controls are available for Libraries only.

From a selected publication artifact, Edit source project opens its local source without another folder picker. An already-open project retains its selected file, drafts, and editor history. You can edit source in one project while keeping other projects open. Returning to Registry cannot prepare over unsaved drafts or active work in the selected source project. Previously signed preparations retain their original frozen bytes.

An installed Template may omit its authoring manifest; opening it as an author project requires that manifest. The separate installed-source inspection and model working-copy workflow remains available.

Connect a project to a model

After inspection, add the project's exact versioned import through Use in this model. Code preserves model text, chooses a readable alias that avoids existing names, and recognizes an existing exact import. Model imports can navigate back to open projects whose inspected identity matches the reference. An association is a navigation aid, not proof that a package is installed or active.

Prepare a preserved development workspace for activation through Package Center. You may compose it with a reviewed existing package workspace, choosing whether to keep or replace conflicting versions. The result is a separate snapshot; source edits do not refresh active runtime bytes automatically. Desktop permits one active package workspace, and activation remains explicit.

Dependencies inspects a selected installed workspace. Copied import statements use readable, collision-safe aliases or preserve an exact authored import's alias. Inspection and copying do not execute package exports.

Check model dependencies inspects the current draft with the model's dependency resolver. Review package activation carries the exact reported import into Package Center, filters the installed catalog and distinguishes an exact match from a different version. Return to Code dependencies returns to the same model context. Package or runtime reviews make the previous resolver report stale; check again explicitly after installation or activation. Catalog presence, activation and successful model resolution are separate observations.

Registry creator workflows

The Registry area supports Libraries, Templates, Solutions and pretrained Models. Choose source and an existing signing key to prepare a publication. Preparation validates and signs preserved local content through the existing CLI; it does not publish. Review the artifact, destination and publisher credential before explicit submission. A Registry may publish immediately after accepting a submission. Stop cannot retract a remote effect that has already occurred.

Prepared content and confirmed remote observations can be reopened after restart. Check status explicitly when a reply was lost; Code does not automatically retry submission or poll in the background. Active native jobs and in-memory credential grants are not restored as if they were still running.

Publisher enrollment likewise prepares and preserves an exact signed proof using an existing key. Submit explicitly, check status, then select an approved credential for publication. Credentials stay in private desktop profile storage; selecting one does not publish an artifact. Key generation, credential backup/export and broader storage management are not part of this workflow.

Catalog search is explicit. Inspect an exact coordinate and its metadata before opening the corresponding installation review. Library/model installation uses the existing package workflow. Templates and Solutions install source into a new native-picker-selected folder through the pinned CLI installer; existing folders are not replaced. Follow output, Stop or recover the latest installation observation after restart. An interrupted observation is not an automatic retry.

After a completed Template/Solution installation, inspect a bounded file inventory and explicit source snapshots. Solutions also expose their current declared models, modules, dependencies and capabilities. Declarations are requirements, not evidence that dependencies are installed or active. Source inspection includes Grid .gs modules and does not evaluate or activate them.

Select a .grid file and choose Prepare model working copy. Review the connected destination, folder and exact files before Create working copy. Preparation freezes current disk bytes; it rejects a selected model changed since preview. Paths stay relative to the installed project root. The copy includes local modules and binary assets, and leaves the installed folder unchanged. Hidden and generated entries are excluded and listed in review. Linked, nonportable, oversized or incomplete projects fail instead of being partly copied. Limits are 512 files, 4,096 directory entries, depth eight and 16 MiB in total. The selected model must also fit the source preview's 1 MiB text limit.

Creation uses the canonical model archive importer and the existing Grid compiler and evaluator. Versioned domain: and pkg: imports are preserved, not rewritten or implicitly activated. Those dependencies must already be available in the destination; otherwise the compiler reports the missing dependency. Use Dependencies in the working model to inspect imports and review the existing package installation and activation workflows. Source folders with one recognized authoring manifest can also open in Projects. Installed Templates that omit that manifest use this separate inspection/working-copy flow; it does not make their installation folder an editable source project.

After creation, Open working copy opens its Code model. Save or resolve current model, surface and extension drafts first. Creating a copy does not navigate away from the current model. An interrupted or failed response retains the exact model ID and offers Check and open working copy, which reads rather than resubmits. Review another copy only after checking the previous outcome. Preparation and attempt observations remain in this model session; they do not survive app restart. Created models remain available in the destination's model browser.