@impetik/xeer-mcp 0.2.21 → 0.2.22

package/README.md

@@ -63,7 +63,7 @@ The generated registry is the complete MCP tool and exclusion surface:
 | `xeer_check` | `check` | `author` / `operator` | Validate a project and report structured diagnostics. | `directory?`: `string` | `read-source`<br>`write-generated` | writes; idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | none |
 | `xeer_build` | `build` | `author` / `operator` | Build and verify a content-addressed application artifact. | `directory?`: `string` | `read-source`<br>`write-generated`<br>`run-local` | writes; idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | none |
 | `xeer_test` | `test` | `author` / `operator` | Run application tests against fresh isolated local state. | `directory?`: `string`<br>`timeoutMilliseconds?`: `integer` [1000..1800000] | `read-source`<br>`write-generated`<br>`run-local`<br>`write-state` | writes; idempotent; reversible; non-destructive | `project-relative` | `xeer.dev.v0` | none |
-| `xeer_new` | `new` | `author` / `operator` | Create a new project from a supported scaffold. | `directory`: `string`<br>`template?`: `notes` / `todo` / `blog` / `personal-site`<br>`ui?`: `preact` / `react` | `write-source` | writes; non-idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | none |
+| `xeer_new` | `new` | `author` / `operator` | Create a new project from a supported scaffold. | `directory`: `string`<br>`template?`: `string`<br>`framework?`: `sveltekit`<br>`ui?`: `preact` / `react` | `write-source`<br>`network-read` | writes; non-idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | none |
 | `xeer_agent_context` | `agent.context` | `author` / `operator` | Read normalized project facts, operations, diagnostics, tests, and safe next actions. | `directory?`: `string` | `read-source` | read-only; idempotent; reversible; non-destructive | `project-relative` | `xeer.agent-context.v0` | none |
 | `xeer_docs_search` | `docs.search` | `author` / `operator` | Search the installed-version Xeer documentation index. | `query`: `string`<br>`limit?`: `integer` [1..20]; default `5` | none | read-only; idempotent; reversible; non-destructive | `none` | `xeer.docs-search.v0` | none |
 | `xeer_doctor` | `doctor` | `author` / `operator` | Diagnose the toolchain and generated project state. | `directory?`: `string` | `read-source`<br>`write-generated` | writes; idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | none |
@@ -76,10 +76,11 @@ The generated registry is the complete MCP tool and exclusion surface:
 | `xeer_dev_stop` | `dev.stop` | `author` / `operator` | Stop a local development session and release its lease. | `sessionId?`: `string`<br>`cursor?`: `integer` [0..9007199254740991]; default `0` | `run-local` | writes; idempotent; reversible; non-destructive | `none` | `xeer.dev.v0` | none |
 | `xeer_diagnostics` | `diagnostics` | `author` / `operator` | Explain one emitted diagnostic code. | `code`: `string` | none | read-only; idempotent; reversible; non-destructive | `none` | `xeer.command.v0` | none |
 
-**CLI actions intentionally excluded from MCP (35).**
+**CLI actions intentionally excluded from MCP (36).**
 
 | CLI action | Action | Summary | Effects | Safety | Path policy | Output | Why no MCP tool |
 | --- | --- | --- | --- | --- | --- | --- | --- |
+| `xeer init` | `init` | Initialize Xeer in an existing SvelteKit project. | `read-source`<br>`write-source`<br>`run-local`<br>`network-read` | writes; idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | Not exposed through MCP v0; use the CLI deliberately. |
 | `xeer agent setup` | `agent.setup` | Install or verify project-confined agent adapters. | `read-source`<br>`write-source` | writes; idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | Not exposed through MCP v0; use the CLI deliberately. |
 | `xeer deploy` | `deploy` | Build and deploy an application artifact. | `read-source`<br>`write-generated`<br>`run-local`<br>`network-read`<br>`network-write`<br>`production-change` | writes; non-idempotent; reversible; non-destructive | `project-relative` | `xeer.command.v0` | MCP exposes a separate preview-only deploy action; direct production deploy stays CLI-only. |
 | `xeer promote` | `promote` | Promote a preview artifact to production. | `network-read`<br>`network-write`<br>`production-change` | writes; non-idempotent; reversible; non-destructive | `project-or-url` | `xeer.command.v0` | MCP promotion is a separate action available only when the server starts in operator profile. |

package/dist/dev-session.d.ts

@@ -17,12 +17,18 @@ import type { Diagnostic, DevEvent } from '../vendor/spec/index.js';
  * inspector, and the rebuild/rollback behaviour that only `dev` has.
  */
 export type DevSessionStatus = 'starting' | 'ready' | 'compile_failed' | 'stopped' | 'crashed';
