@neocompose/cli 0.21.6 → 0.22.1

package/dist/neo.mjs

@@ -256,6 +256,358 @@ var init_ui = __esm({
   }
 });
 
+// src/commands/login.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+async function runLogin(options) {
+  let profile = options.profile;
+  if (profile === null) {
+    profile = isInteractive() && !options.tokenStdin ? await promptSelect({
+      message: "Credential profile",
+      choices: [
+        {
+          name: "editor",
+          value: "editor",
+          description: "Day-to-day schema, content, and branch work (default)"
+        },
+        {
+          name: "release",
+          value: "release",
+          description: "Adds outward-facing ops: publish, archive, channels"
+        }
+      ],
+      nonInteractiveHint: "Pass --profile editor|release."
+    }) : "editor";
+  }
+  const scopes = [...profile === "release" ? RELEASE_SCOPES : EDITOR_SCOPES];
+  if (options.saveProjectId !== null) {
+    scopes.push(`project:${options.saveProjectId}:save:read`);
+  }
+  if (options.tokenStdin) {
+    const token = await readStdin();
+    if (token.length === 0) {
+      throw new Error("--token-stdin received an empty token.");
+    }
+    saveCredential({
+      token,
+      profile,
+      apiBaseUrl: options.apiBaseUrl,
+      scopes,
+      savedAt: Date.now()
+    });
+    console.log(`Stored token for ${options.apiBaseUrl} (${profile}).`);
+    return;
+  }
+  const clientId = CLIENT_ID_BY_PROFILE[profile];
+  const codeResponse = await fetch(
+    new URL("/api/auth/device/code", options.apiBaseUrl),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ client_id: clientId, scope: scopes.join(" ") })
+    }
+  );
+  const codeBody = await codeResponse.json();
+  if (!codeResponse.ok) {
+    throw new Error(
+      `Device authorization request failed (${codeResponse.status}): ${JSON.stringify(codeBody)}`
+    );
+  }
+  if (!isObjectRecord(codeBody)) {
+    throw new Error("Device authorization response must be a JSON object.");
+  }
+  const deviceCode = codeBody.device_code;
+  const userCode = codeBody.user_code;
+  const verificationUriComplete = codeBody.verification_uri_complete;
+  const interval = typeof codeBody.interval === "number" ? codeBody.interval : 5;
+  if (typeof deviceCode !== "string") {
+    throw new Error('Device authorization response is missing "device_code".');
+  }
+  if (typeof userCode !== "string") {
+    throw new Error('Device authorization response is missing "user_code".');
+  }
+  console.log("");
+  console.log(`  To authorize the Neo Compose CLI, open:`);
+  console.log(`    ${color.cyan(String(verificationUriComplete))}`);
+  console.log("");
+  console.log(`  and confirm this code: ${color.bold(userCode)}`);
+  console.log("");
+  if (isInteractive() && process.platform === "darwin") {
+    note("  (opening your browser\u2026)");
+    const { spawn } = await import("node:child_process");
+    spawn("open", [String(verificationUriComplete)], {
+      stdio: "ignore",
+      detached: true
+    }).unref();
+  }
+  const waiting = spinner("Waiting for approval in the browser\u2026");
+  const deadline = Date.now() + 15 * 60 * 1e3;
+  for (; ; ) {
+    if (Date.now() > deadline) {
+      waiting.fail("Device authorization timed out after 15 minutes.");
+      throw new Error("Device authorization timed out after 15 minutes.");
+    }
+    await sleep(interval * 1e3);
+    const tokenResponse = await fetch(
+      new URL("/api/auth/device/token", options.apiBaseUrl),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientId
+        })
+      }
+    );
+    const tokenBody = await tokenResponse.json();
+    if (!isObjectRecord(tokenBody)) {
+      throw new Error("Device token response must be a JSON object.");
+    }
+    if (!tokenResponse.ok) {
+      const errorCode = tokenBody.error;
+      if (errorCode === "authorization_pending" || errorCode === "slow_down") {
+        continue;
+      }
+      waiting.fail("Device authorization failed.");
+      throw new Error(
+        `Device token request failed (${tokenResponse.status}): ${JSON.stringify(tokenBody)}`
+      );
+    }
+    const accessToken = tokenBody.access_token;
+    if (typeof accessToken !== "string") {
+      throw new Error('Device token response is missing "access_token".');
+    }
+    saveCredential({
+      token: accessToken,
+      profile,
+      apiBaseUrl: options.apiBaseUrl,
+      scopes,
+      savedAt: Date.now()
+    });
+    waiting.succeed(`Logged in to ${options.apiBaseUrl} (${profile} profile).`);
+    return;
+  }
+}
+async function runWhoami(apiBaseUrl) {
+  const { loadToken: loadToken2 } = await Promise.resolve().then(() => (init_token_store(), token_store_exports));
+  const token = loadToken2(apiBaseUrl);
+  if (token === null) {
+    throw new Error(
+      `No credentials stored for "${apiBaseUrl}". Run "neo login".`
+    );
+  }
+  const response = await fetch(new URL("/api/auth/get-session", apiBaseUrl), {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      `get-session failed (${response.status}): ${JSON.stringify(body)}`
+    );
+  }
+  if (!isObjectRecord(body) || !isObjectRecord(body.user)) {
+    throw new Error("Not signed in (session lookup returned no user).");
+  }
+  const email = typeof body.user.email === "string" ? body.user.email : "(no email)";
+  const name = typeof body.user.name === "string" ? body.user.name : "(no name)";
+  console.log(`Signed in as ${name} <${email}> at ${apiBaseUrl}`);
+}
+var CLIENT_ID_BY_PROFILE, EDITOR_SCOPES, RELEASE_SCOPES, sleep;
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    init_token_store();
+    init_ui();
+    CLIENT_ID_BY_PROFILE = {
+      editor: "neo-cli-editor",
+      release: "neo-cli-release"
+    };
+    EDITOR_SCOPES = [
+      "openid",
+      "profile:read",
+      "project:list",
+      "project:read",
+      "project:details:read",
+      "project:version:read",
+      "project:version:create",
+      "project:version:status:read",
+      "project:version:changelog:read",
+      "project:record:schema:read",
+      "project:record:schema:write",
+      "project:record:values:read",
+      "project:record:values:write",
+      "project:record:world:read",
+      "project:record:world:write",
+      "project:dialogue:read",
+      "project:dialogue:write",
+      "project:dialogue:logic:read",
+      "project:dialogue:logic:compile",
+      "project:files:read",
+      "project:files:content:read",
+      "project:files:write",
+      "project:localization:config:read",
+      "project:localization:config:write",
+      "project:localization:status:read",
+      "project:localization:status:write",
+      "project:localization:main-values:read",
+      "project:localization:main-values:write",
+      "project:localization:values:read",
+      "project:localization:values:write",
+      "project:localization:export",
+      "project:localization:import",
+      "project:release-channel:read",
+      // `neo export unity` writes project.json + NeoGeneratedTypes.cs headlessly
+      // (the escape hatch when game code references not-yet-generated members and
+      // a broken compile blocks the in-editor sync).
+      "unity:export",
+      // Branch lifecycle (auto-archive after `neo merge`, branch archive/restore)
+      // is editor work; releases stay gated behind the release profile.
+      "project:version:archive",
+      "project:version:restore"
+    ];
+    RELEASE_SCOPES = [
+      ...EDITOR_SCOPES,
+      "project:version:status:write",
+      "project:release-channel:write",
+      "project:release-channel:publish"
+    ];
+    sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+  }
+});
+
+// src/args.ts
+function parseArgs(argv) {
+  const [command = null, ...rest] = argv;
+  const flags = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (arg.startsWith("--")) {
+      const name = arg.slice(2);
+      const next = rest[index + 1];
+      if (!BOOLEAN_FLAGS.has(name) && next !== void 0 && !next.startsWith("--")) {
+        flags.set(name, next);
+        index += 1;
+      } else {
+        flags.set(name, true);
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { command, flags, positional };
+}
+function stringFlag(args, name) {
+  const value = args.flags.get(name);
+  if (value === void 0) return null;
+  if (typeof value !== "string") {
+    throw new Error(`--${name} requires a value.`);
+  }
+  return value;
+}
+function boolFlag(args, name) {
+  return args.flags.get(name) === true;
+}
+function assertKnownFlags(args) {
+  for (const name of args.flags.keys()) {
+    if (KNOWN_FLAGS.has(name)) continue;
+    const hint = args.command === null ? "Run `neo help` for usage." : `Run \`neo ${args.command} --help\` for usage.`;
+    throw new Error(`Unknown flag "--${name}". ${hint}`);
+  }
+}
+var BOOLEAN_FLAGS, KNOWN_FLAGS;
+var init_args = __esm({
+  "src/args.ts"() {
+    "use strict";
+    BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+      "dry-run",
+      "json",
+      "all",
+      "force",
+      "force-recompile",
+      "token-stdin",
+      "push",
+      "mine",
+      "theirs",
+      "accept-bump",
+      "commit",
+      "skip-invalid",
+      "migrate",
+      "server",
+      "replace",
+      "reset",
+      "regenerate-source-names",
+      "generate-ids",
+      "help",
+      "abstract"
+    ]);
+    KNOWN_FLAGS = /* @__PURE__ */ new Set([
+      "accept-bump",
+      "abstract",
+      "all",
+      "api",
+      "args",
+      "member",
+      "bump",
+      "bind",
+      "commit",
+      "dir",
+      "dry-run",
+      "entries",
+      "file",
+      "force",
+      "force-recompile",
+      "function",
+      "from",
+      "generate-ids",
+      "group",
+      "help",
+      "into",
+      "json",
+      "key",
+      "kind",
+      "migrate",
+      "mine",
+      "mode",
+      "out",
+      "profile",
+      "primary",
+      "project",
+      "plan",
+      "push",
+      "replace",
+      "regenerate-source-names",
+      "reset",
+      "returns",
+      "run",
+      "save",
+      "save-project",
+      "server",
+      "skip-invalid",
+      "status",
+      "summary",
+      "confirm-scope",
+      "target",
+      "template",
+      "theirs",
+      "this",
+      "this-value",
+      "token-stdin",
+      "class",
+      "version"
+    ]);
+  }
+});
+
 // ../packages/neoscript-language/src/language-spec.ts
 function neoProjectSourceKind(path) {
   if (path.endsWith(".neoflow")) return "flow";
@@ -11608,11 +11960,18 @@ ${document.text};` : functionUnit ? isolateUnitBody(
     ) : document.text;
     const resolverContext = expressionDocument ? { ...context, kind: "initializer" } : context;
     const ast = parseFunctionBody(compilableSource);
-    const ir = new StrictNeoScriptResolver(
+    const projectIndex = options.projectIndex ?? createProjectIndex(resolverContext.project);
+    const emitted = new StrictNeoScriptResolver(
       resolverContext,
-      options.projectIndex,
+      projectIndex,
       compilableSource
     ).compile(ast);
+    const ir = attachDependencyManifest(
+      emitted,
+      compilableSource,
+      projectIndex,
+      resolverContext
+    );
     return {
       parsed: recovery.parsed,
       ast,
@@ -11688,14 +12047,61 @@ function compileUnit(source, unit, context, label, projectIndex) {
   const isolated = isolateUnitBody(source, unit.bodyStart, unit.bodyEnd);
   try {
     const ast = parseFunctionBody(isolated);
-    return new StrictNeoScriptResolver(context, projectIndex, isolated).compile(
-      ast
+    const indexedProject = projectIndex ?? createProjectIndex(context.project);
+    return attachDependencyManifest(
+      new StrictNeoScriptResolver(context, indexedProject, isolated).compile(
+        ast
+      ),
+      isolated,
+      indexedProject,
+      context
     );
   } catch (error) {
     if (error instanceof CompileError) throw error.withUnit(label);
     throw error;
   }
 }
+function attachDependencyManifest(compiled, source, project, context) {
+  const recordIds = /* @__PURE__ */ new Set();
+  collectDependencyIds(compiled, null, recordIds);
+  const identifiers = new Set(
+    lex2(source).filter((token) => token.kind === "ident").map((token) => token.text)
+  );
+  collectDependencyIds(context.thisClass, null, recordIds);
+  collectDependencyIds(context.declaringType, null, recordIds);
+  collectDependencyIds(context.returnType, null, recordIds);
+  collectDependencyIds(context.parameters, null, recordIds);
+  collectDependencyIds(context.dialogueContextType, null, recordIds);
+  for (const alias of context.valueAliases ?? []) {
+    if (!identifiers.has(alias.name)) continue;
+    recordIds.add(alias.valueId);
+    collectDependencyIds(alias.type, null, recordIds);
+  }
+  const typeNames = [...project.typeByName.keys()].filter(
+    (name) => identifiers.has(name)
+  );
+  return {
+    ...compiled,
+    dependencies: {
+      recordIds: [...recordIds].sort(),
+      typeNames: typeNames.sort()
+    }
+  };
+}
+function collectDependencyIds(value, field, ids) {
+  if (typeof value === "string") {
+    if (field !== null && DEPENDENCY_ID_FIELDS.has(field)) ids.add(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) collectDependencyIds(entry, field, ids);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [childField, child] of Object.entries(value)) {
+    collectDependencyIds(child, childField, ids);
+  }
+}
 function isolateUnitBody(source, start, end) {
   let result = "";
   for (let index = 0; index < source.length; index++) {
@@ -11718,14 +12124,32 @@ function compileErrorDiagnostic(source, error) {
     message: error.message.replace(/^\d+:\d+:\s*/, "")
   };
 }
+var DEPENDENCY_ID_FIELDS;
 var init_compiler = __esm({
   "../packages/neoscript-language/src/compiler.ts"() {
     "use strict";
+    init_project();
     init_source_text();
     init_syntax();
     init_strict_compile_error();
     init_strict_parser();
     init_strict_resolver();
+    init_strict_lexer();
+    DEPENDENCY_ID_FIELDS = /* @__PURE__ */ new Set([
+      "classId",
+      "collectionMemberId",
+      "collectionValueId",
+      "constructorId",
+      "enumId",
+      "fileId",
+      "interfaceId",
+      "listMemberId",
+      "memberId",
+      "ownerClassId",
+      "primaryLinkedValueId",
+      "typeId",
+      "valueId"
+    ]);
   }
 });
 
@@ -21911,7 +22335,7 @@ function isEnumOptionId(id2) {
   }
   return RFC_4122_UUID.test(id2);
 }
-function analyzeNeoProjectSources(inputs) {
+function analyzeNeoProjectSources(inputs, parsedDocuments = /* @__PURE__ */ new Map()) {
   const documents = /* @__PURE__ */ new Map();
   const diagnostics = [];
   for (const input of inputs) {
@@ -21926,7 +22350,8 @@ function analyzeNeoProjectSources(inputs) {
       });
       continue;
     }
-    const document = parseNeoProjectSource(input.text, input.kind, input.uri);
+    const cached = parsedDocuments.get(input.uri);
+    const document = cached?.kind === input.kind && cached.sourceText === input.text ? cached : parseNeoProjectSource(input.text, input.kind, input.uri);
     documents.set(input.uri, document);
     diagnostics.push(
       ...document.diagnostics.map((diagnostic) => ({
@@ -24510,8 +24935,9 @@ var init_project_source_construction_quick_fixes = __esm({
 });
 
 // ../packages/neoscript-language/src/project-source-manifest.ts
-function compileNeoProjectSources(inputs) {
-  const analysis = analyzeNeoProjectSources(inputs);
+function compileNeoProjectSources(inputs, options = {}) {
+  const analysis = analyzeNeoProjectSources(inputs, options.parsedDocuments);
+  options.onDocuments?.(analysis.documents);
   const schemaClasses = [];
   const schemaInterfaces = [];
   const schemaEnums = [];
@@ -47675,6 +48101,46 @@ function normalizeInitializerSource(source) {
     ...lines.slice(1).map((line) => line.length === 0 ? line : line.slice(common))
   ].join("\n");
 }
+function constructorExpressionSlice(source) {
+  let quote6 = null;
+  let escaped = false;
+  let parentheses = 0;
+  let brackets = 0;
+  let braces = 0;
+  let index = 0;
+  while (index < source.length) {
+    const character = source[index];
+    if (quote6 !== null) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote6) quote6 = null;
+      index += 1;
+      continue;
+    }
+    const afterComment = commentEndIndex(source, index);
+    if (afterComment !== null) {
+      index = afterComment;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote6 = character;
+      index += 1;
+      continue;
+    }
+    if (character === "(") parentheses += 1;
+    else if (character === ")") parentheses -= 1;
+    else if (character === "[") brackets += 1;
+    else if (character === "]") brackets -= 1;
+    else if (character === "{") {
+      if (parentheses === 0 && brackets === 0 && braces === 0) {
+        return normalizeInitializerSource(source.slice(0, index).trimEnd());
+      }
+      braces += 1;
+    } else if (character === "}") braces -= 1;
+    index += 1;
+  }
+  return normalizeInitializerSource(source);
+}
 function topLevelEntrySlices(initializer, open, close) {
   const start = topLevelIndexOf(initializer, open);
   if (start < 0) return [];
@@ -50307,8 +50773,8 @@ var init_analyzer_types = __esm({
 });
 
 // ../src/components/projects/member-code/neoscript-language-context-adapter.ts
-function createNeoScriptDocumentContext(context) {
-  const project = createNeoScriptProject(context);
+function createNeoScriptDocumentContext(context, projectOverride) {
+  const project = projectOverride ?? createNeoScriptProject(context);
   const documentKind = context.scriptKind ?? "getter";
   const thisClass = context.thisClass ? namedType(context.thisClass.id, true) : void 0;
   const returnType = context.functionReturnTypeInfo ? functionReturnType(context.functionReturnTypeInfo, context) : context.returnTypeInfo ? toLanguageType(context.returnTypeInfo, context) : void 0;
@@ -50931,19 +51397,14 @@ function createListIndexes(context) {
       continue;
     }
     if (!isMemberListBase(resolved)) continue;
-    let definitions;
-    try {
-      definitions = resolveListIndexDefinitions(
-        {
-          members: context.vm.members,
-          classes: context.vm.classes,
-          enums: context.vm.enums
-        },
-        record3
-      );
-    } catch {
-      continue;
-    }
+    const definitions = resolveListIndexDefinitions(
+      {
+        members: context.vm.members,
+        classes: context.vm.classes,
+        enums: context.vm.enums
+      },
+      record3
+    );
     const listType = memberRuntimeType(record3, context);
     if (listType.kind !== "list") continue;
     for (const definition2 of definitions) {
@@ -51378,6 +51839,7 @@ function projectLanguageVersion(context) {
     ...context.constructors ?? []
   ];
   return [
+    `adapter:${NEOSCRIPT_COMPILER_ADAPTER_REVISION}`,
     context.vm.project.id,
     context.vm.project.updatedAt,
     context.vm.project.rootAssetsMemberId,
@@ -51525,7 +51987,7 @@ function virtualEnumOptionLine(optionName, optionId = optionName) {
 function virtualRootMemberLine(name, memberId) {
   return `    public object ${virtualCSharpIdentifier(name)} { get; } // Neo root member ${memberId}`;
 }
