@powerhousedao/codegen 6.2.2-dev.8 → 6.2.2-dev.81

package/dist/{file-builders-Btk4MK1I.mjs → file-builders-BZEQ9XnO.mjs}

@@ -5,21 +5,23 @@ import path, { join } from "path";
 import { DocumentModelGlobalStateSchema, ManifestSchema } from "@powerhousedao/shared/document-model";
 import fs, { copyFile, mkdir, readdir, writeFile } from "node:fs/promises";
 import { camelCase, capitalCase, constantCase, kebabCase, pascalCase } from "change-case";
+import { DEFAULT_SWITCHBOARD_PORT } from "@powerhousedao/shared/clis/constants";
+import { deriveProjectPorts } from "@powerhousedao/shared/clis/project-ports";
 import { DEFAULT_CONNECT_CONFIG } from "@powerhousedao/shared/connect";
 import { DEFAULT_REGISTRY_URL } from "@powerhousedao/shared/registry";
 import { capitalize, concat, conditional, constant, endsWith, filter, find, first, flatMap, forEach, isDefined, isIncludedIn, isNonNullish, isNot, isStrictEqual, isString, isTruthy, last, map, mapValues, merge, pipe, prop, sort, split, startsWith, subtract, unique, uniqueBy, when } from "remeda";
-import { IndentationText, Project, SyntaxKind, VariableDeclarationKind, ts } from "ts-morph";
+import { FileSystemRefreshResult, IndentationText, Project, SyntaxKind, VariableDeclarationKind, ts } from "ts-morph";
 import arg from "arg";
 import { format } from "oxfmt";
 import { z } from "zod";
 import { loadJsonFile, loadJsonFileSync } from "load-json-file";
+import { existsSync, realpathSync } from "node:fs";
 import { writeJsonFile } from "write-json-file";
 import { stripVTControlCharacters } from "node:util";
 import path$1, { join as join$1, relative } from "node:path";
 import { generate } from "@graphql-codegen/cli";