+/**
+ * Only `url` is universal. The inspector, health, debug, and logs routes are served by the Xeer
+ * runtime; a framework project's dev server is Vite and has none of them, so its `preview.ready`
+ * carries the URL alone. Modelling them as optional keeps that honest instead of inventing routes
+ * that would 404.
+ */
 export interface PreviewUrls {
     url: string;
-    healthUrl: string;
-    inspectorUrl: string;
-    debugUrl: string;
-    logsUrl: string;
+    healthUrl?: string;
+    inspectorUrl?: string;
+    debugUrl?: string;
+    logsUrl?: string;
 }
 export interface DevSessionSummary {
     sessionId: string;

package/dist/dev-session.js

@@ -4,8 +4,9 @@ function hasPreviewUrls(value) {
     if (typeof value !== 'object' || value === null)
         return false;
     const candidate = value;
-    return ['url', 'healthUrl', 'inspectorUrl', 'debugUrl', 'logsUrl']
-        .every((key) => typeof candidate[key] === 'string');
+    return typeof candidate['url'] === 'string'
+        && ['healthUrl', 'inspectorUrl', 'debugUrl', 'logsUrl']
+            .every((key) => candidate[key] === undefined || typeof candidate[key] === 'string');
 }
 const MAX_BUFFERED_EVENTS = 2_000;
 const MAX_STDERR_CHARACTERS = 4_096;
@@ -143,7 +144,8 @@ export class DevSession {
                 this.#compiling = false;
                 break;
             case 'preview.ready':
-                this.#preview = event.data;
+                if (hasPreviewUrls(event.data))
+                    this.#preview = event.data;
                 if (!this.#expectsTunnel)
                     this.#status = 'ready';
                 this.#compiling = false;

package/dist/server.js

@@ -369,8 +369,12 @@ export function createXeerMcpServer(options = {}) {
     server.registerTool('xeer_new', {
         ...toolPolicy('new'),
         outputSchema: commandOutput,
-    }, async ({ directory, template, ui }) => withDirectory(directory, 'new', (resolved) => commandTool('new', ['new', resolved,
+    }, async ({ directory, template, framework, ui }) => withDirectory(directory, 'new', (resolved) => 
+    // Every combination rule stays in the CLI: this forwards what was asked and lets the same
+    // XE30xx refusals come back, rather than growing a second copy of them at the tool boundary.
+    commandTool('new', ['new', resolved,
         ...(template === undefined ? [] : ['--template', template]),
+        ...(framework === undefined ? [] : ['--framework', framework]),
         ...(ui === undefined ? [] : ['--ui', ui]),
     ], projectRoot())));
     server.registerTool('xeer_doctor', {
@@ -429,12 +433,14 @@ export function createXeerMcpServer(options = {}) {
         cursor: z.number(),
         generation: z.number().optional(),
         artifactId: z.string().optional(),
+        // Only the URL is universal: a framework dev server is Vite and serves none of the Xeer
+        // runtime's inspection routes, so it reports the preview URL alone.
         preview: z.object({
             url: z.string(),
-            healthUrl: z.string(),
-            inspectorUrl: z.string(),
-            debugUrl: z.string(),
-            logsUrl: z.string(),
+            healthUrl: z.string().optional(),
+            inspectorUrl: z.string().optional(),
+            debugUrl: z.string().optional(),
+            logsUrl: z.string().optional(),
         }).loose().optional(),
         tunnel: z.object({
             url: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@impetik/xeer-mcp",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "type": "module",
   "description": "Model Context Protocol server for Xeer: the scaffold, check, dev, build, and deploy loop as agent tools.",
   "license": "MIT",
@@ -47,7 +47,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.0.10",
-    "@impetik/xeer": "0.2.21"
+    "@impetik/xeer": "0.2.22"
   },
   "devDependencies": {
     "@types/node": "^24.1.0"

package/vendor/spec/actions.d.ts

@@ -194,10 +194,10 @@ declare const actions: readonly [{
     readonly command: readonly ["new"];
     readonly summary: "Create a new project from a supported scaffold.";
     readonly description: string;
-    readonly usage: readonly ["new <directory> [--template {{templates}}] [--ui preact|react] [--json]"];
+    readonly usage: readonly ["new [directory] [--template <id>] [--framework sveltekit] [--ui preact|react] [--json]"];
     readonly helpOrder: 30;
     readonly outputProtocol: "xeer.command.v0";
-    readonly effects: readonly ["write-source"];
+    readonly effects: readonly ["write-source", "network-read"];
     readonly idempotent: false;
     readonly reversible: true;
     readonly destructive: false;
@@ -212,9 +212,13 @@ declare const actions: readonly [{
                     readonly description: "Target directory, relative to the server root. Must be empty or absent.";
                 };
                 readonly template: {
-                    readonly description: "Which scaffold to write. Defaults to notes.";
+                    readonly description: string;
+                    readonly type: "string";
+                };
+                readonly framework: {
+                    readonly description: string;
                     readonly type: "string";
-                    readonly enum: readonly ["notes", "todo", "blog", "personal-site"];
+                    readonly enum: readonly ["sveltekit"];
                 };
                 readonly ui: {
                     readonly description: string;
@@ -230,6 +234,24 @@ declare const actions: readonly [{
         readonly mcpTool: "xeer_new";
         readonly mcpProfiles: readonly ["author", "operator"];
     };
+}, {
+    readonly id: "init";
+    readonly command: readonly ["init"];
+    readonly summary: "Initialize Xeer in an existing SvelteKit project.";
+    readonly description: string;
+    readonly usage: readonly ["init [directory] [--dry-run] [--json]"];
+    readonly helpOrder: 32;
+    readonly outputProtocol: "xeer.command.v0";
+    readonly effects: readonly ["read-source", "write-source", "run-local", "network-read"];
+    readonly idempotent: true;
+    readonly reversible: true;
+    readonly destructive: false;
+    readonly humanPrerequisites: readonly [];
+    readonly pathPolicy: "project-relative";
+    readonly surfaces: {
+        readonly cli: true;
+        readonly mcpExclusion: "Not exposed through MCP v0; use the CLI deliberately.";
+    };
 }, {
     readonly id: "agent.setup";
     readonly command: readonly ["agent", "setup"];

package/vendor/spec/actions.js

@@ -1,5 +1,6 @@
 /** Stable protocol for the action catalogue consumed by CLI, MCP, and agent context surfaces. */
 import { REVIEW_RECEIPT_ID_SOURCE } from './review.js';
+import { FRAMEWORK_NAMES } from './scaffold-names.js';
 export const ACTION_REGISTRY_PROTOCOL = 'xeer.actions.v0';
 export const XEER_MCP_PROFILES = ['author', 'operator'];
 export const XEER_ARTIFACT_ID_PATTERN = '^sha256:[a-f0-9]{64}$';
@@ -93,8 +94,13 @@ const MCP_PRESENTATION = {
             + 'is public to read and private to write, and "personal-site" has no database at all. None of '
             + 'them scaffolds sign-in UI. "ui" selects the UI provider independently of the template — '
             + '"preact" (the default) or "react" — and changes the manifest rather than any source file. '
-            + 'result is { directory, name, template, ui, files }; an unknown template is XE3002, an '
-            + 'unknown ui is XE3003, and either writes nothing.',
+            + '"framework" is the other axis and is exclusive with "template": "sveltekit" writes a '
+            + 'SvelteKit project with xeer.config.json instead of xeer.app.json, so it has no UI provider '
+            + 'and no declared database, and its commands delegate to the package scripts after an '
+            + 'install. result is { directory, name, files } plus "template" and "ui" for an application '
+            + 'scaffold or "framework" for a framework one; an unknown template is XE3002, an unknown ui '
+            + 'is XE3003, "ui" with "framework" is XE3004, "template" with "framework" is XE3005, an '
+            + 'unknown framework is XE3006, and none of them writes anything.',
     },
     doctor: {
         mcpTitle: 'Diagnose the Xeer toolchain',
@@ -204,12 +210,16 @@ const actions = [
         id: 'new', command: ['new'], summary: 'Create a new project from a supported scaffold.',
         description: 'Creates a complete project that checks, tests, and builds clean. Templates do not '
             + 'scaffold sign-in UI: every visitor already has a verified identity, and the generated README '
-            + 'explains how to opt in to a persistent account. `--template` and `--ui` are orthogonal: the '
-            + 'template decides what the app does, the UI provider decides which renderer the identical '
-            + 'client sources compile against. `result.template` and `result.ui` report both, so neither '
-            + 'has to be inferred from the written files.',
-        usage: ['new <directory> [--template {{templates}}] [--ui preact|react] [--json]'], helpOrder: 30,
-        outputProtocol: 'xeer.command.v0', effects: ['write-source'], idempotent: false,
+            + 'explains how to opt in to a persistent account. The four bundled starter names resolve '
+            + 'offline and accept `--ui`; every other exact template id resolves through the public catalog '
+            + 'and owns its renderer. `--framework sveltekit` writes a framework '
+            + 'project instead: SvelteKit owns the renderer and the routes, Xeer owns `xeer.config.json` '
+            + 'and the deployment, so `result.framework` replaces both fields, `--ui` does not apply and '
+            + 'is refused with `XE3004`, and `--template` alongside it is `XE3005`. To adopt a framework '
+            + 'project that already exists, use `xeer init` rather than this command.',
+        usage: ['new [directory] [--template <id>] [--framework sveltekit] [--ui preact|react] [--json]'],
+        helpOrder: 30,
+        outputProtocol: 'xeer.command.v0', effects: ['write-source', 'network-read'], idempotent: false,
         reversible: true, destructive: false, humanPrerequisites: [], pathPolicy: 'project-relative',
         surfaces: {
             cli: true, mcpTool: 'xeer_new', mcpProfiles: XEER_MCP_PROFILES,
@@ -221,12 +231,20 @@ const actions = [
                         type: 'string', description: 'Target directory, relative to the server root. Must be empty or absent.',
                     },
                     template: {
-                        description: 'Which scaffold to write. Defaults to notes.', type: 'string',
-                        enum: ['notes', 'todo', 'blog', 'personal-site'],
+                        description: 'A bundled starter name or exact template catalog id. Defaults to notes. '
+                            + 'Bundled starters resolve offline. Exclusive with framework, which is refused with XE3005.',
+                        type: 'string',
+                    },
+                    framework: {
+                        description: 'Scaffold a fresh project for this framework instead of a Xeer '
+                            + 'application: it declares xeer.config.json, owns its own renderer and routes, and '
+                            + 'delegates every command to its package scripts. Exclusive with template and ui.',
+                        type: 'string', enum: FRAMEWORK_NAMES,
                     },
                     ui: {
                         description: 'Which UI provider the written manifest selects. Defaults to preact, and '
-                            + 'omitting it writes no client block at all. Orthogonal to template.',
+                            + 'omitting it writes no client block at all. Orthogonal to template, and refused '
+                            + 'with XE3004 alongside a framework that owns its own renderer.',
                         type: 'string', enum: ['preact', 'react'],
                     },
                 },
@@ -234,6 +252,17 @@ const actions = [
             },
         },
     },
+    {
+        id: 'init', command: ['init'], summary: 'Initialize Xeer in an existing SvelteKit project.',
+        description: 'Detects an existing SvelteKit project, runs Wrangler setup when Cloudflare is not '
+            + 'configured, preserves the project\'s native dev/check/test/build scripts and application '
+            + 'source, and creates the Xeer framework configuration. Use --dry-run to inspect the '
+            + 'machine-readable Xeer plan without writing.',
+        usage: ['init [directory] [--dry-run] [--json]'], helpOrder: 32,
+        outputProtocol: 'xeer.command.v0', effects: ['read-source', 'write-source', 'run-local', 'network-read'],
+        idempotent: true, reversible: true, destructive: false, humanPrerequisites: [],
+        pathPolicy: 'project-relative', surfaces: { cli: true, mcpExclusion: NOT_EXPOSED_V0 },
+    },
     {
         id: 'agent.setup', command: ['agent', 'setup'],
         summary: 'Install or verify project-confined agent adapters.',

package/vendor/spec/diagnostics.d.ts

@@ -13,7 +13,7 @@
  * undocumented and a retired code cannot linger here.
  */
 /** Where an agent observes a code, in the vocabulary of the CLI commands. */
-export type DiagnosticSurface = 'any' | 'check' | 'build' | 'dev' | 'preview' | 'test' | 'new' | 'agent' | 'doctor' | 'inspect' | 'state' | 'auth' | 'deploy' | 'deployments' | 'promote' | 'rollback' | 'disable' | 'enable' | 'delete' | 'link' | 'env' | 'token' | 'domains' | 'export' | 'import' | 'db';
+export type DiagnosticSurface = 'any' | 'check' | 'build' | 'dev' | 'preview' | 'test' | 'new' | 'init' | 'agent' | 'doctor' | 'inspect' | 'state' | 'auth' | 'deploy' | 'deployments' | 'promote' | 'rollback' | 'disable' | 'enable' | 'delete' | 'link' | 'env' | 'token' | 'domains' | 'export' | 'import' | 'db';
 export interface DiagnosticFamily {
     /** Numeric prefix the family owns, as it appears in a code. */
     readonly prefix: string;

package/vendor/spec/diagnostics.js

@@ -134,6 +134,11 @@ export const DIAGNOSTIC_FAMILIES = [
         title: 'Agent setup',
         summary: 'xeer agent setup found missing, stale, invalid, or user-owned adapter files.',
     },
+    {
+        prefix: 'XE32',
+        title: 'Existing-project initialization',
+        summary: 'xeer init could not identify or safely initialize an existing framework project.',
+    },
     {
         prefix: 'XE40',
         title: 'Environment',
@@ -397,15 +402,49 @@ export const DIAGNOSTIC_DEFINITIONS = [
         + 'fix: wait out the advertised retry and read again. '
         + "Quote `detail.errorId` when correlating with the Worker's console output.", ['inspect', 'state', 'export']),
     define('XE3001', 'xeer new could not scaffold the project — most often a non-empty target directory.', 'Choose an empty or non-existent directory.', ['new']),
-    define('XE3002', '`--template` named a scaffold that does not exist. Refused before the target '
-        + 'directory is read, so nothing was written.', 'Use one of the names the message lists, or omit --template for the default. `xeer --help` '
-        + 'describes each template.', ['new']),
+    define('XE3002', '`--template` named neither a bundled starter nor an exact id in the reachable catalog.', 'Check the exact catalog id, use a bundled starter, or omit --template for the default. A framework '
+        + 'scaffold is selected with `--framework`.', ['new']),
     define('XE3003', '`--ui` named a UI provider that does not exist. Refused before the target '
         + 'directory is read, so nothing was written.', 'Use preact or react, or omit --ui for the default (preact). The choice is orthogonal to '
-        + '--template: every template scaffolds on either provider from the same client sources.', ['new']),
+        + '--template for every Xeer application template: each scaffolds on either provider from the '
+        + 'same client sources.', ['new']),
+    define('XE3004', '`--ui` was passed with `--framework`, and a framework renders through its own '
+        + 'toolchain rather than through a Xeer UI provider. Refused before the target directory is '
+        + 'read, so nothing was written.', 'Drop --ui. `--framework sveltekit` owns its renderer: it writes no client.runtime.provider to '
+        + 'select, and no value of --ui would change a file it writes.', ['new']),
+    define('XE3005', '`--template` and `--framework` were passed together. They are two exclusive '
+        + 'axes: one writes a Xeer application, the other a project Xeer runs rather than compiles. '
+        + 'Refused before the target directory is read, so nothing was written.', 'Pass exactly one. Keep --template for a bundled Xeer application starter, or keep --framework '
+        + 'to scaffold a fresh framework project.', ['new']),
+    define('XE3006', '`--framework` named a framework Xeer cannot scaffold. Refused before the target '
+        + 'directory is read, so nothing was written.', 'Use one of the names the message lists, or omit --framework to scaffold a Xeer application. To '
+        + 'adopt a framework project that already exists, run `xeer init` in it instead.', ['new']),
+    define('XE3007', 'xeer new could not reach or read the template catalog.', 'Check the network connection and repeat the command.', ['new']),
+    define('XE3008', 'The reachable template catalog is invalid for installation.', 'Wait for the catalog publisher to be repaired, then repeat the command.', ['new']),
+    define('XE3009', 'xeer new could not download the selected template archive.', 'Check the network connection and repeat the command.', ['new']),
+    define('XE3010', 'The downloaded template archive does not match the catalog SHA-256.', 'Do not use the bytes. Repeat later or report the template artifact.', ['new']),
+    define('XE3011', 'The downloaded template archive contains unsafe or unsupported content.', 'Report the template artifact and choose another template.', ['new']),
+    define('XE3012', 'The extracted project root does not match the project metadata declared by the catalog.', 'Report the template artifact and choose another template.', ['new']),
+    define('XE3013', '`--ui` was passed with a catalog template, which owns its project kind and renderer.', 'Drop --ui and install the catalog template unchanged.', ['new']),
     define('XE3101', 'Agent setup check found one or more generated files missing or stale. No files were written.', 'Run `xeer agent setup`, then repeat `xeer agent setup --check --json`.', ['agent']),
     define('XE3102', 'Agent setup found a path owned by the user or another tool. The entire write was refused.', 'Move, rename, or deliberately remove the conflicting path; setup never overwrites an unowned file.', ['agent']),
     define('XE3103', '`--target` named an agent adapter that Xeer does not support.', 'Use auto, agents, claude, codex, cursor, vscode, or mcp.', ['agent']),
+    define('XE3201', 'xeer init did not find an existing SvelteKit package at the selected directory.', 'Run xeer init from the SvelteKit package directory, or pass that directory explicitly.', ['init']),
+    define('XE3202', 'xeer init found an existing xeer.config.json that it does not own.', 'Keep and configure the existing file deliberately; xeer init never overwrites an unowned file.', ['init']),
+    define('XE3203', 'xeer init could not read the existing package.json.', 'Repair package.json, then run xeer init again. No files were written.', ['init']),
+    define('XE3204', 'A framework package script required by Xeer is missing, unavailable, or failed. '
+        + 'A failing check reports one diagnostic per file it could locate, with `file` and `span`.', 'Run the command named in the diagnostic, repair its output, and repeat the Xeer command.', ['check', 'dev', 'build', 'test', 'deploy']),
+    define('XE3205', 'xeer.config.json or its adjacent package.json is invalid.', 'Repair the file named by the diagnostic, then repeat the Xeer command.', ['check', 'dev', 'build', 'test', 'deploy', 'doctor']),
+    define('XE3206', 'Wrangler could not configure the existing framework project for Cloudflare Workers.', 'Repair the Wrangler setup failure, or run wrangler setup manually, then repeat xeer init.', ['init']),
+    define('XE3207', 'The framework build failed, left its previous output in place, or produced '
+        + 'something the platform will not deploy: no Cloudflare Worker at the path the Wrangler '
+        + 'configuration names, or a module, asset, or total payload over the v0 size limits.', 'Read the message: it names the paths that were checked, or the limit that was exceeded. Repair '
+        + 'the project build, then repeat the Xeer build or deploy.', ['build', 'deploy', 'test']),
+    define('XE3208', 'The command reads a Xeer application contract that a framework project does not '
+        + 'have. A project with xeer.config.json owns its own routing, rendering, and datastore, so there '
+        + 'is no Xeer manifest, artifact preview, state, or log ring to read.', 'Use the framework equivalent the hint names — `xeer dev` for a running server, `xeer check` for '
+        + 'the project\'s own diagnostics — or run the command against a Xeer application (xeer.app.json). '
+        + 'Never scaffold a new project over an initialized one.', ['preview', 'inspect', 'state', 'agent']),
     define('XE4001', 'A doctor check failed. `hint` carries the check details as JSON, and result.checks '
         + 'lists every check with its id and status.', 'Fix the environment problem the failing check names. Doctor never edits the project.', ['doctor']),
     define('XE5000', 'An auth subcommand was invoked with wrong arguments.', 'Use `xeer auth <login|status|logout|as|clear>`; `auth as` takes alice or bob.', ['auth']),

package/vendor/spec/framework-config.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const FRAMEWORK_CONFIG_SCHEMA_URL: "https://docs.xeer.run/config-v0.schema.json";
+export declare const FRAMEWORK_CONFIG_FORMAT: "xeer.config.v0";
+declare const frameworkConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    format: z.ZodLiteral<"xeer.config.v0">;
+    name: z.ZodString;
+    framework: z.ZodEnum<{
+        sveltekit: "sveltekit";
+    }>;
+    capabilities: z.ZodObject<{
+        auth: z.ZodOptional<z.ZodObject<{}, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type FrameworkConfigV0 = z.infer<typeof frameworkConfigSchema>;
+export declare const frameworkConfigJsonSchema: Readonly<Record<string, unknown>>;
+export declare function parseFrameworkConfig(value: unknown): FrameworkConfigV0;
+export {};

package/vendor/spec/framework-config.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { FRAMEWORK_NAMES } from './scaffold-names.js';
+export const FRAMEWORK_CONFIG_SCHEMA_URL = 'https://docs.xeer.run/config-v0.schema.json';
+export const FRAMEWORK_CONFIG_FORMAT = 'xeer.config.v0';
+const frameworkConfigSchema = z.object({
+    $schema: z.string().url().optional(),
+    format: z.literal(FRAMEWORK_CONFIG_FORMAT),
+    name: z.string().regex(/^[a-z][a-z0-9-]{0,61}[a-z0-9]$/u),
+    framework: z.enum(FRAMEWORK_NAMES),
+    capabilities: z.object({
+        auth: z.object({}).strict().optional(),
+    }).strict(),
+}).strict();
+export const frameworkConfigJsonSchema = Object.freeze({
+    ...z.toJSONSchema(frameworkConfigSchema),
+    $id: FRAMEWORK_CONFIG_SCHEMA_URL,
+    title: 'Xeer framework configuration v0',
+    description: 'Xeer capabilities and deployment metadata for an existing framework application.',
+});
+export function parseFrameworkConfig(value) {
+    return frameworkConfigSchema.parse(value);
+}

package/vendor/spec/index.d.ts

@@ -8,6 +8,7 @@ export * from './public-assets.js';
 export * from './events.js';
 export * from './value.js';
 export * from './route.js';
+export * from './scaffold-names.js';
 export * from './identity-keys.js';
 export * from './local-identity.js';
 export * from './schema-lifecycle.js';
@@ -21,6 +22,7 @@ export * from './network-policy.js';
 export * from './review.js';
 export * from './template.js';
 export * from './template-distribution.js';
+export * from './framework-config.js';
 export * from './tunnel.js';
 export * from './type-check-profile.js';
 export * from './editor-settings.js';

package/vendor/spec/index.js

@@ -8,6 +8,7 @@ export * from './public-assets.js';
 export * from './events.js';
 export * from './value.js';
 export * from './route.js';
+export * from './scaffold-names.js';
 export * from './identity-keys.js';
 export * from './local-identity.js';
 export * from './schema-lifecycle.js';
@@ -21,6 +22,7 @@ export * from './network-policy.js';
 export * from './review.js';
 export * from './template.js';
 export * from './template-distribution.js';
+export * from './framework-config.js';
 export * from './tunnel.js';
 export * from './type-check-profile.js';
 export * from './editor-settings.js';

package/vendor/spec/public-assets.d.ts

@@ -49,12 +49,24 @@ export declare const IMMUTABLE_ASSET_HASH_LENGTH = 64;
  * bound moves only in lockstep with the retention fold in the control plane's deployment service.
  */
 export declare const MAX_RETAINED_ASSET_GENERATIONS = 2;
+/**
+ * Upper bound on {@link PublicAssetsV0.declaredImmutablePrefixes}. Four, because the declaration is
+ * a trust statement and a short list is one a reviewer can read; no framework adapter mints more
+ * than one such directory.
+ */
+export declare const MAX_DECLARED_IMMUTABLE_PREFIXES = 4;
 /**
  * What a declared entry is an alias *of*. Kept as a string rather than a structured pair because its
  * only consumers are humans reading an artifact and a diagnostic naming the file that produced a
  * collision — nothing branches on it.
  */
 export type PublicAssetOrigin = `module:${string}` | `asset:${string}` | 'document';
+/**
+ * How long an origin may be, prefix included. Published because a producer has to refuse a path it
+ * cannot describe rather than truncate one: two long paths shortened to the same origin would name
+ * one file as the source of both, which is the opposite of what the field is for.
+ */
+export declare const MAX_PUBLIC_ASSET_ORIGIN_LENGTH = 256;
 export interface ImmutableAssetV0 {
     /**
      * `${immutablePrefix}${hash.slice(7)}/${basename}`, and {@link parsePublicAssets} recomputes it
@@ -110,6 +122,22 @@ export interface PublicAssetsV0 {
      * belongs to the control plane and this field should become a floor rather than the whole rule.
      */
     retainedGenerations: number;
+    /**
+     * Additional prefixes under which the *producing build* content-addresses its own output, and
+     * which therefore get the immutable cache directive without Xeer having minted the address.
+     *
+     * Optional, and absent on every artifact the Xeer compiler emits: it hashes its own assets into
+     * {@link IMMUTABLE_ASSET_PREFIX}, where the path *is* the digest and {@link parsePublicAssets}
+     * proves it. A framework bundle cannot do that — SvelteKit's adapter emits `/_app/immutable/`
+     * with Vite's own digest in the filename, in an algorithm and width Xeer does not know — so the
+     * choice is between serving content-addressed files with `max-age=0, must-revalidate` and
+     * accepting a declaration this format cannot verify.
+     *
+     * This field is that declaration, named so the weakening is visible: entries stay in
+     * {@link PublicAssetsV0.revalidate}, because their bytes are not proved by their path and nothing
+     * downstream may treat them as if they were. All it buys is the cache header.
+     */
+    declaredImmutablePrefixes?: string[];
     /** Sorted by path. Cacheable forever, because the path is the digest. */
     immutable: ImmutableAssetV0[];
     /**
@@ -123,6 +151,21 @@ export interface PublicAssetsV0 {
      */
     revalidate: RevalidatedAssetV0[];
 }
+/**
+ * What {@link ImmutableAssetV0.contentType} and {@link RevalidatedAssetV0.contentType} are filled
+ * with, for every producer of a declaration.
+ *
+ * It lives beside the field it populates because the two producers that had a map each — the Xeer
+ * compiler and the SvelteKit framework build — drifted, and the drift was silent: the framework map
+ * omitted `wasm`, so a WebAssembly module shipped as `application/octet-stream`, which
+ * `WebAssembly.instantiateStreaming` refuses. One map, or the same file works through one build path
+ * and breaks through the other.
+ *
+ * Deliberately not a lookup of a real media-type database: this only has to answer for what a build
+ * emits, every value is one a browser treats as the thing it is, and an unknown extension gets the
+ * one answer that is never wrong about encoding.
+ */
+export declare function assetContentType(path: string): string;
 /** The URL a blob of bytes is served at, and the only sanctioned way to mint one. */
 export declare function immutableAssetPath(hash: `sha256:${string}`, basename: string): string;
 /**
@@ -134,11 +177,13 @@ export declare function isImmutableAssetPath(path: string): boolean;
 /**
  * The `_headers` document Cloudflare's static asset layer applies to a deployment.
  *
- * One rule, scoped to the prefix. Nothing else may appear here: an `immutable` directive that leaked
- * onto the HTML document would pin stale markup in every browser that saw it for a year, and no
- * server-side action reaches a browser that has already stored one.
+ * One rule per prefix, and nothing else: an `immutable` directive that leaked onto the HTML document
+ * would pin stale markup in every browser that saw it for a year, and no server-side action reaches
+ * a browser that has already stored one. `declaredPrefixes` adds a rule for each entry of
+ * {@link PublicAssetsV0.declaredImmutablePrefixes}, which {@link parsePublicAssets} has already
+ * refused from taking a platform namespace or naming a whole site.
  */
-export declare function immutableAssetHeaders(prefix?: string): string;
+export declare function immutableAssetHeaders(prefix?: string, declaredPrefixes?: readonly string[]): string;
 /**
  * Validates a declaration rather than trusting one. Every rule below has a failure it exists to
  * prevent, and the two that matter most are the last two:

package/vendor/spec/public-assets.js

@@ -51,6 +51,62 @@ export const IMMUTABLE_ASSET_HASH_LENGTH = 64;
 export const MAX_RETAINED_ASSET_GENERATIONS = 2;
 const IMMUTABLE_PATH = /^\/_xa\/[0-9a-f]{64}\/[A-Za-z0-9](?:[A-Za-z0-9._-]{0,63})$/u;
 const ASSET_HASH = /^sha256:[0-9a-f]{64}$/u;
+/**
+ * Upper bound on {@link PublicAssetsV0.declaredImmutablePrefixes}. Four, because the declaration is
+ * a trust statement and a short list is one a reviewer can read; no framework adapter mints more
+ * than one such directory.
+ */
+export const MAX_DECLARED_IMMUTABLE_PREFIXES = 4;
+const DECLARED_PREFIX = /^\/(?:[A-Za-z0-9._-]+\/)+$/u;
+/** Namespaces the platform claims before assets are consulted, and which no declaration may take. */
+const RESERVED_PREFIXES = ['/_xa/', '/_xeer/', '/__xeer/'];
+/**
+ * How long an origin may be, prefix included. Published because a producer has to refuse a path it
+ * cannot describe rather than truncate one: two long paths shortened to the same origin would name
+ * one file as the source of both, which is the opposite of what the field is for.
+ */
+export const MAX_PUBLIC_ASSET_ORIGIN_LENGTH = 256;
+/**
+ * What {@link ImmutableAssetV0.contentType} and {@link RevalidatedAssetV0.contentType} are filled
+ * with, for every producer of a declaration.
+ *
+ * It lives beside the field it populates because the two producers that had a map each — the Xeer
+ * compiler and the SvelteKit framework build — drifted, and the drift was silent: the framework map
+ * omitted `wasm`, so a WebAssembly module shipped as `application/octet-stream`, which
+ * `WebAssembly.instantiateStreaming` refuses. One map, or the same file works through one build path
+ * and breaks through the other.
+ *
+ * Deliberately not a lookup of a real media-type database: this only has to answer for what a build
+ * emits, every value is one a browser treats as the thing it is, and an unknown extension gets the
+ * one answer that is never wrong about encoding.
+ */
+export function assetContentType(path) {
+    const extension = path.toLowerCase().split('.').at(-1) ?? '';
+    const types = {
+        avif: 'image/avif',
+        css: 'text/css; charset=utf-8',
+        eot: 'application/vnd.ms-fontobject',
+        gif: 'image/gif',
+        html: 'text/html; charset=utf-8',
+        ico: 'image/x-icon',
+        jpeg: 'image/jpeg',
+        jpg: 'image/jpeg',
+        js: 'text/javascript; charset=utf-8',
+        json: 'application/json; charset=utf-8',
+        mjs: 'text/javascript; charset=utf-8',
+        otf: 'font/otf',
+        png: 'image/png',
+        svg: 'image/svg+xml',
+        ttf: 'font/ttf',
+        txt: 'text/plain; charset=utf-8',
+        wasm: 'application/wasm',
+        webp: 'image/webp',
+        woff: 'font/woff',
+        woff2: 'font/woff2',
+        xml: 'application/xml; charset=utf-8',
+    };
+    return types[extension] ?? 'application/octet-stream';
+}
 /** The URL a blob of bytes is served at, and the only sanctioned way to mint one. */
 export function immutableAssetPath(hash, basename) {
     return `${IMMUTABLE_ASSET_PREFIX}${hash.slice('sha256:'.length, 'sha256:'.length + IMMUTABLE_ASSET_HASH_LENGTH)}/${basename}`;
@@ -66,12 +122,15 @@ export function isImmutableAssetPath(path) {
 /**
  * The `_headers` document Cloudflare's static asset layer applies to a deployment.
  *
- * One rule, scoped to the prefix. Nothing else may appear here: an `immutable` directive that leaked
- * onto the HTML document would pin stale markup in every browser that saw it for a year, and no
- * server-side action reaches a browser that has already stored one.
+ * One rule per prefix, and nothing else: an `immutable` directive that leaked onto the HTML document
+ * would pin stale markup in every browser that saw it for a year, and no server-side action reaches
+ * a browser that has already stored one. `declaredPrefixes` adds a rule for each entry of
+ * {@link PublicAssetsV0.declaredImmutablePrefixes}, which {@link parsePublicAssets} has already
+ * refused from taking a platform namespace or naming a whole site.
  */
-export function immutableAssetHeaders(prefix = IMMUTABLE_ASSET_PREFIX) {
-    return `${prefix}*\n  Cache-Control: ${IMMUTABLE_ASSET_CACHE_CONTROL}\n`;
+export function immutableAssetHeaders(prefix = IMMUTABLE_ASSET_PREFIX, declaredPrefixes = []) {
+    return [prefix, ...declaredPrefixes]
+        .map((entry) => `${entry}*\n  Cache-Control: ${IMMUTABLE_ASSET_CACHE_CONTROL}\n`).join('');
 }
 function fail(message) {
     throw new TypeError(`publicAssets: ${message}`);
@@ -84,7 +143,7 @@ function object(value, label) {
 function origin(value, label) {
     // The `:` must be followed by something. An empty `module:` names nothing, and `documentReferences`
     // resolves the document's three subresources by matching on this exact string.
-    if (typeof value !== 'string' || value.length > 256
+    if (typeof value !== 'string' || value.length > MAX_PUBLIC_ASSET_ORIGIN_LENGTH
         || !(value === 'document' || /^(?:module|asset):.+$/u.test(value))) {
         fail(`${label}.origin must be "document", "module:<path>" or "asset:<path>".`);
     }
@@ -155,9 +214,42 @@ export function parsePublicAssets(value) {
     });
     sorted(immutable.map((entry) => entry.path), 'immutable');
     sorted(revalidate.map((entry) => entry.path), 'revalidate');
+    const declaredImmutablePrefixes = declaredPrefixes(input.declaredImmutablePrefixes);
     return { format: PUBLIC_ASSETS_FORMAT, immutablePrefix: IMMUTABLE_ASSET_PREFIX, retainedGenerations,
+        ...(declaredImmutablePrefixes ? { declaredImmutablePrefixes } : {}),
         immutable, revalidate };
 }
+/**
+ * The declared prefixes, or `undefined` for the artifact that declares none — which is every
+ * artifact the Xeer compiler emits, and every bundle built before the field existed. Absent is
+ * carried through as absent rather than as `[]`, so a re-serialized declaration is byte-identical to
+ * the one that was parsed and its `artifactId` does not move.
+ *
+ * The rules are the ones that keep a year-long cache directive from reaching something mutable: a
+ * directory rather than a whole site or a bare file, never one of the platform's own namespaces, and
+ * never nested inside another entry, which would attach two rules to one path.
+ */
+function declaredPrefixes(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length === 0 || value.length > MAX_DECLARED_IMMUTABLE_PREFIXES) {
+        fail(`declaredImmutablePrefixes must be an array of 1 to ${MAX_DECLARED_IMMUTABLE_PREFIXES} prefixes.`);
+    }
+    const prefixes = value.map((item, index) => {
+        if (typeof item !== 'string' || item.length > 128 || !DECLARED_PREFIX.test(item) || item.includes('..')) {
+            fail(`declaredImmutablePrefixes[${index}] must be a "/segment/" path prefix.`);
+        }
+        if (RESERVED_PREFIXES.some((reserved) => item.startsWith(reserved) || reserved.startsWith(item))) {
+            fail(`declaredImmutablePrefixes[${index}] uses a reserved platform namespace.`);
+        }
+        return item;
+    });
+    sorted(prefixes, 'declaredImmutablePrefixes');
+    const nested = prefixes.find((entry, index) => prefixes.some((other, position) => position !== index && entry.startsWith(other)));
+    if (nested !== undefined)
+        fail(`declaredImmutablePrefixes contains a prefix of another: ${nested}`);
+    return prefixes;
+}
 /**
  * Every path that must answer for this deployment, immutable first. The union a control plane uploads
  * is this set for the current artifact plus the immutable half of the retained generations.

package/vendor/spec/scaffold-names.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The names `xeer new` accepts on its two independent axes, in one place because three surfaces
+ * already have to agree on them: the CLI's `--template` and `--framework` parsing, the MCP input
+ * enums the action registry declares, and the template catalog's reserved-name check.
+ *
+ * Here rather than in the CLI because the catalog publisher runs without the CLI installed, and a
+ * second copy of either list is a copy that can drift into publishing a template that the offline
+ * scaffold would shadow.
+ */
+/**
+ * The bundled Xeer application starters: a `xeer.app.json` the platform compiles, plus the sources
+ * it names. Offline, deterministic, and resolved before any catalog request.
+ */
+export declare const BUNDLED_TEMPLATES: readonly ["notes", "todo", "blog", "personal-site"];
+export type BundledTemplateName = (typeof BUNDLED_TEMPLATES)[number];
+/**
+ * The frameworks Xeer runs rather than compiles: a `xeer.config.json` beside a project whose own
+ * toolchain owns the renderer, the routes, and the build.
+ *
+ * A separate axis rather than more template names, because the two write different root contracts
+ * and every later command dispatches on which one is present. `--framework` selects one for a fresh
+ * project; `xeer init` adopts an existing one; `xeer.config.json` declares which one a directory is.
+ */
+export declare const FRAMEWORK_NAMES: readonly ["sveltekit"];
+export type FrameworkName = (typeof FRAMEWORK_NAMES)[number];

package/vendor/spec/scaffold-names.js

@@ -0,0 +1,23 @@
+/**
+ * The names `xeer new` accepts on its two independent axes, in one place because three surfaces
+ * already have to agree on them: the CLI's `--template` and `--framework` parsing, the MCP input
+ * enums the action registry declares, and the template catalog's reserved-name check.
+ *
+ * Here rather than in the CLI because the catalog publisher runs without the CLI installed, and a
+ * second copy of either list is a copy that can drift into publishing a template that the offline
+ * scaffold would shadow.
+ */
+/**
+ * The bundled Xeer application starters: a `xeer.app.json` the platform compiles, plus the sources
+ * it names. Offline, deterministic, and resolved before any catalog request.
+ */
+export const BUNDLED_TEMPLATES = Object.freeze(['notes', 'todo', 'blog', 'personal-site']);
+/**
+ * The frameworks Xeer runs rather than compiles: a `xeer.config.json` beside a project whose own
+ * toolchain owns the renderer, the routes, and the build.
+ *
+ * A separate axis rather than more template names, because the two write different root contracts
+ * and every later command dispatches on which one is present. `--framework` selects one for a fresh
+ * project; `xeer init` adopts an existing one; `xeer.config.json` declares which one a directory is.
+ */
+export const FRAMEWORK_NAMES = Object.freeze(['sveltekit']);

package/vendor/spec/schema.d.ts

@@ -9,9 +9,9 @@ export declare const normalizedDatabaseSchema: z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                json: "json";
                 datetime: "datetime";
                 bytes: "bytes";
-                json: "json";
                 ref: "ref";
             }>;
             optional: z.ZodOptional<z.ZodBoolean>;
@@ -91,9 +91,9 @@ export declare const applicationManifestSchema: z.ZodObject<{
                     string: "string";
                     number: "number";
                     boolean: "boolean";
+                    json: "json";
                     datetime: "datetime";
                     bytes: "bytes";
-                    json: "json";
                     ref: "ref";
                 }>;
                 optional: z.ZodOptional<z.ZodBoolean>;

package/vendor/spec/template-distribution.d.ts

@@ -4,6 +4,18 @@ export declare const TEMPLATE_DISTRIBUTION_CATALOG_SCHEMA_URL: "https://docs.xee
 /** Exact semantic version: no range operator, no `v` prefix, no wildcard. */
 export declare const EXACT_VERSION_PATTERN: string;
 export declare const TEMPLATE_ARCHIVE_CHECKSUM_PATTERN: "^sha256:[a-f0-9]{64}$";
+/**
+ * The two root contracts a template can declare: a `xeer.app.json` the platform compiles, or a
+ * `xeer.config.json` naming a framework Xeer runs. The same distinction every directory-taking
+ * command already dispatches on, spelled once here so the catalog does not grow a third vocabulary.
+ *
+ * These are the words for both, not only for a catalog entry: the CLI's `ProjectKind`
+ * (`packages/cli/src/framework-project.ts`) aliases {@link TemplateProjectKind} rather than spelling
+ * its filesystem probe's answer a second way, so a directory's kind and a published template's kind
+ * are the same value and nothing translates between them.
+ */
+export declare const TEMPLATE_PROJECT_KINDS: readonly ["xeer-application", "framework"];
+export type TemplateProjectKind = (typeof TEMPLATE_PROJECT_KINDS)[number];
 /**
  * One published template. The authored metadata is copied verbatim from `template.json`; everything
  * else is produced by the release job that packed, deployed, and verified this exact artifact.
@@ -45,6 +57,15 @@ export declare const templateDistributionEntrySchema: z.ZodObject<{
     tags: z.ZodArray<z.ZodString>;
     keyHighlights: z.ZodArray<z.ZodString>;
     id: z.ZodString;
+    project: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            framework: "framework";
+            "xeer-application": "xeer-application";
+        }>;
+        framework: z.ZodOptional<z.ZodEnum<{
+            sveltekit: "sveltekit";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type TemplateDistributionEntryV0 = z.infer<typeof templateDistributionEntrySchema>;
 /**
@@ -88,6 +109,15 @@ export declare const templateDistributionCatalogSchema: z.ZodObject<{
         tags: z.ZodArray<z.ZodString>;
         keyHighlights: z.ZodArray<z.ZodString>;
         id: z.ZodString;
+        project: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                framework: "framework";
+                "xeer-application": "xeer-application";
+            }>;
+            framework: z.ZodOptional<z.ZodEnum<{
+                sveltekit: "sveltekit";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type TemplateDistributionCatalogV0 = z.infer<typeof templateDistributionCatalogSchema>;

package/vendor/spec/template-distribution.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { FRAMEWORK_NAMES } from './scaffold-names.js';
 import { checkTemplateMetadataUniqueness, templateAltTextSchema, templateIdentityShape, templateMetadataShape, templateSlugSchema, } from './template.js';
 export const TEMPLATE_DISTRIBUTION_CATALOG_FORMAT = 'xeer.template-distribution-catalog.v0';
 export const TEMPLATE_DISTRIBUTION_CATALOG_SCHEMA_URL = 'https://docs.xeer.run/template-distribution-catalog-v0.schema.json';
@@ -18,6 +19,38 @@ const sourceArchiveSchema = z.strictObject({
     url: httpsUrl,
     sha256: archiveChecksum,
 });
+/**
+ * The two root contracts a template can declare: a `xeer.app.json` the platform compiles, or a
+ * `xeer.config.json` naming a framework Xeer runs. The same distinction every directory-taking
+ * command already dispatches on, spelled once here so the catalog does not grow a third vocabulary.
+ *
+ * These are the words for both, not only for a catalog entry: the CLI's `ProjectKind`
+ * (`packages/cli/src/framework-project.ts`) aliases {@link TemplateProjectKind} rather than spelling
+ * its filesystem probe's answer a second way, so a directory's kind and a published template's kind
+ * are the same value and nothing translates between them.
+ */
+export const TEMPLATE_PROJECT_KINDS = ['xeer-application', 'framework'];
+/**
+ * What the template's own root contract says it is, derived by the publisher from that file and never
+ * authored: `template.json` has no such field and could not carry one.
+ *
+ * It exists so a consumer — a gallery, the CLI's result envelope — reads kind and framework from
+ * metadata rather than parsing meaning out of an id. Ids are opaque; this is the only carrier.
+ */
+const templateProjectSchema = z.strictObject({
+    kind: z.enum(TEMPLATE_PROJECT_KINDS),
+    framework: z.enum(FRAMEWORK_NAMES).optional(),
+}).superRefine((project, ctx) => {
+    if ((project.framework !== undefined) === (project.kind === 'framework'))
+        return;
+    ctx.addIssue({
+        code: 'custom',
+        path: ['framework'],
+        message: project.kind === 'framework'
+            ? 'a framework project must name the framework it runs'
+            : `only a framework project names a framework; a ${project.kind} project does not`,
+    });
+});
 /**
  * One published template. The authored metadata is copied verbatim from `template.json`; everything
  * else is produced by the release job that packed, deployed, and verified this exact artifact.
@@ -30,6 +63,11 @@ const sourceArchiveSchema = z.strictObject({
  */
 export const templateDistributionEntrySchema = z.strictObject({
     id: templateSlugSchema,
+    /**
+     * Absent on every entry published before the field existed, which is why it is optional: those
+     * entries are carried forward verbatim rather than re-derived.
+     */
+    project: templateProjectSchema.optional(),
     ...templateMetadataShape,
     screenshots: z.array(distributedScreenshotSchema).min(1).max(8),
     ...templateIdentityShape,

package/vendor/spec/types.d.ts

@@ -4,6 +4,32 @@ export declare const SOURCE_FORMAT: "xeer.application-source.v0";
 export declare const ARTIFACT_FORMAT: "xeer.application.v0";
 export declare const DEV_PROTOCOL: "xeer.dev.v0";
 export declare const INSPECT_PROTOCOL: "xeer.inspect.v0";
+/**
+ * The workerd release every Xeer-uploaded Worker is compiled and booted against.
+ *
+ * One constant rather than one per producer. The compiler stamps it into the artifact, `xeer dev`
+ * boots the local workerd with it, and the framework deployment wrapper uploads it — and all three
+ * have to agree, because the platform verifies a bundle on the release named here and a project's own
+ * `wrangler.jsonc` may legitimately be newer. It lived as three hand-copied literals with a comment
+ * asking each to be kept in lockstep; the import is the lockstep.
+ */
+export declare const WORKER_COMPATIBILITY_DATE: "2026-07-23";
+/**
+ * The v0 ceilings on what one deployment may carry, enforced wherever a bundle is assembled.
+ *
+ * They are the platform's limits rather than the compiler's, which is why they are here: a framework
+ * bundle assembled without the Xeer compiler has to refuse the same sizes, locally and before
+ * encoding, or the failure arrives as a `RangeError` on the builder's machine or an out-of-memory
+ * control-plane isolate.
+ */
+export declare const MAX_MODULE_BYTES: number;
+export declare const MAX_ASSET_BYTES: number;
+/**
+ * The whole uploaded payload's ceiling, counted the way the control plane counts it: in base64
+ * characters, which is what travels. A producer holding raw bytes compares
+ * `Math.ceil(bytes / 3) * 4` against it.
+ */
+export declare const MAX_DEPLOYMENT_BASE64_BYTES: number;
 export type DiagnosticSeverity = 'error' | 'warning' | 'info';
 export interface SourceSpan {
     line: number;

package/vendor/spec/types.js

@@ -2,6 +2,32 @@ export const SOURCE_FORMAT = 'xeer.application-source.v0';
 export const ARTIFACT_FORMAT = 'xeer.application.v0';
 export const DEV_PROTOCOL = 'xeer.dev.v0';
 export const INSPECT_PROTOCOL = 'xeer.inspect.v0';
+/**
+ * The workerd release every Xeer-uploaded Worker is compiled and booted against.
+ *
+ * One constant rather than one per producer. The compiler stamps it into the artifact, `xeer dev`
+ * boots the local workerd with it, and the framework deployment wrapper uploads it — and all three
+ * have to agree, because the platform verifies a bundle on the release named here and a project's own
+ * `wrangler.jsonc` may legitimately be newer. It lived as three hand-copied literals with a comment
+ * asking each to be kept in lockstep; the import is the lockstep.
+ */
+export const WORKER_COMPATIBILITY_DATE = '2026-07-23';
+/**
+ * The v0 ceilings on what one deployment may carry, enforced wherever a bundle is assembled.
+ *
+ * They are the platform's limits rather than the compiler's, which is why they are here: a framework
+ * bundle assembled without the Xeer compiler has to refuse the same sizes, locally and before
+ * encoding, or the failure arrives as a `RangeError` on the builder's machine or an out-of-memory
+ * control-plane isolate.
+ */
+export const MAX_MODULE_BYTES = 10 * 1024 * 1024;
+export const MAX_ASSET_BYTES = 25 * 1024 * 1024;
+/**
+ * The whole uploaded payload's ceiling, counted the way the control plane counts it: in base64
+ * characters, which is what travels. A producer holding raw bytes compares
+ * `Math.ceil(bytes / 3) * 4` against it.
+ */
+export const MAX_DEPLOYMENT_BASE64_BYTES = 42 * 1024 * 1024;
 /**
  * Whether a set of diagnostics refuses the command that produced it.
  *