-var UNKNOWN_TYPE2, storageResolverByContext;
+var NEOSCRIPT_COMPILER_ADAPTER_REVISION, UNKNOWN_TYPE2, storageResolverByContext;
 var init_neoscript_language_context_adapter = __esm({
   "../src/components/projects/member-code/neoscript-language-context-adapter.ts"() {
     "use strict";
@@ -51541,6 +52003,7 @@ var init_neoscript_language_context_adapter = __esm({
     init_project_root_members();
     init_project_file_registry();
     init_analyzer_types();
+    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 1;
     UNKNOWN_TYPE2 = {
       kind: "primitive",
       name: "unknown"
@@ -51550,6 +52013,28 @@ var init_neoscript_language_context_adapter = __esm({
 });
 
 // ../src/database/neoscript/compile.ts
+function clearNeoScriptBodyCompileCache() {
+  neoScriptBodyCompileCache.clear();
+}
+function createNeoScriptCompilationProject(ctx) {
+  const members = [...ctx.members];
+  const membersById = new Map(members.map((member) => [member.id, member]));
+  return createNeoScriptProject({
+    vm: {
+      project: ctx.project,
+      projectFiles: [...ctx.projectFiles ?? []],
+      members,
+      classes: [...ctx.classes],
+      enums: [...ctx.enums],
+      interfaces: [...ctx.interfaces ?? []],
+      databaseVM: {
+        memberById: (id2) => membersById.get(id2) ?? null
+      }
+    },
+    thisClass: null,
+    ...ctx.constructors ? { constructors: ctx.constructors } : {}
+  });
+}
 function compileNSGetter(code, ctx) {
   return compileStrict(
     code,
@@ -51646,6 +52131,28 @@ function withInitializerSourcePosition(error) {
   );
 }
 function compileStrict(code, context) {
+  const cacheKey = JSON.stringify({
+    code,
+    projectIdentity: compilationProjectIdentity(context.project),
+    kind: context.kind,
+    thisClass: context.thisClass,
+    returnType: context.returnType,
+    parameters: context.parameters,
+    dialogueContextType: context.dialogueContextType,
+    deferred: context.deferred,
+    functionName: context.functionName,
+    migrationContext: context.migrationContext,
+    valueAliases: context.valueAliases,
+    implicitMemberAccess: context.implicitMemberAccess,
+    declaringType: context.declaringType,
+    staticMember: context.staticMember
+  });
+  const cached = neoScriptBodyCompileCache.get(cacheKey);
+  if (cached !== void 0) {
+    neoScriptBodyCompileCache.delete(cacheKey);
+    neoScriptBodyCompileCache.set(cacheKey, cached);
+    return structuredClone(cached);
+  }
   const compiled = assertNeoScriptCompiles(
     {
       uri: `neo-compiler:///${context.kind}.neo`,
@@ -51660,10 +52167,24 @@ function compileStrict(code, context) {
       "A standalone NeoScript compiler entry point returned property units."
     );
   }
+  neoScriptBodyCompileCache.set(cacheKey, structuredClone(compiled));
+  while (neoScriptBodyCompileCache.size > NEOSCRIPT_BODY_COMPILE_CACHE_LIMIT) {
+    const oldest = neoScriptBodyCompileCache.keys().next().value;
+    if (typeof oldest !== "string") break;
+    neoScriptBodyCompileCache.delete(oldest);
+  }
   return compiled;
 }
+function compilationProjectIdentity(project) {
+  const cached = neoScriptProjectIdentityCache.get(project);
+  if (cached !== void 0) return cached;
+  const identity2 = nextNeoScriptProjectIdentity++;
+  neoScriptProjectIdentityCache.set(project, identity2);
+  return identity2;
+}
 function createContext(ctx, options) {
   const members = [...ctx.members];
+  const membersById = new Map(members.map((member) => [member.id, member]));
   const analyzer = {
     vm: {
       project: ctx.project,
@@ -51673,7 +52194,7 @@ function createContext(ctx, options) {
       enums: [...ctx.enums],
       interfaces: [...ctx.interfaces ?? []],
       databaseVM: {
-        memberById: (id2) => members.find((member) => member.id === id2) ?? null
+        memberById: (id2) => membersById.get(id2) ?? null
       }
     },
     thisClass: ctx.thisClass,
@@ -51681,7 +52202,10 @@ function createContext(ctx, options) {
     ...ctx.constructors ? { constructors: ctx.constructors } : {},
     ...options
   };
-  const adapted = createNeoScriptDocumentContext(analyzer);
+  const adapted = createNeoScriptDocumentContext(
+    analyzer,
+    ctx.compilationProject
+  );
   if (ctx.implicitMemberAccess !== true) return adapted;
   return {
     ...adapted,
@@ -51691,11 +52215,16 @@ function createContext(ctx, options) {
     staticMember: ctx.staticMember === true
   };
 }
+var NEOSCRIPT_BODY_COMPILE_CACHE_LIMIT, neoScriptBodyCompileCache, neoScriptProjectIdentityCache, nextNeoScriptProjectIdentity;
 var init_compile = __esm({
   "../src/database/neoscript/compile.ts"() {
     "use strict";
     init_src();
     init_neoscript_language_context_adapter();
+    NEOSCRIPT_BODY_COMPILE_CACHE_LIMIT = 1024;
+    neoScriptBodyCompileCache = /* @__PURE__ */ new Map();
+    neoScriptProjectIdentityCache = /* @__PURE__ */ new WeakMap();
+    nextNeoScriptProjectIdentity = 1;
   }
 });
 
@@ -51711,18 +52240,22 @@ var init_compile_error = __esm({
 var compiler_adapter_exports = {};
 __export(compiler_adapter_exports, {
   CompileError: () => CompileError,
+  NEOSCRIPT_COMPILER_ADAPTER_REVISION: () => NEOSCRIPT_COMPILER_ADAPTER_REVISION,
+  clearNeoScriptBodyCompileCache: () => clearNeoScriptBodyCompileCache,
   compileNSAction: () => compileNSAction,
   compileNSConstructor: () => compileNSConstructor,
   compileNSFunction: () => compileNSFunction,
   compileNSGetter: () => compileNSGetter,
   compileNSInitializer: () => compileNSInitializer,
-  compileNSSetter: () => compileNSSetter
+  compileNSSetter: () => compileNSSetter,
+  createNeoScriptCompilationProject: () => createNeoScriptCompilationProject
 });
 var init_compiler_adapter = __esm({
   "../src/database/neoscript/compiler-adapter.ts"() {
     "use strict";
     init_compile();
     init_compile_error();
+    init_neoscript_language_context_adapter();
   }
 });
 
@@ -51753,6 +52286,7 @@ function compileNSPropertyBodies(args) {
         enums: [...args.enums],
         interfaces: [...args.interfaces ?? []],
         constructors: args.constructors ?? [],
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
         thisClass: args.thisClass,
         returnTypeInfo,
         implicitMemberAccess: true,
@@ -51789,6 +52323,7 @@ function compileNSPropertyBodies(args) {
         enums: [...args.enums],
         interfaces: [...args.interfaces ?? []],
         constructors: args.constructors ?? [],
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
         thisClass: args.thisClass,
         valueTypeInfo: returnTypeInfo,
         implicitMemberAccess: true,
@@ -51837,6 +52372,7 @@ function compileNSFunctionBody(args) {
         enums: [...args.enums],
         interfaces: [...args.interfaces ?? []],
         constructors: args.constructors ?? [],
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
         thisClass: args.thisClass,
         functionName: args.member.name,
         implicitMemberAccess: true,
@@ -51877,6 +52413,7 @@ function compileNSFunctionBody(args) {
       enums: [...args.enums],
       interfaces: [...args.interfaces ?? []],
       constructors: args.constructors ?? [],
+      ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
       thisClass: args.thisClass,
       functionName: args.member.name,
       implicitMemberAccess: true,
@@ -51913,6 +52450,7 @@ function compileMemberInitializerBody(args) {
         enums: [...args.enums],
         interfaces: [...args.interfaces ?? []],
         constructors: args.constructors ?? [],
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
         returnTypeInfo,
         initializerName: args.member.name,
         argumentTypes: initializerArgumentTypes(
@@ -51965,7 +52503,8 @@ function compileValueRowInitializerBody(args) {
         argumentTypes: initializerArgumentTypes(
           args.initializerOwnerClass,
           args.constructors ?? []
-        )
+        ),
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject }
       })
     );
   } catch (error) {
@@ -52076,6 +52615,7 @@ function compileConstructorRecord(args) {
       enums: [...args.enums],
       interfaces: [...args.interfaces ?? []],
       constructors: args.constructors,
+      ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
       thisClass: owner,
       argumentTypes,
       constructorName: owner.name
@@ -52114,6 +52654,7 @@ function compileConstructorBaseArguments(args, owner) {
           enums: [...args.enums],
           interfaces: [...args.interfaces ?? []],
           constructors: args.constructors,
+          ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
           returnTypeInfo: parameter3,
           argumentTypes,
           initializerName: `${owner.name} base argument ${baseArgument.name}`
@@ -52173,6 +52714,7 @@ function compileConstructorBaseInitializerFields(args, owner) {
         enums: [...args.enums],
         interfaces: [...args.interfaces ?? []],
         constructors: args.constructors,
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
         returnTypeInfo,
         argumentTypes: args.constructor.argumentTypes,
         initializerName: `${owner.name} base initializer ${field.name}`
@@ -66064,7 +66606,7 @@ var init_dialogue_lower = __esm({
 });
 
 // src/project-source/root-source.ts
-function emitProjectRootSourceV4(records2, manifest) {
+function emitProjectRootSourceV4(records2, manifest, materializedConstructors) {
   const project = [...records2.values()].find(
     (record3) => !record3.deleted && record3.recordKind === "project"
   );
@@ -66079,6 +66621,11 @@ function emitProjectRootSourceV4(records2, manifest) {
     manifest,
     targetTypedRoot: true
   });
+  if (materializedConstructors !== void 0) {
+    for (const [valueId, expression] of values.materializedConstructors) {
+      materializedConstructors.set(valueId, expression);
+    }
+  }
   const declarations = PROJECT_ROOT_SOURCE_SLOTS.map((slot, index) => {
     const memberId = memberIds[index];
     const member = members.get(memberId);
@@ -67609,20 +68156,985 @@ var init_animation_clips = __esm({
   }
 });
 
+// src/project-source/materialized-construction-cache.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { dirname as dirname2, join as join3 } from "node:path";
+function readMaterializedConstructionBuildCacheV1(root, state) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync3(
+        join3(root, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH),
+        "utf8"
+      )
+    );
+    if (parsed === null || typeof parsed !== "object") return null;
+    const cache = parsed;
+    if (cache.revision !== MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION || cache.stateFingerprint !== materializedConstructionStateFingerprint(state) || cache.expressions === null || typeof cache.expressions !== "object" || Array.isArray(cache.expressions)) {
+      return null;
+    }
+    const expressions = /* @__PURE__ */ new Map();
+    for (const [valueId, expression] of Object.entries(cache.expressions)) {
+      if (typeof expression !== "string") return null;
+      expressions.set(valueId, expression);
+    }
+    return expressions;
+  } catch {
+    return null;
+  }
+}
+function writeMaterializedConstructionBuildCacheV1(root, state, expressions) {
+  const file = join3(root, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH);
+  mkdirSync3(dirname2(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync3(
+    temporary,
+    `${JSON.stringify({
+      revision: MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION,
+      stateFingerprint: materializedConstructionStateFingerprint(state),
+      expressions: Object.fromEntries(
+        [...expressions].sort(([left], [right]) => left.localeCompare(right))
+      )
+    })}
+`,
+    "utf8"
+  );
+  renameSync(temporary, file);
+}
+function materializedConstructionStateFingerprint(state) {
+  const hash = createHash2("sha256");
+  hash.update(String(MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION));
+  for (const [key, record3] of Object.entries(state.records).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    hash.update("\0");
+    hash.update(key);
+    hash.update("\0");
+    hash.update(record3.contentHash);
+  }
+  return hash.digest("hex");
+}
+var MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION;
+var init_materialized_construction_cache = __esm({
+  "src/project-source/materialized-construction-cache.ts"() {
+    "use strict";
+    MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH = ".neo/build/materialized-constructions-v1.json";
+    MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION = 1;
+  }
+});
+
+// ../src/database/canonical-json.ts
+function canonicalJsonStringify(value) {
+  return JSON.stringify(toCanonicalJsonValue(value));
+}
+function toCanonicalJsonValue(value) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Cannot canonicalize a non-finite number.");
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    throw new Error("Cannot canonicalize bigint values.");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot canonicalize symbol values.");
+  }
+  if (typeof value === "function") {
+    throw new Error("Cannot canonicalize function values.");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      const canonicalItem = toCanonicalJsonValue(item);
+      if (canonicalItem === void 0) return null;
+      return canonicalItem;
+    });
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  const canonicalObject = {};
+  for (const [key, entryValue] of entries) {
+    const canonicalValue = toCanonicalJsonValue(entryValue);
+    if (canonicalValue === void 0) continue;
+    canonicalObject[key] = canonicalValue;
+  }
+  return canonicalObject;
+}
+var init_canonical_json = __esm({
+  "../src/database/canonical-json.ts"() {
+    "use strict";
+  }
+});
+
+// ../src/database/neo-script-recompile-scope.ts
+function memberNeoScriptContractChanged(current, next) {
+  return canonicalJsonStringify(neoScriptMemberContractProjection(current)) !== canonicalJsonStringify(neoScriptMemberContractProjection(next));
+}
+function neoScriptMemberContractProjection(value) {
+  const ignored = new Set(NON_CONTRACT_MEMBER_FIELDS);
+  if (value.kind === 10 /* NSProperty */) {
+    for (const field of NS_PROPERTY_BODY_FIELDS) ignored.add(field);
+  }
+  if (value.kind === 23 /* NSFunction */) {
+    for (const field of NS_FUNCTION_BODY_FIELDS) ignored.add(field);
+  }
+  return {
+    ...withoutFields(value, ignored),
+    defaultPresent: value.defaultValue != null
+  };
+}
+function collectNeoScriptRecompileTargets(args) {
+  if (args.forceRecompile === true) return completeTargets(args.postDocument);
+  const explicit = explicitTargetIds(args.changes);
+  const { impactedIds, impactedTypeNames, constructedClassIds } = collectChangedContractIds(args);
+  includeDerivedConstructionContracts(
+    constructedClassIds,
+    args.postDocument.classes
+  );
+  const schemaRecords = [
+    ...collectSchemaDependencyRecords(args.postDocument),
+    ...collectStructuralDependencyRecords(args.postDocument)
+  ];
+  const dependentsById = /* @__PURE__ */ new Map();
+  for (const record3 of schemaRecords) {
+    for (const dependencyId of collectCompilerReferenceIds(record3.value)) {
+      const dependents = dependentsById.get(dependencyId) ?? [];
+      dependents.push(record3);
+      dependentsById.set(dependencyId, dependents);
+    }
+  }
+  const queue = [...impactedIds];
+  for (let index = 0; index < queue.length; index += 1) {
+    const dependencyId = queue[index];
+    if (dependencyId === void 0) continue;
+    for (const dependent of dependentsById.get(dependencyId) ?? []) {
+      addImpactedId(impactedIds, queue, dependent.id);
+    }
+  }
+  const constructorOwnerById = constructorOwners(args.postDocument);
+  const memberIds = new Set(explicit.memberIds);
+  for (const member of args.postDocument.members) {
+    if (recordDependsOnChangedContract(
+      member,
+      impactedIds,
+      impactedTypeNames,
+      constructedClassIds
+    )) {
+      memberIds.add(member.id);
+    }
+  }
+  const postValues = args.postDocument.values ?? [];
+  const valueIds = selectedRecordIds(
+    postValues,
+    explicit.valueIds,
+    impactedIds,
+    impactedTypeNames,
+    constructedClassIds
+  );
+  if (impactedIds.size > 0 && postValues.length > 0) {
+    const ownerByValueId = resolveOwnerMembersForValues(
+      args.postDocument,
+      new Set(postValues.map((record3) => record3.id))
+    );
+    for (const [valueId, owner] of ownerByValueId) {
+      const ownerId = Reflect.get(owner, "id");
+      if (typeof ownerId === "string" && impactedIds.has(ownerId)) {
+        valueIds.add(valueId);
+      }
+    }
+  }
+  return {
+    complete: false,
+    memberIds,
+    constructorIds: selectedRecordIds(
+      args.postDocument.constructors ?? [],
+      explicit.constructorIds,
+      impactedIds,
+      impactedTypeNames,
+      constructedClassIds,
+      (record3) => constructorOwnerById.get(record3.id) ?? null
+    ),
+    migrationIds: selectedRecordIds(
+      args.postDocument.migrations ?? [],
+      explicit.migrationIds,
+      impactedIds,
+      impactedTypeNames,
+      constructedClassIds
+    ),
+    dialogueNodeIds: selectedRecordIds(
+      args.postDocument.dialogueNodes ?? [],
+      explicit.dialogueNodeIds,
+      impactedIds,
+      impactedTypeNames,
+      constructedClassIds
+    ),
+    dialogueGroupIds: selectedRecordIds(
+      args.postDocument.dialogueGroups ?? [],
+      explicit.dialogueGroupIds,
+      impactedIds,
+      impactedTypeNames,
+      constructedClassIds
+    ),
+    valueIds
+  };
+}
+function collectCompilerReferenceIds(value) {
+  const ids = /* @__PURE__ */ new Set();
+  collectCompilerReferenceIdsInto(value, null, ids);
+  return ids;
+}
+function collectCompilerReferenceNames(value) {
+  const names = /* @__PURE__ */ new Set();
+  collectCompilerReferenceNamesInto(value, null, names);
+  return names;
+}
+function collectConstructedClassIds(value) {
+  const ids = /* @__PURE__ */ new Set();
+  collectConstructedClassIdsInto(value, ids);
+  return ids;
+}
+function collectConstructedClassIdsInto(value, ids) {
+  if (Array.isArray(value)) {
+    for (const entry of value) collectConstructedClassIdsInto(entry, ids);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  const record3 = value;
+  if ((record3.type === "classConstructor" || record3.type === "declaredConstructor") && record3.info !== null && typeof record3.info === "object") {
+    const schemaClassInfo = Reflect.get(record3.info, "schemaClassInfo");
+    if (schemaClassInfo !== null && typeof schemaClassInfo === "object") {
+      const classId = Reflect.get(schemaClassInfo, "classId");
+      if (typeof classId === "string") ids.add(classId);
+    }
+  }
+  for (const child of Object.values(record3)) {
+    collectConstructedClassIdsInto(child, ids);
+  }
+}
+function collectCompilerReferenceIdsInto(value, field, ids) {
+  if (typeof value === "string") {
+    if (field !== null && isCompilerReferenceField(field)) ids.add(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value)
+      collectCompilerReferenceIdsInto(entry, field, ids);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [childField, child] of Object.entries(value)) {
+    collectCompilerReferenceIdsInto(child, childField, ids);
+  }
+}
+function collectCompilerReferenceNamesInto(value, field, names) {
+  if (typeof value === "string") {
+    if (field === "declaredTypeName" || field === "typeName" || field === "typeNames") {
+      names.add(value);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectCompilerReferenceNamesInto(entry, field, names);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [childField, child] of Object.entries(value)) {
+    collectCompilerReferenceNamesInto(child, childField, names);
+  }
+}
+function isCompilerReferenceField(field) {
+  return /(?:member|class|enum|interface|constructor)(?:Type)?Ids?$/i.test(field) || field === "baseTypeIds" || field === "collectionValueId" || field === "fileId" || field === "primaryLinkedValueId" || field === "recordIds" || field === "valueId";
+}
+function collectChangedContractIds(args) {
+  const impactedIds = /* @__PURE__ */ new Set();
+  const impactedTypeNames = /* @__PURE__ */ new Set();
+  const constructedClassIds = /* @__PURE__ */ new Set();
+  const currentMembers = new Map(
+    args.currentDocument.members.map((member) => [member.id, member])
+  );
+  const postMembers = new Map(
+    args.postDocument.members.map((member) => [member.id, member])
+  );
+  const currentConstructors = new Map(
+    (args.currentDocument.constructors ?? []).map((record3) => [
+      record3.id,
+      record3
+    ])
+  );
+  const postConstructors = new Map(
+    (args.postDocument.constructors ?? []).map((record3) => [record3.id, record3])
+  );
+  const currentValues = new Map(
+    (args.currentDocument.values ?? []).map((record3) => [record3.id, record3])
+  );
+  const postValues = new Map(
+    (args.postDocument.values ?? []).map((record3) => [record3.id, record3])
+  );
+  const currentSchemaRecords = schemaRecordsByKind(args.currentDocument);
+  const postSchemaRecords = schemaRecordsByKind(args.postDocument);
+  for (const change of args.changes) {
+    if (change.recordKind === "class" || change.recordKind === "enum" || change.recordKind === "interface") {
+      const kind = change.recordKind;
+      const current2 = currentSchemaRecords[kind].get(change.recordId);
+      const next2 = postSchemaRecords[kind].get(change.recordId);
+      if (current2 !== void 0 && next2 !== void 0 && !schemaNeoScriptContractChanged(kind, current2, next2)) {
+        continue;
+      }
+      impactedIds.add(change.recordId);
+      const currentName = current2?.name;
+      const nextName = next2?.name;
+      if (typeof currentName === "string" && currentName !== nextName) {
+        impactedTypeNames.add(currentName);
+      }
+      if (typeof nextName === "string" && nextName !== currentName) {
+        impactedTypeNames.add(nextName);
+      }
+      continue;
+    }
+    if (change.recordKind === "constructor") {
+      const current2 = currentConstructors.get(change.recordId);
+      const next2 = postConstructors.get(change.recordId);
+      if (current2 !== void 0 && next2 !== void 0 && !constructorNeoScriptContractChanged(
+        current2,
+        next2
+      )) {
+        continue;
+      }
+      impactedIds.add(change.recordId);
+      continue;
+    }
+    if (change.recordKind === "value") {
+      const current2 = currentValues.get(change.recordId);
+      const next2 = postValues.get(change.recordId);
+      if (current2 === void 0 || next2 === void 0 || Reflect.get(current2, "classId") !== Reflect.get(next2, "classId")) {
+        impactedIds.add(change.recordId);
+      }
+      continue;
+    }
+    if (change.recordKind !== "member") continue;
+    const current = currentMembers.get(change.recordId);
+    const next = postMembers.get(change.recordId);
+    if (current !== void 0 && next !== void 0 && !memberNeoScriptContractChanged(
+      current,
+      next
+    )) {
+      continue;
+    }
+    impactedIds.add(change.recordId);
+    const currentRecord = current;
+    const nextRecord = next;
+    const canChangeUnqualifiedResolution = currentRecord === void 0 || nextRecord === void 0 || currentRecord.name !== nextRecord.name || currentRecord.kind !== nextRecord.kind || currentRecord.isStatic !== nextRecord.isStatic;
+    if (canChangeUnqualifiedResolution) {
+      for (const ownerId of classPlacementsForMember(
+        change.recordId,
+        args.currentDocument
+      )) {
+        impactedIds.add(ownerId);
+      }
+      for (const ownerId of classPlacementsForMember(
+        change.recordId,
+        args.postDocument
+      )) {
+        impactedIds.add(ownerId);
+      }
+    }
+    if (generatedConstructorMemberContractChanged(currentRecord, nextRecord)) {
+      for (const ownerId of classPlacementsForMember(
+        change.recordId,
+        args.currentDocument
+      )) {
+        constructedClassIds.add(ownerId);
+      }
+      for (const ownerId of classPlacementsForMember(
+        change.recordId,
+        args.postDocument
+      )) {
+        constructedClassIds.add(ownerId);
+      }
+    }
+  }
+  return { impactedIds, impactedTypeNames, constructedClassIds };
+}
+function generatedConstructorMemberContractChanged(current, next) {
+  if (current === void 0 || next === void 0) return true;
+  if (current.isStatic === true && next.isStatic === true) return false;
+  const ignored = /* @__PURE__ */ new Set([
+    ...NON_CONTRACT_MEMBER_FIELDS,
+    ...NS_PROPERTY_BODY_FIELDS,
+    ...NS_FUNCTION_BODY_FIELDS,
+    "accessModifierKind",
+    "indexes",
+    "locked",
+    "setter",
+    "setterCode",
+    "storage"
+  ]);
+  const project = (value) => ({
+    ...withoutFields(value, ignored),
+    defaultPresent: value.defaultValue != null
+  });
+  return canonicalJsonStringify(project(current)) !== canonicalJsonStringify(project(next));
+}
+function schemaNeoScriptContractChanged(kind, current, next) {
+  return canonicalJsonStringify(neoScriptSchemaContractProjection(kind, current)) !== canonicalJsonStringify(neoScriptSchemaContractProjection(kind, next));
+}
+function neoScriptSchemaContractProjection(kind, value) {
+  const ignored = /* @__PURE__ */ new Set([
+    "createdAt",
+    "updatedAt",
+    "projectId",
+    "docsText",
+    "system"
+  ]);
+  if (kind === "class") ignored.add("hiddenInMemberSelector");
+  if (kind === "enum") ignored.add("optionKeyOrder");
+  if (kind === "interface") ignored.add("memberKeyOrder");
+  const projected = withoutFields(value, ignored);
+  if (kind === "enum" && isObjectRecord3(projected.options)) {
+    projected.options = Object.fromEntries(
+      Object.entries(projected.options).map(([id2, option]) => [
+        id2,
+        isObjectRecord3(option) ? { id: option.id, name: option.name } : option
+      ])
+    );
+  }
+  if (kind === "interface" && isObjectRecord3(projected.members)) {
+    projected.members = Object.fromEntries(
+      Object.entries(projected.members).map(([key, member]) => [
+        key,
+        isObjectRecord3(member) ? withoutFields(member, /* @__PURE__ */ new Set(["docsText"])) : member
+      ])
+    );
+  }
+  return projected;
+}
+function schemaRecordsByKind(document) {
+  const map = (records2) => new Map(
+    records2.map((record3) => [
+      record3.id,
+      record3
+    ])
+  );
+  return {
+    class: map(document.classes),
+    member: map(document.members),
+    constructor: map(document.constructors ?? []),
+    enum: map(document.enums),
+    interface: map(document.interfaces ?? [])
+  };
+}
+function constructorNeoScriptContractChanged(current, next) {
+  return canonicalJsonStringify(neoScriptConstructorContractProjection(current)) !== canonicalJsonStringify(neoScriptConstructorContractProjection(next));
+}
+function neoScriptConstructorContractProjection(value) {
+  const ignored = /* @__PURE__ */ new Set([
+    "code",
+    "action",
+    "compiledBaseArguments",
+    "compiledBaseInitializerFields",
+    "createdAt",
+    "updatedAt",
+    "projectId",
+    "docsText"
+  ]);
+  return withoutFields(value, ignored);
+}
+function collectSchemaDependencyRecords(document) {
+  return [
+    ...document.classes.map((value) => ({
+      id: value.id,
+      value: neoScriptSchemaContractProjection(
+        "class",
+        value
+      )
+    })),
+    ...document.members.map((value) => ({
+      id: value.id,
+      value: neoScriptMemberContractProjection(
+        value
+      )
+    })),
+    ...(document.constructors ?? []).map((value) => ({
+      id: value.id,
+      value: neoScriptConstructorContractProjection(
+        value
+      )
+    })),
+    ...document.enums.map((value) => ({
+      id: value.id,
+      value: neoScriptSchemaContractProjection(
+        "enum",
+        value
+      )
+    })),
+    ...(document.interfaces ?? []).map((value) => ({
+      id: value.id,
+      value: neoScriptSchemaContractProjection(
+        "interface",
+        value
+      )
+    }))
+  ];
+}
+function collectStructuralDependencyRecords(document) {
+  const records2 = [];
+  const resolver = new EffectiveStorageResolver({
+    members: document.members,
+    classes: document.classes,
+    rootStorage: buildRootStorageMap(document.project)
+  });
+  for (const member of document.members) {
+    for (const parentId of resolver.parentMemberIds(member.id)) {
+      records2.push({ id: member.id, value: { memberId: parentId } });
+    }
+  }
+  for (const schemaClass2 of document.classes) {
+    for (const entry of mergeSchemas(
+      resolveInheritanceChain(schemaClass2.id, document.classes)
+    )) {
+      records2.push({
+        id: entry.memberId,
+        value: { classId: schemaClass2.id }
+      });
+    }
+  }
+  return records2;
+}
+function classPlacementsForMember(memberId, document) {
+  const placements = /* @__PURE__ */ new Set();
+  for (const schemaClass2 of document.classes) {
+    const surface = mergeSchemas(
+      resolveInheritanceChain(schemaClass2.id, document.classes)
+    );
+    if (surface.some((entry) => entry.memberId === memberId)) {
+      placements.add(schemaClass2.id);
+    }
+  }
+  return placements;
+}
+function explicitTargetIds(changes) {
+  const result = {
+    memberIds: /* @__PURE__ */ new Set(),
+    constructorIds: /* @__PURE__ */ new Set(),
+    migrationIds: /* @__PURE__ */ new Set(),
+    dialogueNodeIds: /* @__PURE__ */ new Set(),
+    dialogueGroupIds: /* @__PURE__ */ new Set(),
+    valueIds: /* @__PURE__ */ new Set()
+  };
+  for (const change of changes) {
+    if (change.operation === "delete") continue;
+    if (change.recordKind === "member") result.memberIds.add(change.recordId);
+    if (change.recordKind === "constructor") {
+      result.constructorIds.add(change.recordId);
+    }
+    if (change.recordKind === "migration") {
+      result.migrationIds.add(change.recordId);
+    }
+    if (change.recordKind === "dialogue-node") {
+      result.dialogueNodeIds.add(change.recordId);
+    }
+    if (change.recordKind === "dialogue-group") {
+      result.dialogueGroupIds.add(change.recordId);
+    }
+    if (change.recordKind === "value") result.valueIds.add(change.recordId);
+  }
+  return result;
+}
+function selectedRecordIds(records2, explicitIds, impactedIds, impactedTypeNames, constructedClassIds, ownerId = () => null) {
+  const selected2 = new Set(explicitIds);
+  for (const record3 of records2) {
+    const owner = ownerId(record3);
+    if (owner !== null && impactedIds.has(owner) || recordDependsOnChangedContract(
+      record3,
+      impactedIds,
+      impactedTypeNames,
+      constructedClassIds
+    )) {
+      selected2.add(record3.id);
+    }
+  }
+  return selected2;
+}
+function recordDependsOnChangedContract(record3, impactedIds, impactedTypeNames, constructedClassIds) {
+  if (intersects(collectCompilerReferenceIds(record3), impactedIds)) return true;
+  if (intersects(collectCompilerReferenceNames(record3), impactedTypeNames)) {
+    return true;
+  }
+  if (intersects(collectConstructedClassIds(record3), constructedClassIds)) {
+    return true;
+  }
+  return (impactedIds.size > 0 || impactedTypeNames.size > 0) && containsAuthoredNeoScriptSource(record3) && !containsCompiledNeoScriptBody(record3);
+}
+function containsAuthoredNeoScriptSource(value) {
+  if (Array.isArray(value)) {
+    return value.some(containsAuthoredNeoScriptSource);
+  }
+  if (!isObjectRecord3(value)) return false;
+  for (const [field, child] of Object.entries(value)) {
+    if ((field === "code" || field === "setterCode") && typeof child === "string" && child.trim().length > 0) {
+      return true;
+    }
+    if (containsAuthoredNeoScriptSource(child)) return true;
+  }
+  return false;
+}
+function containsCompiledNeoScriptBody(value) {
+  if (Array.isArray(value)) return value.some(containsCompiledNeoScriptBody);
+  if (!isObjectRecord3(value)) return false;
+  if (Array.isArray(value.parameters) && Array.isArray(value.instructions) && isObjectRecord3(value.typeInfo)) {
+    return true;
+  }
+  return Object.values(value).some(containsCompiledNeoScriptBody);
+}
+function isObjectRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function constructorOwners(document) {
+  const owners = /* @__PURE__ */ new Map();
+  const constructorIds = new Set(
+    (document.constructors ?? []).map((record3) => record3.id)
+  );
+  for (const schemaClass2 of document.classes) {
+    for (const referenceId3 of collectCompilerReferenceIds(schemaClass2)) {
+      if (constructorIds.has(referenceId3)) {
+        owners.set(referenceId3, schemaClass2.id);
+      }
+    }
+  }
+  return owners;
+}
+function includeDerivedConstructionContracts(classIds, classes) {
+  const derivedByBaseId = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classes) {
+    if (schemaClass2.extendsClassId === void 0) continue;
+    const derived = derivedByBaseId.get(schemaClass2.extendsClassId) ?? [];
+    derived.push(schemaClass2.id);
+    derivedByBaseId.set(schemaClass2.extendsClassId, derived);
+  }
+  const queue = [...classIds];
+  for (let index = 0; index < queue.length; index += 1) {
+    const baseClassId = queue[index];
+    if (baseClassId === void 0) continue;
+    for (const derivedClassId of derivedByBaseId.get(baseClassId) ?? []) {
+      if (classIds.has(derivedClassId)) continue;
+      classIds.add(derivedClassId);
+      queue.push(derivedClassId);
+    }
+  }
+}
+function completeTargets(document) {
+  return {
+    complete: true,
+    memberIds: new Set(document.members.map((record3) => record3.id)),
+    constructorIds: new Set(
+      (document.constructors ?? []).map((record3) => record3.id)
+    ),
+    migrationIds: new Set(
+      (document.migrations ?? []).map((record3) => record3.id)
+    ),
+    dialogueNodeIds: new Set(
+      (document.dialogueNodes ?? []).map((record3) => record3.id)
+    ),
+    dialogueGroupIds: new Set(
+      (document.dialogueGroups ?? []).map((record3) => record3.id)
+    ),
+    valueIds: new Set((document.values ?? []).map((record3) => record3.id))
+  };
+}
+function addImpactedId(impactedIds, queue, id2) {
+  if (impactedIds.has(id2)) return;
+  impactedIds.add(id2);
+  queue.push(id2);
+}
+function intersects(left, right) {
+  for (const value of left) {
+    if (right.has(value)) return true;
+  }
+  return false;
+}
+function withoutFields(value, ignored) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([field]) => !ignored.has(field))
+  );
+}
+var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS;
+var init_neo_script_recompile_scope = __esm({
+  "../src/database/neo-script-recompile-scope.ts"() {
+    "use strict";
+    init_canonical_json();
+    init_member_kind_enum();
+    init_inheritance();
+    init_effective_storage();
+    init_project_root_members();
+    init_value_row_owner_members();
+    NON_CONTRACT_MEMBER_FIELDS = /* @__PURE__ */ new Set([
+      "createdAt",
+      "updatedAt",
+      "projectId",
+      "docsText",
+      "valueId",
+      "defaultValue",
+      "system",
+      "storageKey",
+      "searchKey",
+      "minValue",
+      "maxValue",
+      "decimalPoints",
+      "columnSettings",
+      "schemaKeyOrder",
+      "templateId"
+    ]);
+    NS_PROPERTY_BODY_FIELDS = /* @__PURE__ */ new Set([
+      "code",
+      "getter"
+    ]);
+    NS_FUNCTION_BODY_FIELDS = /* @__PURE__ */ new Set([
+      "code",
+      "action",
+      "bodyMode",
+      "uiAction"
+    ]);
+  }
+});
+
+// ../src/database/project-content-hash.ts
+import { createHash as createHash3 } from "node:crypto";
+function hashCanonicalJson(value) {
+  const canonicalJson = canonicalJsonStringify(value);
+  return createHash3("sha256").update(canonicalJson).digest("hex");
+}
+var init_project_content_hash = __esm({
+  "../src/database/project-content-hash.ts"() {
+    "use strict";
+    init_canonical_json();
+    init_canonical_json();
+  }
+});
+
+// ../src/database/neoscript/project-fingerprint.ts
+function neoScriptCompilationProjectContract(document) {
+  return {
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+    adapterRevision: NEOSCRIPT_COMPILER_ADAPTER_REVISION,
+    project: {
+      id: document.project.id,
+      rootAssetsMemberId: document.project.rootAssetsMemberId,
+      rootSaveFileMemberId: document.project.rootSaveFileMemberId,
+      rootSessionMemberId: document.project.rootSessionMemberId
+    },
+    projectFiles: (document.projectFiles ?? []).map((file) => ({
+      id: file.id,
+      name: file.name,
+      fileType: file.fileType
+    })),
+    members: document.members.map(
+      (member) => neoScriptMemberContractProjection(
+        member
+      )
+    ),
+    classes: document.classes.map(
+      (schemaClass2) => neoScriptSchemaContractProjection(
+        "class",
+        schemaClass2
+      )
+    ),
+    enums: document.enums.map(
+      (enumDefinition) => neoScriptSchemaContractProjection(
+        "enum",
+        enumDefinition
+      )
+    ),
+    interfaces: (document.interfaces ?? []).map(
+      (neoInterface) => neoScriptSchemaContractProjection(
+        "interface",
+        neoInterface
+      )
+    ),
+    constructors: (document.constructors ?? []).map(
+      (constructorRecord) => neoScriptConstructorContractProjection(
+        constructorRecord
+      )
+    )
+  };
+}
+var init_project_fingerprint = __esm({
+  "../src/database/neoscript/project-fingerprint.ts"() {
+    "use strict";
+    init_src();
+    init_neo_script_recompile_scope();
+    init_compiler_adapter();
+  }
+});
+
+// src/project-source/neoscript-build-cache.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { dirname as dirname3, join as join4 } from "node:path";
+function loadOrBuildNeoScriptProjectV1(root, document) {
+  const fingerprint = neoScriptProjectFingerprint(document);
+  if (root.length > 0) {
+    const cached = readCache(join4(root, NEOSCRIPT_BUILD_CACHE_PATH));
+    if (cached?.fingerprint === fingerprint) return cached.project;
+  }
+  const project = createNeoScriptCompilationProject({
+    project: document.project,
+    projectFiles: document.projectFiles,
+    members: document.members,
+    classes: document.classes,
+    enums: document.enums,
+    interfaces: document.interfaces,
+    constructors: document.constructors ?? []
+  });
+  if (root.length > 0) {
+    writeCache(join4(root, NEOSCRIPT_BUILD_CACHE_PATH), {
+      formatVersion: 1,
+      fingerprint,
+      project
+    });
+  }
+  return project;
+}
+function neoScriptProjectFingerprint(document) {
+  return createHash4("sha256").update(
+    canonicalJsonStringify(neoScriptCompilationProjectContract(document))
+  ).digest("hex");
+}
+function readCache(path) {
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object") return null;
+    const cache = parsed;
+    if (cache.formatVersion !== 1 || typeof cache.fingerprint !== "string" || !isNeoScriptProject(cache.project)) {
+      return null;
+    }
+    return cache;
+  } catch {
+    return null;
+  }
+}
+function writeCache(path, cache) {
+  mkdirSync4(dirname3(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync4(temporary, `${JSON.stringify(cache)}
+`, "utf8");
+  renameSync2(temporary, path);
+}
+function isNeoScriptProject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const record3 = value;
+  return (typeof record3.version === "string" || typeof record3.version === "number") && Array.isArray(record3.types) && Array.isArray(record3.globals) && Array.isArray(record3.roots);
+}
+var NEOSCRIPT_BUILD_CACHE_PATH;
+var init_neoscript_build_cache = __esm({
+  "src/project-source/neoscript-build-cache.ts"() {
+    "use strict";
+    init_project_content_hash();
+    init_compiler_adapter();
+    init_project_fingerprint();
+    NEOSCRIPT_BUILD_CACHE_PATH = ".neo/build/neoscript-project-v1.json";
+  }
+});
+
 // src/project-source/local-initializer-materialization.ts
 function materializedInitializerReconciliationFailuresV4(args) {
   if (args.reconciliations.size === 0) return [];
   const records2 = reconciliationRecords(args.workspace, args.changes);
   const document = readPulledProjectDocumentV4(records2);
+  const currentDocument = readPulledProjectDocumentV4(
+    reconciliationRecords(args.workspace, [])
+  );
+  const recompileTargets = collectNeoScriptRecompileTargets({
+    currentDocument,
+    postDocument: document,
+    forceRecompile: args.forceRecompile,
+    changes: args.changes.map((change) => ({
+      recordKind: change.recordKind,
+      recordId: change.recordId,
+      operation: change.kind,
+      ...change.kind === "delete" ? { deleted: true } : {},
+      ...change.nextData === void 0 ? {} : { nextData: change.nextData }
+    }))
+  });
   const currentRows = valueRowsFromWorkspace(args.workspace);
   const currentGraph = new MaterializedValueGraphContext(document, currentRows);
+  const reconciliationByValueId = new Map(
+    [...args.reconciliations.values()].map((entry) => [entry.valueId, entry])
+  );
+  const candidateValueIds = new Set(
+    [...reconciliationByValueId.values()].filter((reconciliation) => reconciliation.storedConstructorArgs !== null).map((reconciliation) => reconciliation.valueId)
+  );
+  const candidateOwners = resolveOwnerMembersForValues(
+    document,
+    candidateValueIds
+  );
+  const currentRecords = reconciliationRecords(args.workspace, []);
+  const cachedExpressions = readMaterializedConstructionBuildCacheV1(
+    args.workspace.root,
+    args.workspace.state
+  );
+  const canonicalExpressions = new Map(cachedExpressions ?? []);
+  if (args.manifest !== void 0) {
+    const missingRoots = [...candidateValueIds].flatMap((valueId) => {
+      if (canonicalExpressions.has(valueId)) return [];
+      const owner = candidateOwners.get(valueId);
+      return owner === void 0 ? [] : [
+        {
+          valueId,
+          member: owner
+        }
+      ];
+    });
+    if (missingRoots.length > 0) {
+      for (const [valueId, expression] of emitStoredConstructorExpressionsV4(
+        currentRecords,
+        args.manifest,
+        missingRoots
+      )) {
+        canonicalExpressions.set(valueId, expression);
+      }
+      writeMaterializedConstructionBuildCacheV1(
+        args.workspace.root,
+        args.workspace.state,
+        canonicalExpressions
+      );
+    }
+  }
+  const replayableValueIds = /* @__PURE__ */ new Set();
+  for (const valueId of candidateValueIds) {
+    const reconciliation = reconciliationByValueId.get(valueId);
+    const owner = candidateOwners.get(valueId);
+    if (reconciliation === void 0 || owner === void 0) continue;
+    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpressions.get(valueId) !== constructorExpressionSlice(reconciliation.code);
+    if (authoredConstructionChanged || recompileTargets.valueIds.has(valueId)) {
+      replayableValueIds.add(valueId);
+    }
+  }
+  const owners = resolveOwnerMembersForValues(document, replayableValueIds);
+  const compilationProject = replayableValueIds.size === 0 ? void 0 : loadOrBuildNeoScriptProjectV1(args.workspace.root, document);
   const failures = [];
   for (const reconciliation of args.reconciliations.values()) {
+    if (reconciliation.storedConstructorArgs === null) continue;
+    if (!replayableValueIds.has(reconciliation.valueId)) continue;
+    const owner = owners.get(reconciliation.valueId);
+    if (owner === void 0) {
+      throw new Error(
+        `Cannot reconcile stored construction for value "${reconciliation.valueId}": its owning member is unresolved.`
+      );
+    }
     const replayRows = new Map(currentRows);
     for (const [id2, row] of replayStoredConstructionV4({
       records: records2,
+      document,
       valueId: reconciliation.valueId,
-      code: reconciliation.code
+      code: reconciliation.code,
+      member: owner,
+      ...compilationProject === void 0 ? {} : { compilationProject }
     })) {
       if (!isMemberValue(row)) {
         throw new Error(
@@ -67634,7 +69146,7 @@ function materializedInitializerReconciliationFailuresV4(args) {
     const replay = replayRows.get(reconciliation.valueId);
     const replayArgs = replay !== void 0 && isLiteralValueContent(replay) ? replay.constructorArgs : void 0;
     const currentRoot = currentRows.get(reconciliation.valueId);
-    const argumentsMatch = reconciliation.storedConstructorArgs === null ? true : isObjectRecord2(replayArgs) && currentRoot !== void 0 && replay !== void 0 && canonicallyEqual(
+    const argumentsMatch = isObjectRecord2(replayArgs) && currentRoot !== void 0 && replay !== void 0 && canonicallyEqual(
       currentGraph.normalizeConstructorArguments(
         reconciliation.storedConstructorArgs,
         currentRoot
@@ -67928,10 +69440,14 @@ var init_local_initializer_materialization = __esm({
     init_source_diagnostics();
     init_projection();
     init_value_sources();
+    init_init_source();
+    init_materialized_construction_cache();
     init_initializer_replay();
     init_members();
     init_constructor_argument_ownership();
     init_value_row_owner_members();
+    init_neo_script_recompile_scope();
+    init_neoscript_build_cache();
   }
 });
 
@@ -68081,6 +69597,12 @@ function compareWorkspacePaths(left, right) {
   return 0;
 }
 function computeWorkspaceStatus(workspace, options) {
+  let phaseStarted = performance.now();
+  const reportPhase = (phase) => {
+    const finished = performance.now();
+    options.reportPhase?.(phase, finished - phaseStarted);
+    phaseStarted = finished;
+  };
   const conflictedFiles = [];
   const parseErrors = [];
   const parseWarnings = [];
@@ -68138,13 +69660,12 @@ function computeWorkspaceStatus(workspace, options) {
         "Format-4 status requires a pulled schema base; run `neo pull --reset`."
       );
     }
-    const analysis = compileNeoProjectSources(
-      projectSources.map((source) => ({
-        uri: source.uri,
-        kind: source.kind,
-        text: source.source
-      }))
-    );
+    const compilationSources = projectSources.map((source) => ({
+      uri: source.uri,
+      kind: source.kind,
+      text: source.source
+    }));
+    const analysis = options.readProjectAnalysisCache?.(workspace.root, compilationSources) ?? options.compileProjectAnalysis?.(workspace.root, compilationSources) ?? compileNeoProjectSources(compilationSources);
     projectAnalysisV4 = analysis;
     for (const diagnostic of analysis.diagnostics) {
       const positioned = new SchemaSourceError(
@@ -68220,7 +69741,12 @@ function computeWorkspaceStatus(workspace, options) {
         })
       };
     }
-    options.writeProjectAnalysisCache?.(workspace.root, analysis);
+    options.writeProjectAnalysisCache?.(
+      workspace.root,
+      analysis,
+      compilationSources
+    );
+    reportPhase("analysis-schema-defaults");
   } catch (error) {
     parseErrors.push(
       error instanceof SchemaSourceError ? error : new SchemaSourceError(
@@ -68295,6 +69821,7 @@ function computeWorkspaceStatus(workspace, options) {
     manifest,
     { registry: valueLowerRegistry }
   );
+  reportPhase("documents-static-root");
   authoredValueSeeds = new Map([...authoredValueSeeds, ...rootValues.seeds]);
   const rootPathResolutionState = overlayProspectiveSourceRecords(
     workspace.state.records,
@@ -68407,6 +69934,7 @@ function computeWorkspaceStatus(workspace, options) {
     prospectiveState,
     projectAnalysisV4
   );
+  reportPhase("supplemental-dialogue");
   records2.push(
     ...staticValues.records,
     ...memberDefaults.records,
@@ -68523,6 +70051,7 @@ function computeWorkspaceStatus(workspace, options) {
       )
     );
   }
+  reportPhase("record-diff-references");
   if (referenceFailures.length > 0) {
     return {
       changes: [],
@@ -68555,6 +70084,8 @@ function computeWorkspaceStatus(workspace, options) {
         changes,
         authoredValueSeeds,
         reconciliations: valueLowerRegistry.initializerReconciliations,
+        manifest,
+        forceRecompile: options.forceRecompile,
         sourceTextByUri: new Map(
           sourceEntries.map((entry) => [entry.relPath, entry.source])
         )
@@ -68570,6 +70101,7 @@ function computeWorkspaceStatus(workspace, options) {
       )
     );
   }
+  reportPhase("initializer-reconciliation");
   for (const fileId of options.trustedPendingProjectFiles?.keys() ?? []) {
     const key = `project-file:${fileId}`;
     const base = workspace.state.records[key];
@@ -68607,6 +70139,7 @@ function computeWorkspaceStatus(workspace, options) {
   binaryChanges = binaryFiles.filter(
     (binary) => binary.action !== "unchanged" && binary.action !== "converged"
   );
+  reportPhase("binary-inspection");
   const invalidatedFileIds = /* @__PURE__ */ new Set([
     ...binaryFiles.filter(
       (binary) => binary.action === "create" || binary.action === "upload"
@@ -70134,62 +71667,6 @@ var init_member_access_modifier_validation = __esm({
   }
 });
 
-// ../src/database/canonical-json.ts
-function canonicalJsonStringify(value) {
-  return JSON.stringify(toCanonicalJsonValue(value));
-}
-function toCanonicalJsonValue(value) {
-  if (value === null) return null;
-  if (value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") return value;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error("Cannot canonicalize a non-finite number.");
-    }
-    return value;
-  }
-  if (typeof value === "bigint") {
-    throw new Error("Cannot canonicalize bigint values.");
-  }
-  if (typeof value === "symbol") {
-    throw new Error("Cannot canonicalize symbol values.");
-  }
-  if (typeof value === "function") {
-    throw new Error("Cannot canonicalize function values.");
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => {
-      const canonicalItem = toCanonicalJsonValue(item);
-      if (canonicalItem === void 0) return null;
-      return canonicalItem;
-    });
-  }
-  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
-  const canonicalObject = {};
-  for (const [key, entryValue] of entries) {
-    const canonicalValue = toCanonicalJsonValue(entryValue);
-    if (canonicalValue === void 0) continue;
-    canonicalObject[key] = canonicalValue;
-  }
-  return canonicalObject;
-}
-var init_canonical_json = __esm({
-  "../src/database/canonical-json.ts"() {
-    "use strict";
-  }
-});
-
-// ../src/database/project-content-hash.ts
-var init_project_content_hash = __esm({
-  "../src/database/project-content-hash.ts"() {
-    "use strict";
-    init_canonical_json();
-    init_canonical_json();
-  }
-});
-
 // ../src/database/project-migration-created-values.ts
 function validateCreatedMigrationGraph(args) {
   if (args.createdSessionValues.length === 0) return [];
@@ -72459,60 +73936,9 @@ var init_localizable_member_value_writes = __esm({
   }
 });
 
-// ../src/database/neo-script-recompile-scope.ts
-function memberNeoScriptContractChanged(current, next) {
-  if (current.kind !== next.kind) return true;
-  const ignored = new Set(NON_CONTRACT_MEMBER_FIELDS);
-  if (current.kind === 10 /* NSProperty */) {
-    for (const field of NS_PROPERTY_BODY_FIELDS) ignored.add(field);
-  }
-  if (current.kind === 23 /* NSFunction */) {
-    for (const field of NS_FUNCTION_BODY_FIELDS) ignored.add(field);
-  }
-  return canonicalJsonStringify(withoutFields(current, ignored)) !== canonicalJsonStringify(withoutFields(next, ignored));
-}
-function withoutFields(value, ignored) {
-  return Object.fromEntries(
-    Object.entries(value).filter(([field]) => !ignored.has(field))
-  );
-}
-var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS;
-var init_neo_script_recompile_scope = __esm({
-  "../src/database/neo-script-recompile-scope.ts"() {
-    "use strict";
-    init_project_content_hash();
-    init_member_kind_enum();
-    NON_CONTRACT_MEMBER_FIELDS = /* @__PURE__ */ new Set([
-      "createdAt",
-      "updatedAt",
-      "projectId",
-      "docsText",
-      "valueId",
-      "system",
-      "storageKey",
-      "searchKey",
-      "minValue",
-      "maxValue",
-      "decimalPoints",
-      "columnSettings",
-      "schemaKeyOrder",
-      "templateId"
-    ]);
-    NS_PROPERTY_BODY_FIELDS = /* @__PURE__ */ new Set([
-      "code",
-      "getter"
-    ]);
-    NS_FUNCTION_BODY_FIELDS = /* @__PURE__ */ new Set([
-      "code",
-      "action",
-      "bodyMode",
-      "uiAction"
-    ]);
-  }
-});
-
 // ../src/database/project-version-schema-commit.ts
 function prepareServerOwnedSchemaCommit(args) {
+  if (args.forceRecompile === true) clearNeoScriptBodyCompileCache();
   assertUniqueChanges(args.changes);
   let authoredChanges = completeLocalizedTextCreateEnvelopes({
     document: args.document,
@@ -72547,19 +73973,21 @@ function prepareServerOwnedSchemaCommit(args) {
   if (!hasSchemaChange && !hasMigrationChange && !hasDialogueSourceChange && !hasValueChange) {
     return authoredChanges;
   }
-  const requiresCompleteSweep = schemaChangesRequireCompleteBodySweep(
+  const authoredPostDocument = applyProjectVersionWriteChanges(
     args.document,
     authoredChanges
   );
+  const recompileTargets = collectNeoScriptRecompileTargets({
+    currentDocument: args.document,
+    postDocument: authoredPostDocument,
+    changes: authoredChanges,
+    forceRecompile: args.forceRecompile
+  });
   const explicitlyChangedMemberIds = new Set(
     authoredChanges.filter(
       (change) => change.recordKind === "member" && change.operation !== "delete"
     ).map((change) => change.recordId)
   );
-  const authoredPostDocument = applyProjectVersionWriteChanges(
-    args.document,
-    authoredChanges
-  );
   const currentById = new Map(
     args.document.members.map((member) => [member.id, member])
   );
@@ -72569,24 +73997,33 @@ function prepareServerOwnedSchemaCommit(args) {
   const currentSourceMembers = args.document.members.map(
     (member) => stripDerivedBodies(member)
   );
+  const postCompilationProject = cachedServerCompilationProject({
+    ...authoredPostDocument,
+    members: sourceMembers
+  });
+  const currentCompilationProject = cachedServerCompilationProject({
+    ...args.document,
+    members: currentSourceMembers
+  });
   const toleratedPreexistingFailures = /* @__PURE__ */ new Set();
   for (const member of sourceMembers) {
     if (!hasAuthoredNeoScriptBody(member)) continue;
-    if (!requiresCompleteSweep && !explicitlyChangedMemberIds.has(member.id)) {
+    if (!recompileTargets.memberIds.has(member.id)) {
       continue;
     }
     try {
       compileOneAuthoredMember({
         document: authoredPostDocument,
         members: sourceMembers,
-        member
+        member,
+        compilationProject: postCompilationProject
       });
     } catch (postWriteError) {
       if (explicitlyChangedMemberIds.has(member.id)) {
         throw postWriteError;
       }
       const current = currentById.get(member.id);
-      if (!requiresCompleteSweep || current === void 0 || !hasAuthoredNeoScriptBody(current)) {
+      if (current === void 0 || !hasAuthoredNeoScriptBody(current)) {
         throw postWriteError;
       }
       const currentClone = stripDerivedBodies(current);
@@ -72594,7 +74031,8 @@ function prepareServerOwnedSchemaCommit(args) {
         compileOneAuthoredMember({
           document: args.document,
           members: currentSourceMembers,
-          member: currentClone
+          member: currentClone,
+          compilationProject: currentCompilationProject
         });
       } catch (preWriteError) {
         if (sameCompileFailure(preWriteError, postWriteError)) {
@@ -72627,7 +74065,7 @@ function prepareServerOwnedSchemaCommit(args) {
     args.contentHashHeads.filter((head) => !head.deleted).map((head) => [`${head.recordKind}:${head.recordId}`, head.contentHash])
   );
   for (const compiled of sourceMembers) {
-    if (!requiresCompleteSweep) break;
+    if (!recompileTargets.memberIds.has(compiled.id)) continue;
     if (explicitMemberIds.has(compiled.id)) continue;
     if (toleratedPreexistingFailures.has(compiled.id)) continue;
     if (!hasAuthoredNeoScriptBody(compiled)) continue;
@@ -72654,7 +74092,7 @@ function prepareServerOwnedSchemaCommit(args) {
     document: args.document,
     postDocument: authoredPostDocument,
     prepared,
-    requiresCompleteSweep,
+    targetIds: recompileTargets.constructorIds,
     contentHashHeads: args.contentHashHeads
   });
   const compiledPostDocument = applyProjectVersionWriteChanges(
@@ -72730,14 +74168,14 @@ function prepareServerOwnedSchemaCommit(args) {
     document: args.document,
     postDocument,
     prepared,
-    requiresCompleteSweep,
+    targetIds: recompileTargets.migrationIds,
     contentHashHeads: args.contentHashHeads
   });
   prepareServerOwnedDialogueBodies({
     currentDocument: args.document,
     postDocument,
     prepared,
-    requiresCompleteSweep,
+    recompileTargets,
     contentHashHeads: args.contentHashHeads
   });
   materializeAuthoredValueSeeds({
@@ -72750,7 +74188,7 @@ function prepareServerOwnedSchemaCommit(args) {
     document: args.document,
     postDocument,
     prepared,
-    requiresCompleteSweep,
+    targetIds: recompileTargets.valueIds,
     contentHashHeads: args.contentHashHeads
   });
   materializePreparedInstanceInitializers({
@@ -72769,7 +74207,7 @@ function prepareServerOwnedSchemaCommit(args) {
     document: args.document,
     postDocument,
     prepared,
-    requiresCompleteSweep,
+    targetIds: recompileTargets.valueIds,
     contentHashHeads: args.contentHashHeads
   });
   const committedDocument = applyProjectVersionWriteChanges(
@@ -73709,7 +75147,6 @@ function prepareServerOwnedDialogueBodies(args) {
       explicitGroupIds.add(change.recordId);
     }
   }
-  const compileEveryNode = args.requiresCompleteSweep;
   const compiledNodes = /* @__PURE__ */ new Map();
   for (const node of postNodes) {
     const nodeId = requiredRecordString(node, "id", "dialogue node");
@@ -73718,7 +75155,9 @@ function prepareServerOwnedDialogueBodies(args) {
       "dialogueId",
       `dialogue node ${nodeId}`
     );
-    if (!compileEveryNode && !changedDialogueIds.has(dialogueId)) continue;
+    if (!changedDialogueIds.has(dialogueId) && !args.recompileTargets.dialogueNodeIds.has(nodeId)) {
+      continue;
+    }
     const dialogue = postDialogues.get(dialogueId);
     if (dialogue === void 0) {
       throw new Error(
@@ -73739,7 +75178,9 @@ function prepareServerOwnedDialogueBodies(args) {
   for (const groupValue of args.postDocument.dialogueGroups ?? []) {
     const group = groupValue;
     const groupId = requiredRecordString(group, "id", "dialogue group");
-    if (!args.requiresCompleteSweep && !explicitGroupIds.has(groupId)) continue;
+    if (!explicitGroupIds.has(groupId) && !args.recompileTargets.dialogueGroupIds.has(groupId)) {
+      continue;
+    }
     compiledGroups.set(
       groupId,
       compileDialogueGroupSourceBodies({ group, document: args.postDocument })
@@ -74989,11 +76430,11 @@ function prepareServerOwnedValueInitializerBodies(args) {
     if (row === null) continue;
     explicitRows.set(index, row);
   }
-  const sweepRows = args.requiresCompleteSweep ? args.postDocument.values.filter(
-    (value) => isInitValueContent(value) && !args.prepared.some(
+  const sweepRows = args.postDocument.values.filter(
+    (value) => args.targetIds.has(value.id) && isInitValueContent(value) && !args.prepared.some(
       (change) => change.recordKind === "value" && change.recordId === value.id
     )
-  ) : [];
+  );
   if (explicitRows.size === 0 && sweepRows.length === 0) return;
   const committedDocument = applyProjectVersionWriteChanges(
     args.postDocument,
@@ -75101,11 +76542,11 @@ function prepareServerOwnedDelegateValueBodies(args) {
     const row = delegateValueRow(change.nextData);
     if (row !== null) explicitRows.set(index, row);
   }
-  const sweepRows = args.requiresCompleteSweep ? args.postDocument.values.filter(
-    (value) => delegateValueRow(value) !== null && !args.prepared.some(
+  const sweepRows = args.postDocument.values.filter(
+    (value) => args.targetIds.has(value.id) && delegateValueRow(value) !== null && !args.prepared.some(
       (change) => change.recordKind === "value" && change.recordId === value.id
     )
-  ) : [];
+  );
   if (explicitRows.size === 0 && sweepRows.length === 0) return;
   const committedDocument = applyProjectVersionWriteChanges(
     args.postDocument,
@@ -75204,12 +76645,19 @@ function prepareServerOwnedConstructorBodies(args) {
   const sourceConstructors = (args.postDocument.constructors ?? []).map(
     (record3) => stripConstructorDerivedBodies(record3)
   );
+  const postCompilationProject = cachedServerCompilationProject({
+    ...args.postDocument,
+    constructors: sourceConstructors
+  });
+  const currentCompilationProject = cachedServerCompilationProject(
+    args.document
+  );
   const explicitIds = new Set(
     args.prepared.filter(
       (change) => change.recordKind === "constructor" && change.operation !== "delete"
     ).map((change) => change.recordId)
   );
-  const compileOne = (document, constructors, constructorRecord) => {
+  const compileOne = (document, constructors, constructorRecord, compilationProject) => {
     compileConstructorRecord({
       project: document.project,
       projectFiles: document.projectFiles,
@@ -75218,24 +76666,33 @@ function prepareServerOwnedConstructorBodies(args) {
       enums: document.enums,
       interfaces: document.interfaces,
       constructors,
+      compilationProject,
       constructor: constructorRecord
     });
   };
   const toleratedFailures = /* @__PURE__ */ new Set();
   for (const constructorRecord of sourceConstructors) {
-    if (!args.requiresCompleteSweep && !explicitIds.has(constructorRecord.id)) {
+    if (!args.targetIds.has(constructorRecord.id)) {
       continue;
     }
     try {
-      compileOne(args.postDocument, sourceConstructors, constructorRecord);
+      compileOne(
+        args.postDocument,
+        sourceConstructors,
+        constructorRecord,
+        postCompilationProject
+      );
     } catch (postWriteError) {
       if (explicitIds.has(constructorRecord.id)) throw postWriteError;
       const current = currentById.get(constructorRecord.id);
       if (current === void 0) throw postWriteError;
       try {
-        compileOne(args.document, args.document.constructors ?? [], {
-          ...current
-        });
+        compileOne(
+          args.document,
+          args.document.constructors ?? [],
+          { ...current },
+          currentCompilationProject
+        );
       } catch (preWriteError) {
         if (sameCompileFailure(preWriteError, postWriteError)) {
           toleratedFailures.add(constructorRecord.id);
@@ -75260,7 +76717,6 @@ function prepareServerOwnedConstructorBodies(args) {
     }
     args.prepared[index] = { ...change, nextData: compiled };
   }
-  if (!args.requiresCompleteSweep) return;
   const explicitAllIds = new Set(
     args.prepared.filter((change) => change.recordKind === "constructor").map((change) => change.recordId)
   );
@@ -75268,6 +76724,7 @@ function prepareServerOwnedConstructorBodies(args) {
     args.contentHashHeads.filter((head) => head.recordKind === "constructor" && !head.deleted).map((head) => [head.recordId, head.contentHash])
   );
   for (const compiled of sourceConstructors) {
+    if (!args.targetIds.has(compiled.id)) continue;
     if (explicitAllIds.has(compiled.id)) continue;
     if (toleratedFailures.has(compiled.id)) continue;
     const current = currentById.get(compiled.id);
@@ -75307,7 +76764,7 @@ function prepareServerOwnedMigrationBodies(args) {
   );
   const toleratedFailures = /* @__PURE__ */ new Set();
   for (const migration of sourceMigrations) {
-    if (!args.requiresCompleteSweep && !explicitIds.has(migration.id)) continue;
+    if (!args.targetIds.has(migration.id)) continue;
     try {
       Object.assign(migration, {
         action: compileProjectMigrationAction(args.postDocument, migration)
@@ -75343,7 +76800,6 @@ function prepareServerOwnedMigrationBodies(args) {
     }
     args.prepared[index] = { ...change, nextData: compiled };
   }
-  if (!args.requiresCompleteSweep) return;
   const explicitAllIds = new Set(
     args.prepared.filter((change) => change.recordKind === "migration").map((change) => change.recordId)
   );
@@ -75351,6 +76807,7 @@ function prepareServerOwnedMigrationBodies(args) {
     args.contentHashHeads.filter((head) => head.recordKind === "migration" && !head.deleted).map((head) => [head.recordId, head.contentHash])
   );
   for (const compiled of sourceMigrations) {
+    if (!args.targetIds.has(compiled.id)) continue;
     if (explicitAllIds.has(compiled.id) || toleratedFailures.has(compiled.id)) {
       continue;
     }
@@ -75384,6 +76841,7 @@ function compileOneAuthoredMember(args) {
     enums: args.document.enums,
     interfaces: args.document.interfaces,
     constructors: args.document.constructors,
+    compilationProject: args.compilationProject,
     member: args.member,
     thisClass: placement?.ownerClass ?? null
   });
@@ -75392,22 +76850,24 @@ function sameCompileFailure(left, right) {
   if (!(left instanceof Error) || !(right instanceof Error)) return false;
   return left.name === right.name && left.message === right.message;
 }
-function schemaChangesRequireCompleteBodySweep(document, changes) {
-  const currentMembers = new Map(
-    document.members.map((member) => [member.id, member])
+function cachedServerCompilationProject(document) {
+  const fingerprint = hashCanonicalJson(
+    neoScriptCompilationProjectContract(document)
   );
-  for (const change of changes) {
-    if (change.recordKind === "class" || change.recordKind === "constructor" || change.recordKind === "enum" || change.recordKind === "interface") {
-      return true;
-    }
-    if (change.recordKind !== "member") continue;
-    if (change.operation !== "update") return true;
-    const current = currentMembers.get(change.recordId);
-    const next = asRecord(change.nextData);
-    if (current === void 0 || next === null) return true;
-    if (memberNeoScriptContractChanged({ ...current }, next)) return true;
+  const cached = serverCompilationProjectCache.get(fingerprint);
+  if (cached !== void 0) {
+    serverCompilationProjectCache.delete(fingerprint);
+    serverCompilationProjectCache.set(fingerprint, cached);
+    return cached;
   }
-  return false;
+  const compiled = createNeoScriptCompilationProject(document);
+  serverCompilationProjectCache.set(fingerprint, compiled);
+  while (serverCompilationProjectCache.size > SERVER_COMPILATION_PROJECT_CACHE_LIMIT) {
+    const oldest = serverCompilationProjectCache.keys().next().value;
+    if (typeof oldest !== "string") break;
+    serverCompilationProjectCache.delete(oldest);
+  }
+  return compiled;
 }
 function assertUniqueChanges(changes) {
   const keys = /* @__PURE__ */ new Set();
@@ -75673,7 +77133,7 @@ function requiredRecordString(value, field, label) {
 function canonicallyEqual2(left, right) {
   return canonicalJsonStringify(left) === canonicalJsonStringify(right);
 }
-var READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE, SCHEMA_RECORD_KINDS, DIALOGUE_SOURCE_RECORD_KINDS;
+var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE, SCHEMA_RECORD_KINDS, DIALOGUE_SOURCE_RECORD_KINDS;
 var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
@@ -75688,6 +77148,8 @@ var init_project_version_schema_commit = __esm({
     init_internal_record_relations();
     init_project_content_hash();
     init_compile_ns_property();
+    init_compiler_adapter();
+    init_project_fingerprint();
     init_project_migration_runner();
     init_neoscript_evaluator();
     init_project_version_intents();
@@ -75704,6 +77166,8 @@ var init_project_version_schema_commit = __esm({
     init_member_value_id();
     init_world_system_classes();
     init_neo_script_recompile_scope();
+    SERVER_COMPILATION_PROJECT_CACHE_LIMIT = 4;
+    serverCompilationProjectCache = /* @__PURE__ */ new Map();
     READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE = "server-readonly-source-conversion";
     SCHEMA_RECORD_KINDS = /* @__PURE__ */ new Set([
       "member",
@@ -78917,7 +80381,8 @@ function prepareServerPreparationChanges(args) {
     initializerMaterialization: args.initializerMaterialization,
     // A CLI push is always a trusted-source commit, so the server always
     // expands read-only source conversions for it.
-    expandReadOnlySourceConversions: true
+    expandReadOnlySourceConversions: true,
+    forceRecompile: args.forceRecompile
   });
   assertProjectVersionWholeGraphWritesValid({ document, changes: prepared });
   return prepared;
@@ -79072,7 +80537,8 @@ function replayStoredConstructionV4(args) {
     valueId: args.valueId,
     // Instance calls are self-contained. Declaration calls inherit the class
     // header parameters that are in lexical scope at their source site.
-    initializerOwnerClass: args.initializerOwnerClass ?? null
+    initializerOwnerClass: args.initializerOwnerClass ?? null,
+    ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject }
   });
   if (!isMemberValue(candidate) || !isInitValueContent(candidate)) {
     throw new Error(
@@ -79265,7 +80731,8 @@ function buildValueEmitContext(records2, manifest) {
     ),
     fileSymbols: projectFileSymbols(records2),
     localizedTextIds: /* @__PURE__ */ new Set(),
-    constructionReplays: /* @__PURE__ */ new Map()
+    constructionReplays: /* @__PURE__ */ new Map(),
+    materializedConstructors: /* @__PURE__ */ new Map()
   };
 }
 function emitStoredValueBindingSourcesV4(records2, memberIds, options) {
@@ -79302,7 +80769,100 @@ function emitStoredValueBindingSourcesV4(records2, memberIds, options) {
     );
     context.localizedTextIds.clear();
   }
-  return { initializers, recordKeysByMember };
+  return {
+    initializers,
+    recordKeysByMember,
+    materializedConstructors: context.materializedConstructors
+  };
+}
+function emitStoredConstructorExpressionsV4(records2, manifest, roots) {
+  const context = buildValueEmitContext(records2, manifest);
+  return new Map(
+    roots.map(({ member, valueId }) => [
+      valueId,
+      emitStoredConstructorExpression(context, member, valueId)
+    ])
+  );
+}
+function emitStoredConstructorExpression(context, member, valueId) {
+  const value = context.values.get(valueId);
+  if (value === void 0) {
+    throw new Error(`Stored member value ${valueId} was not pulled.`);
+  }
+  const resolvedMember = resolveGenericValueMember(
+    context,
+    member,
+    declaringClassGenericEnvironment(context, member)
+  );
+  if (numberField(resolvedMember, "kind") !== 7 /* Class */) {
+    throw new Error(
+      `Stored construction ${valueId} belongs to a non-Class member.`
+    );
+  }
+  const classId = stringOrNull(value.classId) ?? stringField3(resolvedMember, "classId");
+  const schemaClass2 = context.classes.get(classId);
+  if (schemaClass2 === void 0) {
+    throw new Error(`Unknown value class ${classId}.`);
+  }
+  const storedEnvironment = valueGenericEnvironment(
+    value,
+    instanceGenericEnvironment(context, classId, resolvedMember, void 0)
+  );
+  const targetValueIds = animationConstructorProjectionTargetValueIds(
+    context,
+    classId,
+    value
+  );
+  const environment = inferAnimationChildOverrideEmitEnvironment(
+    context,
+    classId,
+    targetValueIds,
+    storedEnvironment
+  );
+  const className = classValueTypeName(
+    context,
+    classId,
+    resolvedMember,
+    environment
+  );
+  const constructor2 = storedConstructorCallSource(
+    context,
+    schemaClass2,
+    value,
+    className,
+    environment,
+    /* @__PURE__ */ new Set([valueId]),
+    false
+  );
+  if (constructor2 === null) {
+    throw new Error(
+      `Stored materialized value ${valueId} has no constructor arguments.`
+    );
+  }
+  return constructor2;
+}
+function animationConstructorProjectionTargetValueIds(context, classId, value) {
+  if (context.manifestClasses.get(classId)?.system?.worldKind !== "animationChildOverride" || !isObjectRecord2(value.value)) {
+    return [];
+  }
+  const targetIds = [];
+  for (const projection of inheritedConstructorProjections2(
+    context.manifestClasses,
+    classId
+  )) {
+    const schemaKey = inheritedProjectionSchemaKey(
+      context.manifestClasses,
+      classId,
+      projection.memberId
+    );
+    const childValueId = schemaKey === null ? void 0 : value.value[schemaKey];
+    const childValue = typeof childValueId === "string" ? context.values.get(childValueId) : void 0;
+    const projectedMember = context.members.get(projection.memberId);
+    if (childValue !== void 0 && projectedMember !== void 0 && numberField(projectedMember, "kind") === 9 /* Lookup */ && Array.isArray(childValue.value) && typeof childValue.value[0] === "string") {
+      targetIds.push(childValue.value[0]);
+    }
+  }
+  return targetIds;
 }
 function rowBackedDefaultBody(member, isPulledValueRow) {
   if (member.isStatic === true) return null;
@@ -79393,7 +80953,11 @@ function emitMemberDefaultSourcesV4(records2, manifest) {
     );
     context.localizedTextIds.clear();
   }
-  return { initializers, recordKeysByMember };
+  return {
+    initializers,
+    recordKeysByMember,
+    materializedConstructors: context.materializedConstructors
+  };
 }
 function qualifiedProjectFileSymbolsV4(records2) {
   const symbols = projectFileSymbols(records2);
@@ -83053,6 +84617,9 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     visited,
     targetTyped
   );
+  if (storedConstruction !== null && typeof value.id === "string") {
+    context.materializedConstructors.set(value.id, storedConstruction);
+  }
   const replayConstruction = storedConstruction === null ? null : storedConstructorCallSource(
     context,
     schemaClass2,
@@ -84340,7 +85907,15 @@ function emitProjectDocumentFilesV4(records2) {
     };
   });
   const supplementalFiles = emitSupplementalProjectSourcesV4(records2);
-  const rootFile = emitProjectRootSourceV4(records2, manifest);
+  const materializedConstructors = new Map([
+    ...staticValues.materializedConstructors,
+    ...memberDefaults.materializedConstructors
+  ]);
+  const rootFile = emitProjectRootSourceV4(
+    records2,
+    manifest,
+    materializedConstructors
+  );
   const dialogueFiles = emitDialogueProjectSourcesV4(records2);
   const files = [
     ...source.files,
@@ -84379,7 +85954,7 @@ ${errors.map(
       ).join("\n")}`
     );
   }
-  return { files, recordFiles, analysis };
+  return { files, recordFiles, analysis, materializedConstructors };
 }
 function relationEndpointExpressions(records2) {
   const ownerByMemberId = /* @__PURE__ */ new Map();
@@ -84447,33 +86022,178 @@ var init_project_documents = __esm({
 });
 
 // src/project-source/project-document-cache.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-function writeProjectSourceAnalysisCacheV4(root, analysis) {
-  const file = join3(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
-  mkdirSync3(dirname2(file), { recursive: true });
-  writeFileSync3(file, `${JSON.stringify(analysis, null, 2)}
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import { dirname as dirname4, join as join5 } from "node:path";
+function readProjectSourceAnalysisBuildCacheV4(root, sources) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync5(join5(root, PROJECT_SOURCE_BUILD_CACHE_PATH), "utf8")
+    );
+    if (parsed === null || typeof parsed !== "object") return null;
+    const cache = parsed;
+    if (cache.revision !== PROJECT_SOURCE_BUILD_CACHE_REVISION || cache.fingerprint !== projectSourceFingerprint(sources)) {
+      return null;
+    }
+    assertProjectSourceAnalysisV4(cache.analysis);
+    return cache.analysis;
+  } catch {
+    return null;
+  }
+}
+function writeProjectSourceAnalysisCacheV4(root, analysis, sources) {
+  const file = join5(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
+  mkdirSync5(dirname4(file), { recursive: true });
+  writeFileSync5(file, `${JSON.stringify(analysis, null, 2)}
 `, "utf8");
+  if (sources === void 0) return;
+  const buildFile = join5(root, PROJECT_SOURCE_BUILD_CACHE_PATH);
+  mkdirSync5(dirname4(buildFile), { recursive: true });
+  const temporary = `${buildFile}.${process.pid}.tmp`;
+  writeFileSync5(
+    temporary,
+    `${JSON.stringify({
+      revision: PROJECT_SOURCE_BUILD_CACHE_REVISION,
+      fingerprint: projectSourceFingerprint(sources),
+      analysis
+    })}
+`,
+    "utf8"
+  );
+  renameSync3(temporary, buildFile);
+}
+function compileProjectSourceAnalysisWithBuildCacheV4(root, sources) {
+  const parsedDocuments = readProjectSourceDocumentBuildCacheV1(root, sources);
+  let documents;
+  try {
+    const analysis = compileNeoProjectSources(sources, {
+      parsedDocuments,
+      onDocuments: (result) => {
+        documents = result;
+      }
+    });
+    if (documents !== void 0) {
+      writeProjectSourceDocumentBuildCacheV1(root, sources, documents);
+    }
+    return analysis;
+  } catch (error) {
+    if (parsedDocuments.size === 0) throw error;
+    documents = void 0;
+    const analysis = compileNeoProjectSources(sources, {
+      onDocuments: (result) => {
+        documents = result;
+      }
+    });
+    if (documents !== void 0) {
+      writeProjectSourceDocumentBuildCacheV1(root, sources, documents);
+    }
+    return analysis;
+  }
+}
+function readProjectSourceDocumentBuildCacheV1(root, sources) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync5(
+        join5(root, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH),
+        "utf8"
+      )
+    );
+    if (parsed === null || typeof parsed !== "object") return /* @__PURE__ */ new Map();
+    const cache = parsed;
+    if (cache.revision !== PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION || cache.compilerRevision !== NEOSCRIPT_COMPILER_REVISION || cache.files === null || typeof cache.files !== "object" || Array.isArray(cache.files)) {
+      return /* @__PURE__ */ new Map();
+    }
+    const files = cache.files;
+    const documents = /* @__PURE__ */ new Map();
+    for (const source of sources) {
+      const cached = files[source.uri];
+      if (cached?.fingerprint !== projectSourceFileFingerprint(source) || !isCachedProjectSourceDocument(cached.document, source)) {
+        continue;
+      }
+      documents.set(source.uri, cached.document);
+    }
+    return documents;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function writeProjectSourceDocumentBuildCacheV1(root, sources, documents) {
+  const file = join5(root, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH);
+  mkdirSync5(dirname4(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync5(
+    temporary,
+    `${JSON.stringify({
+      revision: PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION,
+      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+      files: Object.fromEntries(
+        sources.flatMap((source) => {
+          const document = documents.get(source.uri);
+          return document === void 0 ? [] : [
+            [
+              source.uri,
+              {
+                fingerprint: projectSourceFileFingerprint(source),
+                document
+              }
+            ]
+          ];
+        })
+      )
+    })}
+`,
+    "utf8"
+  );
+  renameSync3(temporary, file);
+}
+function projectSourceFileFingerprint(source) {
+  return createHash5("sha256").update(String(PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION)).update("\0").update(String(NEOSCRIPT_COMPILER_REVISION)).update("\0").update(source.kind).update("\0").update(source.text).digest("hex");
+}
+function isCachedProjectSourceDocument(value, source) {
+  if (value === null || typeof value !== "object") return false;
+  const document = value;
+  return document.kind === source.kind && document.sourceText === source.text && Array.isArray(document.declarations) && Array.isArray(document.diagnostics);
+}
+function projectSourceFingerprint(sources) {
+  const hash = createHash5("sha256");
+  hash.update(String(PROJECT_SOURCE_BUILD_CACHE_REVISION));
+  hash.update("\0");
+  hash.update(String(NEOSCRIPT_COMPILER_REVISION));
+  for (const source of sources) {
+    hash.update("\0");
+    hash.update(source.kind);
+    hash.update("\0");
+    hash.update(source.uri);
+    hash.update("\0");
+    hash.update(source.text);
+  }
+  return hash.digest("hex");
 }
+var PROJECT_SOURCE_BUILD_CACHE_PATH, PROJECT_SOURCE_BUILD_CACHE_REVISION, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION;
 var init_project_document_cache = __esm({
   "src/project-source/project-document-cache.ts"() {
     "use strict";
+    init_src();
     init_project_documents();
+    PROJECT_SOURCE_BUILD_CACHE_PATH = ".neo/build/project-source-analysis-v4.json";
+    PROJECT_SOURCE_BUILD_CACHE_REVISION = 1;
+    PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH = ".neo/build/project-source-documents-v1.json";
+    PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION = 1;
   }
 });
 
 // src/project-source/project-files.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import {
   existsSync as existsSync3,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync6,
   readdirSync,
-  renameSync,
+  renameSync as renameSync4,
   rmSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { basename, dirname as dirname3, extname, join as join4, relative, sep } from "node:path";
+import { basename, dirname as dirname5, extname, join as join6, relative, sep } from "node:path";
 function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {}) {
   const templateIds = fileTemplateIdsByName2(analysis);
   const declarations = analysis.files.registries.flatMap(
@@ -84504,7 +86224,7 @@ function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {})
     seenSymbols.set(symbolKey, declaration);
     const baseState = state[`project-file:${declaration.recordId}`];
     const base = isObjectRecord2(baseState?.data) ? baseState.data : null;
-    const absolute = join4(root, normalizedPath);
+    const absolute = join6(root, normalizedPath);
     const trustedPending = options.trustedPendingFiles?.get(
       declaration.recordId
     );
@@ -84621,7 +86341,7 @@ function inspectProjectBinaryStatusV4(root, state, analysis) {
   const result = explicit.map((declaration) => {
     const baseState = state[`project-file:${declaration.recordId}`];
     const data = isObjectRecord2(baseState?.data) ? baseState.data : {};
-    const absolute = join4(root, declaration.path);
+    const absolute = join6(root, declaration.path);
     const local = existsSync3(absolute) ? inspectBinaryFile(absolute, declaration.path) : null;
     const baseSha256 = baseState?.projectBinary?.sha256 ?? normalizeSha256V4(
       data.contentSha256,
@@ -84693,7 +86413,7 @@ function discoverProjectBinariesV4(root, explicit, ignoredPaths = []) {
   );
   const candidates = [];
   for (const directory of ["Files/Images", "Files/AudioClips"]) {
-    const absoluteDirectory = join4(root, directory);
+    const absoluteDirectory = join6(root, directory);
     if (!existsSync3(absoluteDirectory)) continue;
     visitBinaryFiles(absoluteDirectory, (absolute) => {
       const path = normalizeSlash2(relative(root, absolute));
@@ -84710,10 +86430,10 @@ function discoverProjectBinariesV4(root, explicit, ignoredPaths = []) {
   }).sort((left, right) => compareCodePoints(left.path, right.path));
 }
 function sha256Bytes(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex");
+  return createHash6("sha256").update(bytes).digest("hex");
 }
 function sha256File(path) {
-  return sha256Bytes(readFileSync3(path));
+  return sha256Bytes(readFileSync6(path));
 }
 function planBinaryMergeV4(input) {
   const { baseDigest, localDigest, remoteDigest, declarationPresent } = input;
@@ -84744,17 +86464,17 @@ function writeVerifiedBinaryDownloadV4(destination, bytes, expectedSha256) {
       `Downloaded project file checksum ${actual} did not match expected SHA-256 ${expectedSha256}.`
     );
   }
-  mkdirSync4(dirname3(destination), { recursive: true });
+  mkdirSync6(dirname5(destination), { recursive: true });
   const temporary = `${destination}.neo-download-${process.pid}`;
   try {
-    writeFileSync4(temporary, bytes);
-    renameSync(temporary, destination);
+    writeFileSync6(temporary, bytes);
+    renameSync4(temporary, destination);
   } finally {
     rmSync(temporary, { force: true });
   }
 }
 function writeBinaryConflictArtifactV4(root, fileId, fileName2, bytes, expectedSha256) {
-  const destination = join4(
+  const destination = join6(
     root,
     ".neo",
     "conflicts",
@@ -84906,7 +86626,7 @@ function inspectBinaryFile(absolute, path) {
     throw new Error(
       `Unsupported project binary extension ${JSON.stringify(extname(path))} at ${path}.`
     );
-  const bytes = readFileSync3(absolute);
+  const bytes = readFileSync6(absolute);
   return {
     path: normalizeSlash2(path),
     kind: type.kind,
@@ -84920,7 +86640,7 @@ function visitBinaryFiles(directory, visit) {
     (a, b) => compareCodePoints(a.name, b.name)
   )) {
     if (entry.isSymbolicLink()) continue;
-    const path = join4(directory, entry.name);
+    const path = join6(directory, entry.name);
     if (entry.isDirectory()) visitBinaryFiles(path, visit);
     else if (entry.isFile() && SUPPORTED_BINARY_TYPES.has(extname(entry.name).toLowerCase()))
       visit(path);
@@ -84994,15 +86714,15 @@ var init_supplemental_records_file_system = __esm({
 });
 
 // src/project-source/workspace-status.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "node:fs";
-import { join as join5, relative as relative2, sep as sep2 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "node:fs";
+import { join as join7, relative as relative2, sep as sep2 } from "node:path";
 function listProjectSourceFilesV4(root) {
   const files = [];
   const visit = (directory) => {
     if (!existsSync4(directory)) return;
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
-      const path = join5(directory, entry.name);
+      const path = join7(directory, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_SCHEMA_DIRECTORIES2.has(entry.name)) continue;
         visit(path);
@@ -85017,12 +86737,14 @@ function listProjectSourceFilesV4(root) {
 function computeWorkspaceStatus2(workspace, options = {}) {
   const virtualSourceFiles = options.virtualSourceFiles ?? listProjectSourceFilesV4(workspace.root).map((path) => ({
     path: relative2(workspace.root, path).split(sep2).join("/"),
-    content: readFileSync4(path, "utf8")
+    content: readFileSync7(path, "utf8")
   }));
   return computeWorkspaceStatus(workspace, {
     ...options,
     virtualSourceFiles,
     writeProjectAnalysisCache: options.writeProjectAnalysisCache ?? writeProjectSourceAnalysisCacheV4,
+    readProjectAnalysisCache: options.readProjectAnalysisCache ?? readProjectSourceAnalysisBuildCacheV4,
+    compileProjectAnalysis: options.compileProjectAnalysis ?? compileProjectSourceAnalysisWithBuildCacheV4,
     inspectProjectBinaries: inspectProjectBinaryStatusV4,
     lowerSupplementalRecords: (state, analysis, trustedPendingFiles) => lowerSupplementalProjectSourcesV4(workspace.root, state, analysis, {
       ...trustedPendingFiles === void 0 ? {} : { trustedPendingFiles }
@@ -85048,6 +86770,111 @@ var init_workspace_status = __esm({
   }
 });
 
+// src/project-source/status-output.ts
+function groupProjectStatusChangesV4(status) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const change of status.changes) {
+    const reconstructed3 = status.reconstructed.get(
+      recordStateKey(change.recordKind, change.recordId)
+    );
+    const source = reconstructed3?.sourceSpan?.path ?? change.file ?? "<unplaced>";
+    const entries = groups.get(source) ?? [];
+    entries.push(change);
+    groups.set(source, entries);
+  }
+  return [...groups].sort(([left], [right]) => compareCodePoints(left, right)).map(([source, changes]) => ({ source, changes }));
+}
+function projectStatusJsonV4(status, options) {
+  return {
+    conflictedFiles: status.conflictedFiles,
+    // P49 §5. Warnings ride the same channel with `blocking: false`, so an
+    // agent reading this envelope sees a rule that has not been promoted yet
+    // without having to know which codes those are.
+    diagnostics: [...status.parseErrors, ...status.parseWarnings].map(
+      (error) => ({
+        path: error.file,
+        line: error.line,
+        column: error.column,
+        code: error.code ?? null,
+        severity: error.severity,
+        blocking: isBlockingSchemaSourceError(error),
+        message: error.message
+      })
+    ),
+    records: status.changes.map(
+      (change) => recordChangeJsonV4(change, status, options)
+    ),
+    files: (status.binaryChanges ?? []).map((binary) => ({
+      fileId: binary.fileId,
+      symbol: binary.symbol,
+      path: binary.path,
+      kind: binary.kind,
+      action: binary.action,
+      digests: {
+        baseSha256: binary.baseSha256,
+        localSha256: binary.localSha256,
+        remoteSha256: binary.remoteSha256
+      },
+      byteLength: binary.byteLength,
+      mimeType: binary.mimeType,
+      uploadIntent: binary.action === "create" || binary.action === "upload" ? {
+        operation: binary.action === "create" ? "create" : "replace",
+        contentSha256: binary.localSha256,
+        byteLength: binary.byteLength,
+        mimeType: binary.mimeType
+      } : null,
+      conflictArtifactPath: binary.conflictArtifactPath ?? null
+    }))
+  };
+}
+function recordChangeJsonV4(change, status, options) {
+  const reconstructed3 = status.reconstructed.get(
+    recordStateKey(change.recordKind, change.recordId)
+  );
+  const sourceSpan = reconstructed3?.sourceSpan ?? (reconstructed3 === void 0 ? change.file === null ? null : pointSpan(change.file, 1) : pointSpan(reconstructed3.file, reconstructed3.line));
+  const semanticData = change.nextData ?? change.baseData;
+  const result = {
+    operation: change.kind,
+    recordKind: change.recordKind,
+    recordId: change.recordId,
+    baseContentHash: change.baseContentHash ?? null,
+    expectedBaseContentHash: change.casBaseHash ?? null,
+    sourceSpan,
+    placement: placementJsonV4(semanticData)
+  };
+  if (options.includeRecordData) {
+    result.baseData = change.baseData ?? null;
+    result.nextData = change.nextData ?? null;
+  }
+  return result;
+}
+function placementJsonV4(value) {
+  if (!isObjectRecord2(value)) return null;
+  const placement = {};
+  for (const field of [
+    "classId",
+    "containerId",
+    "mapKey",
+    "genericBindings"
+  ]) {
+    if (value[field] !== void 0) placement[field] = value[field];
+  }
+  return Object.keys(placement).length === 0 ? null : placement;
+}
+function pointSpan(path, oneBasedLine) {
+  const point = { line: Math.max(0, oneBasedLine - 1), character: 0 };
+  return { path, start: point, end: point };
+}
+var init_status_output = __esm({
+  "src/project-source/status-output.ts"() {
+    "use strict";
+    init_workspace();
+    init_projection();
+    init_source_diagnostics();
+    init_source_format();
+  }
+});
+
 // ../convex/_generated/api.js
 var api_exports = {};
 __export(api_exports, {
@@ -85562,36 +87389,36 @@ var init_conflict_markers = __esm({
 // src/project-source/reset.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync5,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync3,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync7,
   statSync
 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { dirname as dirname6, join as join8 } from "node:path";
 function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
   const emitted = emitProjectDocumentFilesV4(emissionRecords);
   assertUniqueEmittedPaths2(emitted.files);
   const previous = managedFilesBeforeReset(workspace.root);
   for (const directory of FORMAT_4_MANAGED_DIRECTORIES) {
-    rmSync2(join6(workspace.root, directory), { recursive: true, force: true });
+    rmSync2(join8(workspace.root, directory), { recursive: true, force: true });
   }
-  rmSync2(join6(workspace.root, "Scripts"), { recursive: true, force: true });
+  rmSync2(join8(workspace.root, "Scripts"), { recursive: true, force: true });
   for (const file of LEGACY_ROOT_FILES) {
-    rmSync2(join6(workspace.root, file), { force: true });
+    rmSync2(join8(workspace.root, file), { force: true });
   }
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
-    rmSync2(join6(workspace.root, privatePath), { recursive: true, force: true });
+    rmSync2(join8(workspace.root, privatePath), { recursive: true, force: true });
   }
   for (const file of emitted.files) {
-    const absolute = join6(workspace.root, file.path);
-    mkdirSync5(dirname4(absolute), { recursive: true });
-    if (existsSync5(absolute) && readFileSync5(absolute, "utf8") === file.content) {
+    const absolute = join8(workspace.root, file.path);
+    mkdirSync7(dirname6(absolute), { recursive: true });
+    if (existsSync5(absolute) && readFileSync8(absolute, "utf8") === file.content) {
       continue;
     }
-    writeFileSync5(absolute, file.content, "utf8");
+    writeFileSync7(absolute, file.content, "utf8");
   }
   writeProjectSourceAnalysisCacheV4(workspace.root, emitted.analysis);
   const records2 = {};
@@ -85607,11 +87434,16 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
     };
   }
   workspace.state.records = records2;
+  writeMaterializedConstructionBuildCacheV1(
+    workspace.root,
+    workspace.state,
+    emitted.materializedConstructors
+  );
   writeWorkspaceState(workspace.root, workspace.state);
   workspace.config = { ...workspace.config, formatVersion: 4 };
   writeWorkspaceConfig(workspace.root, workspace.config);
   const removed = [...previous].filter(
-    (file) => !existsSync5(join6(workspace.root, file))
+    (file) => !existsSync5(join8(workspace.root, file))
   ).length;
   return {
     written: emitted.files.length,
@@ -85638,7 +87470,7 @@ function managedFilesBeforeReset(root) {
     collectFiles(root, directory, files);
   }
   for (const file of LEGACY_ROOT_FILES) {
-    if (existsSync5(join6(root, file))) files.add(file);
+    if (existsSync5(join8(root, file))) files.add(file);
   }
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
     collectFiles(root, privatePath, files);
@@ -85646,7 +87478,7 @@ function managedFilesBeforeReset(root) {
   return files;
 }
 function collectFiles(root, path, files) {
-  const absolute = join6(root, path);
+  const absolute = join8(root, path);
   if (!existsSync5(absolute)) return;
   if (statSync(absolute).isFile()) {
     files.add(path);
@@ -85669,6 +87501,7 @@ var init_reset = __esm({
     init_workspace();
     init_project_documents();
     init_project_document_cache();
+    init_materialized_construction_cache();
     init_dialogue_sources();
     FORMAT_4_MANAGED_DIRECTORIES = [
       "Classes",
@@ -85810,7 +87643,7 @@ var init_http = __esm({
 
 // src/project-source/project-file-pull.ts
 import { existsSync as existsSync6, rmSync as rmSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 async function pullProjectBinariesV4(args) {
   let client = args.client ?? null;
   const localById = new Map(
@@ -85832,7 +87665,7 @@ async function pullProjectBinariesV4(args) {
     const localStatus = localById.get(record3.recordId);
     const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
     const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record3.data);
-    const absolute = join7(args.workspace.root, path);
+    const absolute = join9(args.workspace.root, path);
     const localDigest = existsSync6(absolute) ? sha256File(absolute) : null;
     const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
     const remoteDigest = requiredSha256(
@@ -85915,7 +87748,7 @@ async function pullProjectBinariesV4(args) {
     if (args.document.records.has(key)) continue;
     const localStatus = localById.get(previous.recordId);
     const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
-    const absolute = join7(args.workspace.root, path);
+    const absolute = join9(args.workspace.root, path);
     const localDigest = existsSync6(absolute) ? sha256File(absolute) : null;
     const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
     const action = planBinaryMergeV4({
@@ -86008,7 +87841,7 @@ function fileName(data) {
 }
 function removePreviousConflict(root, state) {
   if (state?.conflict?.artifactPath === void 0) return;
-  rmSync3(join7(root, state.conflict.artifactPath), { force: true });
+  rmSync3(join9(root, state.conflict.artifactPath), { force: true });
 }
 var init_project_file_pull = __esm({
   "src/project-source/project-file-pull.ts"() {
@@ -86070,13 +87903,13 @@ __export(pull_exports, {
   runPull: () => runPull
 });
 import {
-  mkdirSync as mkdirSync6,
-  writeFileSync as writeFileSync6,
+  mkdirSync as mkdirSync8,
+  writeFileSync as writeFileSync8,
   rmSync as rmSync4,
   existsSync as existsSync7,
-  readFileSync as readFileSync6
+  readFileSync as readFileSync9
 } from "node:fs";
-import { dirname as dirname5, join as join8 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 async function runPull(workspace, options) {
   if (options.reset) {
     await runResetPull(workspace);
@@ -86367,12 +88200,12 @@ async function finishFormat4Pull(args) {
       versionId: workspace.config.versionId
     }) : local;
     if (content === void 0) continue;
-    const absolute = join8(workspace.root, path);
-    mkdirSync6(dirname5(absolute), { recursive: true });
-    const existing = existsSync7(absolute) ? readFileSync6(absolute, "utf8") : null;
+    const absolute = join10(workspace.root, path);
+    mkdirSync8(dirname7(absolute), { recursive: true });
+    const existing = existsSync7(absolute) ? readFileSync9(absolute, "utf8") : null;
     if (existing !== null && !rewritePaths.has(path)) continue;
     if (existing !== content) {
-      writeFileSync6(absolute, content, "utf8");
+      writeFileSync8(absolute, content, "utf8");
       written += 1;
     }
   }
@@ -86380,7 +88213,7 @@ async function finishFormat4Pull(args) {
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
     if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join8(workspace.root, previousPath);
+    const absolute = join10(workspace.root, previousPath);
     if (existsSync7(absolute)) {
       rmSync4(absolute);
       removed += 1;
@@ -86443,6 +88276,14 @@ async function finishFormat4Pull(args) {
   writeWorkspaceState(workspace.root, workspace.state);
   if (conflictCount === 0) {
     writeProjectSourceAnalysisCacheV4(workspace.root, localResult.analysis);
+    writeMaterializedConstructionBuildCacheV1(
+      workspace.root,
+      workspace.state,
+      // The cache is a baseline for workspace.state, not the merged authored
+      // tree. Retaining a local constructor edit here would bless it as the
+      // pulled construction and bypass the P61 recreate-conflict check.
+      serverResult.materializedConstructors
+    );
   }
   const summary = [
     `Pulled ${document.records.size} records`,
@@ -86583,6 +88424,7 @@ var init_pull = __esm({
     init_reset();
     init_project_documents();
     init_project_document_cache();
+    init_materialized_construction_cache();
     init_project_manifest();
     init_project_documents();
     init_project_file_pull();
@@ -86596,8 +88438,8 @@ var init_exports = {};
 __export(init_exports, {
   runInit: () => runInit
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join9, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join11, resolve as resolve2 } from "node:path";
 async function runInit(options) {
   let projectId = options.projectId;
   let projects = [];
@@ -86694,10 +88536,10 @@ async function runInit(options) {
     }) : "neo";
   }
   const root = resolve2(directory);
-  if (existsSync8(join9(root, NEO_CONFIG_FILE))) {
-    throw new Error(`"${join9(root, NEO_CONFIG_FILE)}" already exists.`);
+  if (existsSync8(join11(root, NEO_CONFIG_FILE))) {
+    throw new Error(`"${join11(root, NEO_CONFIG_FILE)}" already exists.`);
   }
-  mkdirSync7(root, { recursive: true });
+  mkdirSync9(root, { recursive: true });
   ensurePrivateStateIgnored(root);
   const config = {
     formatVersion: CURRENT_FORMAT_VERSION,
@@ -86720,14 +88562,14 @@ async function runInit(options) {
   });
 }
 function ensurePrivateStateIgnored(root) {
-  const path = join9(root, ".gitignore");
-  const existing = existsSync8(path) ? readFileSync7(path, "utf8") : "";
+  const path = join11(root, ".gitignore");
+  const existing = existsSync8(path) ? readFileSync10(path, "utf8") : "";
   if (existing.split(/\r?\n/u).some((line) => line.trim() === ".neo/" || line.trim() === ".neo")) {
     return;
   }
   const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}
 `;
-  writeFileSync7(path, `${prefix}.neo/
+  writeFileSync9(path, `${prefix}.neo/
 `, "utf8");
 }
 var init_init = __esm({
@@ -87311,14 +89153,14 @@ __export(scaffold_exports, {
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   existsSync as existsSync9,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync11,
   readdirSync as readdirSync4,
-  renameSync as renameSync2,
+  renameSync as renameSync5,
   rmSync as rmSync5,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname6, isAbsolute, join as join10, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
+import { dirname as dirname8, isAbsolute, join as join12, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
 function runClassNew(workspace, name, isAbstract) {
   assertFormat4(workspace);
   assertIdentifier4(name, "Class name");
@@ -87542,7 +89384,7 @@ function loadValidSources(workspace) {
     return {
       uri,
       kind: requiredSourceKind(uri),
-      text: readFileSync8(absolute, "utf8")
+      text: readFileSync11(absolute, "utf8")
     };
   });
   const analysis = analyzeNeoProjectSources(inputs);
@@ -87993,18 +89835,18 @@ function commitExistingSourceEdits(root, originals, planned) {
   const staged = [];
   try {
     for (const [uri, content] of planned) {
-      const target = join10(root, uri);
+      const target = join12(root, uri);
       const original = originals.get(uri);
       if (original === void 0)
         throw new Error(`Source ${uri} was not loaded.`);
-      if (readFileSync8(target, "utf8") !== original) {
+      if (readFileSync11(target, "utf8") !== original) {
         throw new Error(
           `${uri} changed while the scaffold was being prepared; retry the command.`
         );
       }
       const temporary = `${target}.neo-scaffold-${nonce}.tmp`;
       const backup = `${target}.neo-scaffold-${nonce}.bak`;
-      writeFileSync8(temporary, content, { encoding: "utf8", flag: "wx" });
+      writeFileSync10(temporary, content, { encoding: "utf8", flag: "wx" });
       staged.push({
         target,
         temporary,
@@ -88014,16 +89856,16 @@ function commitExistingSourceEdits(root, originals, planned) {
       });
     }
     for (const file of staged) {
-      renameSync2(file.target, file.backup);
+      renameSync5(file.target, file.backup);
       file.movedOriginal = true;
-      renameSync2(file.temporary, file.target);
+      renameSync5(file.temporary, file.target);
       file.installed = true;
     }
   } catch (error) {
     for (const file of [...staged].reverse()) {
       if (file.installed) rmSync5(file.target, { force: true });
       if (file.movedOriginal && existsSync9(file.backup)) {
-        renameSync2(file.backup, file.target);
+        renameSync5(file.backup, file.target);
       }
       rmSync5(file.temporary, { force: true });
       rmSync5(file.backup, { force: true });
@@ -88033,15 +89875,15 @@ function commitExistingSourceEdits(root, originals, planned) {
   for (const file of staged) rmSync5(file.backup, { force: true });
 }
 function writeNewSource(root, uri, content) {
-  const absolute = join10(root, uri);
-  mkdirSync8(dirname6(absolute), { recursive: true });
-  writeFileSync8(absolute, content, { encoding: "utf8", flag: "wx" });
+  const absolute = join12(root, uri);
+  mkdirSync10(dirname8(absolute), { recursive: true });
+  writeFileSync10(absolute, content, { encoding: "utf8", flag: "wx" });
 }
 function assertNewPathAvailable(root, uri) {
-  const absolute = join10(root, uri);
+  const absolute = join12(root, uri);
   if (existsSync9(absolute))
     throw new Error(`${uri} already exists; no file was changed.`);
-  const directory = dirname6(absolute);
+  const directory = dirname8(absolute);
   if (!existsSync9(directory)) return;
   const basename3 = absolute.slice(directory.length + 1);
   const collision = readdirSync4(directory).find(
@@ -88049,7 +89891,7 @@ function assertNewPathAvailable(root, uri) {
   );
   if (collision) {
     throw new Error(
-      `${uri} collides case-insensitively with ${join10(relative3(root, directory), collision)}.`
+      `${uri} collides case-insensitively with ${join12(relative3(root, directory), collision)}.`
     );
   }
 }
@@ -88105,9 +89947,9 @@ import {
   constants as fsConstants,
   accessSync,
   existsSync as existsSync10,
-  readFileSync as readFileSync9
+  readFileSync as readFileSync12
 } from "node:fs";
-import { extname as extname2, isAbsolute as isAbsolute2, join as join11, relative as relative4, sep as sep4 } from "node:path";
+import { extname as extname2, isAbsolute as isAbsolute2, join as join13, relative as relative4, sep as sep4 } from "node:path";
 function inspectNeoDoctor(workspace) {
   const formatCompatible = workspace.config.formatVersion === CURRENT_FORMAT_VERSION;
   const compiler = inspectCompilerContract();
@@ -88174,7 +90016,7 @@ function inspectSourceContract(workspace) {
     const inputs = files.map((file, index) => ({
       uri: relativeFiles[index],
       kind: requiredSourceKind2(relativeFiles[index]),
-      text: readFileSync9(file, "utf8")
+      text: readFileSync12(file, "utf8")
     }));
     const analysis = compileNeoProjectSources(inputs);
     assertProjectSourceAnalysisV4(analysis);
@@ -88205,7 +90047,7 @@ function inspectSourceContract(workspace) {
   }
 }
 function inspectExtensionContract(root) {
-  const cachePath = join11(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
+  const cachePath = join13(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
   if (!existsSync10(cachePath)) {
     return {
       id: NEO_VSCODE_EXTENSION_ID,
@@ -88217,7 +90059,7 @@ function inspectExtensionContract(root) {
     };
   }
   try {
-    const value = JSON.parse(readFileSync9(cachePath, "utf8"));
+    const value = JSON.parse(readFileSync12(cachePath, "utf8"));
     assertProjectSourceAnalysisV4(value);
     return {
       id: NEO_VSCODE_EXTENSION_ID,
@@ -88289,7 +90131,7 @@ function inspectTrackedBinary(root, record3, errors) {
       `Project file ${record3.recordId} has an invalid SHA-256 base digest.`
     );
   }
-  const absolute = join11(root, path);
+  const absolute = join13(root, path);
   if (existsSync10(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
     errors.push(`Tracked project file ${path} is not readable.`);
   }
@@ -88384,8 +90226,8 @@ var init_doctor = __esm({
 });
 
 // src/commands/push-body-diagnostics.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
+import { join as join14 } from "node:path";
 function createNeoScriptBodySourceLocator(workspace, status) {
   const textByFile = /* @__PURE__ */ new Map();
   return {
@@ -88407,8 +90249,8 @@ function createNeoScriptBodySourceLocator(workspace, status) {
     textOf(file) {
       const cached = textByFile.get(file);
       if (cached !== void 0) return cached;
-      const path = join12(workspace.root, file);
-      const text = existsSync11(path) ? readFileSync10(path, "utf8") : null;
+      const path = join14(workspace.root, file);
+      const text = existsSync11(path) ? readFileSync13(path, "utf8") : null;
       textByFile.set(file, text);
       return text;
     }
@@ -89030,7 +90872,7 @@ __export(script_exports, {
   readDocumentArrays: () => readDocumentArrays,
   runScript: () => runScript
 });
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 function readDocumentArrays(raw) {
   const arrayOf2 = (field) => {
     const value = raw[field];
@@ -89542,9 +91384,9 @@ function buildRootValue(document) {
 }
 function readSource(options, fallback) {
   if (options.source !== null) return options.source;
-  if (options.file !== null) return readFileSync11(options.file, "utf8");
+  if (options.file !== null) return readFileSync14(options.file, "utf8");
   if (fallback !== void 0) return fallback;
-  const stdin = readFileSync11(0, "utf8");
+  const stdin = readFileSync14(0, "utf8");
   if (stdin.trim().length === 0) {
     throw new Error(
       "Provide NeoScript source as an argument, --file, or stdin."
@@ -90651,8 +92493,8 @@ __export(migrate_exports, {
   runMigrate: () => runMigrate
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync5, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync11, readdirSync as readdirSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join15 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
     const name = positional[0];
@@ -90661,8 +92503,8 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
         "Usage: neo migrate new <name> [--target <ClassName|project>]"
       );
     }
-    const migrationsDir = join13(workspace.root, "Migrations");
-    mkdirSync9(migrationsDir, { recursive: true });
+    const migrationsDir = join15(workspace.root, "Migrations");
+    mkdirSync11(migrationsDir, { recursive: true });
     let nextOrder = 1;
     if (existsSync12(migrationsDir)) {
       for (const entry of readdirSync5(migrationsDir)) {
@@ -90673,7 +92515,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       }
     }
     const relPath = migrationFileName(nextOrder, name);
-    const absolute = join13(workspace.root, relPath);
+    const absolute = join15(workspace.root, relPath);
     if (existsSync12(absolute)) {
       throw new Error(`"${relPath}" already exists.`);
     }
@@ -90685,7 +92527,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       target === "project" ? "// Runs once with root context. Write the NeoScript action below." : `// Runs once per ${target} value; \`this\` is the instance.`,
       ""
     ].join("\n");
-    writeFileSync9(absolute, template, "utf8");
+    writeFileSync11(absolute, template, "utf8");
     console.log(`Created ${relPath} \u2014 edit the action body, then "neo push".`);
     console.log("(The id is assigned at push, same as schema creates.)");
     return;
@@ -93114,7 +94956,7 @@ __export(content_exports, {
   runRecords: () => runRecords,
   runValues: () => runValues
 });
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
 function versionPath(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
@@ -93122,9 +94964,9 @@ function versionPath(workspace, suffix) {
 function readBatch(file) {
   let raw = null;
   if (file !== null) {
-    raw = readFileSync12(file, "utf8");
+    raw = readFileSync15(file, "utf8");
   } else if (!process.stdin.isTTY) {
-    raw = readFileSync12(0, "utf8");
+    raw = readFileSync15(0, "utf8");
     if (raw.trim().length === 0) raw = null;
   }
   if (raw === null) return null;
@@ -94146,8 +95988,8 @@ async function uploadProjectFile(context, filePath, preferredTemplateId) {
   const { readFileSync: readFile } = await import("node:fs");
   const { basename: basename3, extname: extname3 } = await import("node:path");
   const bytes = readFile(filePath);
-  const { createHash: createHash4 } = await import("node:crypto");
-  const contentSha256 = createHash4("sha256").update(bytes).digest("hex");
+  const { createHash: createHash8 } = await import("node:crypto");
+  const contentSha256 = createHash8("sha256").update(bytes).digest("hex");
   const name = basename3(filePath);
   const extension = extname3(filePath).toLowerCase();
   const mimeByExtension = {
@@ -94281,7 +96123,7 @@ async function runFiles(context, subcommand, positional) {
         "Usage: neo files texture-settings <fileId> --file <settings.json>"
       );
     }
-    const payload = JSON.parse(readFileSync12(payloadPath, "utf8"));
+    const payload = JSON.parse(readFileSync15(payloadPath, "utf8"));
     const result = await context.client.post(
       versionPath(context.workspace, `files/${fileId}/unity-texture-settings`),
       payload
@@ -94309,8 +96151,8 @@ var export_exports = {};
 __export(export_exports, {
   runExportUnity: () => runExportUnity
 });
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join14 } from "node:path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join16 } from "node:path";
 async function runExportUnity(workspace, outDir) {
   if (outDir === null) {
     throw new Error(
@@ -94322,23 +96164,23 @@ async function runExportUnity(workspace, outDir) {
     `/api/projects/${workspace.config.projectId}/export`,
     { versionId: workspace.config.versionId }
   );
-  const resourcesDir = join14(outDir, "Resources", "Neo");
-  const localizationDir = join14(resourcesDir, "Localization");
-  const scriptsDir = join14(outDir, "Scripts", "Neo");
-  mkdirSync10(localizationDir, { recursive: true });
-  mkdirSync10(scriptsDir, { recursive: true });
-  writeFileSync10(join14(resourcesDir, "project.json"), response.projectJson);
-  writeFileSync10(
-    join14(scriptsDir, "NeoGeneratedTypes.cs"),
+  const resourcesDir = join16(outDir, "Resources", "Neo");
+  const localizationDir = join16(resourcesDir, "Localization");
+  const scriptsDir = join16(outDir, "Scripts", "Neo");
+  mkdirSync12(localizationDir, { recursive: true });
+  mkdirSync12(scriptsDir, { recursive: true });
+  writeFileSync12(join16(resourcesDir, "project.json"), response.projectJson);
+  writeFileSync12(
+    join16(scriptsDir, "NeoGeneratedTypes.cs"),
     response.generatedTypes
   );
   for (const file of response.localizationFiles ?? []) {
-    writeFileSync10(join14(localizationDir, file.fileName), file.content);
+    writeFileSync12(join16(localizationDir, file.fileName), file.content);
   }
-  console.log(`wrote ${join14(resourcesDir, "project.json")}`);
-  console.log(`wrote ${join14(scriptsDir, "NeoGeneratedTypes.cs")}`);
+  console.log(`wrote ${join16(resourcesDir, "project.json")}`);
+  console.log(`wrote ${join16(scriptsDir, "NeoGeneratedTypes.cs")}`);
   for (const file of response.localizationFiles ?? []) {
-    console.log(`wrote ${join14(localizationDir, file.fileName)}`);
+    console.log(`wrote ${join16(localizationDir, file.fileName)}`);
   }
   const diagnostics = response.diagnostics ?? [];
   for (const diagnostic of diagnostics) {
@@ -94356,7 +96198,7 @@ var init_export = __esm({
 });
 
 // ../src/database/project-source-identity.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function hashProjectSourceFiles(inputFiles) {
   const files = normalizeSourceFiles(inputFiles);
   const bytes = Buffer.from(JSON.stringify({ version: 1, files }), "utf8");
@@ -94365,7 +96207,7 @@ function hashProjectSourceFiles(inputFiles) {
       `Project source identity is ${bytes.byteLength} bytes; the limit is ${MAX_SOURCE_BYTES} bytes.`
     );
   }
-  return createHash3("sha256").update(bytes).digest("hex");
+  return createHash7("sha256").update(bytes).digest("hex");
 }
 function normalizeSourceFiles(inputFiles) {
   if (inputFiles.length > MAX_SOURCE_FILES) {
@@ -94456,8 +96298,8 @@ var init_project_source_identity = __esm({
 });
 
 // src/project-source/project-file-push.ts
-import { basename as basename2, join as join15 } from "node:path";
-import { readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename2, join as join17 } from "node:path";
+import { readFileSync as readFileSync16 } from "node:fs";
 function ensureProjectFileBinaryChangesV4(args) {
   for (const binary of args.binaryChanges) {
     if (binary.action !== "upload") continue;
@@ -94502,8 +96344,8 @@ function prepareProjectFilePushesV4(args) {
         `Project file ${recordId} has upload bytes but its source change has no record data.`
       );
     }
-    const absolute = join15(args.workspace.root, binary.path);
-    const bytes = new Uint8Array(readFileSync13(absolute));
+    const absolute = join17(args.workspace.root, binary.path);
+    const bytes = new Uint8Array(readFileSync16(absolute));
     const digest = sha256Bytes(bytes);
     if (binary.localSha256 !== null && digest !== binary.localSha256) {
       throw new Error(
@@ -94846,11 +96688,11 @@ function assertProjectFileAuthoringRecordIdentifiers(recordKind, data) {
   if (recordKind !== "unity-texture-template" && recordKind !== "unity-audio-clip-template") {
     return;
   }
-  if (!isObjectRecord3(data) || typeof data.name !== "string") return;
+  if (!isObjectRecord4(data) || typeof data.name !== "string") return;
   const label = recordKind === "unity-texture-template" ? "Unity texture template name" : "Unity audio clip template name";
   assertProjectFileAuthoringIdentifier(data.name, label);
 }
-function isObjectRecord3(value) {
+function isObjectRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var init_project_file_authoring_identifiers = __esm({
@@ -94965,18 +96807,17 @@ __export(push_exports, {
   prepareNSPropertySetterChanges: () => prepareNSPropertySetterChanges,
   rewriteFilesFromState: () => rewriteFilesFromState,
   runPush: () => runPush,
-  stripServerDerivedNeoScript: () => stripServerDerivedNeoScript,
-  workspaceChangesRequireCompleteBodySweep: () => workspaceChangesRequireCompleteBodySweep
+  stripServerDerivedNeoScript: () => stripServerDerivedNeoScript
 });
 import { randomUUID as randomUUID5 } from "node:crypto";
 import {
-  mkdirSync as mkdirSync11,
-  writeFileSync as writeFileSync11,
+  mkdirSync as mkdirSync13,
+  writeFileSync as writeFileSync13,
   rmSync as rmSync6,
   existsSync as existsSync13,
-  readFileSync as readFileSync14
+  readFileSync as readFileSync17
 } from "node:fs";
-import { dirname as dirname7, join as join16, relative as relative5, sep as sep5 } from "node:path";
+import { dirname as dirname9, join as join18, relative as relative5, sep as sep5 } from "node:path";
 function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInitializerMaterialization) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -95549,7 +97390,9 @@ async function downloadProjectVersionTransactionResult(args) {
 }
 async function preparePushStatus(workspace, options, onPhase = () => void 0) {
   onPhase("Analyzing working copy\u2026");
-  const status = computeWorkspaceStatus2(workspace);
+  const status = computeWorkspaceStatus2(workspace, {
+    forceRecompile: options.forceRecompile
+  });
   if (status.conflictedFiles.length > 0) {
     throw new Error(
       `Resolve conflict markers before pushing: ${status.conflictedFiles.join(", ")}`
@@ -95595,18 +97438,15 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     (change) => change.recordKind === "member" || change.recordKind === "class" || change.recordKind === "enum" || change.recordKind === "interface" || change.nextData !== void 0 && change.recordKind === "migration" && typeof change.nextData.code === "string" && change.nextData.code.trim().length > 0
   );
   const compileSchema = needsNeoScriptCompilation ? await (async () => {
-    const completeSweep = workspaceChangesRequireCompleteBodySweep(
-      status.changes
-    );
     onPhase(
-      completeSweep ? "Compiling affected NeoScript across the changed schema\u2026" : `Compiling NeoScript for ${status.changes.length.toLocaleString("en-US")} changed record(s)\u2026`
+      options.forceRecompile === true ? "Compiling every stored NeoScript body\u2026" : `Compiling NeoScript for ${status.changes.length.toLocaleString("en-US")} changed record(s)\u2026`
     );
     return await buildPostPushCompileSchema(workspace, status);
   })() : null;
   const bodySourceLocator = createNeoScriptBodySourceLocator(workspace, status);
   if (compileSchema !== null) {
     prepareCompleteNeoScriptBodyChanges(workspace, status, compileSchema, {
-      completeSweep: workspaceChangesRequireCompleteBodySweep(status.changes),
+      completeSweep: options.forceRecompile === true,
       bodySourceLocator
     });
   }
@@ -95670,7 +97510,10 @@ async function runPush(workspace, options, preparationOverride) {
         workspace,
         options.dryRun ? cloneStatusForDryRun(status) : status,
         (label) => preparation?.update(label),
-        { fullValidation: options.dryRun }
+        {
+          fullValidation: options.dryRun,
+          forceRecompile: options.forceRecompile === true
+        }
       );
     } catch (error) {
       if (options.dryRun) {
@@ -95829,7 +97672,8 @@ async function runPush(workspace, options, preparationOverride) {
       summary: options.summary ?? "neo push",
       // P43 §4. The local evaluator computes against the pulled snapshot, so
       // the server rejects a push whose base is not the project head.
-      headTransactionHash: workspace.state.headTransactionHash ?? null
+      headTransactionHash: workspace.state.headTransactionHash ?? null,
+      forceRecompile: options.forceRecompile === true
     },
     force ? { "x-neo-force-project-version-write": "true" } : void 0
   );
@@ -95842,6 +97686,7 @@ async function runPush(workspace, options, preparationOverride) {
       throw error;
     }
     if (accepted === null) {
+      const committedChangeCount = immediateCommittedChangeCount(response);
       try {
         if (!applyCommittedHeadTransactionHash(workspace, response)) {
           await recoverHeadTransactionHashFromSchemaSignal(workspace);
@@ -95855,14 +97700,19 @@ async function runPush(workspace, options, preparationOverride) {
         type: "project-transaction-progress",
         transactionId: immediateTransactionId(response),
         phase: "committed",
-        totalChangeCount: status.changes.length,
-        appliedChangeCount: status.changes.length,
+        totalChangeCount: committedChangeCount,
+        appliedChangeCount: committedChangeCount,
         totalChunkCount: null,
         appliedChunkCount: 0,
         errorCode: null,
         errorMessage: null
       });
       reporter.stop();
+      reportAdditionalServerChanges(
+        committedChangeCount,
+        status.changes.length,
+        options.json === true
+      );
       if (options.json !== true) success("Push complete.");
       return true;
     }
@@ -95944,6 +97794,11 @@ async function runPush(workspace, options, preparationOverride) {
       errorMessage: null
     });
     reporter.stop();
+    reportAdditionalServerChanges(
+      completed.totalChangeCount,
+      status.changes.length,
+      options.json === true
+    );
     if (options.json !== true) success("Push complete.");
     return true;
   };
@@ -96034,7 +97889,10 @@ async function runPush(workspace, options, preparationOverride) {
   }
   await finishCommitResponse(result, progress);
 }
-async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => void 0, options = { fullValidation: true }) {
+async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => void 0, options = {
+  fullValidation: true,
+  forceRecompile: false
+}) {
   onPhase("Hashing canonical project source\u2026");
   const source = createPendingProjectSourceIdentityV4(
     workspace,
@@ -96094,7 +97952,8 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
       changes: transportChanges,
       authoredValueSeeds: transportSeeds,
       sourceByRecord: status.reconstructed,
-      localInitializerMaterialization: pendingAssignment.localInitializerMaterialization
+      localInitializerMaterialization: pendingAssignment.localInitializerMaterialization,
+      forceRecompile: options.forceRecompile
     });
   }
   return {
@@ -96407,6 +98266,20 @@ function immediateTransactionId(result) {
   if (!isObjectRecord2(result.transaction)) return null;
   return typeof result.transaction.id === "string" ? result.transaction.id : null;
 }
+function immediateCommittedChangeCount(result) {
+  if (!isObjectRecord2(result) || !Array.isArray(result.changedRecords)) {
+    throw new Error("Transaction response is missing changedRecords.");
+  }
+  return result.changedRecords.length;
+}
+function reportAdditionalServerChanges(totalChangeCount, authoredChangeCount, json) {
+  if (json || totalChangeCount <= authoredChangeCount) return;
+  console.log(
+    color.dim(
+      `Server prepared ${totalChangeCount - authoredChangeCount} additional derived record change(s) (${totalChangeCount} total).`
+    )
+  );
+}
 function applyCommittedProjectTransactionResult(args) {
   const { workspace, result, submittedChanges, candidateAssignments } = args;
   const localStatus = computeWorkspaceStatus2(workspace);
@@ -96735,15 +98608,15 @@ ${finalErrors.map(
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
     if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join16(workspace.root, previousPath);
+    const absolute = join18(workspace.root, previousPath);
     if (existsSync13(absolute)) rmSync6(absolute);
   }
   for (const file of files) {
-    const absolute = join16(workspace.root, file.path);
-    mkdirSync11(dirname7(absolute), { recursive: true });
-    const existing = existsSync13(absolute) ? readFileSync14(absolute, "utf8") : null;
+    const absolute = join18(workspace.root, file.path);
+    mkdirSync13(dirname9(absolute), { recursive: true });
+    const existing = existsSync13(absolute) ? readFileSync17(absolute, "utf8") : null;
     if (existing !== file.content)
-      writeFileSync11(absolute, file.content, "utf8");
+      writeFileSync13(absolute, file.content, "utf8");
   }
   for (const [key, recordState] of Object.entries(workspace.state.records)) {
     const file = result.recordFiles.get(key);
@@ -96778,7 +98651,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
       return {
         uri,
         kind,
-        text: readFileSync14(absolutePath, "utf8")
+        text: readFileSync17(absolutePath, "utf8")
       };
     }
   );
@@ -97113,7 +98986,7 @@ function compileNSFunctionChange(schema, memberData, locator) {
   return next;
 }
 function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options = {}) {
-  const completeSweep = options.completeSweep ?? true;
+  const completeSweep = options.completeSweep ?? false;
   const locator = options.bodySourceLocator ?? createNeoScriptBodySourceLocator(workspace, status);
   const changesById = new Map(
     status.changes.filter((change) => change.recordKind === "member").map((change) => [change.recordId, change])
@@ -97123,17 +98996,19 @@ function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options
     if (!completeSweep && !explicitlyChangedMemberIds.has(String(member.id))) {
       return member;
     }
-    if (member.kind === 10) {
+    if (member.kind === 10 /* NSProperty */) {
       return compileNSPropertyChange(schema, member, locator);
     }
-    if (member.kind === 23) {
+    if (member.kind === 23 /* NSFunction */) {
       return compileNSFunctionChange(schema, member, locator);
     }
     return member;
   });
   schema.members = compiledMembers;
   for (const compiled of compiledMembers) {
-    if (compiled.kind !== 10 && compiled.kind !== 23) continue;
+    if (compiled.kind !== 10 /* NSProperty */ && compiled.kind !== 23 /* NSFunction */) {
+      continue;
+    }
     if (typeof compiled.id !== "string") continue;
     const explicit = changesById.get(compiled.id);
     if (explicit !== void 0) {
@@ -97191,22 +99066,6 @@ function mergeCompiledNeoScriptBody(persisted, compiled) {
   }
   return next;
 }
-function workspaceChangesRequireCompleteBodySweep(changes) {
-  for (const change of changes) {
-    if (change.recordKind === "class" || change.recordKind === "enum" || change.recordKind === "interface") {
-      return true;
-    }
-    if (change.recordKind !== "member") continue;
-    if (change.kind !== "update") return true;
-    const current = isObjectRecord2(change.baseData) ? change.baseData : null;
-    const next = change.nextData;
-    if (current === null || next === void 0 || current.kind !== next.kind) {
-      return true;
-    }
-    if (memberNeoScriptContractChanged(current, next)) return true;
-  }
-  return false;
-}
 function prepareNSPropertySetterChanges(workspace, status) {
   const members = /* @__PURE__ */ new Map();
   for (const record3 of status.reconstructed.values()) {
@@ -97495,11 +99354,11 @@ var init_push = __esm({
     init_project2();
     init_localization2();
     init_world_system_classes();
+    init_members();
     init_project_manifest();
     init_merge();
     init_push_change_intent();
     init_push_body_diagnostics();
-    init_neo_script_recompile_scope();
     ({ compileNSAction: compileNSAction2, compileNSFunction: compileNSFunction2, compileNSGetter: compileNSGetter2, compileNSSetter: compileNSSetter2 } = compiler_adapter_exports);
     ProjectTransactionInterruptedError = class extends Error {
       constructor(transactionId) {
@@ -97541,7 +99400,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join19 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -97651,7 +99510,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join17(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join19(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -97706,15 +99565,15 @@ __export(resolve_exports, {
   runResolve: () => runResolve,
   workspaceFilePath: () => workspaceFilePath
 });
-import { readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join18 } from "node:path";
+import { readFileSync as readFileSync18, rmSync as rmSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join20 } from "node:path";
 function runResolve(workspace, side) {
   let resolvedFiles = 0;
   for (const filePath of listProjectSourceFilesV4(workspace.root)) {
-    const source = readFileSync15(filePath, "utf8");
+    const source = readFileSync18(filePath, "utf8");
     if (detectConflictMarkers(source) === null) continue;
     const resolved = resolveMarkers(source, side);
-    writeFileSync12(filePath, resolved, "utf8");
+    writeFileSync14(filePath, resolved, "utf8");
     resolvedFiles += 1;
   }
   let resolvedBinaries = 0;
@@ -97722,12 +99581,12 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join18(workspace.root, binary.path);
+    const destination = join20(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync15(join18(workspace.root, conflict2.artifactPath)),
+          readFileSync18(join20(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -97737,7 +99596,7 @@ function runResolve(workspace, side) {
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync7(join18(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync7(join20(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -97790,7 +99649,7 @@ function resolveMarkers(source, side) {
   return output.join("\n");
 }
 function workspaceFilePath(workspace, file) {
-  return join18(workspace.root, file);
+  return join20(workspace.root, file);
 }
 var init_resolve = __esm({
   "src/commands/resolve.ts"() {
@@ -97802,451 +99661,8 @@ var init_resolve = __esm({
   }
 });
 
-// src/commands/login.ts
-init_token_store();
-init_ui();
-var CLIENT_ID_BY_PROFILE = {
-  editor: "neo-cli-editor",
-  release: "neo-cli-release"
-};
-var EDITOR_SCOPES = [
-  "openid",
-  "profile:read",
-  "project:list",
-  "project:read",
-  "project:details:read",
-  "project:version:read",
-  "project:version:create",
-  "project:version:status:read",
-  "project:version:changelog:read",
-  "project:record:schema:read",
-  "project:record:schema:write",
-  "project:record:values:read",
-  "project:record:values:write",
-  "project:record:world:read",
-  "project:record:world:write",
-  "project:dialogue:read",
-  "project:dialogue:write",
-  "project:dialogue:logic:read",
-  "project:dialogue:logic:compile",
-  "project:files:read",
-  "project:files:content:read",
-  "project:files:write",
-  "project:localization:config:read",
-  "project:localization:config:write",
-  "project:localization:status:read",
-  "project:localization:status:write",
-  "project:localization:main-values:read",
-  "project:localization:main-values:write",
-  "project:localization:values:read",
-  "project:localization:values:write",
-  "project:localization:export",
-  "project:localization:import",
-  "project:release-channel:read",
-  // `neo export unity` writes project.json + NeoGeneratedTypes.cs headlessly
-  // (the escape hatch when game code references not-yet-generated members and
-  // a broken compile blocks the in-editor sync).
-  "unity:export",
-  // Branch lifecycle (auto-archive after `neo merge`, branch archive/restore)
-  // is editor work; releases stay gated behind the release profile.
-  "project:version:archive",
-  "project:version:restore"
-];
-var RELEASE_SCOPES = [
-  ...EDITOR_SCOPES,
-  "project:version:status:write",
-  "project:release-channel:write",
-  "project:release-channel:publish"
-];
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks).toString("utf8").trim();
-}
-var sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
-async function runLogin(options) {
-  let profile = options.profile;
-  if (profile === null) {
-    profile = isInteractive() && !options.tokenStdin ? await promptSelect({
-      message: "Credential profile",
-      choices: [
-        {
-          name: "editor",
-          value: "editor",
-          description: "Day-to-day schema, content, and branch work (default)"
-        },
-        {
-          name: "release",
-          value: "release",
-          description: "Adds outward-facing ops: publish, archive, channels"
-        }
-      ],
-      nonInteractiveHint: "Pass --profile editor|release."
-    }) : "editor";
-  }
-  const scopes = [...profile === "release" ? RELEASE_SCOPES : EDITOR_SCOPES];
-  if (options.saveProjectId !== null) {
-    scopes.push(`project:${options.saveProjectId}:save:read`);
-  }
-  if (options.tokenStdin) {
-    const token = await readStdin();
-    if (token.length === 0) {
-      throw new Error("--token-stdin received an empty token.");
-    }
-    saveCredential({
-      token,
-      profile,
-      apiBaseUrl: options.apiBaseUrl,
-      scopes,
-      savedAt: Date.now()
-    });
-    console.log(`Stored token for ${options.apiBaseUrl} (${profile}).`);
-    return;
-  }
-  const clientId = CLIENT_ID_BY_PROFILE[profile];
-  const codeResponse = await fetch(
-    new URL("/api/auth/device/code", options.apiBaseUrl),
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ client_id: clientId, scope: scopes.join(" ") })
-    }
-  );
-  const codeBody = await codeResponse.json();
-  if (!codeResponse.ok) {
-    throw new Error(
-      `Device authorization request failed (${codeResponse.status}): ${JSON.stringify(codeBody)}`
-    );
-  }
-  if (!isObjectRecord(codeBody)) {
-    throw new Error("Device authorization response must be a JSON object.");
-  }
-  const deviceCode = codeBody.device_code;
-  const userCode = codeBody.user_code;
-  const verificationUriComplete = codeBody.verification_uri_complete;
-  const interval = typeof codeBody.interval === "number" ? codeBody.interval : 5;
-  if (typeof deviceCode !== "string") {
-    throw new Error('Device authorization response is missing "device_code".');
-  }
-  if (typeof userCode !== "string") {
-    throw new Error('Device authorization response is missing "user_code".');
-  }
-  console.log("");
-  console.log(`  To authorize the Neo Compose CLI, open:`);
-  console.log(`    ${color.cyan(String(verificationUriComplete))}`);
-  console.log("");
-  console.log(`  and confirm this code: ${color.bold(userCode)}`);
-  console.log("");
-  if (isInteractive() && process.platform === "darwin") {
-    note("  (opening your browser\u2026)");
-    const { spawn } = await import("node:child_process");
-    spawn("open", [String(verificationUriComplete)], {
-      stdio: "ignore",
-      detached: true
-    }).unref();
-  }
-  const waiting = spinner("Waiting for approval in the browser\u2026");
-  const deadline = Date.now() + 15 * 60 * 1e3;
-  for (; ; ) {
-    if (Date.now() > deadline) {
-      waiting.fail("Device authorization timed out after 15 minutes.");
-      throw new Error("Device authorization timed out after 15 minutes.");
-    }
-    await sleep(interval * 1e3);
-    const tokenResponse = await fetch(
-      new URL("/api/auth/device/token", options.apiBaseUrl),
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-          device_code: deviceCode,
-          client_id: clientId
-        })
-      }
-    );
-    const tokenBody = await tokenResponse.json();
-    if (!isObjectRecord(tokenBody)) {
-      throw new Error("Device token response must be a JSON object.");
-    }
-    if (!tokenResponse.ok) {
-      const errorCode = tokenBody.error;
-      if (errorCode === "authorization_pending" || errorCode === "slow_down") {
-        continue;
-      }
-      waiting.fail("Device authorization failed.");
-      throw new Error(
-        `Device token request failed (${tokenResponse.status}): ${JSON.stringify(tokenBody)}`
-      );
-    }
-    const accessToken = tokenBody.access_token;
-    if (typeof accessToken !== "string") {
-      throw new Error('Device token response is missing "access_token".');
-    }
-    saveCredential({
-      token: accessToken,
-      profile,
-      apiBaseUrl: options.apiBaseUrl,
-      scopes,
-      savedAt: Date.now()
-    });
-    waiting.succeed(`Logged in to ${options.apiBaseUrl} (${profile} profile).`);
-    return;
-  }
-}
-async function runWhoami(apiBaseUrl) {
-  const { loadToken: loadToken2 } = await Promise.resolve().then(() => (init_token_store(), token_store_exports));
-  const token = loadToken2(apiBaseUrl);
-  if (token === null) {
-    throw new Error(
-      `No credentials stored for "${apiBaseUrl}". Run "neo login".`
-    );
-  }
-  const response = await fetch(new URL("/api/auth/get-session", apiBaseUrl), {
-    headers: { Authorization: `Bearer ${token}` }
-  });
-  const body = await response.json();
-  if (!response.ok) {
-    throw new Error(
-      `get-session failed (${response.status}): ${JSON.stringify(body)}`
-    );
-  }
-  if (!isObjectRecord(body) || !isObjectRecord(body.user)) {
-    throw new Error("Not signed in (session lookup returned no user).");
-  }
-  const email = typeof body.user.email === "string" ? body.user.email : "(no email)";
-  const name = typeof body.user.name === "string" ? body.user.name : "(no name)";
-  console.log(`Signed in as ${name} <${email}> at ${apiBaseUrl}`);
-}
-
-// src/args.ts
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
-  "dry-run",
-  "json",
-  "all",
-  "force",
-  "token-stdin",
-  "push",
-  "mine",
-  "theirs",
-  "accept-bump",
-  "commit",
-  "skip-invalid",
-  "migrate",
-  "server",
-  "replace",
-  "reset",
-  "regenerate-source-names",
-  "generate-ids",
-  "help",
-  "abstract"
-]);
-var KNOWN_FLAGS = /* @__PURE__ */ new Set([
-  "accept-bump",
-  "abstract",
-  "all",
-  "api",
-  "args",
-  "member",
-  "bump",
-  "bind",
-  "commit",
-  "dir",
-  "dry-run",
-  "entries",
-  "file",
-  "force",
-  "function",
-  "from",
-  "generate-ids",
-  "group",
-  "help",
-  "into",
-  "json",
-  "key",
-  "kind",
-  "migrate",
-  "mine",
-  "mode",
-  "out",
-  "profile",
-  "primary",
-  "project",
-  "plan",
-  "push",
-  "replace",
-  "regenerate-source-names",
-  "reset",
-  "returns",
-  "run",
-  "save",
-  "save-project",
-  "server",
-  "skip-invalid",
-  "status",
-  "summary",
-  "confirm-scope",
-  "target",
-  "template",
-  "theirs",
-  "this",
-  "this-value",
-  "token-stdin",
-  "class",
-  "version"
-]);
-function parseArgs(argv) {
-  const [command = null, ...rest] = argv;
-  const flags = /* @__PURE__ */ new Map();
-  const positional = [];
-  for (let index = 0; index < rest.length; index += 1) {
-    const arg = rest[index];
-    if (arg.startsWith("--")) {
-      const name = arg.slice(2);
-      const next = rest[index + 1];
-      if (!BOOLEAN_FLAGS.has(name) && next !== void 0 && !next.startsWith("--")) {
-        flags.set(name, next);
-        index += 1;
-      } else {
-        flags.set(name, true);
-      }
-    } else {
-      positional.push(arg);
-    }
-  }
-  return { command, flags, positional };
-}
-function stringFlag(args, name) {
-  const value = args.flags.get(name);
-  if (value === void 0) return null;
-  if (typeof value !== "string") {
-    throw new Error(`--${name} requires a value.`);
-  }
-  return value;
-}
-function boolFlag(args, name) {
-  return args.flags.get(name) === true;
-}
-function assertKnownFlags(args) {
-  for (const name of args.flags.keys()) {
-    if (KNOWN_FLAGS.has(name)) continue;
-    const hint = args.command === null ? "Run `neo help` for usage." : `Run \`neo ${args.command} --help\` for usage.`;
-    throw new Error(`Unknown flag "--${name}". ${hint}`);
-  }
-}
-
 // src/main.ts
-init_workspace_status();
-init_workspace();
-
-// src/project-source/status-output.ts
-init_workspace();
-init_projection();
-init_source_diagnostics();
-init_source_format();
-function groupProjectStatusChangesV4(status) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const change of status.changes) {
-    const reconstructed3 = status.reconstructed.get(
-      recordStateKey(change.recordKind, change.recordId)
-    );
-    const source = reconstructed3?.sourceSpan?.path ?? change.file ?? "<unplaced>";
-    const entries = groups.get(source) ?? [];
-    entries.push(change);
-    groups.set(source, entries);
-  }
-  return [...groups].sort(([left], [right]) => compareCodePoints(left, right)).map(([source, changes]) => ({ source, changes }));
-}
-function projectStatusJsonV4(status, options) {
-  return {
-    conflictedFiles: status.conflictedFiles,
-    // P49 §5. Warnings ride the same channel with `blocking: false`, so an
-    // agent reading this envelope sees a rule that has not been promoted yet
-    // without having to know which codes those are.
-    diagnostics: [...status.parseErrors, ...status.parseWarnings].map(
-      (error) => ({
-        path: error.file,
-        line: error.line,
-        column: error.column,
-        code: error.code ?? null,
-        severity: error.severity,
-        blocking: isBlockingSchemaSourceError(error),
-        message: error.message
-      })
-    ),
-    records: status.changes.map(
-      (change) => recordChangeJsonV4(change, status, options)
-    ),
-    files: (status.binaryChanges ?? []).map((binary) => ({
-      fileId: binary.fileId,
-      symbol: binary.symbol,
-      path: binary.path,
-      kind: binary.kind,
-      action: binary.action,
-      digests: {
-        baseSha256: binary.baseSha256,
-        localSha256: binary.localSha256,
-        remoteSha256: binary.remoteSha256
-      },
-      byteLength: binary.byteLength,
-      mimeType: binary.mimeType,
-      uploadIntent: binary.action === "create" || binary.action === "upload" ? {
-        operation: binary.action === "create" ? "create" : "replace",
-        contentSha256: binary.localSha256,
-        byteLength: binary.byteLength,
-        mimeType: binary.mimeType
-      } : null,
-      conflictArtifactPath: binary.conflictArtifactPath ?? null
-    }))
-  };
-}
-function recordChangeJsonV4(change, status, options) {
-  const reconstructed3 = status.reconstructed.get(
-    recordStateKey(change.recordKind, change.recordId)
-  );
-  const sourceSpan = reconstructed3?.sourceSpan ?? (reconstructed3 === void 0 ? change.file === null ? null : pointSpan(change.file, 1) : pointSpan(reconstructed3.file, reconstructed3.line));
-  const semanticData = change.nextData ?? change.baseData;
-  const result = {
-    operation: change.kind,
-    recordKind: change.recordKind,
-    recordId: change.recordId,
-    baseContentHash: change.baseContentHash ?? null,
-    expectedBaseContentHash: change.casBaseHash ?? null,
-    sourceSpan,
-    placement: placementJsonV4(semanticData)
-  };
-  if (options.includeRecordData) {
-    result.baseData = change.baseData ?? null;
-    result.nextData = change.nextData ?? null;
-  }
-  return result;
-}
-function placementJsonV4(value) {
-  if (!isObjectRecord2(value)) return null;
-  const placement = {};
-  for (const field of [
-    "classId",
-    "containerId",
-    "mapKey",
-    "genericBindings"
-  ]) {
-    if (value[field] !== void 0) placement[field] = value[field];
-  }
-  return Object.keys(placement).length === 0 ? null : placement;
-}
-function pointSpan(path, oneBasedLine) {
-  const point = { line: Math.max(0, oneBasedLine - 1), character: 0 };
-  return { path, start: point, end: point };
-}
-
-// src/main.ts
-init_ui();
-var DEFAULT_API_BASE_URL = "https://app.neocompose.com";
+var main_exports = {};
 function profileFlag(args) {
   const value = stringFlag(args, "profile");
   if (value === null) return null;
@@ -98280,7 +99696,7 @@ ${h("Start")}
   whoami    ${d("[--api <url>]")}
 
 ${h("Working copy")}
-  pull      ${d("[--force|--reset] [--regenerate-source-names]")}  push ${d("[--dry-run] [--summary <text>] [--accept-bump] [--json]")}
+  pull      ${d("[--force|--reset] [--regenerate-source-names]")}  push ${d("[--dry-run] [--force-recompile] [--summary <text>] [--accept-bump] [--json]")}
   status    ${d("[--json]")}                  diff    ${d("[--json]")}
   dev       ${d("[--push]")}                  resolve ${d("[--mine|--theirs]")}
   doctor    ${d("[--json]")}                  ${d("validate format/compiler/editor/source/file contracts")}
@@ -98330,10 +99746,11 @@ and tracked project binary from the authoritative server records.
     return `${h("neo push")} \u2014 commit the working copy to the server
 
 ${h("Usage")}
-  neo push ${d("[--dry-run] [--summary <text>] [--accept-bump] [--json]")}
+  neo push ${d("[--dry-run] [--force-recompile] [--summary <text>] [--accept-bump] [--json]")}
 
 ${h("Flags")}
   --dry-run         ${d("Preview the change set; commit nothing.")}
+  --force-recompile ${d("Exhaustively recompile every stored NeoScript body through the durable server path (parity/recovery; slower, and may surface unrelated invalid bodies).")}
   --summary <text>  ${d("Attach a summary message to the transaction.")}
   --accept-bump     ${d("Accept a server-required version bump instead of aborting.")}
   --json            ${d("Emit machine-readable plan and transaction progress events.")}
@@ -98841,6 +100258,7 @@ async function main() {
             dryRun: boolFlag(args, "dry-run"),
             summary: stringFlag(args, "summary"),
             acceptBump: boolFlag(args, "accept-bump"),
+            forceRecompile: boolFlag(args, "force-recompile"),
             json
           },
           preparation
@@ -98937,11 +100355,29 @@ async function main() {
       process.exitCode = 1;
   }
 }
-main().catch((error) => {
-  if (isPromptExit(error)) {
-    process.exitCode = 130;
-    return;
+var DEFAULT_API_BASE_URL;
+var init_main = __esm({
+  "src/main.ts"() {
+    "use strict";
+    init_login();
+    init_args();
+    init_workspace_status();
+    init_workspace();
+    init_status_output();
+    init_ui();
+    DEFAULT_API_BASE_URL = "https://app.neocompose.com";
+    main().catch((error) => {
+      if (isPromptExit(error)) {
+        process.exitCode = 130;
+        return;
+      }
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    });
   }
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exitCode = 1;
 });
+
+// src/entry.ts
+var invocationCwd = process.env.NEO_CLI_INVOCATION_CWD;
+if (invocationCwd !== void 0) process.chdir(invocationCwd);
+await Promise.resolve().then(() => (init_main(), main_exports));