-import { generatorTypeDefs, validationSchema } from "@powerhousedao/document-engineering/graphql";
-import { Kind, parse } from "graphql";
-import { realpathSync } from "node:fs";
+import { generatorTypeDefs, getPHCustomScalarByTypeName, validationSchema } from "@powerhousedao/document-engineering/graphql";
+import { Kind, parse, print } from "graphql";
 import { fileURLToPath, pathToFileURL } from "node:url";
 function isEOL(c) {
 	return c === 10 || c === 13;
@@ -2153,12 +2155,22 @@ This project creates document models, editors, processors and subgraphs for the
 - **Reactor Package**: A deployable bundle that extends the Reactor. It contains one or more document models, editors, processors, and subgraphs. A Vetra project generates a Reactor Package.
 - **Connect**: The Powerhouse web application for document management. End users open Connect to browse drives, create documents, and interact with editors.
 - **Switchboard**: The Powerhouse API service. It exposes GraphQL and MCP endpoints so external tools can read/write documents programmatically.
-- **Vetra**: The local development environment for building Reactor Packages. It includes Vetra Studio (a local Connect instance) and Vetra Switchboard (a local Switchboard with reactor-mcp). Start it with \`ph vetra\`.
+- **Vetra**: The local development environment for building Reactor Packages. It includes Vetra Studio (a local Connect instance) and Vetra Switchboard (a local Switchboard with reactor-mcp). **You start it yourself** with \`ph vetra --strictPort --watch\` as a background process — see the MCP rules below. Its ports are assigned per project in \`powerhouse.config.json\`, so they never collide with another project's.
 
 ## CRITICAL: MCP Tool Usage Rules
 
 **MANDATORY**: The \`reactor-mcp\` MUST BE USED when handling documents or document-models for the Powerhouse/Vetra ecosystem.
-If the \`reactor-mcp\` server is unavailable, ask the user to run \`ph vetra\` on a separate terminal to start the server and try to reconnect to the MCP server, DO NOT run it yourself.
+If the \`reactor-mcp\` server is unavailable, **start Vetra yourself** — do not ask the user to do it:
+
+1. **Check for a running instance.** If \`.ph/vetra-runtime.json\` exists and describes a live instance, Vetra is already up: report its Connect URL and stop. Never start a second one — a project must have exactly one reactor, because two would contend for the same \`.ph/\` storage and leave you with two drives that diverge.
+2. **Start it in the background:** \`ph vetra --strictPort --watch\`. Pass no port flags. The project's ports live in \`powerhouse.config.json\` and are already what \`.mcp.json\` points at; choosing your own port is how you end up talking to a different project's reactor. \`--strictPort\` makes a genuine conflict fail loudly instead of silently binding a neighbouring port.
+3. **Wait for readiness.** Poll \`GET http://localhost:<port>/ready\` until it returns 200, for at most 60 seconds, where \`<port>\` is the one in \`.mcp.json\`. Poll that port specifically: it is the only one your MCP client will ever use, so a timeout there is the correct signal even if Vetra came up somewhere else.
+4. **Tell the user the Connect URL** so they can watch their editors render.
+5. **Reconnect to the MCP server** and continue the task.
+
+Escalate to the user only when startup actually fails — \`--strictPort\` rejected the port, \`/ready\` never returned 200, or the process crashed — and include the real error output.
+
+**Never edit \`.mcp.json\` to chase a port.** A mismatch between it and the running switchboard is a bug worth reporting, not routing around; \`ph vetra\` owns that reconciliation and will rewrite the file itself when a local override moves the port.
 
 ### Key Requirements:
 
@@ -2881,16 +2893,18 @@ const claudeSettingsLocalTemplate = json`
 `.raw;
 //#endregion
 //#region src/templates/boilerplate/cursor/mcp.json.ts
-const cursorMcpTemplate = json`
+/** Cursor's copy of the MCP config. Same literal-port reasoning as `.mcp.json`. */
+const buildCursorMcpTemplate = (port) => json`
 {
   "mcpServers": {
     "reactor-mcp": {
       "type": "http",
-      "url": "http://localhost:4001/mcp"
+      "url": "http://localhost:${String(port)}/mcp"
     }
   }
 }
 `.raw;
+const cursorMcpTemplate = buildCursorMcpTemplate(DEFAULT_SWITCHBOARD_PORT);
 //#endregion
 //#region src/templates/boilerplate/docker/connect-entrypoint.sh.ts
 const connectEntrypointTemplate = `#!/bin/sh
@@ -4446,16 +4460,25 @@ const { updateLocalPackage } = startConnect(localPackage);
 `.raw;
 //#endregion
 //#region src/templates/boilerplate/mcp.json.ts
-const mcpTemplate = json`
+/**
+* Render `.mcp.json` for a project whose switchboard listens on `port`.
+*
+* The port is a literal rather than an env reference on purpose: an MCP
+* client resolves this file at session start and cannot read `.env` or
+* `powerhouse.config.json`. `ph vetra` reconciles the literal if an override
+* moves the port.
+*/
+const buildMcpTemplate = (port) => json`
 {
   "mcpServers": {
     "reactor-mcp": {
       "type": "http",
-      "url": "http://localhost:4001/mcp"
+      "url": "http://localhost:${String(port)}/mcp"
     }
   }
 }
 `.raw;
+const mcpTemplate = buildMcpTemplate(DEFAULT_SWITCHBOARD_PORT);
 //#endregion
 //#region src/templates/boilerplate/npmrc.ts
 const npmrcTemplate = `@jsr:registry=https://npm.jsr.io`;
@@ -4482,9 +4505,9 @@ const packageJsonTemplate = (projectName, peerDependencies, devDependencies) =>
     ${exportsTemplate}
   },
   "scripts": {
-    "test": "vitest run",
+    "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage --passWithNoTests",
     "lint": "oxlint --type-aware --type-check",
     "lint:fix": "oxlint --type-aware --type-check --fix",
     "format": "oxfmt",
@@ -4578,22 +4601,25 @@ const packageJsonExportsTemplate = {
 * see fully-defined values instead of `undefined`.
 */
 async function buildPowerhouseConfigTemplate(args) {
+	const ports = deriveProjectPorts(args.name);
 	const config = {
 		$schema: "https://raw.githubusercontent.com/powerhouse-inc/powerhouse/main/packages/shared/clis/source-config.schema.json",
 		documentModelsDir: "./document-models",
 		editorsDir: "./editors",
 		processorsDir: "./processors",
 		subgraphsDir: "./subgraphs",
-		studio: { port: 3e3 },
-		reactor: { port: 4001 },
+		studio: { port: ports.studioPort },
+		reactor: { port: ports.switchboardPort },
 		packages: [],
 		packageRegistryUrl: DEFAULT_REGISTRY_URL,
 		connect: DEFAULT_CONNECT_CONFIG
 	};
-	if (args.remoteDrive) config.vetra = {
-		driveId: args.remoteDrive.split("/").pop() ?? "",
-		driveUrl: args.remoteDrive
-	};
+	const vetra = { connectPort: ports.vetraConnectPort };
+	if (args.remoteDrive) {
+		vetra.driveId = args.remoteDrive.split("/").pop() ?? "";
+		vetra.driveUrl = args.remoteDrive;
+	}
+	config.vetra = vetra;
 	return `${JSON.stringify(config, null, 2)}\n`;
 }
 //#endregion
@@ -5185,36 +5211,88 @@ ${buildCreatorsExports(v.specification.modules, v.camelCaseDocumentType)}
 `.raw;
 //#endregion
 //#region src/templates/document-model/gen/document-schema.ts
-const documentModelDocumentSchemaFileTemplate = (v) => ts$1`
+function priorVersions(versions, currentVersion) {
+	return versions.filter((k) => k < currentVersion);
+}
+function makeOlderStateSchemaImports(versions, currentVersion, phStateName) {
+	return priorVersions(versions, currentVersion).map((k) => `import { ${phStateName}Schema as ${phStateName}SchemaV${k} } from "../../v${k}/gen/document-schema.js";`).join("\n");
+}
+function makeStateSchemasByVersion(versions, currentVersion, phStateName) {
+	return `{ ${versions.filter((k) => k <= currentVersion).map((k) => {
+		return `${k}: ${k === currentVersion ? `${phStateName}Schema` : `${phStateName}SchemaV${k}`}`;
+	}).join(", ")} }`;
+}
+function makeDocumentSchemasByVersion(versions, currentVersion, v) {
+	return `{ ${versions.filter((k) => k <= currentVersion).map((k) => {
+		if (k === currentVersion) return `${k}: ${v.phDocumentSchemaName}`;
+		return `${k}: z.object({ header: ${v.phDocumentTypeName}HeaderSchema, state: ${v.phStateName}SchemaV${k}, initialState: ${v.phStateName}SchemaV${k} })`;
+	}).join(", ")} }`;
+}
 /**
- * WARNING: DO NOT EDIT
- * This file is auto-generated and updated by codegen
- */
-import {
-  BaseDocumentHeaderSchema,
-  BaseDocumentStateSchema,
-} from "document-model";
-import { z } from "zod";
-import { ${v.documentTypeVariableName} } from "./document-type.js";
-import { ${v.stateSchemaName} } from "./schema/zod.js";
-import type { ${v.phDocumentTypeName}, ${v.phStateName} } from "./types.js";
+* Version-aware validators are only emitted for versions with released
+* predecessors: a document is validated against the schema of the version it
+* is stamped with, so a later version may add non-nullable fields without
+* rejecting documents that have not been upgraded yet.
+*/
+function makeVersionAwareValidators(v) {
+	return `
+const ${v.phStateName}SchemasByVersion: Record<number, z.ZodType> = ${makeStateSchemasByVersion(v.versions, v.version, v.phStateName)};
 
-/** Schema for validating the header object of a ${v.pascalCaseDocumentType} document */
-export const ${v.phDocumentTypeName}HeaderSchema = BaseDocumentHeaderSchema.extend({
-  documentType: z.literal(${v.documentTypeVariableName}),
-});
+const ${v.phDocumentSchemaName}sByVersion: Record<number, z.ZodType> = ${makeDocumentSchemasByVersion(v.versions, v.version, v)};
 
-/** Schema for validating the state object of a ${v.pascalCaseDocumentType} document */
-export const ${v.phStateName}Schema = BaseDocumentStateSchema.extend({
-  global: ${v.stateSchemaName}(),
-});
+/** The document model version stamped in a state's document scope. States stamped with 0 or nothing predate versioning and are treated as version 1. */
+function stampedDocumentModelVersion(state: unknown): number {
+  if (typeof state !== "object" || state === null) return 1;
+  const documentScope = (state as { document?: unknown }).document;
+  if (typeof documentScope !== "object" || documentScope === null) return 1;
+  const version = (documentScope as { version?: unknown }).version;
+  return normalizeDocumentModelVersion(typeof version === "number" ? version : undefined);
+}
 
-export const ${v.phDocumentSchemaName} = z.object({
-  header: ${v.phDocumentTypeName}HeaderSchema,
-  state: ${v.phStateName}Schema,
-  initialState: ${v.phStateName}Schema,
-});
+function resolve${v.phStateName}Schema(state: unknown): z.ZodType {
+  const schema = ${v.phStateName}SchemasByVersion[stampedDocumentModelVersion(state)];
+  return schema ?? ${v.phStateName}Schema;
+}
+
+function resolve${v.phDocumentSchemaName}(document: unknown): z.ZodType {
+  const state = typeof document === "object" && document !== null
+    ? (document as { state?: unknown }).state
+    : undefined;
+  const schema = ${v.phDocumentSchemaName}sByVersion[stampedDocumentModelVersion(state)];
+  return schema ?? ${v.phDocumentSchemaName};
+}
+
+/** Simple helper function to check if a state object is a ${v.pascalCaseDocumentType} document state object. Validates against the schema of the version the state is stamped with. */
+export function ${v.isPhStateOfTypeFunctionName}(
+  state: unknown,
+): state is ${v.phStateName} {
+  return resolve${v.phStateName}Schema(state).safeParse(state).success;
+}
+
+/** Simple helper function to assert that a document state object is a ${v.pascalCaseDocumentType} document state object. Validates against the schema of the version the state is stamped with. */
+export function ${v.assertIsPhStateOfTypeFunctionName}(
+  state: unknown,
+): asserts state is ${v.phStateName} {
+  resolve${v.phStateName}Schema(state).parse(state);
+}
+
+/** Simple helper function to check if a document is a ${v.pascalCaseDocumentType} document. Validates against the schema of the version the document is stamped with, so documents on older versions remain valid until they are upgraded. */
+export function ${v.isPhDocumentOfTypeFunctionName}(
+  document: unknown,
+): document is ${v.phDocumentTypeName} {
+  return resolve${v.phDocumentSchemaName}(document).safeParse(document).success;
+}
 
+/** Simple helper function to assert that a document is a ${v.pascalCaseDocumentType} document. Validates against the schema of the version the document is stamped with, so documents on older versions remain valid until they are upgraded. */
+export function ${v.assertIsPhDocumentOfTypeFunctionName}(
+  document: unknown,
+): asserts document is ${v.phDocumentTypeName} {
+  resolve${v.phDocumentSchemaName}(document).parse(document);
+}
+`;
+}
+function makeSingleVersionValidators(v) {
+	return `
 /** Simple helper function to check if a state object is a ${v.pascalCaseDocumentType} document state object */
 export function ${v.isPhStateOfTypeFunctionName}(
   state: unknown,
@@ -5242,7 +5320,42 @@ export function ${v.assertIsPhDocumentOfTypeFunctionName}(
 ): asserts document is ${v.phDocumentTypeName} {
   ${v.phDocumentSchemaName}.parse(document);
 }
-`.raw;
+`;
+}
+const documentModelDocumentSchemaFileTemplate = (v) => {
+	const olderImports = makeOlderStateSchemaImports(v.versions, v.version, v.phStateName);
+	const hasPriorVersions = olderImports.length > 0;
+	return ts$1`
+/**
+ * WARNING: DO NOT EDIT
+ * This file is auto-generated and updated by codegen
+ */
+import {
+  BaseDocumentHeaderSchema,
+  BaseDocumentStateSchema,${hasPriorVersions ? "\n  normalizeDocumentModelVersion," : ""}
+} from "document-model";
+import { z } from "zod";
+import { ${v.documentTypeVariableName} } from "./document-type.js";
+import { ${v.stateSchemaName} } from "./schema/zod.js";
+import type { ${v.phDocumentTypeName}, ${v.phStateName} } from "./types.js";
+${hasPriorVersions ? olderImports + "\n" : ""}
+/** Schema for validating the header object of a ${v.pascalCaseDocumentType} document */
+export const ${v.phDocumentTypeName}HeaderSchema = BaseDocumentHeaderSchema.extend({
+  documentType: z.literal(${v.documentTypeVariableName}),
+});
+
+/** Schema for validating the state object of a ${v.pascalCaseDocumentType} document */
+export const ${v.phStateName}Schema = BaseDocumentStateSchema.extend({
+  global: ${v.stateSchemaName}(),
+});
+
+export const ${v.phDocumentSchemaName} = z.object({
+  header: ${v.phDocumentTypeName}HeaderSchema,
+  state: ${v.phStateName}Schema,
+  initialState: ${v.phStateName}Schema,
+});
+${hasPriorVersions ? makeVersionAwareValidators(v) : makeSingleVersionValidators(v)}`.raw;
+};
 //#endregion
 //#region src/templates/document-model/gen/document-type.ts
 const documentModelDocumentTypeTemplate = (v) => ts$1`
@@ -6198,7 +6311,7 @@ const documentModelOperationsModuleTestFileTemplate = (v) => ts$1`
  */
 
 import { describe, it, expect } from 'vitest';
-import { generateMock } from 'document-model';
+import { generateMock } from 'document-model/mock';
 import {
   reducer,
   utils,
@@ -6231,11 +6344,66 @@ const upgradeManifestTemplate = (v) => ts$1`
   `.raw;
 //#endregion
 //#region src/templates/document-model/upgrades/upgrade-transition.ts
-const upgradeTransitionTemplate = (v) => ts$1`
+/**
+* The generated v{N}.ts upgrade transition. Written once and never
+* overwritten, so hand edits survive regeneration.
+*
+* For mechanical schema changes the migration is derived: fields added in
+* the new version are initialized (from the new version's initial value or
+* the schema's zero value) and existing data is preserved. When the change
+* cannot be derived — a field changed type, a nested type changed shape —
+* the reducer throws until the migration is hand-written: silently running
+* a no-op migration would stamp documents with a version whose schema their
+* state does not satisfy, crashing every consumer that validates them.
+*/
+const upgradeTransitionTemplate = (v) => {
+	const body = v.plan.kind === "manual" ? manualReducer(v, v.plan.reason) : fillReducer(v, v.plan.fills);
+	return ts$1`
+/**
+ * WARNING: DO NOT EDIT
+ * This file is auto-generated and updated by codegen
+ */
 import type { Action, PHDocument, UpgradeTransition } from "document-model";
 import type { ${v.phStateName} as StateV${v.version - 1} } from "${v.documentModelImportPath}/v${v.version - 1}";
 import type { ${v.phStateName} as StateV${v.version} } from "${v.documentModelImportPath}/v${v.version}";
 
+${body}
+
+export const v${v.version}: UpgradeTransition = {
+  toVersion: ${v.version},
+  upgradeReducer,
+  description: "",
+};
+`.raw;
+};
+function manualReducer(v, reason) {
+	const message = `The ${v.documentModelState.id} v${v.version} migration is not implemented: ${reason}. Implement it in document-models/${v.documentModelDirName}/upgrades/v${v.version}.ts.`;
+	return `
+/*
+ * This migration could not be derived automatically: ${reason}.
+ * Implement it (migrate BOTH state and initialState), then remove the throw.
+ */
+function upgradeReducer(
+  document: PHDocument<StateV${v.version - 1}>,
+  action: Action,
+): PHDocument<StateV${v.version}> {
+  throw new Error(${JSON.stringify(message)});
+}
+`;
+}
+function fillReducer(v, fills) {
+	const fillConsts = [];
+	const scopeLines = (source) => ["global", "local"].filter((scope) => fills[scope]).map((scope) => `      ${scope}: { ...added${capitalize$1(scope)}Fields, ...document.${source}.${scope} },`).join("\n");
+	for (const scope of ["global", "local"]) {
+		const fill = fills[scope];
+		if (!fill) continue;
+		fillConsts.push(`const added${capitalize$1(scope)}Fields = ${JSON.stringify(fill, null, 2)} satisfies Partial<StateV${v.version}["${scope}"]>;`);
+	}
+	if (fillConsts.length === 0) return `
+/*
+ * No fields were added between v${v.version - 1} and v${v.version}, so existing state
+ * carries over unchanged.
+ */
 function upgradeReducer(
   document: PHDocument<StateV${v.version - 1}>,
   action: Action,
@@ -6244,13 +6412,37 @@ function upgradeReducer(
     ...document,
   };
 }
+`;
+	return `
+${fillConsts.join("\n\n")}
 
-export const v${v.version}: UpgradeTransition = {
-  toVersion: ${v.version},
-  upgradeReducer,
-  description: "",
-};
-`.raw;
+/*
+ * Fields added in v${v.version} are initialized from the new version's initial
+ * value (or the schema's zero value); existing data wins for every field
+ * that already existed. Both state and initialState are migrated so a
+ * rebuild from the operation log converges with the stored state.
+ */
+function upgradeReducer(
+  document: PHDocument<StateV${v.version - 1}>,
+  action: Action,
+): PHDocument<StateV${v.version}> {
+  return {
+    ...document,
+    state: {
+      ...document.state,
+${scopeLines("state")}
+    },
+    initialState: {
+      ...document.initialState,
+${scopeLines("initialState")}
+    },
+  };
+}
+`;
+}
+function capitalize$1(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
 //#endregion
 //#region src/templates/document-model/utils.ts
 const documentModelUtilsTemplate = ({ phStateName, pascalCaseDocumentType }) => ts$1`
@@ -6268,9 +6460,23 @@ export const utils: DocumentModelUtils<${phStateName}> = { ...genUtils, ...custo
 `.raw;
 //#endregion
 //#region src/templates/processors/utils.ts
-function getDocumentType(documentTypes) {
-	if (!documentTypes.length) return `"*"`;
-	return documentTypes.map((type) => `"${type}"`).join(", ");
+const FILTER_FIELD_ORDER = [
+	"branch",
+	"documentId",
+	"documentType",
+	"scope"
+];
+/** Splits, trims and compacts one filter field, so `-t a -t b` and
+* `-t "a,b"` mean the same thing instead of the latter yielding one value. */
+function parseFilterValues(values) {
+	return (values ?? []).flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+}
+/** Renders a generated factory's `ProcessorFilter`, omitting empty fields:
+* only `documentId` honours `"*"`, so `["*"]` elsewhere matches nothing. */
+function renderProcessorFilter(fields) {
+	const properties = FILTER_FIELD_ORDER.map((name) => [name, parseFilterValues(fields[name])]).filter(([, values]) => values.length > 0).map(([name, values]) => `  ${name}: [${values.map((value) => `"${value}"`).join(", ")}],`);
+	if (properties.length === 0) return "{}";
+	return `{\n${properties.join("\n")}\n}`;
 }
 //#endregion
 //#region src/templates/processors/analytics/factory.ts
@@ -6288,12 +6494,12 @@ export const ${v.camelCaseName}FactoryBuilder: ProcessorFactoryBuilder = (module
   return [
     {
       processor: new ${v.pascalCaseName}(module.analyticsStore),
-      filter: {
-        branch: ["main"],
-        documentId: ["*"],
-        scope: ["*"],
-        documentType: [${getDocumentType(v.documentTypes)}],
-      },
+      // An omitted field matches every value. Only \`documentId\` honours "*".
+      filter: ${renderProcessorFilter({
+	branch: ["main"],
+	documentId: ["*"],
+	documentType: v.documentTypes
+})},
     },
   ];
 }
@@ -6347,7 +6553,7 @@ const factoryBuildersTemplate = ts$1`
  * WARNING: DO NOT EDIT
  * This file is auto-generated and updated by codegen
  */
-import type { ProcessorFactoryBuilder } from "@powerhousedao/reactor";
+import type { ProcessorFactoryBuilder } from "@powerhousedao/reactor-browser";
 
 export const processorFactoryBuilders: ProcessorFactoryBuilder[] = [];
 `.raw;
@@ -6421,16 +6627,22 @@ export const ${v.camelCaseName}FactoryBuilder: ProcessorFactoryBuilder = (module
     namespace,
   );
 
-  // Create a filter for the processor
-  const filter: ProcessorFilter = {
-    branch: ["main"],
-    documentId: ["*"],
-    documentType: [${getDocumentType(v.documentTypes)}],
-    scope: ["global"],
-  };
+  // Create a filter for the processor. An omitted field matches every value.
+  // Only \`documentId\` honours "*", so "*" elsewhere would match nothing.
+  const filter: ProcessorFilter = ${renderProcessorFilter({
+	branch: ["main"],
+	documentId: ["*"],
+	documentType: v.documentTypes,
+	scope: ["global"]
+})};
 
   // Create the processor
   const processor = new ${v.pascalCaseName}(namespace, filter, store);
+
+  // Run the processor's migrations. Nothing in the runtime calls this, so
+  // without it the first write hits a database with no tables.
+  await processor.initAndUpgrade();
+
   return [
     {
       processor,
@@ -6659,8 +6871,47 @@ async function formatSafe(sourceText, parser = "typescript") {
 		return sourceText;
 	}
 }
+/**
+* Formats the current working directory with the pinned oxfmt version.
+* The pin matters when the project was scaffolded with skipInstall: with no
+* local oxfmt, a bare `npx oxfmt` downloads the latest release, whose
+* behavior can drift from the version the boilerplate depends on.
+*/
 async function runOxfmt() {
-	await spawnAsync("npx", ["oxfmt", "."]);
+	await spawnAsync("npx", [`oxfmt@${externalDevDependencies.oxfmt}`, "."]);
+}
+//#endregion
+//#region src/utils/generate-mock-import.ts
+const GENERATE_MOCK_NAME = "generateMock";
+const GENERATE_MOCK_MODULE_SPECIFIER = "document-model/mock";
+/**
+* Points every `generateMock` import at its subpath. An import that also
+* brings in other names keeps them where they are and gets a separate
+* `generateMock` import added.
+*/
+function fixGenerateMockImports(sourceFile) {
+	for (const importDeclaration of sourceFile.getImportDeclarations()) {
+		const namedImports = importDeclaration.getNamedImports();
+		const generateMockSpecifier = namedImports.find((namedImport) => namedImport.getName() === GENERATE_MOCK_NAME);
+		if (!generateMockSpecifier) continue;
+		if (importDeclaration.getModuleSpecifierValue() === "document-model/mock") continue;
+		if (namedImports.length === 1 && !importDeclaration.getDefaultImport() && !importDeclaration.getNamespaceImport()) {
+			importDeclaration.setModuleSpecifier(GENERATE_MOCK_MODULE_SPECIFIER);
+			continue;
+		}
+		const alias = generateMockSpecifier.getAliasNode()?.getText();
+		generateMockSpecifier.remove();
+		sourceFile.addImportDeclaration({
+			namedImports: [{
+				name: GENERATE_MOCK_NAME,
+				alias
+			}],
+			moduleSpecifier: GENERATE_MOCK_MODULE_SPECIFIER
+		});
+	}
+}
+function hasGenerateMockImport(sourceFile) {
+	return sourceFile.getImportDeclarations().some((importDeclaration) => importDeclaration.getNamedImports().some((namedImport) => namedImport.getName() === GENERATE_MOCK_NAME));
 }
 //#endregion
 //#region src/utils/get-editor-metadata.ts
@@ -6713,20 +6964,52 @@ function getSubgraphMetadata(project, dirName) {
 //#region src/utils/source-files.ts
 /** Gets a SourceFile by name in a ts-morph Project, or creates a new one
 * if none with that path exists.
+*
+* "Exists" has to mean *on disk*, not merely "already loaded in this Project".
+* Projects here are built with `skipAddingFilesFromTsConfig` (see
+* `buildTsMorphProject`), so they start empty and `getSourceFile` alone reports
+* every existing file as missing. Combined with `overwrite: true` that silently
+* discarded whatever the user had written — `alreadyExists` was always `false`,
+* so builders that scaffold-once-then-amend (tests, reducers, subgraphs,
+* editors, processors) re-scaffolded from scratch on every run and hand-written
+* code was lost on `project.save()`.
+*
+* Reading the file in when it is on disk but not yet loaded mirrors what
+* `DirectoryManager.createSourceFile` already does. Files that codegen fully
+* owns are unaffected: they call `replaceWithText` immediately afterwards.
+*
+* The rule has to hold on the cache-hit path too, which is the other half of
+* the same data loss. `ph vetra` builds one Project per process and reuses it
+* for every codegen run, and nothing ever refreshes it, so a SourceFile loaded
+* by an earlier run keeps the text it had then: codegen scaffolds a reducer
+* with TODO stubs, the user writes the real body on disk, and the next run in
+* that session still sees the stubs and writes them back on `project.save()`.
+* A fresh process (`ph generate`) never hit this — the cache miss forced a read
+* from disk. Refreshing a cached SourceFile before handing it out makes the
+* long-lived Project behave like a fresh one. Only cached files are refreshed;
+* `addSourceFileAtPathIfExists` has just read disk, so refreshing that again
+* would be I/O for a guaranteed `NoChange`.
 */
 function getOrCreateSourceFile(project, filePath) {
 	const dirName = path.dirname(filePath);
 	if (!project.getDirectory(dirName)) project.createDirectory(dirName);
-	const sourceFile = project.getSourceFile(filePath);
+	const cachedSourceFile = project.getSourceFile(filePath);
+	const sourceFile = cachedSourceFile ? refreshCachedSourceFile(cachedSourceFile) : project.addSourceFileAtPathIfExists(filePath);
 	if (!sourceFile) return {
 		alreadyExists: false,
-		sourceFile: project.createSourceFile(filePath, "", { overwrite: true })
+		sourceFile: project.createSourceFile(filePath, "", { overwrite: false })
 	};
 	return {
 		alreadyExists: true,
 		sourceFile
 	};
 }
+/** Re-reads a cached SourceFile from disk, `undefined` once it is gone from
+* disk (ts-morph forgets it then, so the caller re-creates it). */
+function refreshCachedSourceFile(sourceFile) {
+	if (!sourceFile.isSaved()) return sourceFile;
+	return sourceFile.refreshFromFileSystemSync() === FileSystemRefreshResult.Deleted ? void 0 : sourceFile;
+}
 /** Gets a Directory by name in a ts-morph Project, or creates a new one
 * if none with that path exists.
 */
@@ -7249,7 +7532,7 @@ async function writeAiConfigFiles(projectDir = process.cwd()) {
 	await writeFileEnsuringDir(join(projectDir, ".cursor/mcp.json"), cursorMcpTemplate.trimStart());
 	await writeFileEnsuringDir(join(projectDir, ".claude/settings.local.json"), claudeSettingsLocalTemplate.trimStart());
 }
-async function writeProjectRootFiles(args, projectDir = process.cwd()) {
+async function writeProjectRootFiles(args, _projectDir = process.cwd()) {
 	const { name, tag, version, remoteDrive, packageManager } = args;
 	await writeFileEnsuringDir("LICENSE", licenseTemplate);
 	await writeFileEnsuringDir("README.md", readmeTemplate);
@@ -7261,15 +7544,12 @@ async function writeProjectRootFiles(args, projectDir = process.cwd()) {
 		version
 	});
 	await writeFileEnsuringDir("powerhouse.config.json", await buildPowerhouseConfigTemplate({
+		name,
 		tag,
 		version,
 		remoteDrive
 	}));
 	await writeFileEnsuringDir("package.json", packageJson);
-	await applyProjectCustomizations({
-		name,
-		projectDir
-	});
 }
 /**
 * Per-project customizations applied to a project directory — the parts
@@ -7286,14 +7566,32 @@ async function applyProjectCustomizations(args) {
 	pkg.name = name;
 	await writeJsonFile(pkgPath, pkg, { indent: 2 });
 	await createOrUpdateManifest({ name }, projectDir);
+	const ports = deriveProjectPorts(name);
+	const configPath = join(projectDir, "powerhouse.config.json");
+	const config = await loadJsonFile(configPath);
+	config.studio = {
+		...config.studio,
+		port: ports.studioPort
+	};
+	config.reactor = {
+		...config.reactor,
+		port: ports.switchboardPort
+	};
+	const vetra = {
+		...config.vetra,
+		connectPort: ports.vetraConnectPort
+	};
 	if (remoteDrive) {
-		const configPath = join(projectDir, "powerhouse.config.json");
-		const config = await loadJsonFile(configPath);
-		config.vetra = {
-			driveId: remoteDrive.split("/").pop() ?? "",
-			driveUrl: remoteDrive
-		};
-		await writeJsonFile(configPath, config, { indent: 2 });
+		vetra.driveId = remoteDrive.split("/").pop() ?? "";
+		vetra.driveUrl = remoteDrive;
+	}
+	config.vetra = vetra;
+	await writeJsonFile(configPath, config, { indent: 2 });
+	const mcpFiles = [[".mcp.json", buildMcpTemplate(ports.switchboardPort)], [join(".cursor", "mcp.json"), buildCursorMcpTemplate(ports.switchboardPort)]];
+	for (const [rel, contents] of mcpFiles) {
+		const target = join(projectDir, rel);
+		if (!existsSync(target)) continue;
+		await writeFileEnsuringDir(target, contents.trimStart());
 	}
 }
 async function writeCIFiles(projectDir = process.cwd()) {
@@ -7453,7 +7751,9 @@ const DATE_LIKE_SCALARS = new Set(["Date", "DateTime"]);
 const SCALAR_MOCK_OVERRIDES = {
 	Date: `"2024-01-01T00:00:00.000Z"`,
 	DateTime: `"2024-01-01T00:00:00.000Z"`,
-	URL: `"https://example.com"`
+	URL: `"https://example.com"`,
+	AttachmentRef: `"attachment://v1:${"a".repeat(64)}"`,
+	Address: `"eip155:0x${"0".repeat(40)}"`
 };
 function unwrapNamedTypeName(type) {
 	if (type.kind === Kind.NAMED_TYPE) return type.name.value;
@@ -7803,8 +8103,8 @@ async function makeReducerOperationHandlerForModule({ project, module, version,
 	const operationsInterfaceTypeName = `${pascalCaseDocumentType}${pascalCaseModuleName}Operations`;
 	const operationsInterfaceVariableName = `${camelCaseDocumentType}${pascalCaseModuleName}Operations`;
 	const existingOperationsInterfaceTypeImport = sourceFile.getImportDeclaration((importDeclaration) => !!importDeclaration.getNamedImports().find((importSpecifier) => importSpecifier.getName() === operationsInterfaceTypeName));
-	if (existingOperationsInterfaceTypeImport) existingOperationsInterfaceTypeImport.remove();
-	sourceFile.addImportDeclaration({
+	if (existingOperationsInterfaceTypeImport) existingOperationsInterfaceTypeImport.setModuleSpecifier(versionImportPath);
+	else sourceFile.addImportDeclaration({
 		namedImports: [operationsInterfaceTypeName],
 		moduleSpecifier: versionImportPath,
 		isTypeOnly: true
@@ -7915,7 +8215,7 @@ async function makeOperationModuleTestFile(args) {
 				version
 			});
 		} else sourceFile.replaceWithText(ts$1`
-        import { generateMock } from "document-model";
+        import { generateMock } from "document-model/mock";
         import { describe, expect, it } from "vitest";
 
         describe("${moduleOperationsTypeName}", () => {
@@ -7967,13 +8267,13 @@ async function makeOperationModuleTestFile(args) {
 		})));
 	}));
 	describeCallBody.addStatements(testCasesToAdd);
-	const GENERATE_MOCK_NAME = "generateMock";
-	const GENERATE_MOCK_MODULE_SPECIFIER = "document-model";
-	const generateMockImport = sourceFile.getImportDeclaration((i) => i.getNamedImports().some((v) => v.getText().includes(GENERATE_MOCK_NAME)));
-	if (sourceFile.getText().includes(GENERATE_MOCK_NAME) && !generateMockImport) sourceFile.addImportDeclaration({
-		namedImports: [GENERATE_MOCK_NAME],
-		moduleSpecifier: GENERATE_MOCK_MODULE_SPECIFIER
-	});
+	if (sourceFile.getText().includes("generateMock")) {
+		fixGenerateMockImports(sourceFile);
+		if (!hasGenerateMockImport(sourceFile)) sourceFile.addImportDeclaration({
+			namedImports: [GENERATE_MOCK_NAME],
+			moduleSpecifier: GENERATE_MOCK_MODULE_SPECIFIER
+		});
+	}
 	sourceFile.fixUnusedIdentifiers();
 	await formatSourceFileWithPrettier(sourceFile);
 }
@@ -7992,13 +8292,253 @@ async function makeDocumentModelTestFile(args) {
 	await formatSourceFileWithPrettier(sourceFile);
 }
 //#endregion
+//#region src/file-builders/document-model/upgrade-migration.ts
+/**
+* Derives the migration between two consecutive spec versions. Mechanical
+* changes — field additions on the scope's state type (initialized from the
+* new version's initial value, falling back to the schema's zero value) and
+* field removals — produce a "fill" plan. Anything else (changed field
+* types, edits to nested types that pre-existing documents reference,
+* additions codegen cannot synthesize a value for) produces a "manual" plan.
+*/
+function buildMigrationPlan(args) {
+	const { previousSpec, specification, stateName, localStateName } = args;
+	if (!previousSpec) return {
+		kind: "manual",
+		reason: "the previous specification version is not available"
+	};
+	const fills = {};
+	const scopes = [{
+		scope: "global",
+		typeName: stateName
+	}, {
+		scope: "local",
+		typeName: localStateName
+	}];
+	for (const { scope, typeName } of scopes) {
+		const oldState = previousSpec.state[scope];
+		const newState = specification.state[scope];
+		const analysis = analyzeScope({
+			oldSchema: oldState?.schema ?? "",
+			newSchema: newState?.schema ?? "",
+			newInitialValue: newState?.initialValue ?? "",
+			typeName,
+			scope
+		});
+		if (analysis.kind === "manual") return analysis;
+		if (analysis.fill && Object.keys(analysis.fill).length > 0) fills[scope] = analysis.fill;
+	}
+	return {
+		kind: "fill",
+		fills
+	};
+}
+function analyzeScope(args) {
+	const { oldSchema, newSchema, newInitialValue, typeName, scope } = args;
+	const oldDoc = safeParseSdl(oldSchema);
+	const newDoc = safeParseSdl(newSchema);
+	if (oldSchema.trim() && !oldDoc) return {
+		kind: "manual",
+		reason: `the previous ${scope} state schema could not be parsed`
+	};
+	if (newSchema.trim() && !newDoc) return {
+		kind: "manual",
+		reason: `the new ${scope} state schema could not be parsed`
+	};
+	const oldType = oldDoc ? findObjectType(oldDoc, typeName) : void 0;
+	const newType = newDoc ? findObjectType(newDoc, typeName) : void 0;
+	if (!newType || !newDoc) return {
+		kind: "fill",
+		fill: void 0
+	};
+	if (oldType && oldDoc) {
+		const oldReachable = collectReachableTypes(oldDoc, typeName);
+		for (const [name, oldDefinition] of oldReachable) {
+			if (name === typeName) continue;
+			const newDefinition = findTypeDefinition(newDoc, name);
+			if (!newDefinition) continue;
+			if (print(oldDefinition) !== print(newDefinition)) return {
+				kind: "manual",
+				reason: `the ${scope} state type "${name}" changed between versions`
+			};
+		}
+	}
+	const oldFields = new Map((oldType?.fields ?? []).map((field) => [field.name.value, field]));
+	const newFields = newType.fields ?? [];
+	const initialValueObject = safeParseJsonRecord(newInitialValue);
+	const fill = {};
+	for (const field of newFields) {
+		const fieldName = field.name.value;
+		const oldField = oldFields.get(fieldName);
+		if (oldField) {
+			if (print(oldField.type) !== print(field.type)) return {
+				kind: "manual",
+				reason: `the ${scope} state field "${fieldName}" changed type between versions`
+			};
+			continue;
+		}
+		if (initialValueObject && fieldName in initialValueObject) {
+			fill[fieldName] = initialValueObject[fieldName];
+			continue;
+		}
+		const zero = zeroValueForType(field.type, newDoc, /* @__PURE__ */ new Set());
+		if (!zero.ok) return {
+			kind: "manual",
+			reason: `no initial value could be derived for the added ${scope} state field "${fieldName}"`
+		};
+		fill[fieldName] = zero.value;
+	}
+	return {
+		kind: "fill",
+		fill
+	};
+}
+function zeroValueForType(typeNode, schemaDoc, visitedTypes) {
+	if (typeNode.kind !== Kind.NON_NULL_TYPE) return {
+		ok: true,
+		value: null
+	};
+	const inner = typeNode.type;
+	if (inner.kind === Kind.LIST_TYPE) return {
+		ok: true,
+		value: []
+	};
+	const name = inner.name.value;
+	switch (name) {
+		case "String":
+		case "ID": return {
+			ok: true,
+			value: ""
+		};
+		case "Int":
+		case "Float": return {
+			ok: true,
+			value: 0
+		};
+		case "Boolean": return {
+			ok: true,
+			value: false
+		};
+	}
+	const definition = findTypeDefinition(schemaDoc, name);
+	if (!definition) {
+		const defaultValue = getPHCustomScalarByTypeName(name)?.getDefaultValue?.();
+		if (defaultValue !== void 0) return {
+			ok: true,
+			value: defaultValue
+		};
+		return { ok: false };
+	}
+	if (definition.kind === Kind.ENUM_TYPE_DEFINITION) return zeroValueForEnum(definition);
+	if (definition.kind === Kind.OBJECT_TYPE_DEFINITION) {
+		if (visitedTypes.has(name)) return { ok: false };
+		visitedTypes.add(name);
+		const value = {};
+		for (const field of definition.fields ?? []) {
+			const fieldZero = zeroValueForType(field.type, schemaDoc, visitedTypes);
+			if (!fieldZero.ok) return { ok: false };
+			value[field.name.value] = fieldZero.value;
+		}
+		visitedTypes.delete(name);
+		return {
+			ok: true,
+			value
+		};
+	}
+	if (definition.kind === Kind.SCALAR_TYPE_DEFINITION) {
+		const defaultValue = getPHCustomScalarByTypeName(name)?.getDefaultValue?.();
+		if (defaultValue !== void 0) return {
+			ok: true,
+			value: defaultValue
+		};
+		return { ok: false };
+	}
+	return { ok: false };
+}
+function zeroValueForEnum(definition) {
+	const first = definition.values?.[0]?.name.value;
+	if (first === void 0) return { ok: false };
+	return {
+		ok: true,
+		value: first
+	};
+}
+function collectReachableTypes(schemaDoc, rootTypeName) {
+	const reachable = /* @__PURE__ */ new Map();
+	const queue = [rootTypeName];
+	while (queue.length > 0) {
+		const name = queue.shift();
+		if (reachable.has(name)) continue;
+		const definition = findTypeDefinition(schemaDoc, name);
+		if (!definition) continue;
+		reachable.set(name, definition);
+		if (definition.kind === Kind.OBJECT_TYPE_DEFINITION) for (const field of definition.fields ?? []) queue.push(namedTypeOf(field.type));
+		else if (definition.kind === Kind.UNION_TYPE_DEFINITION) for (const member of definition.types ?? []) queue.push(member.name.value);
+	}
+	return reachable;
+}
+function namedTypeOf(typeNode) {
+	let node = typeNode;
+	while (node.kind !== Kind.NAMED_TYPE) node = node.type;
+	return node.name.value;
+}
+function findObjectType(schemaDoc, name) {
+	const definition = findTypeDefinition(schemaDoc, name);
+	return definition?.kind === Kind.OBJECT_TYPE_DEFINITION ? definition : void 0;
+}
+function findTypeDefinition(schemaDoc, name) {
+	for (const definition of schemaDoc.definitions) switch (definition.kind) {
+		case Kind.OBJECT_TYPE_DEFINITION:
+		case Kind.ENUM_TYPE_DEFINITION:
+		case Kind.SCALAR_TYPE_DEFINITION:
+		case Kind.UNION_TYPE_DEFINITION:
+		case Kind.INTERFACE_TYPE_DEFINITION:
+		case Kind.INPUT_OBJECT_TYPE_DEFINITION: if (definition.name.value === name) return definition;
+	}
+}
+function safeParseSdl(sdl) {
+	if (!sdl.trim()) return null;
+	try {
+		return parse(sdl);
+	} catch {
+		return null;
+	}
+}
+function safeParseJsonRecord(json) {
+	if (!json.trim()) return null;
+	try {
+		const parsed = JSON.parse(json);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Serializes a fill value to TypeScript source. Fill values come from JSON
+* (initial values) or the zero-value synthesizer, so JSON serialization is
+* sufficient.
+*/
+function fillToTsLiteral(fill) {
+	return JSON.stringify(fill, null, 2);
+}
+//#endregion
 //#region src/file-builders/document-model/upgrades-dir.ts
 async function makeUpgradeFile(args) {
 	const { project, version, upgradesDirPath } = args;
 	if (version < 2) return;
 	const { alreadyExists, sourceFile } = getOrCreateSourceFile(project, path.join(upgradesDirPath, `v${version}.ts`));
 	if (alreadyExists) return;
-	const template = upgradeTransitionTemplate(args);
+	const plan = buildMigrationPlan({
+		previousSpec: args.documentModelState.specifications.find((specification) => specification.version === version - 1),
+		specification: args.specification,
+		stateName: args.stateName,
+		localStateName: args.localStateName
+	});
+	const template = upgradeTransitionTemplate({
+		...args,
+		plan
+	});
 	sourceFile.replaceWithText(template);
 	await formatSourceFileWithPrettier(sourceFile);
 }
@@ -8280,6 +8820,10 @@ async function makeDocumentModelsIndexFile(args) {
 			moduleSpecifier
 		});
 	}));
+	sourceFile.addExportDeclaration({
+		namedExports: ["upgradeManifests"],
+		moduleSpecifier: "./upgrade-manifests.js"
+	});
 	await formatSourceFileWithPrettier(sourceFile);
 }
 /** Writes a json file derived from a `documentModelState` */
@@ -8592,6 +9136,29 @@ function getFactoryBuildersArray(sourceFile, name) {
 	return sourceFile.getDescendantsOfKind(ts.SyntaxKind.VariableStatement).flatMap((d) => d.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration)).find((d) => d.getName() === name)?.getDescendantsOfKind(ts.SyntaxKind.ArrayLiteralExpression).at(0);
 }
 //#endregion
+//#region src/file-builders/project-index.ts
+const AI_TOOLS_MODULE_SPECIFIER = "./ai/tools.js";
+/**
+* Idempotently syncs the optional `aiTools` export in the project's root
+* `index.ts`: the line is present if and only if `ai/tools.ts` exists.
+* The export is how the host app (Connect) discovers the tool descriptors
+* this package offers to the in-browser AI assistant.
+*/
+function syncProjectAiToolsExport(project) {
+	const { directory: documentModelsDir } = getOrCreateDirectory(project, "document-models");
+	const projectDir = documentModelsDir.getParentOrThrow().getPath();
+	const indexPath = join$1(projectDir, "index.ts");
+	if (!existsSync(indexPath)) return;
+	const { sourceFile } = getOrCreateSourceFile(project, indexPath);
+	const hasAiToolsFile = existsSync(join$1(projectDir, "ai", "tools.ts"));
+	const existing = sourceFile.getExportDeclarations().find((declaration) => declaration.getModuleSpecifier()?.getText().trim() === `"${AI_TOOLS_MODULE_SPECIFIER}"` && declaration.getNamedExports().some((exported) => exported.getText() === "aiTools"));
+	if (hasAiToolsFile && !existing) sourceFile.addExportDeclarations([{
+		namedExports: ["aiTools"],
+		moduleSpecifier: AI_TOOLS_MODULE_SPECIFIER
+	}]);
+	else if (!hasAiToolsFile && existing) existing.remove();
+}
+//#endregion
 //#region src/file-builders/subgraphs.ts
 async function tsMorphGenerateSubgraph(args) {
 	const { subgraphName, project } = args;
@@ -8658,6 +9225,6 @@ async function makeSubgraphsIndexFile(args) {
 	await formatSourceFileWithPrettier(sourceFile);
 }
 //#endregion
-export { getVariableDeclarationByTypeName as $, documentModelsTemplate as $n, documentModelOperationsModuleErrorFileTemplate as $t, writeGeneratedProcessorsFiles as A, buildPowerhouseConfigTemplate as An, factoryBuildersTemplate as At, updateVersionedImports as B, reactorTsTemplate as Bn, makeTestCaseForOperation as Bt, buildBoilerplatePackageJson as C, vitestConfigTemplate as Cn, relationalDbSchemaTemplate as Ct, writeCIFiles as D, styleTemplate as Dn, relationalDbFactoryTemplate as Dt, writeAllGeneratedProjectFiles as E, subgraphsIndexTemplate as En, relationalDbIndexTemplate as Et, tsMorphGenerateApp as F, packageJsonTemplate as Fn, upgradeTransitionTemplate as Ft, getAllImportModuleSpecifiers as G, syncAndPublishWorkflowTemplate as Gn, documentModelIndexTemplate as Gt, DEFAULT_PROJECT_OPTIONS as H, legacyIndexHtmlTemplate as Hn, documentModelSrcUtilsTemplate as Ht, makeEditorModuleFile as I, npmrcTemplate as In, upgradeManifestTemplate as It, getObjectLiteral as J, oxlintConfigTemplate as Jn, documentModelGenTypesTemplate as Jt, getAllImportNames as K, geminiSettingsTemplate as Kn, documentModelHooksFileTemplate as Kt, makeEditorsFile as L, mcpTemplate as Ln, documentModelOperationsModuleTestFileTemplate as Lt, writeGeneratedSubgraphsFiles as M, packageJsonScriptsTemplate as Mn, analyticsIndexTemplate as Mt, writeModuleFiles as N, pnpmWorkspaceTemplate as Nn, analyticsFactoryTemplate as Nt, writeGeneratedDocumentModelsFiles as O, readmeTemplate as On, processorsIndexTemplate as Ot, writeProjectRootFiles as P, exportsTemplate as Pn, documentModelUtilsTemplate as Pt, getStringPropertyValue as Q, documentModelsIndexTemplate as Qn, documentModelOperationsModuleOperationsFileTemplate as Qt, makeEditorsIndexFile as R, mainTsxTemplate as Rn, makeOperationImportNames as Rt, writeCliDocsMarkdownFile as S, docsFromCliHelpTemplate as Sn, subgraphIndexFileTemplate as St, writeAiConfigFiles as T, tsconfigPathsTemplate as Tn, relationalDbMigrationsTemplate as Tt, buildTsMorphProject as U, indexHtmlTemplate as Un, documentModelSrcIndexFileTemplate as Ut, getInitialStates as V, indexTsTemplate as Vn, documentModelTestFileTemplate as Vt, getDefaultProjectOptions as W, gitIgnoreTemplate as Wn, documentModelModuleFileTemplate as Wt, getProperyAssignmentByName as X, editorsTemplate as Xn, documentModelGenReducerFileTemplate as Xt, getObjectProperty as Y, editorsIndexTemplate as Yn, documentModelSchemaIndexTemplate as Yt, getStringArrayPropertyElements as Z, upgradeManifestsTemplate as Zn, documentModelPhFactoriesFileTemplate as Zt, scalarsValidation as _, documentModelGenControllerFileTemplate as _n, parseArgs as _t, getOrCreateManifestFile as a, getDocumentModelVariableNames as an, claudeSettingsLocalTemplate as ar, getOrCreateSourceFile as at, getCommandsHelpInfo as b, documentEditorModuleFileTemplate as bn, customSubgraphSchemaTemplate as bt, operationHasEmptyInput as c, getLatestDocumentModelSpecVersionNumber as cn, appConfigFileTemplate as cr, getProcessorMetadata as ct, generateDocumentModelZodSchemas as d, getActionType as dn, appFoldersFileTemplate as dr, formatSafe as dt, documentModelOperationsModuleCreatorsFileTemplate as en, switchboardEntrypointTemplate as er, loadDocumentModelInDir as et, generateTypesAndZodSchemasFromGraphql as f, getActionTypeName as fn, appFilesFileTemplate as fr, formatSourceFileWithPrettier as ft, scalars as g, documentModelGenCreatorsFileTemplate as gn, createDocumentFileTemplate as gr, configSpec as gt, getMockOverrideFieldNames as h, documentModelDocumentSchemaFileTemplate as hn, appDriveContentsFileTemplate as hr, documentModelDocumentTypeMetadata as ht, createOrUpdateManifest as i, getDocumentModelSpecByVersionNumber as in, cursorMcpTemplate as ir, getOrCreateDirectory as it, writeGeneratedProjectRootFiles as j, packageJsonExportsTemplate as jn, analyticsProcessorTemplate as jt, writeGeneratedEditorsFiles as k, ManifestTemplate as kn, processorsFactoryTemplate as kt, operationHasInput as l, getActionInputName as ln, driveExplorerNavigationBreadcrumbsFileTemplate as lr, getAppMetadata as lt, getInputFieldNames as m, documentModelDocumentTypeTemplate as mn, driveExplorerFileTemplate as mr, getDocumentTypeMetadata as mt, tsMorphGenerateSubgraph as n, getModuleExportType as nn, dockerfileTemplate as nr, buildStringLiteral as nt, pruneManifestSection as o, getEditorVariableNames as on, agentsTemplate as or, getPreviousVersionSourceFile as ot, getDateLikeFieldNames as p, documentModelGenIndexFileTemplate as pn, emptyStateFileTemplate as pr, runOxfmt as pt, getBooleanPropertyValue as q, oxfmtConfigTemplate as qn, documentModelGenUtilsTemplate as qt, tsMorphGenerateProcessor as r, getDocumentModelDirName as rn, connectEntrypointTemplate as rr, ensureDirectoriesExist as rt, makeModulesIndexFile as s, getLatestDocumentModelSpec as sn, appEditorFileTemplate as sr, getSubgraphMetadata as st, makeSubgraphsIndexFile as t, documentModelOperationModuleActionsFileTemplate as tn, nginxConfTemplate as tr, buildObjectLiteral as tt, tsMorphGenerateDocumentModel as u, getActionInputTypeNames as un, folderTreeFileTemplate as ur, getEditorMetadata as ut, tsMorphGenerateDocumentEditor as v, documentModelGenActionsFileTemplate as vn, parseConfig as vt, applyProjectCustomizations as w, tsConfigTemplate as wn, relationalDbProcessorTemplate as wt, makeCliDocsFromHelp as x, documentEditorEditorFileTemplate as xn, subgraphLibFileTemplate as xt, getCommandHelpInfo as y, documentModelRootActionsFileTemplate as yn, customSubgraphResolversTemplate as yt, validateDocumentModelState as z, licenseTemplate as zn, makeOperationsImports as zt };
+export { getProperyAssignmentByName as $, indexHtmlTemplate as $n, documentModelModuleFileTemplate as $t, writeCIFiles as A, documentEditorEditorFileTemplate as An, relationalDbSchemaTemplate as At, makeEditorsFile as B, packageJsonExportsTemplate as Bn, analyticsFactoryTemplate as Bt, getCommandsHelpInfo as C, documentModelDocumentTypeTemplate as Cn, appFilesFileTemplate as Cr, configSpec as Ct, applyProjectCustomizations as D, documentModelGenActionsFileTemplate as Dn, createDocumentFileTemplate as Dr, customSubgraphSchemaTemplate as Dt, buildBoilerplatePackageJson as E, documentModelGenControllerFileTemplate as En, appDriveContentsFileTemplate as Er, customSubgraphResolversTemplate as Et, writeGeneratedSubgraphsFiles as F, subgraphsIndexTemplate as Fn, processorsIndexTemplate as Ft, DEFAULT_PROJECT_OPTIONS as G, npmrcTemplate as Gn, upgradeManifestTemplate as Gt, validateDocumentModelState as H, pnpmWorkspaceTemplate as Hn, renderProcessorFilter as Ht, writeModuleFiles as I, styleTemplate as In, processorsFactoryTemplate as It, getAllImportModuleSpecifiers as J, mainTsxTemplate as Jn, makeOperationsImports as Jt, buildTsMorphProject as K, buildMcpTemplate as Kn, documentModelOperationsModuleTestFileTemplate as Kt, writeProjectRootFiles as L, readmeTemplate as Ln, factoryBuildersTemplate as Lt, writeGeneratedEditorsFiles as M, vitestConfigTemplate as Mn, relationalDbMigrationsTemplate as Mt, writeGeneratedProcessorsFiles as N, tsConfigTemplate as Nn, relationalDbIndexTemplate as Nt, writeAiConfigFiles as O, documentModelRootActionsFileTemplate as On, subgraphLibFileTemplate as Ot, writeGeneratedProjectRootFiles as P, tsconfigPathsTemplate as Pn, relationalDbFactoryTemplate as Pt, getObjectProperty as Q, legacyIndexHtmlTemplate as Qn, documentModelSrcIndexFileTemplate as Qt, tsMorphGenerateApp as R, ManifestTemplate as Rn, analyticsProcessorTemplate as Rt, getCommandHelpInfo as S, documentModelGenIndexFileTemplate as Sn, appFoldersFileTemplate as Sr, documentModelDocumentTypeMetadata as St, writeCliDocsMarkdownFile as T, documentModelGenCreatorsFileTemplate as Tn, driveExplorerFileTemplate as Tr, parseConfig as Tt, updateVersionedImports as U, exportsTemplate as Un, documentModelUtilsTemplate as Ut, makeEditorsIndexFile as V, packageJsonScriptsTemplate as Vn, parseFilterValues as Vt, getInitialStates as W, packageJsonTemplate as Wn, upgradeTransitionTemplate as Wt, getBooleanPropertyValue as X, reactorTsTemplate as Xn, documentModelTestFileTemplate as Xt, getAllImportNames as Y, licenseTemplate as Yn, makeTestCaseForOperation as Yt, getObjectLiteral as Z, indexTsTemplate as Zn, documentModelSrcUtilsTemplate as Zt, getInputFieldNames as _, getLatestDocumentModelSpecVersionNumber as _n, agentsTemplate as _r, hasGenerateMockImport as _t, createOrUpdateManifest as a, documentModelGenReducerFileTemplate as an, editorsIndexTemplate as ar, buildStringLiteral as at, scalarsValidation as b, getActionType as bn, driveExplorerNavigationBreadcrumbsFileTemplate as br, runOxfmt as bt, makeModulesIndexFile as c, documentModelOperationsModuleErrorFileTemplate as cn, documentModelsIndexTemplate as cr, getOrCreateSourceFile as ct, tsMorphGenerateDocumentModel as d, getModuleExportType as dn, nginxConfTemplate as dr, getProcessorMetadata as dt, documentModelIndexTemplate as en, gitIgnoreTemplate as er, getStringArrayPropertyElements as et, buildMigrationPlan as f, getDocumentModelDirName as fn, dockerfileTemplate as fr, getAppMetadata as ft, getDateLikeFieldNames as g, getLatestDocumentModelSpec as gn, claudeSettingsLocalTemplate as gr, fixGenerateMockImports as gt, generateTypesAndZodSchemasFromGraphql as h, getEditorVariableNames as hn, cursorMcpTemplate as hr, GENERATE_MOCK_NAME as ht, tsMorphGenerateProcessor as i, documentModelSchemaIndexTemplate as in, oxlintConfigTemplate as ir, buildObjectLiteral as it, writeGeneratedDocumentModelsFiles as j, docsFromCliHelpTemplate as jn, relationalDbProcessorTemplate as jt, writeAllGeneratedProjectFiles as k, documentEditorModuleFileTemplate as kn, subgraphIndexFileTemplate as kt, operationHasEmptyInput as l, documentModelOperationsModuleCreatorsFileTemplate as ln, documentModelsTemplate as lr, getPreviousVersionSourceFile as lt, generateDocumentModelZodSchemas as m, getDocumentModelVariableNames as mn, buildCursorMcpTemplate as mr, GENERATE_MOCK_MODULE_SPECIFIER as mt, tsMorphGenerateSubgraph as n, documentModelGenUtilsTemplate as nn, geminiSettingsTemplate as nr, getVariableDeclarationByTypeName as nt, getOrCreateManifestFile as o, documentModelPhFactoriesFileTemplate as on, editorsTemplate as or, ensureDirectoriesExist as ot, fillToTsLiteral as p, getDocumentModelSpecByVersionNumber as pn, connectEntrypointTemplate as pr, getEditorMetadata as pt, getDefaultProjectOptions as q, mcpTemplate as qn, makeOperationImportNames as qt, syncProjectAiToolsExport as r, documentModelGenTypesTemplate as rn, oxfmtConfigTemplate as rr, loadDocumentModelInDir as rt, pruneManifestSection as s, documentModelOperationsModuleOperationsFileTemplate as sn, upgradeManifestsTemplate as sr, getOrCreateDirectory as st, makeSubgraphsIndexFile as t, documentModelHooksFileTemplate as tn, syncAndPublishWorkflowTemplate as tr, getStringPropertyValue as tt, operationHasInput as u, documentModelOperationModuleActionsFileTemplate as un, switchboardEntrypointTemplate as ur, getSubgraphMetadata as ut, getMockOverrideFieldNames as v, getActionInputName as vn, appEditorFileTemplate as vr, formatSafe as vt, makeCliDocsFromHelp as w, documentModelDocumentSchemaFileTemplate as wn, emptyStateFileTemplate as wr, parseArgs as wt, tsMorphGenerateDocumentEditor as x, getActionTypeName as xn, folderTreeFileTemplate as xr, getDocumentTypeMetadata as xt, scalars as y, getActionInputTypeNames as yn, appConfigFileTemplate as yr, formatSourceFileWithPrettier as yt, makeEditorModuleFile as z, buildPowerhouseConfigTemplate as zn, analyticsIndexTemplate as zt };
 
-//# sourceMappingURL=file-builders-Btk4MK1I.mjs.map
+//# sourceMappingURL=file-builders-BZEQ9XnO.mjs.map