@wairon/cli 5.1.1-dev.95 → 5.1.1-dev.97

package/dist/index.js

@@ -2959,7 +2959,6 @@ var require_dist = __commonJS({
         "# languages:",
         "#   rust:",
         "#     unsupportedFlow: {}",
-        "#     foreignBuiltins: []",
         "languages: {}",
         "",
         "# Reusable, versioned architecture patterns:",
@@ -3186,12 +3185,12 @@ var require_dist = __commonJS({
       const suggestedFileName = `${sealed.name}-${sealed.version}.wpack`;
       return { archive: archiveBytes, info, suggestedFileName };
     }
-    function inspectArchive(archiveBytes) {
-      const entries = listEntries(archiveBytes);
+    function inspectArchive(archive) {
+      const entries = listEntries(archive);
       if (!entries.some((entry) => entry.path === ENVELOPE_FILENAME)) {
         throw new Error("not a .wpack archive (missing wairon-pack.yaml envelope)");
       }
-      const envelopeBytes = inflateEntry(archiveBytes, ENVELOPE_FILENAME);
+      const envelopeBytes = inflateEntry(archive, ENVELOPE_FILENAME);
       const manifest = parseManifest(decode(envelopeBytes));
       const compatible = checkCompatibility(manifest, SDK_VERSION);
       const fileEntries = entries.filter((entry) => entry.kind === "file");
@@ -3209,13 +3208,13 @@ var require_dist = __commonJS({
       if (manifest.minWaironVersion !== void 0) info.minWaironVersion = manifest.minWaironVersion;
       return info;
     }
-    function extractPack(archiveBytes, destDir, limits) {
+    function extractPack(archive, destDir, limits) {
       const effectiveLimits = limits === void 0 ? defaultLimits() : limits;
-      const entries = listEntries(archiveBytes);
+      const entries = listEntries(archive);
       const plan6 = planExtraction(entries, effectiveLimits);
       const files = [];
       for (const approvedPath of plan6.paths) {
-        const contents = inflateEntry(archiveBytes, approvedPath);
+        const contents = inflateEntry(archive, approvedPath);
         files.push({ path: approvedPath, contents });
       }
       const envelope = files.find((file) => file.path === ENVELOPE_FILENAME);
@@ -3272,28 +3271,28 @@ var require_dist = __commonJS({
       const suggestedFileName = `${slugify(projectName)}.waitree`;
       return { archive: archiveBytes, manifest: sealed, suggestedFileName, fileCount: files.length };
     }
-    function inspectTreeArchive3(archiveBytes) {
-      const entries = listEntries(archiveBytes);
+    function inspectTreeArchive3(archive) {
+      const entries = listEntries(archive);
       if (!entries.some((entry) => entry.path === TREE_ENVELOPE_FILENAME)) {
         throw new Error("not a .waitree archive (missing wairon-tree.yaml envelope)");
       }
-      const envelopeBytes = inflateEntry(archiveBytes, TREE_ENVELOPE_FILENAME);
+      const envelopeBytes = inflateEntry(archive, TREE_ENVELOPE_FILENAME);
       const manifest = parseTreeManifest(decode(envelopeBytes));
       const compatible = checkTreeCompatibility(manifest, SDK_VERSION);
       const fileEntries = entries.filter((entry) => entry.kind === "file");
       const totalUncompressedBytes = entries.reduce((sum, entry) => sum + entry.uncompressedSize, 0);
       return { manifest, entryCount: fileEntries.length, totalUncompressedBytes, compatible };
     }
-    function extractTreeArchive3(archiveBytes, destDir, limits, refuseExecutableEntries) {
+    function extractTreeArchive3(archive, destDir, limits, refuseExecutableEntries) {
       const effectiveLimits = limits === void 0 ? defaultTreeLimits() : limits;
-      const entries = listEntries(archiveBytes);
+      const entries = listEntries(archive);
       const plan6 = planTreeExtraction(entries, effectiveLimits);
       if (refuseExecutableEntries === true) {
         assertPortableTreePaths(plan6.paths);
       }
       const files = [];
       for (const approvedPath of plan6.paths) {
-        const contents = inflateEntry(archiveBytes, approvedPath);
+        const contents = inflateEntry(archive, approvedPath);
         files.push({ path: approvedPath, contents });
       }
       const envelope = files.find((file) => file.path === TREE_ENVELOPE_FILENAME);
@@ -3326,9 +3325,9 @@ var require_dist = __commonJS({
     }
     function readInnerIdentity(files, manifest) {
       const innerPath = manifest.kind === "code" ? "package.json" : manifest.entry;
-      const inner = files.find((file) => file.path === innerPath);
-      if (!inner) throw new Error(`pack build: inner pack manifest "${innerPath}" is missing`);
-      const parsed = manifest.kind === "code" ? JSON.parse(decode(inner.contents)) : (0, import_js_yaml3.load)(decode(inner.contents));
+      const inner2 = files.find((file) => file.path === innerPath);
+      if (!inner2) throw new Error(`pack build: inner pack manifest "${innerPath}" is missing`);
+      const parsed = manifest.kind === "code" ? JSON.parse(decode(inner2.contents)) : (0, import_js_yaml3.load)(decode(inner2.contents));
       const name = parsed?.name;
       const version = parsed?.version;
       if (typeof name !== "string" || typeof version !== "string") {
@@ -3394,7 +3393,6 @@ __export(src_exports, {
   AgentTemplateSchema: () => AgentTemplateSchema,
   BACKEND_COMMANDS: () => BACKEND_COMMANDS,
   BUILTIN_PROFILES: () => BUILTIN_PROFILES,
-  BUILTIN_TYPES: () => BUILTIN_TYPES,
   BoundaryItemSchema: () => BoundaryItemSchema,
   BuiltinTargetConfigSchema: () => BuiltinTargetConfigSchema,
   BuiltinTargetSchema: () => BuiltinTargetSchema,
@@ -3428,6 +3426,7 @@ __export(src_exports, {
   DurabilitySchema: () => DurabilitySchema,
   EXTERNAL_ALIAS_RE: () => EXTERNAL_ALIAS_RE,
   EndpointSchema: () => EndpointSchema,
+  EnumValueSchema: () => EnumValueSchema,
   EventBindingSchema: () => EventBindingSchema,
   ExtDataSchema: () => ExtDataSchema,
   ExternalDeclarationSchema: () => ExternalDeclarationSchema,
@@ -3442,6 +3441,7 @@ __export(src_exports, {
   GeminiExporter: () => GeminiExporter,
   GroupSpecSchema: () => GroupSpecSchema,
   GuaranteeSchema: () => GuaranteeSchema,
+  HOLDABLE_PRIMITIVES: () => HOLDABLE_PRIMITIVES,
   HttpMethodSchema: () => HttpMethodSchema,
   ImplementationSpecSchema: () => ImplementationSpecSchema,
   InterfaceSpecSchema: () => InterfaceSpecSchema,
@@ -3461,6 +3461,7 @@ __export(src_exports, {
   NarrativeStepTypeSchema: () => NarrativeStepTypeSchema,
   OutputTargetSchema: () => OutputTargetSchema,
   PATTERN_TYPES: () => PATTERN_TYPES,
+  PRIMITIVE_TYPES: () => PRIMITIVE_TYPES,
   PROJECT_ID_RE: () => PROJECT_ID_RE,
   PROJECT_KINDS: () => PROJECT_KINDS,
   PUBLIC_NAME_RE: () => PUBLIC_NAME_RE,
@@ -3548,6 +3549,7 @@ __export(src_exports, {
   buildRuleContext: () => buildRuleContext,
   callSitesOf: () => callSitesOf,
   canonicalTypeRef: () => canonicalTypeRef,
+  canonicalTypeText: () => canonicalTypeText,
   captureApprovedSpecs: () => captureApprovedSpecs,
   checkDeclarativePack: () => checkDeclarativePack,
   clearLoaderIssues: () => clearLoaderIssues,
@@ -3592,6 +3594,7 @@ __export(src_exports, {
   detectDomainCandidates: () => detectDomainCandidates,
   diagnoseProjectPacks: () => diagnoseProjectPacks,
   diagramSetIndex: () => diagramSetIndex,
+  dialectOf: () => dialectOf,
   diffAgainstApproval: () => diffAgainstApproval,
   diffSize: () => diffSize,
   discoverPacks: () => discoverPacks,
@@ -3599,6 +3602,7 @@ __export(src_exports, {
   effectiveDetail: () => effectiveDetail,
   effectiveProjectId: () => effectiveProjectId,
   emptyExtensions: () => emptyExtensions,
+  emptyTypeSpellingFacts: () => emptyTypeSpellingFacts,
   ensureDir: () => ensureDir,
   ensureProjectInitialized: () => ensureProjectInitialized,
   excerptParent: () => excerpt,
@@ -3645,6 +3649,7 @@ __export(src_exports, {
   importSpecTree: () => importSpecTree,
   injectGuide: () => injectGuide,
   installPackFromDirectory: () => installPackFromDirectory,
+  interfaceCanonicalTypes: () => interfaceCanonicalTypes,
   interfaceGenericParameters: () => interfaceGenericParameters,
   internalizeMember: () => internalizeMember,
   isDraftSubsystem: () => isDraftSubsystem,
@@ -3656,9 +3661,11 @@ __export(src_exports, {
   isProjectInitialized: () => isProjectInitialized,
   isProvidedBy: () => isProvidedBy,
   isRetired: () => isRetired,
+  isTypeVocabulary: () => isTypeVocabulary,
   judgesCode: () => judgesCode,
   keyIn: () => keyIn,
   landReference: () => landReference,
+  languageOfSourcePath: () => languageOfSourcePath,
   listDirectChainedSubprojects: () => listDirectChainedSubprojects,
   listFiles: () => listFiles,
   listFilesRecursive: () => listFilesRecursive,
@@ -3701,6 +3708,7 @@ __export(src_exports, {
   moveMethods: () => moveMethods,
   moveMountToMembers: () => moveMountToMembers,
   nameKey: () => nameKey,
+  namesAnInteger: () => namesAnInteger,
   narrativeStepForeignFields: () => narrativeStepForeignFields,
   normalizeReferences: () => normalizeReferences2,
   ownerOf: () => ownerOf,
@@ -3712,6 +3720,8 @@ __export(src_exports, {
   parseDeclarativePack: () => parseDeclarativePack,
   parseDeclaredCall: () => parseDeclaredCall,
   parseMemberSource: () => parseMemberSource,
+  parseTypeExpression: () => parseTypeExpression,
+  parseTypePosition: () => parseTypePosition,
   parseYaml: () => parseYaml,
   passesIntentFloor: () => passesIntentFloor,
   pathExists: () => pathExists,
@@ -3725,6 +3735,7 @@ __export(src_exports, {
   provisionProject: () => provisionProject,
   qualifiedTypeId: () => qualifiedTypeId,
   rangeProblem: () => rangeProblem,
+  readCodeAnnotation: () => readCodeAnnotation,
   readFileOrNull: () => readFileOrNull,
   readJsonFile: () => readJsonFile,
   readLockRecord: () => readLockRecord,
@@ -3747,6 +3758,7 @@ __export(src_exports, {
   renderDiagram: () => renderDiagram,
   repairForeignStepFields: () => repairForeignStepFields,
   repairSignatures: () => repairSignatures,
+  repairTypeSpellings: () => repairTypeSpellings,
   repointExternal: () => repointExternal,
   requiredPolicies: () => requiredPolicies,
   resolveAgentTopology: () => resolveAgentTopology,
@@ -3758,7 +3770,7 @@ __export(src_exports, {
   resolveImport: () => resolveImport,
   resolveInstalledPack: () => resolveInstalledPack,
   resolveProjectExports: () => resolveProjectExports,
-  resolveSignatures: () => resolveTree,
+  resolveSignatures: () => resolveSignatures,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
   resolveSubsystemExports: () => resolveSubsystemExports,
   resolveVariantGuidance: () => resolveVariantGuidance,
@@ -3794,9 +3806,15 @@ __export(src_exports, {
   technologyTokens: () => technologyTokens,
   toMarkdown: () => toMarkdown,
   typeBindingOf: () => typeBindingOf,
+  typeCanonicalTypes: () => typeCanonicalTypes,
+  typeDialectFor: () => typeDialectFor,
   typeGenericParameters: () => typeGenericParameters,
+  typeIsMany: () => typeIsMany,
   typeMatchesRef: () => typeMatchesRef,
+  typeNamedRefs: () => typeNamedRefs,
+  typeProblemIntProposal: () => typeProblemIntProposal,
   typeSourceFiles: () => typeSourceFiles,
+  typeSpellingFacts: () => typeSpellingFacts,
   uninstallPack: () => uninstallPack,
   updateMember: () => updateMember,
   updateSpec: () => updateSpec,
@@ -3811,7 +3829,8 @@ __export(src_exports, {
   writeReachDenials: () => writeReachDenials,
   writeReachPermits: () => writeReachPermits,
   writeRootGuideDelegator: () => writeRootGuideDelegator,
-  writeYamlFile: () => writeYamlFile
+  writeYamlFile: () => writeYamlFile,
+  writtenTypeRefs: () => writtenTypeRefs
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -4260,6 +4279,14 @@ var AgentBriefSchema = import_zod2.z.object({
   instructions: import_zod2.z.string(),
   /** Rendered variant guidance, also folded into instructions */
   variantGuidance: import_zod2.z.string().optional(),
+  /**
+   * How the neutral types of the contracts this agent implements are spelled
+   * in its language: the write table (type_dialect.mappingLines) of the dialect
+   * for the language its implementations are written in, also folded into
+   * instructions. Absent when no dialect is shipped for that language or the
+   * agent implements nothing.
+   */
+  typeMapping: import_zod2.z.array(import_zod2.z.string()).optional(),
   /**
    * Set only on a brief for a member's agent (an id qualified `<alias>::`): the
    * member's directory relative to the root the brief was asked from. The
@@ -5272,14 +5299,16 @@ function locateScalar(tokens, path49) {
     const base = Math.min(...region.map((t) => t.col));
     const last = k === path49.length - 1;
     let at;
-    if (typeof segment === "string") {
+    const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
+    if (items.length === 0) {
       at = region.findIndex((t) => t.kind === "key" && t.col === base && t.name === segment);
       if (at < 0) return `no block key "${segment}" at ${path49.slice(0, k).join(".") || "the document root"}`;
       if (last) return region[at].valueStart !== void 0 ? region[at] : `"${segment}" holds no inline scalar`;
     } else {
-      const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
-      if (segment >= items.length) return `no block sequence item ${segment} at ${path49.slice(0, k).join(".")}`;
-      at = items[segment].i;
+      if (!/^\d+$/.test(segment)) return `"${segment}" is not a sequence index at ${path49.slice(0, k).join(".") || "the document root"}`;
+      const index = Number(segment);
+      if (index >= items.length) return `no block sequence item ${segment} at ${path49.slice(0, k).join(".")}`;
+      at = items[index].i;
       if (last) {
         const value = region[at + 1];
         return value && value.kind === "scalar" && value.line === region[at].line ? value : `item ${segment} holds no inline scalar`;
@@ -5751,7 +5780,7 @@ function registryOver(store, root) {
           const at = typeof entry.at === "string" ? entry.at : void 0;
           const covers = Array.isArray(entry.covers) ? entry.covers.filter((u) => typeof u === "string") : void 0;
           const next = rekeyAnchor(rename, { spec: entry.spec, at, covers });
-          const base = ["rules", "conformance", "carried", g, "findings", f];
+          const base = ["rules", "conformance", "carried", String(g), "findings", String(f)];
           const named2 = { code: String(entry.code), spec: entry.spec, at: at ?? "" };
           const change = (path49, field, from, to) => {
             if (from === to) return;
@@ -5760,7 +5789,7 @@ function registryOver(store, root) {
           };
           change(["spec"], "spec", entry.spec, next.spec);
           if (at !== void 0) change(["at"], "at", at, next.at);
-          (covers ?? []).forEach((unit, u) => change(["covers", u], "covers", unit, next.covers[u]));
+          (covers ?? []).forEach((unit, u) => change(["covers", String(u)], "covers", unit, next.covers[u]));
         });
       });
       store.rewriteScalars(edits, dryRun);
@@ -7087,11 +7116,10 @@ var GuaranteeSchema = import_zod8.z.string().min(1);
 var MethodParamSchema = import_zod8.z.object({
   name: import_zod8.z.string(),
   /**
-   * A primitive/builtin or a defined type id (qualified across subsystems, e.g.
-   * "billing.Invoice"), on its own or inside a generic, an array or a UNION:
-   * `Invoice | null`, `Promise<Invoice | null>`, `Invoice[] | null`. Every
-   * identifier the string names has to resolve — see the grammar on
-   * src/models/type-references.ts.
+   * A type expression in the neutral type grammar (src/models/type-grammar.ts):
+   * a primitive, a named type (`billing.Invoice`, `alias::name`), `list<T>`,
+   * `set<T>`, `map<K, V>`, `T?`, a union of named types. Stored canonical; an
+   * alias (`Invoice[]`, `Invoice | null`, `boolean`) is normalised on write.
    */
   type: import_zod8.z.string(),
   description: import_zod8.z.string().optional(),
@@ -7110,8 +7138,9 @@ var MethodSignatureSchema = import_zod8.z.object({
   description: import_zod8.z.string(),
   signature: import_zod8.z.string().optional(),
   // e.g. "save(key: string, data: Buffer): Promise<void>"
-  // e.g. "Promise<void>", or a union: "Invoice | null" — the commonest shape in
-  // any real tree. See the grammar on src/models/type-references.ts.
+  // A type expression in the neutral grammar, at the returns position — the only
+  // one `async T` and `void` may stand in: "async void", "Invoice?". Stored
+  // canonical; see src/models/type-grammar.ts.
   returns: import_zod8.z.string().optional(),
   /** Structured parameters (authoritative for type checking when present). */
   params: import_zod8.z.array(MethodParamSchema).optional(),
@@ -7133,11 +7162,16 @@ var MethodSignatureSchema = import_zod8.z.object({
    */
   guarantees: import_zod8.z.array(GuaranteeSchema).optional(),
   /**
-   * State-effect direction of this method on its component's held state. Required on a
-   * durable Store's contract methods so the durability round-trip rule can pair external
-   * writes with hydration read-backs (MISSING_HYDRATION); optional elsewhere.
+   * What this method does to its component's held state: `read` observes it, `write`
+   * modifies an entity's domain fields, and `lifecycle` creates, destroys, or
+   * (un)registers an entity's existence or membership without modifying its fields —
+   * closed under composition (a lifecycle method calls only read and lifecycle methods,
+   * LIFECYCLE_CALLS_WRITE). Required on a durable Store's contract methods so the
+   * durability round-trip rule can pair mutations with hydration read-backs
+   * (MISSING_HYDRATION); a Supervisor may call a data component it does not own only
+   * through read and lifecycle methods (SUPERVISOR_WRITE_SHORTCUT). Optional elsewhere.
    */
-  effect: import_zod8.z.enum(["read", "write"]).optional(),
+  effect: import_zod8.z.enum(["read", "write", "lifecycle"]).optional(),
   /**
    * Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph
    * (runtime timer/hook, external system, sibling subsystem). Unused-detection
@@ -7587,12 +7621,12 @@ function implementationSourceFiles(impl) {
   for (const method of impl.methods ?? []) add2(method.sourcePath);
   return files;
 }
-var TypeKindSchema = import_zod8.z.enum(["entity", "value-object", "signature"]);
+var TypeKindSchema = import_zod8.z.enum(["entity", "value-object", "signature", "enum"]);
 var TypeFieldSchema = import_zod8.z.object({
   name: import_zod8.z.string(),
-  // A primitive, or another type id (qualified across subsystems, e.g.
-  // "billing.Invoice") — on its own or inside a generic, an array or a union
-  // ("Invoice[] | null"). See the grammar on src/models/type-references.ts.
+  // A type expression in the neutral grammar (src/models/type-grammar.ts): a
+  // primitive, a named type ("billing.Invoice"), list/set/map, `T?`, a union
+  // of named types. Stored canonical.
   type: import_zod8.z.string(),
   description: import_zod8.z.string().optional(),
   optional: import_zod8.z.boolean().default(false),
@@ -7646,9 +7680,13 @@ var InvariantSchema = import_zod8.z.object({
   /** The property that must hold, stated precisely enough to test against. */
   description: import_zod8.z.string().min(1)
 });
+var EnumValueSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1),
+  description: import_zod8.z.string().optional()
+});
 var TypeSpecSchema = import_zod8.z.object({
   kind: TypeKindSchema,
-  // discriminator — entity | value-object | signature
+  // discriminator — entity | value-object | signature | enum
   id: SpecIdSchema,
   name: import_zod8.z.string(),
   description: import_zod8.z.string().optional(),
@@ -7711,6 +7749,20 @@ var TypeSpecSchema = import_zod8.z.object({
   params: import_zod8.z.array(MethodParamSchema).optional(),
   /** A signature's one output type; required on kind signature and only there (SIGNATURE_TYPE_MEMBERS). */
   returns: import_zod8.z.string().optional(),
+  /**
+   * An enum's values, in declared order (the order is part of the design),
+   * unique by nameKey; required and non-empty on kind enum and only there
+   * (ENUM_MEMBERS).
+   */
+  values: import_zod8.z.array(EnumValueSchema).optional(),
+  /**
+   * A named scalar's one primitive (string, int, float, bool, bytes, date,
+   * datetime or duration), in place of fields: a value-object that is a
+   * newtype or type alias in every language. Read as a type position (the
+   * grammar's `holds` position); only on a value-object and never beside
+   * fields (NAMED_SCALAR_MEMBERS).
+   */
+  holds: import_zod8.z.string().optional(),
   createdAt: import_zod8.z.string().datetime(),
   updatedAt: import_zod8.z.string().datetime()
 });
@@ -7753,7 +7805,11 @@ var SurfaceTypeDefSchema = import_zod8.z.object({
     optional: import_zod8.z.boolean().optional()
   })).optional(),
   /** A signature's one output type; only on kind signature. */
-  returns: import_zod8.z.string().optional()
+  returns: import_zod8.z.string().optional(),
+  /** An enum's values in declared order; only on kind enum. */
+  values: import_zod8.z.array(EnumValueSchema).optional(),
+  /** A named scalar's one primitive, in place of fields; only on a value-object that declares it. */
+  holds: import_zod8.z.string().optional()
 });
 var SurfaceTypeExportSchema = import_zod8.z.object({
   /** The type's public name in the producer's export table. */
@@ -7862,80 +7918,767 @@ var GroupSpecSchema = import_zod8.z.object({
   updatedAt: import_zod8.z.string().datetime()
 });
 
-// src/models/type-references.ts
-var BUILTIN_TYPES = /* @__PURE__ */ new Set([
-  "string",
-  "str",
-  "number",
-  "boolean",
-  "bool",
-  "float",
-  "double",
-  "int",
-  "integer",
-  "u8",
-  "u16",
-  "u32",
-  "u64",
-  "u128",
-  "usize",
-  "i8",
-  "i16",
-  "i32",
-  "i64",
-  "i128",
-  "isize",
-  "f32",
-  "f64",
-  "char",
-  "byte",
+// src/models/type-grammar.ts
+var PRIMITIVE_TYPES = ["string", "int", "float", "bool", "bytes", "date", "datetime", "duration", "void", "any"];
+var PRIMITIVES = new Set(PRIMITIVE_TYPES);
+var HOLDABLE_PRIMITIVES = PRIMITIVE_TYPES.filter((p) => p !== "void" && p !== "any");
+var PRIMITIVE_ALIASES = /* @__PURE__ */ new Map([
+  ["boolean", "bool"],
+  ["integer", "int"],
+  ["long", "int"],
+  ["i8", "int"],
+  ["i16", "int"],
+  ["i32", "int"],
+  ["i64", "int"],
+  ["i128", "int"],
+  ["isize", "int"],
+  ["u8", "int"],
+  ["u16", "int"],
+  ["u32", "int"],
+  ["u64", "int"],
+  ["u128", "int"],
+  ["usize", "int"],
+  ["double", "float"],
+  ["f32", "float"],
+  ["f64", "float"],
+  ["Buffer", "bytes"],
+  ["Uint8Array", "bytes"],
+  ["Date", "datetime"],
+  ["timestamp", "datetime"],
+  ["object", "any"],
+  ["unknown", "any"],
+  ["json", "any"],
+  ["Json", "any"],
+  ["str", "string"]
+]);
+var GENERIC_ALIASES = /* @__PURE__ */ new Map([
+  ["list", { form: "list", arity: 1 }],
+  ["Array", { form: "list", arity: 1 }],
+  ["ReadonlyArray", { form: "list", arity: 1 }],
+  ["List", { form: "list", arity: 1 }],
+  ["vec", { form: "list", arity: 1 }],
+  ["vector", { form: "list", arity: 1 }],
+  ["set", { form: "set", arity: 1 }],
+  ["Set", { form: "set", arity: 1 }],
+  ["ReadonlySet", { form: "set", arity: 1 }],
+  ["map", { form: "map", arity: 2 }],
+  ["Map", { form: "map", arity: 2 }],
+  ["Record", { form: "map", arity: 2 }],
+  ["ReadonlyMap", { form: "map", arity: 2 }],
+  ["dict", { form: "map", arity: 2 }],
+  ["dictionary", { form: "map", arity: 2 }],
+  ["HashMap", { form: "map", arity: 2 }],
+  ["Option", { form: "optional", arity: 1 }],
+  ["Optional", { form: "optional", arity: 1 }],
+  ["Promise", { form: "async", arity: 1 }]
+]);
+var NOT_NEUTRAL = /* @__PURE__ */ new Map([
+  ["uuid", "a named value-object holding a string (e.g. order_id)"],
+  ["decimal", "a named value-object (e.g. money), or float"],
+  ["char", "string"],
+  ["byte", "int, or bytes for binary data"],
+  ["time", "datetime for an instant, or duration for an elapsed time"],
+  ["tuple", "a named value-object"],
+  ["result", "the success type as the returns (failures as findings or throws), or a named value-object"],
+  ["error", "a named value-object"],
+  ["never", "void"],
+  ["box", "the inner type (ownership is an implementation detail)"],
+  ["arc", "the inner type (ownership is an implementation detail)"],
+  ["rc", "the inner type (ownership is an implementation detail)"],
+  ["ref", "the inner type (ownership is an implementation detail)"],
+  ["cell", "the inner type (ownership is an implementation detail)"],
+  ["refcell", "the inner type (ownership is an implementation detail)"],
+  ["mutex", "the inner type (synchronisation is an implementation detail)"],
+  ["rwlock", "the inner type (synchronisation is an implementation detail)"],
+  ["std", "a named type"],
+  ["mcpserver", "a named type"]
+]);
+var UTILITY_TYPES = /* @__PURE__ */ new Set([
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "Parameters",
+  "InstanceType",
+  "Awaited",
+  "ConstructorParameters",
+  "ThisType",
+  "Uppercase",
+  "Lowercase"
+]);
+var NONES = /* @__PURE__ */ new Set(["null", "undefined"]);
+var LOWER_PRIMITIVE = new Map([
+  ...PRIMITIVE_TYPES.map((p) => [p, p]),
+  ...[...PRIMITIVE_ALIASES].map(([k, v]) => [k.toLowerCase(), v])
+]);
+var LOWER_GENERIC = new Map([...GENERIC_ALIASES].map(([k, v]) => [k.toLowerCase(), v]));
+function isTypeVocabulary(name) {
+  const lower = name.toLowerCase();
+  return LOWER_PRIMITIVE.has(lower) || LOWER_GENERIC.has(lower) || NOT_NEUTRAL.has(lower) || NONES.has(lower) || lower === "true" || lower === "false" || lower === "number";
+}
+function primitiveOf(name) {
+  if (PRIMITIVES.has(name)) return name;
+  const exact = PRIMITIVE_ALIASES.get(name);
+  if (exact) return exact;
+  return LOWER_PRIMITIVE.get(name.toLowerCase());
+}
+function genericOf(name) {
+  return GENERIC_ALIASES.get(name) ?? LOWER_GENERIC.get(name.toLowerCase());
+}
+var TypeSyntaxError = class extends Error {
+};
+var PUNCTUATION = ["...", "::", "=>", "<", ">", ",", "|", "?", "(", ")", "[", "]", "{", "}", ":", "&", ";", "."];
+function tokenize2(text3) {
+  const out = [];
+  let i = 0;
+  while (i < text3.length) {
+    const c = text3[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(c)) {
+      let j = i + 1;
+      while (j < text3.length && /[A-Za-z0-9_$-]/.test(text3[j])) j++;
+      while (text3[j - 1] === "-") j--;
+      out.push({ t: "id", v: text3.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (/[0-9]/.test(c)) {
+      let j = i + 1;
+      while (j < text3.length && /[0-9.]/.test(text3[j])) j++;
+      out.push({ t: "num", v: text3.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") {
+      let j = i + 1;
+      while (j < text3.length && text3[j] !== c) j += text3[j] === "\\" ? 2 : 1;
+      if (j >= text3.length) throw new TypeSyntaxError(`an unterminated string literal at "${text3.slice(i)}"`);
+      out.push({ t: "str", v: text3.slice(i, j + 1) });
+      i = j + 1;
+      continue;
+    }
+    const punct = PUNCTUATION.find((p) => text3.startsWith(p, i));
+    if (!punct) throw new TypeSyntaxError(`"${c}" is not part of any type spelling`);
+    out.push({ t: "p", v: punct });
+    i += punct.length;
+  }
+  return out;
+}
+var RawParser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.at = 0;
+  }
+  /** type-position: an optional `async` prefix, one type, and nothing after it. */
+  position() {
+    if (this.tokens.length === 0) throw new TypeSyntaxError("the position is empty");
+    const node = this.isAsyncPrefix() ? (this.at++, { k: "async", inner: this.type() }) : this.type();
+    if (this.at < this.tokens.length) throw new TypeSyntaxError(`"${this.rest()}" is left over after the type`);
+    return node;
+  }
+  isAsyncPrefix() {
+    const first = this.tokens[0];
+    const next = this.tokens[1];
+    if (!first || first.t !== "id" || first.v !== "async" || !next) return false;
+    return next.t !== "p" || ["(", "{", "[", "::"].includes(next.v);
+  }
+  rest() {
+    return this.tokens.slice(this.at).map((t) => t.v).join(" ");
+  }
+  peek(offset = 0) {
+    return this.tokens[this.at + offset];
+  }
+  isP(v, offset = 0) {
+    const t = this.peek(offset);
+    return !!t && t.t === "p" && t.v === v;
+  }
+  expect(v) {
+    if (!this.isP(v)) {
+      const got = this.peek();
+      throw new TypeSyntaxError(got ? `expected "${v}" but found "${got.v}"` : `expected "${v}" but the text ended`);
+    }
+    this.at++;
+  }
+  type() {
+    if (this.isP("|")) this.at++;
+    const members = [this.intersection()];
+    while (this.isP("|")) {
+      this.at++;
+      members.push(this.intersection());
+    }
+    return members.length === 1 ? members[0] : { k: "union", members };
+  }
+  intersection() {
+    const members = [this.postfix()];
+    while (this.isP("&")) {
+      this.at++;
+      members.push(this.postfix());
+    }
+    return members.length === 1 ? members[0] : { k: "intersection", members };
+  }
+  postfix() {
+    let node = this.primary();
+    for (; ; ) {
+      if (this.isP("[") && this.isP("]", 1)) {
+        this.at += 2;
+        node = { k: "array", elem: node };
+      } else if (this.isP("?")) {
+        this.at++;
+        node = { k: "opt", inner: node };
+      } else {
+        return node;
+      }
+    }
+  }
+  primary() {
+    const tok = this.peek();
+    if (!tok) throw new TypeSyntaxError("a type was expected but the text ended");
+    if (tok.t === "str" || tok.t === "num") {
+      this.at++;
+      return { k: "literal", text: tok.v };
+    }
+    if (tok.t === "id" && (tok.v === "keyof" || tok.v === "typeof" || tok.v === "unique") && this.peek(1)?.t === "id") {
+      this.at++;
+      return { k: "operator", op: tok.v, inner: this.postfix() };
+    }
+    const next = this.peek(1);
+    if (tok.t === "id" && tok.v === "readonly" && next && (next.t === "id" || next.t === "p" && (next.v === "(" || next.v === "["))) {
+      this.at++;
+      return this.postfix();
+    }
+    if (tok.t === "id" || tok.t === "p" && tok.v === "::") return this.named();
+    if (tok.t === "p" && tok.v === "(") return this.parenOrFunction();
+    if (tok.t === "p" && tok.v === "{") return this.objectShape();
+    if (tok.t === "p" && tok.v === "[") return this.tuple();
+    throw new TypeSyntaxError(`"${tok.v}" cannot start a type`);
+  }
+  ident() {
+    const tok = this.peek();
+    if (!tok || tok.t !== "id") throw new TypeSyntaxError(tok ? `expected a name but found "${tok.v}"` : "expected a name but the text ended");
+    this.at++;
+    return tok.v;
+  }
+  named() {
+    let name = "";
+    if (this.isP("::")) {
+      this.at++;
+      name = "::";
+    }
+    name += this.ident();
+    while (this.isP("::") || this.isP(".")) {
+      const sep14 = this.peek().v;
+      this.at++;
+      name += sep14 + this.ident();
+    }
+    if (!this.isP("<")) return { k: "name", name };
+    this.at++;
+    const args = [this.type()];
+    while (this.isP(",")) {
+      this.at++;
+      args.push(this.type());
+    }
+    this.expect(">");
+    return { k: "name", name, args };
+  }
+  /** The index of the `)` closing the `(` at the cursor, or -1. */
+  closingParen() {
+    let depth = 0;
+    for (let i = this.at; i < this.tokens.length; i++) {
+      const t = this.tokens[i];
+      if (t.t !== "p") continue;
+      if (t.v === "(") depth++;
+      else if (t.v === ")" && --depth === 0) return i;
+    }
+    return -1;
+  }
+  parenOrFunction() {
+    const close2 = this.closingParen();
+    const after = close2 === -1 ? void 0 : this.tokens[close2 + 1];
+    if (!after || after.t !== "p" || after.v !== "=>") {
+      this.expect("(");
+      const inner2 = this.type();
+      this.expect(")");
+      return { k: "paren", inner: inner2 };
+    }
+    this.expect("(");
+    const params = [];
+    while (!this.isP(")")) {
+      if (this.isP("...")) this.at++;
+      this.ident();
+      if (this.isP("?")) this.at++;
+      if (this.isP(":")) {
+        this.at++;
+        params.push(this.type());
+      }
+      if (!this.isP(",")) break;
+      this.at++;
+    }
+    this.expect(")");
+    this.expect("=>");
+    return { k: "function", params, ret: this.type() };
+  }
+  objectShape() {
+    this.expect("{");
+    const members = [];
+    while (!this.isP("}")) {
+      if (this.isP("[")) {
+        this.at++;
+        this.ident();
+        this.expect(":");
+        members.push(this.type());
+        this.expect("]");
+      } else {
+        if (this.peek()?.t === "id" && this.peek().v === "readonly" && this.peek(1)?.t === "id") this.at++;
+        const key = this.peek();
+        if (!key || key.t !== "id" && key.t !== "str" && key.t !== "num") throw new TypeSyntaxError("an inline object member has no name");
+        this.at++;
+        if (this.isP("?")) this.at++;
+        if (this.isP("(")) {
+          members.push(this.parenOrFunctionMember());
+          this.skipSeparator();
+          continue;
+        }
+      }
+      this.expect(":");
+      members.push(this.type());
+      this.skipSeparator();
+    }
+    this.expect("}");
+    return { k: "object", members };
+  }
+  /** A method member of an inline object: (params): returns. */
+  parenOrFunctionMember() {
+    this.expect("(");
+    const params = [];
+    while (!this.isP(")")) {
+      if (this.isP("...")) this.at++;
+      this.ident();
+      if (this.isP("?")) this.at++;
+      if (this.isP(":")) {
+        this.at++;
+        params.push(this.type());
+      }
+      if (!this.isP(",")) break;
+      this.at++;
+    }
+    this.expect(")");
+    this.expect(":");
+    return { k: "function", params, ret: this.type() };
+  }
+  skipSeparator() {
+    if (this.isP(";") || this.isP(",")) this.at++;
+  }
+  tuple() {
+    this.expect("[");
+    const elems = [];
+    while (!this.isP("]")) {
+      elems.push(this.type());
+      if (!this.isP(",")) break;
+      this.at++;
+    }
+    this.expect("]");
+    return { k: "tuple", elems };
+  }
+};
+function readRaw(text3) {
+  return new RawParser(tokenize2(text3)).position();
+}
+var TypeProblemError = class extends Error {
+  constructor(code, detail, replacement) {
+    super(detail);
+    this.code = code;
+    this.detail = detail;
+    this.replacement = replacement;
+  }
+};
+var RETURNS_POSITIONS = /* @__PURE__ */ new Set(["returns", "type-method-returns", "signature-returns"]);
+var LOOSE_NUMBER = "number";
+function primitive(name) {
+  return { form: "primitive", name, args: [] };
+}
+function optionalOf(inner2) {
+  if (inner2.form === "primitive" && inner2.name === "any") return inner2;
+  if (inner2.form === "optional") throw new TypeProblemError("TYPE_POSITION_INVALID", "a type is made optional twice (T??)", "T?");
+  if (inner2.form === "primitive" && inner2.name === "void") throw new TypeProblemError("TYPE_POSITION_INVALID", "void cannot be optional (void?)", "void");
+  return { form: "optional", args: [inner2] };
+}
+function inner(ctx) {
+  return { ...ctx, top: false, voidAllowed: false, omittable: false };
+}
+function normalise(node, ctx, notes) {
+  switch (node.k) {
+    case "paren":
+      return normalise(node.inner, ctx, notes);
+    case "async":
+      return asyncOf(node.inner, ctx, notes, "async");
+    case "array":
+      return { form: "list", args: [normalise(node.elem, inner(ctx), notes)] };
+    case "opt":
+      return optionalOf(normalise(node.inner, inner(ctx), notes));
+    case "union":
+      return unionOf(node.members, ctx, notes);
+    case "name":
+      return node.args === void 0 ? bareName(node.name, ctx, notes) : appliedName(node.name, node.args, ctx, notes);
+    case "literal":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `${node.text} is a literal value, not a type \u2014 a literal union is not in the grammar`, "an enum type naming the values");
+    case "object":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "an inline object shape is not in the grammar", "a named value-object");
+    case "function":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "an inline function type is not in the grammar", "a signature type");
+    case "intersection":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "an intersection (A & B) is not in the grammar", "a named type");
+    case "tuple":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "a tuple is not in the grammar", "a named value-object");
+    case "operator":
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `"${node.op}" is TypeScript's type algebra, not in the grammar`, "a named type");
+  }
+}
+function asyncOf(innerNode, ctx, notes, spelled) {
+  if (!ctx.top || !RETURNS_POSITIONS.has(ctx.position)) {
+    throw new TypeProblemError("TYPE_POSITION_INVALID", `${spelled} may stand only at the top of a returns, not in a ${ctx.position}`);
+  }
+  const read2 = normalise(innerNode, { ...inner(ctx), voidAllowed: true }, notes);
+  return { form: "async", args: [read2] };
+}
+function bareName(name, ctx, notes) {
+  const lower = name.toLowerCase();
+  if (NONES.has(name)) {
+    throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" on its own names no type \u2014 "no value" joins a type as T?`, "T?, or void for a returns that answers nothing");
+  }
+  if (lower === "true" || lower === "false") {
+    throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `${name} is a literal value, not a type`, "bool, or an enum type naming the values");
+  }
+  if (name === "number" || lower === "number") {
+    if (ctx.looseNumber) return primitive(LOOSE_NUMBER);
+    notes.notNeutral ??= { detail: '"number" does not say whether it holds an integer \u2014 int or float?', replacement: "int or float" };
+    return primitive("float");
+  }
+  const prim = primitiveOf(name);
+  if (prim !== void 0) {
+    if (prim === "void" && !ctx.voidAllowed) {
+      throw new TypeProblemError("TYPE_POSITION_INVALID", `void may stand only as a whole returns (or async void), not in a ${ctx.top ? ctx.position : "collection, union or argument"}`);
+    }
+    return primitive(prim);
+  }
+  if (genericOf(name) !== void 0) {
+    throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" needs its type arguments`, `${genericOf(name)?.form ?? "list"}<...>`);
+  }
+  const legacy = NOT_NEUTRAL.get(lower);
+  if (legacy !== void 0) {
+    notes.notNeutral ??= { detail: `"${name}" has no neutral meaning`, replacement: legacy };
+    return primitive("any");
+  }
+  return { form: "named", name, args: [] };
+}
+function appliedName(name, args, ctx, notes) {
+  const alias = genericOf(name);
+  if (alias !== void 0) {
+    if (args.length !== alias.arity) {
+      throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" takes ${alias.arity} type argument${alias.arity === 1 ? "" : "s"}, ${args.length} given`);
+    }
+    if (alias.form === "async") return asyncOf(args[0], ctx, notes, `${name}<...>`);
+    if (alias.form === "optional") return optionalOf(normalise(args[0], inner(ctx), notes));
+    const read2 = args.map((a) => normalise(a, inner(ctx), notes));
+    if (alias.form === "map") assertMapKey(read2[0], args[0]);
+    return { form: alias.form, args: read2 };
+  }
+  if (UTILITY_TYPES.has(name)) {
+    throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", `"${name}<...>" is a TypeScript utility type, not in the grammar`, "a named type");
+  }
+  if (primitiveOf(name) !== void 0 || NONES.has(name)) {
+    throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" takes no type arguments`);
+  }
+  const legacy = NOT_NEUTRAL.get(name.toLowerCase());
+  if (legacy !== void 0) {
+    args.forEach((a) => normalise(a, { ...inner(ctx), voidAllowed: true }, notes));
+    notes.notNeutral ??= { detail: `"${name}<...>" has no neutral meaning`, replacement: legacy };
+    return primitive("any");
+  }
+  return { form: "applied", name, args: args.map((a) => normalise(a, inner(ctx), notes)) };
+}
+function assertHoldable(expression) {
+  if (expression.form === "primitive" && HOLDABLE_PRIMITIVES.includes(expression.name ?? "")) return;
+  throw new TypeProblemError(
+    "TYPE_POSITION_INVALID",
+    `a named scalar holds one primitive (${HOLDABLE_PRIMITIVES.join(", ")}), not ${canonicalTypeText(expression)}`,
+    "one of those primitives, or fields for a value-object that holds more than one value"
+  );
+}
+function assertMapKey(key, written) {
+  if (key.form === "named") return;
+  if (key.form === "primitive" && (key.name === "string" || key.name === "int" || key.name === LOOSE_NUMBER)) return;
+  if (key.form === "primitive" && key.name === "float" && written.k === "name" && written.name.toLowerCase() === "number") return;
+  throw new TypeProblemError("TYPE_POSITION_INVALID", "a map key must be string, int or an enum", "map<string, V>");
+}
+function unionOf(members, ctx, notes) {
+  const nones = members.filter((m) => m.k === "name" && m.args === void 0 && NONES.has(m.name));
+  const rest = members.filter((m) => !(m.k === "name" && m.args === void 0 && NONES.has(m.name)));
+  if (rest.length === 0) throw new TypeProblemError("TYPE_EXPRESSION_INVALID", "a union of nones names no type");
+  if (rest.some((m) => m.k === "literal" || m.k === "name" && m.args === void 0 && /^(true|false)$/i.test(m.name))) {
+    throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "a union of literal values is not in the grammar", "an enum type naming the values");
+  }
+  const memberCtx = inner(ctx);
+  let hasNone = nones.length > 0;
+  const read2 = rest.map((m) => {
+    const e = normalise(m, memberCtx, notes);
+    if (e.form !== "optional") return e;
+    hasNone = true;
+    return e.args[0];
+  });
+  let base;
+  if (read2.length === 1) {
+    base = read2[0];
+  } else {
+    const loose = read2.find((e) => e.form !== "named" && e.form !== "applied");
+    if (loose) {
+      throw new TypeProblemError("TYPE_FORM_UNSUPPORTED", "a union may hold only named types \u2014 this one mixes in a primitive or a collection", "a named type (an entity, value-object or enum), or two params");
+    }
+    base = { form: "union", args: read2 };
+  }
+  if (!hasNone) return base;
+  const onlyUndefined = nones.length > 0 && nones.every((n) => n.name === "undefined") && read2.length === rest.length && !rest.some((m) => m.k === "opt");
+  if (ctx.omittable && ctx.top && onlyUndefined) return base;
+  return optionalOf(base);
+}
+function canonicalTypeText(expr) {
+  switch (expr.form) {
+    case "primitive":
+    case "named":
+      return expr.name ?? "";
+    case "list":
+    case "set":
+      return `${expr.form}<${canonicalTypeText(expr.args[0])}>`;
+    case "map":
+      return `map<${canonicalTypeText(expr.args[0])}, ${canonicalTypeText(expr.args[1])}>`;
+    case "optional": {
+      const innerText = canonicalTypeText(expr.args[0]);
+      return expr.args[0].form === "union" ? `(${innerText})?` : `${innerText}?`;
+    }
+    case "union":
+      return expr.args.map(canonicalTypeText).join(" | ");
+    case "async":
+      return `async ${canonicalTypeText(expr.args[0])}`;
+    case "applied":
+      return `${expr.name}<${expr.args.map(canonicalTypeText).join(", ")}>`;
+  }
+}
+function typeNamedRefs(expr) {
+  if (expr.form === "named") return [expr.name];
+  const own = expr.form === "applied" ? [expr.name] : [];
+  return [...own, ...expr.args.flatMap(typeNamedRefs)];
+}
+function typeIsMany(expr) {
+  if (expr.form === "list" || expr.form === "set" || expr.form === "map") return true;
+  if (expr.form === "optional" || expr.form === "async") return typeIsMany(expr.args[0]);
+  return false;
+}
+function contextFor(position, omittable2, looseNumber = false) {
+  return { position, top: true, voidAllowed: RETURNS_POSITIONS.has(position), omittable: omittable2, looseNumber };
+}
+function parseTypePosition(text3, position, omittable2 = false) {
+  let raw;
+  try {
+    raw = readRaw(text3);
+  } catch (e) {
+    if (!(e instanceof TypeSyntaxError)) throw e;
+    return { expression: null, canonical: text3, problem: { code: "TYPE_EXPRESSION_INVALID", written: text3, detail: `"${text3}" does not parse as a type: ${e.message}` } };
+  }
+  const notes = {};
+  try {
+    const expression = normalise(raw, contextFor(position, omittable2), notes);
+    if (position === "holds") assertHoldable(expression);
+    const problem = notes.notNeutral ? { code: "TYPE_NOT_NEUTRAL", written: text3, detail: notes.notNeutral.detail, replacement: notes.notNeutral.replacement } : null;
+    return { expression, canonical: canonicalTypeText(expression), problem };
+  } catch (e) {
+    if (!(e instanceof TypeProblemError)) throw e;
+    return {
+      expression: null,
+      canonical: text3,
+      problem: { code: e.code, written: text3, detail: `"${text3}": ${e.detail}`, ...e.replacement ? { replacement: e.replacement } : {} }
+    };
+  }
+}
+function parseTypeExpression(text3, position) {
+  return parseTypePosition(text3, position);
+}
+function readCodeAnnotation(annotation, looseNumber) {
+  let raw;
+  try {
+    raw = readRaw(annotation);
+  } catch (e) {
+    if (e instanceof TypeSyntaxError) return null;
+    throw e;
+  }
+  try {
+    return normalise(raw, contextFor("returns", false, looseNumber), {});
+  } catch (e) {
+    if (e instanceof TypeProblemError) return null;
+    throw e;
+  }
+}
+function writtenTypeRefs(text3, position) {
+  const parse = parseTypePosition(text3, position);
+  if (parse.expression && !parse.problem) return typeNamedRefs(parse.expression);
+  try {
+    return rawRefs(readRaw(text3));
+  } catch (e) {
+    if (e instanceof TypeSyntaxError) return [];
+    throw e;
+  }
+}
+function rawRefs(node) {
+  switch (node.k) {
+    case "name": {
+      const own = isTypeVocabulary(node.name) || UTILITY_TYPES.has(node.name) ? [] : [node.name];
+      return [...own, ...(node.args ?? []).flatMap(rawRefs)];
+    }
+    case "array":
+      return rawRefs(node.elem);
+    case "opt":
+    case "paren":
+    case "async":
+    case "operator":
+      return rawRefs(node.inner);
+    case "union":
+    case "intersection":
+    case "object":
+      return node.members.flatMap(rawRefs);
+    case "tuple":
+      return node.elems.flatMap(rawRefs);
+    case "function":
+      return [...node.params.flatMap(rawRefs), ...rawRefs(node.ret)];
+    case "literal":
+      return [];
+  }
+}
+var Canonicalizer = class {
+  constructor(specId, kind) {
+    this.specId = specId;
+    this.kind = kind;
+    this.respellings = [];
+    this.problems = [];
+  }
+  /** One position: its canonical text when it has one, else the text as written, recorded either way. */
+  read(text3, position, path49, omittable2 = false) {
+    const parse = parseTypePosition(text3, position, omittable2);
+    if (parse.problem) {
+      this.problems.push({ ...parse.problem, specId: this.specId, kind: this.kind, path: path49 });
+      return text3;
+    }
+    if (parse.canonical !== text3) this.respellings.push({ specId: this.specId, kind: this.kind, path: path49, written: text3, stored: parse.canonical });
+    return parse.canonical;
+  }
+  params(params, position, prefix) {
+    return params.map((p) => ({ ...p, type: this.read(p.type, position, `${prefix}.${p.name}`, !!p.optional) }));
+  }
+};
+function interfaceCanonicalTypes(intf) {
+  const reader = new Canonicalizer(intf.id, "interface");
+  const methods = (intf.methods ?? []).map((m) => {
+    if (m.signatureFrom !== void 0) return m;
+    const out = { ...m };
+    if (m.params !== void 0) out.params = reader.params(m.params, "param", `methods.${m.name}.params`);
+    if (typeof m.returns === "string") out.returns = reader.read(m.returns, "returns", `methods.${m.name}.returns`);
+    return out;
+  });
+  return { spec: { ...intf, methods }, respellings: reader.respellings, problems: reader.problems };
+}
+function typeCanonicalTypes(type) {
+  const reader = new Canonicalizer(type.id, "type");
+  const out = { ...type };
+  if (Array.isArray(type.fields)) {
+    out.fields = type.fields.map((f) => ({ ...f, type: reader.read(f.type, "field", `fields.${f.name}`, !!f.optional) }));
+  }
+  if (Array.isArray(type.methods)) {
+    out.methods = type.methods.map((m) => {
+      const method = { ...m };
+      if (m.params !== void 0) method.params = reader.params(m.params, "type-method-param", `methods.${m.name}.params`);
+      if (typeof m.returns === "string") method.returns = reader.read(m.returns, "type-method-returns", `methods.${m.name}.returns`);
+      return method;
+    });
+  }
+  if (type.params !== void 0) out.params = reader.params(type.params, "signature-param", "params");
+  if (typeof type.holds === "string") out.holds = reader.read(type.holds, "holds", "holds");
+  if (typeof type.returns === "string") out.returns = reader.read(type.returns, "signature-returns", "returns");
+  return { spec: out, respellings: reader.respellings, problems: reader.problems };
+}
+var INTEGER_WORDS = /* @__PURE__ */ new Set([
+  "count",
+  "counts",
+  "size",
+  "sizes",
+  "length",
+  "len",
+  "limit",
+  "limits",
+  "port",
+  "step",
+  "steps",
+  "index",
+  "idx",
+  "depth",
+  "level",
+  "levels",
+  "days",
+  "day",
+  "hours",
+  "minutes",
+  "seconds",
+  "ms",
+  "millis",
+  "milliseconds",
   "bytes",
-  "any",
-  "void",
-  "null",
-  "undefined",
-  "object",
-  "date",
-  "datetime",
-  "time",
-  "timestamp",
-  "duration",
-  "uuid",
-  "decimal",
-  "json",
-  "true",
-  "false",
-  "list",
-  "vector",
-  "vec",
-  "array",
-  "map",
-  "set",
-  "dict",
-  "dictionary",
-  "hashmap",
-  "tuple",
-  "result",
-  "option",
-  "box",
-  "arc",
-  "rc",
-  "ref",
-  "cell",
-  "refcell",
-  "mutex",
-  "rwlock",
-  "std",
-  "promise",
-  "record",
-  "json",
-  "unknown",
-  "never",
-  "error",
-  "mcpserver"
+  "version",
+  "total",
+  "offset",
+  "page",
+  "pages",
+  "retries",
+  "attempts",
+  "number",
+  "num",
+  "line",
+  "lines",
+  "column",
+  "columns",
+  "max",
+  "min",
+  "width",
+  "height"
 ]);
+function namesAnInteger(name) {
+  const words2 = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_\-.]+/).filter(Boolean);
+  return words2.some((word) => INTEGER_WORDS.has(word));
+}
+function positionNameOf(path49) {
+  const segments = path49.split(".");
+  const last = segments[segments.length - 1];
+  return last === "returns" && segments.length >= 3 ? segments[segments.length - 2] : last;
+}
+var NUMBER_NAME = /(?<![\w:.-])number(?![\w:.-])/g;
+function typeProblemIntProposal(problem) {
+  if (problem.code !== "TYPE_NOT_NEUTRAL" || problem.replacement !== "int or float") return null;
+  if (problem.specId === void 0 || problem.kind === void 0 || problem.path === void 0) return null;
+  if (!namesAnInteger(positionNameOf(problem.path))) return null;
+  const parse = parseTypePosition(problem.written.replace(NUMBER_NAME, "int"), "returns");
+  if (!parse.expression || parse.problem) return null;
+  return { specId: problem.specId, kind: problem.kind, path: problem.path, written: problem.written, stored: parse.canonical };
+}
+function emptyTypeSpellingFacts() {
+  return { respellings: [], problems: [] };
+}
+
+// src/models/type-references.ts
 function extractTypeIdentifiers(typeStr) {
-  let cleaned = typeStr.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  let cleaned = typeStr.replace(/^\s*async\s+(?=\S)/, "").replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   cleaned = cleaned.replace(/(?<=\S)\s*\([^)]*\)\s*$/, "");
   cleaned = cleaned.replace(/(?<=\S)\s+[-—:]\s+[a-z\s_-]+$/, "");
   cleaned = cleaned.replace(/(["'`])(?:\\.|[^\\])*?\1/g, " ");
@@ -8021,16 +8764,19 @@ function methodTypeRefs(m) {
   if (m.params && m.params.length > 0) {
     const refs = [];
     for (const p of m.params) {
-      refs.push(...extractTypeIdentifiers(p.type));
+      refs.push(...writtenTypeRefs(p.type, "param"));
     }
-    refs.push(...extractTypeIdentifiers(m.returns ?? ""));
+    if (m.returns !== void 0) refs.push(...writtenTypeRefs(m.returns, "returns"));
     return Array.from(new Set(refs));
   }
   return extractTypesFromSignature(m.signature ?? "", m.returns ?? "");
 }
 function signatureTypeRefs(type) {
   if (type.kind !== "signature") return [];
-  const refs = [...(type.params ?? []).flatMap((p) => extractTypeIdentifiers(p.type)), ...extractTypeIdentifiers(type.returns ?? "")];
+  const refs = [
+    ...(type.params ?? []).flatMap((p) => writtenTypeRefs(p.type, "signature-param")),
+    ...type.returns !== void 0 ? writtenTypeRefs(type.returns, "signature-returns") : []
+  ];
   return Array.from(new Set(refs));
 }
 function methodGenericParameters(method) {
@@ -8065,12 +8811,108 @@ function typeGenericParameters(type) {
 }
 function fieldTypeRefs(type, fieldType) {
   const generics = new Set(Array.from(typeGenericParameters(type)).map((g) => g.toLowerCase()));
-  return extractTypeIdentifiers(fieldType).filter((ref) => !generics.has(ref.toLowerCase()));
+  return writtenTypeRefs(fieldType, "field").filter((ref) => !generics.has(ref.toLowerCase()));
 }
 function interfaceGenericParameters(intf) {
   return extractTypeGenerics(intf.name);
 }
 
+// src/models/type-dialects.ts
+function lastSegment(name) {
+  return name.split(/::|\./).filter(Boolean).pop() ?? name;
+}
+function sameType(code, spec, codeNames) {
+  if (code.form === "primitive" && code.name === "number") return spec.form === "primitive" && (spec.name === "int" || spec.name === "float");
+  if (code.form === "named" && (spec.form === "named" || spec.form === "applied")) {
+    if (spec.form === "applied") return false;
+    return namesAgree(code.name, spec.name, codeNames);
+  }
+  if (code.form !== spec.form) return false;
+  if (code.form === "primitive") return code.name === spec.name;
+  if (code.form === "applied" && !namesAgree(code.name, spec.name, codeNames)) return false;
+  if (code.args.length !== spec.args.length) return false;
+  return code.args.every((arg, i) => sameType(arg, spec.args[i], codeNames));
+}
+function namesAgree(codeName, specName, codeNames) {
+  if (codeName === specName) return true;
+  const mapped = codeNames.get(specName) ?? codeNames.get(lastSegment(specName));
+  return mapped === codeName || mapped === lastSegment(codeName);
+}
+function writeTypeScript(expr) {
+  switch (expr.form) {
+    case "primitive":
+      return TS_PRIMITIVES[expr.name ?? ""] ?? expr.name ?? "unknown";
+    case "named":
+      return expr.name ?? "unknown";
+    case "list": {
+      const elem = writeTypeScript(expr.args[0]);
+      return /[|\s]/.test(elem) ? `(${elem})[]` : `${elem}[]`;
+    }
+    case "set":
+      return `Set<${writeTypeScript(expr.args[0])}>`;
+    case "map":
+      return `Record<${writeTypeScript(expr.args[0])}, ${writeTypeScript(expr.args[1])}>`;
+    case "optional":
+      return `${writeTypeScript(expr.args[0])} | null`;
+    case "union":
+      return expr.args.map(writeTypeScript).join(" | ");
+    case "async":
+      return `Promise<${writeTypeScript(expr.args[0])}>`;
+    case "applied":
+      return `${expr.name}<${expr.args.map(writeTypeScript).join(", ")}>`;
+  }
+}
+var TS_PRIMITIVES = {
+  string: "string",
+  int: "number",
+  float: "number",
+  bool: "boolean",
+  bytes: "Uint8Array",
+  date: "string",
+  datetime: "string",
+  duration: "string",
+  void: "void",
+  any: "unknown"
+};
+var typescriptDialect = {
+  language: "typescript",
+  read(annotation) {
+    return readCodeAnnotation(annotation, false);
+  },
+  agrees(annotation, expression, codeNames) {
+    const code = readCodeAnnotation(annotation, true);
+    return code !== null && sameType(code, expression, codeNames);
+  },
+  write(expression) {
+    return writeTypeScript(expression);
+  },
+  mappingLines() {
+    return [
+      "string \u2192 string",
+      "int, float \u2192 number",
+      "bool \u2192 boolean",
+      "bytes \u2192 Uint8Array",
+      "date, datetime, duration \u2192 string (ISO 8601)",
+      "any \u2192 unknown",
+      "list<T> \u2192 T[]",
+      "set<T> \u2192 Set<T>",
+      "map<K, V> \u2192 Record<K, V>",
+      "T? \u2192 T | null",
+      "A | B \u2192 A | B",
+      "async T \u2192 Promise<T>",
+      "an enum E \u2192 type E = 'a' | 'b' (a string-literal union alias)",
+      "a named scalar E holding P \u2192 type E = P (an alias of the primitive)"
+    ];
+  }
+};
+var DIALECTS = /* @__PURE__ */ new Map([
+  ["typescript", typescriptDialect],
+  ["javascript", typescriptDialect]
+]);
+function typeDialectFor(language) {
+  return DIALECTS.get(language.toLowerCase()) ?? null;
+}
+
 // src/models/step-graph.ts
 function stepGraph(method) {
   const steps = method.narrative;
@@ -8365,6 +9207,36 @@ function callSitesOf(facts, fn) {
 function hasFunctionBody(facts, symbol) {
   return callSitesOf(facts, symbol) !== void 0;
 }
+var EXTENSION_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".cs": "csharp",
+  ".java": "java",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".hpp": "cpp",
+  ".rb": "ruby",
+  ".php": "php",
+  ".kt": "kotlin",
+  ".swift": "swift"
+};
+function languageOfSourcePath(sourcePath) {
+  return EXTENSION_LANGUAGE[path9.extname(sourcePath).toLowerCase()];
+}
+function dialectOf(facts) {
+  return facts.language ? typeDialectFor(facts.language) : null;
+}
 function resolveImport(fromFile, specifier, knownPaths) {
   if (!specifier.startsWith(".")) return void 0;
   const joined = pathKey(path9.posix.normalize(path9.posix.join(path9.posix.dirname(fromFile), specifier)));
@@ -8410,11 +9282,18 @@ function closureTypeOf(snapshot, identifier) {
   if (matches.length === 1) return matches[0];
   return matches.find((def) => nameKey(def.id) === nameKey(ref));
 }
+function renamedRefs(expr, rename) {
+  const args = expr.args.map((a) => renamedRefs(a, rename));
+  return expr.form === "named" || expr.form === "applied" ? { ...expr, name: rename(expr.name), args } : { ...expr, args };
+}
 function canonicalTypeRef(snapshot, typeExpr) {
+  const rename = (identifier) => closureTypeOf(snapshot, identifier)?.id ?? identifier;
+  const parse = parseTypeExpression(typeExpr, "returns");
+  if (parse.expression) return canonicalTypeText(renamedRefs(parse.expression, rename));
   return typeExpr.replace(TYPE_IDENTIFIER, (identifier) => {
     if (!/[A-Za-z]/.test(identifier)) return identifier;
-    if (BUILTIN_TYPES.has(identifier.toLowerCase())) return identifier.toLowerCase();
-    return closureTypeOf(snapshot, identifier)?.id ?? identifier;
+    if (isTypeVocabulary(identifier)) return identifier.toLowerCase();
+    return rename(identifier);
   });
 }
 function typeShape(snapshot, def) {
@@ -8426,7 +9305,9 @@ function typeShape(snapshot, def) {
     ...def.kind === "signature" ? {
       params: (def.params ?? []).map((p) => ({ type: canonicalTypeRef(snapshot, p.type), optional: p.optional === true })),
       returns: canonicalTypeRef(snapshot, def.returns ?? "unknown")
-    } : {}
+    } : {},
+    ...def.kind === "enum" ? { values: (def.values ?? []).map((v) => v.name) } : {},
+    ...def.holds !== void 0 ? { holds: canonicalTypeRef(snapshot, def.holds) } : {}
   };
 }
 function typeDefExprs(def) {
@@ -8694,7 +9575,7 @@ function shortestPath(from, to, members, edges, rank) {
 // src/models/validation-options.ts
 function selectsFamily(options, declaresMembers) {
   if (options?.family) return true;
-  return declaresMembers && options?.recursive !== false;
+  return declaresMembers && options?.memberDepth !== 0;
 }
 
 // src/core/narrative-labels.ts
@@ -9423,17 +10304,23 @@ function buildCanvasModel(issues = [], relations) {
     })),
     methods: t.methods.map((m) => ({ name: m.name, signature: m.signature, returns: m.returns, ...m.description ? { description: m.description } : {} })),
     ...t.kind === "signature" ? { signature: deriveTypeSignature(t) } : {},
+    ...t.kind === "enum" ? { values: (t.values ?? []).map((v) => ({ name: v.name, ...v.description ? { description: v.description } : {} })) } : {},
+    ...t.holds !== void 0 ? { holds: t.holds } : {},
     usedBy: usedByFor(t),
     ...t.componentClass ? { componentClass: t.componentClass } : {},
     ...t.database ? { database: t.database } : {},
     ...t.table ? { table: t.table } : {},
     ...t.linkedEntity ? { linkedEntity: t.linkedEntity } : {}
   }));
-  const MANY_SHAPE = /\[\s*\]|Array<|Vec<|Set<|List<|Map<|Record<|HashMap</i;
+  const multiplicity = (field) => {
+    const expression = parseTypeExpression(field.type, "field").expression;
+    if (expression && typeIsMany(expression)) return "*";
+    return field.optional || expression?.form === "optional" ? "0..1" : "1";
+  };
   const typeEdges = [];
   for (const t of typeSpecs) {
     for (const field of t.fields) {
-      const refs = new Set(extractTypeIdentifiers(field.type));
+      const refs = new Set(writtenTypeRefs(field.type, "field"));
       if (field.references) {
         const refStr = field.references;
         refs.add(refStr);
@@ -9448,8 +10335,8 @@ function buildCanvasModel(issues = [], relations) {
           const qualified = other.subsystem && !other.id.startsWith(`${other.subsystem}::`) ? `${other.subsystem}::${other.id}` : other.id;
           return matchTypeRef(ref, qualified);
         });
-        if (target && target.id !== t.id) {
-          const card = MANY_SHAPE.test(field.type) ? "*" : field.optional ? "0..1" : "1";
+        if (target && target.id !== t.id && target.kind !== "enum" && target.holds === void 0) {
+          const card = multiplicity(field);
           if (!typeEdges.some((e) => e.from === t.id && e.to === target.id && e.field === field.name)) {
             typeEdges.push({ from: t.id, to: target.id, field: field.name, card });
           }
@@ -11114,7 +12001,7 @@ var MODEL = __MODEL_JSON__;
       return '';
     }
     function visibleFields(t) {
-      if (det === 'names') return [];
+      if (det === 'names' || t.values || t.holds) return [];
       if (det === 'keys') return t.fields.filter(function (f) { return markerOf(t, f) !== ''; });
       return t.fields;
     }
@@ -11159,15 +12046,19 @@ var MODEL = __MODEL_JSON__;
       var meths = det === 'full' ? t.methods : [];
       // A signature type is drawn with its derived text in place of a field list.
       var sig = t.signature && det !== 'names' ? t.signature : '';
-      var head = t.name + '  \\u00AB' + t.kind + '\\u00BB';
-      var rows = (sig ? [sig] : []).concat(fields.map(function (f) { return rowText(t, f); }))
+      // An enum is drawn with its values in place of a field list.
+      var vals = t.values && det !== 'names' ? t.values : [];
+      // A named scalar is drawn compactly: its name and the primitive it holds.
+      var head = t.name + (t.holds ? ' = ' + t.holds : '') + '  \\u00AB' + t.kind + '\\u00BB';
+      var rows = (sig ? [sig] : []).concat(vals.map(function (v) { return '\\u2022 ' + v.name; }))
+        .concat(fields.map(function (f) { return rowText(t, f); }))
         .concat(meths.map(function (m) { return '\\u0192 ' + m.name + '(): ' + m.returns; }));
       var longest = head.length + 4;
       rows.forEach(function (r) { if (r.length > longest) longest = r.length; });
       var plain = rows.length === 0;
       var pw = Math.max(170, head.length * 6.8 + 26);
       var W = Math.max(210, Math.min(400, longest * 6.6 + 30));
-      return { fields: fields, meths: meths, sig: sig, head: head, plain: plain, w: plain ? pw : W, h: plain ? 40 : TH_H + (sig ? ROW_H : 0) + fields.length * ROW_H + meths.length * ROW_H };
+      return { fields: fields, meths: meths, sig: sig, vals: vals, head: head, plain: plain, w: plain ? pw : W, h: plain ? 40 : TH_H + (sig ? ROW_H : 0) + vals.length * ROW_H + fields.length * ROW_H + meths.length * ROW_H };
     }
 
     // Emit one type table with its top-left at (ax, ay); returns its size.
@@ -11198,6 +12089,13 @@ var MODEL = __MODEL_JSON__;
         });
         ry += ROW_H;
       }
+      sh.vals.forEach(function (v, vi) {
+        eles.push({
+          data: { id: 'TV~' + t.id + '~' + vi, parent: 'T~' + t.id, label: '\\u2022 ' + v.name, w: sh.w, h: ROW_H, tw: sh.w - 14 },
+          position: { x: ax + sh.w / 2, y: ry + ROW_H / 2 }, classes: 'typeRow' + (dim ? ' dimmed' : ''), grabbable: false,
+        });
+        ry += ROW_H;
+      });
       sh.fields.forEach(function (f) {
         var rid = 'TF~' + t.id + '~' + f.name;
         rowIds[rid] = 1;
@@ -13731,6 +14629,17 @@ var MODEL = __MODEL_JSON__;
           : '<span class="desc">no fields</span>';
         if (ty.signature) {
           body += section('Signature', 1, '<div class="method"><code>' + esc(ty.signature) + '</code></div>', true);
+        } else if (ty.holds) {
+          body += section('Holds', 1, '<div class="method"><code>' + esc(ty.holds) + '</code>'
+            + '<div class="mdesc">A named scalar: one ' + esc(ty.holds) + ' under this name.</div></div>', true);
+        } else if (ty.values) {
+          body += section('Values', ty.values.length, ty.values.length
+            ? ty.values.map(function (v) {
+                return '<div class="method"><div class="mname">' + esc(v.name) + '</div>'
+                  + (v.description ? '<div class="mdesc">' + esc(v.description) + '</div>' : '')
+                  + '</div>';
+              }).join('')
+            : '<span class="desc">no values</span>', true);
         } else {
           body += section('Fields', ty.fields.length, fieldsInner, true);
         }
@@ -14056,7 +14965,7 @@ function computeTypeClosure(entries, types, exported = []) {
     queue.push(key);
   };
   const enqueueRef = (ref) => {
-    if (BUILTIN_TYPES.has(ref.toLowerCase())) return;
+    if (isTypeVocabulary(ref)) return;
     for (const spec of types) {
       if (matchTypeRef(ref, qualifiedTypeId2(spec))) include(spec);
     }
@@ -14070,13 +14979,13 @@ function computeTypeClosure(entries, types, exported = []) {
   while (queue.length) {
     const spec = included.get(queue.shift());
     for (const field of spec.fields) {
-      for (const ref of extractTypeIdentifiers(field.type)) enqueueRef(ref);
+      for (const ref of writtenTypeRefs(field.type, "field")) enqueueRef(ref);
     }
     for (const param of spec.params ?? []) {
-      for (const ref of extractTypeIdentifiers(param.type)) enqueueRef(ref);
+      for (const ref of writtenTypeRefs(param.type, "signature-param")) enqueueRef(ref);
     }
     if (spec.returns) {
-      for (const ref of extractTypeIdentifiers(spec.returns)) enqueueRef(ref);
+      for (const ref of writtenTypeRefs(spec.returns, "signature-returns")) enqueueRef(ref);
     }
   }
   const usedIds = /* @__PURE__ */ new Set();
@@ -14095,7 +15004,11 @@ function computeTypeClosure(entries, types, exported = []) {
       kind: t.kind,
       fields: t.fields.map(describe2),
       // A signature type travels complete: its params and returns with it.
-      ...t.kind === "signature" ? { params: (t.params ?? []).map(describe2), returns: t.returns ?? "unknown" } : {}
+      ...t.kind === "signature" ? { params: (t.params ?? []).map(describe2), returns: t.returns ?? "any" } : {},
+      // An enum travels with its values, in declared order.
+      ...t.kind === "enum" ? { values: (t.values ?? []).map((v) => ({ name: v.name, ...v.description ? { description: v.description } : {} })) } : {},
+      // A named scalar travels with the primitive it holds.
+      ...t.holds !== void 0 ? { holds: t.holds } : {}
     };
   });
 }
@@ -14714,7 +15627,7 @@ function depthOf(family, node) {
   return depth;
 }
 function selectProjects(family, options) {
-  const limit = typeof options.recursive === "number" ? options.recursive : options.recursive === false ? 0 : Infinity;
+  const limit = options.memberDepth ?? Infinity;
   const nodes = family.nodes.filter((n) => depthOf(family, n) <= limit);
   const scope = options.scopeSubsystem;
   if (!scope) return nodes.map((node) => ({ node }));
@@ -15242,7 +16155,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.95";
+var WAIRON_VERSION = "5.1.1-dev.97";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -15469,7 +16382,7 @@ var ProfileDefSchema = import_zod9.z.object({
 });
 var LanguagePackDefSchema = import_zod9.z.object({
   unsupportedFlow: import_zod9.z.record(import_zod9.z.string()).default({}),
-  foreignBuiltins: import_zod9.z.array(import_zod9.z.string()).default([])
+  foreignBuiltins: import_zod9.z.array(import_zod9.z.string()).optional()
 });
 var PackSkillSchema = import_zod9.z.object({
   /** A NEW skill, installed namespaced as `<pack-id>-<id>`. Mutually exclusive with `extends`. */
@@ -15603,8 +16516,9 @@ function globalPacksEnabled(config) {
   return config.extensions?.useGlobalPacks ?? GLOBAL_PACKS_DEFAULT;
 }
 function emptyExtensions() {
-  return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [] };
+  return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [], deprecations: [] };
 }
+var FOREIGN_BUILTINS_RETIRED = "nothing replaces it: contracts are written in the neutral type grammar and a language is chosen at L4, so the foreign-builtin check it fed is retired";
 function globalPacksDir() {
   return process.env.WAIRON_PACKS_DIR ?? path17.join(os3.homedir(), ".wairon", "packs");
 }
@@ -15665,11 +16579,11 @@ function mergePack(out, pack, ref, scope, packDir) {
   Object.assign(out.profiles, pack.profiles);
   for (const [lang, def] of Object.entries(pack.languages)) {
     const key = lang.toLowerCase();
+    if (def.foreignBuiltins !== void 0) {
+      out.deprecations.push(`${pack.name}: languages.${lang}.foreignBuiltins \u2014 ${FOREIGN_BUILTINS_RETIRED}`);
+    }
     const existing = out.languages[key];
-    out.languages[key] = existing ? {
-      unsupportedFlow: { ...existing.unsupportedFlow, ...def.unsupportedFlow },
-      foreignBuiltins: [.../* @__PURE__ */ new Set([...existing.foreignBuiltins, ...def.foreignBuiltins])]
-    } : def;
+    out.languages[key] = { unsupportedFlow: { ...existing?.unsupportedFlow, ...def.unsupportedFlow } };
   }
   for (const s of pack.skills) out.skills.push({ ...s, pack: pack.name, packVersion: pack.version, sourcePath: path17.resolve(packDir, s.source) });
   for (const p of pack.patterns) out.patterns.push({ ...p, pack: pack.name });
@@ -16217,7 +17131,7 @@ function buildImportGraph(index, universe) {
 function buildOwnershipIndex(ctx) {
   const ownedBy2 = /* @__PURE__ */ new Map();
   for (const comp of ctx.components) {
-    if (isRetired(comp) || !isPattern(comp)) continue;
+    if (isRetired(comp) || !(isPattern(comp) || comp.componentType === "Supervisor")) continue;
     for (const memberId of comp.owns) {
       const member = ctx.componentMap.get(memberId);
       if (!member || isPattern(member)) continue;
@@ -16275,7 +17189,7 @@ function buildImplementationMethods(ctx) {
     const component = ctx.componentMap.get(contract.component);
     if (!component) continue;
     if (ctx.isInChainedSubproject(component.subsystem)) continue;
-    const draftContext3 = ctx.isImplementationDraft(impl);
+    const draftContext4 = ctx.isImplementationDraft(impl);
     for (const method of impl.methods) {
       const sourceFile = methodSourceFile(method, impl.sourcePath);
       out.push({
@@ -16283,7 +17197,7 @@ function buildImplementationMethods(ctx) {
         method,
         component,
         ...sourceFile !== void 0 ? { sourceFile } : {},
-        draftContext: draftContext3
+        draftContext: draftContext4
       });
     }
   }
@@ -16521,7 +17435,7 @@ var roundtripRule = {
 var typeDeclarationsRule = {
   name: "type-declarations",
   judges: "design",
-  description: "A type owned by a subsystem must reference an existing one, and a type declaring neither fields nor methods is a placeholder that can inform neither implementers nor the ERD.",
+  description: "A type owned by a subsystem must reference an existing one, and a type declaring neither fields nor methods (nor, for an enum, values, nor, for a signature type, returns, nor, for a named scalar, the primitive it holds) is a placeholder that can inform neither implementers nor the ERD.",
   codes: [
     { code: "INVALID_SUBSYSTEM_REFERENCE", defaultSeverity: "error", summary: "Type references a non-existent owning subsystem" },
     { code: "HOLLOW_TYPE", defaultSeverity: "warning", summary: "Type declares no fields and no methods \u2014 a placeholder that informs neither implementers nor the ERD" }
@@ -16539,7 +17453,8 @@ var typeDeclarationsRule = {
           isDraftCtx
         );
       }
-      if ((!t.fields || t.fields.length === 0) && (!t.methods || t.methods.length === 0)) {
+      const models = (t.fields?.length ?? 0) > 0 || (t.methods?.length ?? 0) > 0 || (t.values?.length ?? 0) > 0 || t.returns !== void 0 || t.holds !== void 0;
+      if (!models) {
         ctx.addIssue(
           "warning",
           "HOLLOW_TYPE",
@@ -16776,6 +17691,7 @@ var signatureTypesRule = {
         );
         continue;
       }
+      if (t.kind === "enum") continue;
       const stated = [...t.params !== void 0 ? ["params"] : [], ...t.returns !== void 0 ? ["returns"] : []];
       if (stated.length === 0) continue;
       ctx.addIssue(
@@ -16822,6 +17738,184 @@ var signatureTextRule = {
   }
 };
 
+// src/core/rules/integrity/type-expressions.ts
+function draftContext3(ctx, specId, kind) {
+  if (kind === "interface") {
+    const intf = ctx.interfaceMap.get(specId);
+    return !!intf && (ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design");
+  }
+  const type = ctx.types.find((t) => t.id === specId);
+  const sub = type?.subsystem ? ctx.subsystems.find((s) => s.id === type.subsystem) : void 0;
+  return !!sub && (sub.status === "draft" || sub.status === "design");
+}
+function siteOf(path49) {
+  const [head2, name] = path49.split(".");
+  return (head2 === "methods" || head2 === "fields") && name ? name : path49;
+}
+function located(kind, specId, path49) {
+  return `${path49 ? `"${path49}" of ` : ""}${kind ?? "spec"} "${specId}"`;
+}
+function problemMessage(problem, specId) {
+  const where = located(problem.kind, specId, problem.path);
+  const replacement = problem.replacement ? ` Write ${problem.replacement} instead.` : "";
+  switch (problem.code) {
+    case "TYPE_EXPRESSION_INVALID":
+      return `The type at ${where} does not parse under the type grammar: ${problem.detail}.${replacement} Every reader treats the position as opaque any until it does.`;
+    case "TYPE_POSITION_INVALID":
+      return `The type at ${where} breaks a position rule: ${problem.detail}.${replacement}`;
+    case "TYPE_FORM_UNSUPPORTED":
+      return `The type at ${where} uses a form the type grammar leaves out: ${problem.detail}.${replacement} Every reader treats the position as opaque any until it is remodelled; the writer refuses it in a new write.`;
+    case "TYPE_NOT_NEUTRAL": {
+      if (problem.replacement === "int or float") {
+        const proposal = typeProblemIntProposal({ ...problem, specId }) ? ` Its name says a whole number, so \`wairon doctor\` proposes int here \u2014 confirm it by writing int, or write float.` : " Write int or float.";
+        return `The type at ${where} is "${problem.written}": number does not say whether it holds an integer \u2014 int or float?${proposal} Until then it is read as float.`;
+      }
+      return `The type at ${where} is "${problem.written}": ${problem.detail}, so it is read as any.${replacement}`;
+    }
+  }
+}
+var typeExpressionsRule = {
+  name: "type-expressions",
+  judges: "design",
+  description: "Reports what the scan's type canonicalisation recorded (ctx.typeSpellingFacts), one finding per position, located by spec and path: a stored text that does not parse (TYPE_EXPRESSION_INVALID); one that breaks a position rule \u2014 void or async out of place, a map key that is not string, int or an enum, a named scalar's holds that is not one primitive other than void and any, `T??` (TYPE_POSITION_INVALID); one using a form the grammar leaves out \u2014 an inline object shape, an inline function type, a string-literal union, a union mixing in a primitive or a collection, an intersection, a utility type or a tuple (TYPE_FORM_UNSUPPORTED); one naming `number` or a legacy builtin with no neutral meaning (TYPE_NOT_NEUTRAL); and one that is an alias of its canonical spelling (TYPE_SPELLING_STALE, which any save or doctor --fix repairs). Every message names the replacement: `number` asks \"int or float?\" (and says when the doctor repair proposes int), a function type names a signature type, a literal union an enum, an inline object or a mixed union a named value-object. The writer refuses all but the stale spelling at write time; these findings are how a tree that held them before the grammar existed is told, while it still loads and its consumers read the position as opaque any \u2014 which is why only what no real tree holds (a text that does not parse, a broken position rule) is an error. No finding when the run carries no facts (a candidate run).",
+  codes: [
+    { code: "TYPE_EXPRESSION_INVALID", defaultSeverity: "error", summary: "A structured type position does not parse under the type grammar" },
+    { code: "TYPE_POSITION_INVALID", defaultSeverity: "error", summary: "A type position breaks a position rule: void or async out of place, a non-scalar map key, or T??" },
+    { code: "TYPE_FORM_UNSUPPORTED", defaultSeverity: "warning", summary: "A type position uses a form the grammar leaves out \u2014 inline object, inline function type, string-literal union, union mixing in a primitive or collection, intersection, utility type or tuple \u2014 and the message names its named replacement" },
+    { code: "TYPE_NOT_NEUTRAL", defaultSeverity: "warning", summary: "A type position names number (int or float?) or a legacy builtin with no neutral meaning, and the message names the replacement" },
+    { code: "TYPE_SPELLING_STALE", defaultSeverity: "warning", summary: "A stored type position is an alias of its canonical spelling; any save or doctor --fix rewrites it" }
+  ],
+  check(ctx) {
+    const facts = ctx.typeSpellingFacts;
+    if (!facts) return;
+    for (const problem of facts.problems) {
+      if (problem.specId === void 0 || !ctx.isSpecInScope(problem.specId)) continue;
+      const severity = problem.code === "TYPE_EXPRESSION_INVALID" || problem.code === "TYPE_POSITION_INVALID" ? "error" : "warning";
+      ctx.addIssue(
+        severity,
+        problem.code,
+        problemMessage(problem, problem.specId),
+        problem.specId,
+        draftContext3(ctx, problem.specId, problem.kind),
+        void 0,
+        problem.path ? { at: siteOf(problem.path) } : void 0
+      );
+    }
+    for (const respelling of facts.respellings) {
+      if (!ctx.isSpecInScope(respelling.specId)) continue;
+      ctx.addIssue(
+        "warning",
+        "TYPE_SPELLING_STALE",
+        `The type at ${located(respelling.kind, respelling.specId, respelling.path)} is stored as "${respelling.written}", an alias of its canonical spelling "${respelling.stored}" \u2014 which is what every reader is shown. Any save of the spec writes the canonical text, and \`wairon doctor --fix\` rewrites every stale spelling at once.`,
+        respelling.specId,
+        draftContext3(ctx, respelling.specId, respelling.kind),
+        void 0,
+        { at: siteOf(respelling.path) }
+      );
+    }
+  }
+};
+
+// src/core/rules/integrity/enum-types.ts
+var enumTypesRule = {
+  name: "enum-types",
+  judges: "design",
+  description: "An enum is a closed, ordered set of named values with optional pure methods, nothing else: an enum without values, with two values equal by reference_resolution.nameKey (every language derives one identifier from both), or carrying fields, params, returns, invariants, componentClass, database, table or linkedEntity is reported; so are values on a type of any other kind, where they mean nothing.",
+  codes: [
+    { code: "ENUM_MEMBERS", defaultSeverity: "error", summary: "An enum has no values, two values equal by nameKey, or a member it cannot carry; or a type of another kind carries values" }
+  ],
+  check(ctx) {
+    for (const t of ctx.types) {
+      if (!ctx.isSpecInScope(t.id)) continue;
+      const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+      const isDraft = !!sub && (sub.status === "draft" || sub.status === "design");
+      if (t.kind === "enum") {
+        const values = t.values ?? [];
+        const problems = [];
+        if (values.length === 0) problems.push("lists no values");
+        const seen = /* @__PURE__ */ new Map();
+        for (const value of values) {
+          const key = nameKey(value.name);
+          const earlier = seen.get(key);
+          if (earlier !== void 0) problems.push(`lists "${earlier}" and "${value.name}", which every language derives one identifier from`);
+          else seen.set(key, value.name);
+        }
+        const members = [
+          ...t.fields.length > 0 ? ["fields"] : [],
+          ...t.params !== void 0 ? ["params"] : [],
+          ...t.returns !== void 0 ? ["returns"] : [],
+          ...(t.invariants?.length ?? 0) > 0 ? ["invariants"] : [],
+          ...t.componentClass !== void 0 ? ["componentClass"] : [],
+          ...t.database !== void 0 ? ["database"] : [],
+          ...t.table !== void 0 ? ["table"] : [],
+          ...t.linkedEntity !== void 0 ? ["linkedEntity"] : []
+        ];
+        if (members.length > 0) problems.push(`carries ${members.join(", ")}`);
+        if (problems.length === 0) continue;
+        ctx.addIssue(
+          "error",
+          "ENUM_MEMBERS",
+          `Enum type "${t.id}" ${problems.join("; ")}. An enum is a closed, ordered set of named values, unique by name ignoring case and separators, with optional pure methods and nothing else.`,
+          t.id,
+          isDraft
+        );
+        continue;
+      }
+      if (t.values === void 0) continue;
+      ctx.addIssue(
+        "error",
+        "ENUM_MEMBERS",
+        `Type "${t.id}" is ${t.kind === "entity" ? "an entity" : `a ${t.kind}`} and carries values, which only an enum has. Make it kind enum, or drop them.`,
+        t.id,
+        isDraft
+      );
+    }
+  }
+};
+
+// src/core/rules/integrity/named-scalar-types.ts
+var namedScalarTypesRule = {
+  name: "named-scalar-types",
+  judges: "design",
+  description: "A named scalar is a value-object that declares `holds: <primitive>` in place of fields \u2014 a newtype or type alias in every language. It models its value and nothing else beside its pure methods and invariants: holds beside fields, componentClass, database, table or linkedEntity is reported, and so is holds on an entity, an enum or a signature type, where it means nothing. Whether holds names one of the primitives is the type-expressions rule's question (TYPE_POSITION_INVALID on the holds position), never a second voice here. Mirrors enum-types and signature-types: judged at validate time, on the type's own fields.",
+  codes: [
+    { code: "NAMED_SCALAR_MEMBERS", defaultSeverity: "error", summary: "A named scalar (a value-object holding a primitive) carries fields or a member it cannot carry; or a type of another kind declares holds" }
+  ],
+  check(ctx) {
+    for (const t of ctx.types) {
+      if (!ctx.isSpecInScope(t.id)) continue;
+      if (t.holds === void 0) continue;
+      const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+      const isDraft = !!sub && (sub.status === "draft" || sub.status === "design");
+      if (t.kind !== "value-object") {
+        ctx.addIssue(
+          "error",
+          "NAMED_SCALAR_MEMBERS",
+          `Type "${t.id}" is ${t.kind === "entity" ? "an entity" : `a ${t.kind}`} and declares holds, which only a value-object has: a named scalar is a value-object holding one primitive. Make it a value-object, or drop holds.`,
+          t.id,
+          isDraft
+        );
+        continue;
+      }
+      const members = [
+        ...t.fields.length > 0 ? ["fields"] : [],
+        ...t.componentClass !== void 0 ? ["componentClass"] : [],
+        ...t.database !== void 0 ? ["database"] : [],
+        ...t.table !== void 0 ? ["table"] : [],
+        ...t.linkedEntity !== void 0 ? ["linkedEntity"] : []
+      ];
+      if (members.length === 0) continue;
+      ctx.addIssue(
+        "error",
+        "NAMED_SCALAR_MEMBERS",
+        `Named scalar "${t.id}" holds ${t.holds} and carries ${members.join(", ")}. A named scalar is one primitive under a name, with optional pure methods and invariants and nothing else: drop ${members.length === 1 ? "it" : "them"}, or drop holds and model the value-object's fields.`,
+        t.id,
+        isDraft
+      );
+    }
+  }
+};
+
 // src/core/rules/integrity/public-surface-binding.ts
 var publicSurfaceBindingRule = {
   name: "public-surface-binding",
@@ -17334,10 +18428,10 @@ var projectBoundariesRule = {
 var lintAllowsRule = {
   name: "lint-allows",
   judges: "design",
-  description: "Per-spec lint suppressions (lint.allow) must name real issue codes and actually suppress a finding \u2014 unknown codes and stale allows are flagged. An allow covers exactly the occurrence it names: a finding that reports a site is silenced only by an allow whose `at` is that site, a finding that reports none only by an allow that names none, and an aggregating finding only by an allow whose `covers` lists every unit it reports \u2014 a unit nobody listed is named back as new instead of inheriting a decision taken about its neighbours. So a coarse allow left on a rule that names sites, and an allow whose site the run no longer reports, are both UNUSED_LINT_ALLOW, and the finding names the sites that did fire. Allows silence warnings and notices; errors always surface.",
+  description: "Per-spec lint suppressions (lint.allow) must name real issue codes and actually suppress a finding \u2014 unknown codes and stale allows are flagged. An allow covers exactly the occurrence it names: a finding that reports a site is silenced only by an allow whose `at` is that site, a finding that reports none only by an allow that names none, and an aggregating finding only by an allow whose `covers` lists every unit it reports \u2014 a unit nobody listed is named back as new instead of inheriting a decision taken about its neighbours. So a coarse allow left on a rule that names sites, and an allow whose site the run no longer reports, are both UNUSED_LINT_ALLOW, and the finding names the sites that did fire. Allows silence warnings and notices; errors always surface \u2014 so an allow naming a code that is an error on its spec (it fired there as one, or its resolved severity is error) covers nothing, and the finding says plainly that an error cannot be allowed rather than that the code never fired.",
   codes: [
     { code: "UNKNOWN_LINT_ALLOW_CODE", defaultSeverity: "warning", summary: "lint.allow names an issue code no registered rule emits" },
-    { code: "UNUSED_LINT_ALLOW", defaultSeverity: "warning", summary: "lint.allow entry matched no finding this run \u2014 the code never fired, or it fired at sites this allow does not name" }
+    { code: "UNUSED_LINT_ALLOW", defaultSeverity: "warning", summary: "lint.allow entry covers nothing this run \u2014 the code never fired, it fired at sites this allow does not name, or it is an error, which no allow can cover" }
   ],
   check(ctx) {
     for (const a of ctx.lintAllows) {
@@ -17350,9 +18444,20 @@ var lintAllowsRule = {
         );
         continue;
       }
-      if (a.used) continue;
       const reported = ctx.sitesReported(a.specId, a.code);
       const at = a.at ? ` at "${a.at}"` : "";
+      const fired = reported.unsited || reported.sites.length > 0;
+      const isError = reported.errored || !fired && ctx.severityOf(a.code, a.specId) === "error";
+      if (isError) {
+        ctx.addIssue(
+          "warning",
+          "UNUSED_LINT_ALLOW",
+          `Spec "${a.specId}" allows "${a.code}"${at} (reason: ${a.reason}), but "${a.code}" is an error${fired ? " and fired here as one" : ""}, and an error cannot be allowed \u2014 lint.allow silences warnings and notices only. Fix what the finding names, or remove the allow (a project may re-tune the code's severity in rules.sddRuleSeverity).`,
+          a.specId
+        );
+        continue;
+      }
+      if (a.used) continue;
       let why;
       if (a.at && reported.unsited && reported.sites.length === 0) {
         why = `findings of "${a.code}" on this spec name no site at all, so this allow must not name one \u2014 drop the \`at\``;
@@ -18250,11 +19355,11 @@ var detailSufficiencyRule = {
       const contract = ctx.interfaceMap.get(impl.contract);
       if (!contract) continue;
       const component = ctx.componentMap.get(contract.component);
-      const draftContext3 = ctx.isImplementationDraft(impl);
+      const draftContext4 = ctx.isImplementationDraft(impl);
       for (const method of impl.methods) {
         const detail = effectiveDetail(method, impl, component);
         if (contract.methods.some((m) => m.name === method.name) && method.narrative.length === 0 && detail.level !== "full") {
-          dialedDown.push({ implementation: impl, method, component, detail, draftContext: draftContext3 });
+          dialedDown.push({ implementation: impl, method, component, detail, draftContext: draftContext4 });
         }
       }
     }
@@ -18875,18 +19980,47 @@ var dataBlockDepsRule = {
 };
 
 // src/core/rules/doctrine/entrypoint-dependencies.ts
+function maintainedRegistries(ctx) {
+  const maintained = /* @__PURE__ */ new Map();
+  const add2 = (supervisorId, registryId) => {
+    let set = maintained.get(supervisorId);
+    if (!set) maintained.set(supervisorId, set = /* @__PURE__ */ new Set());
+    set.add(registryId);
+  };
+  for (const comp of ctx.components) {
+    if (comp.componentType !== "Supervisor" || isRetired(comp)) continue;
+    for (const memberId of comp.owns) {
+      if (ctx.componentMap.get(memberId)?.componentType === "Registry") add2(comp.id, memberId);
+    }
+  }
+  for (const impl of ctx.implementations) {
+    const contract = ctx.interfaceMap.get(impl.contract);
+    const supervisor = contract ? ctx.componentMap.get(contract.component) : void 0;
+    if (!supervisor || supervisor.componentType !== "Supervisor" || isRetired(supervisor)) continue;
+    for (const implMethod of impl.methods) {
+      for (const step of implMethod.narrative) {
+        if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+        if (ctx.componentMap.get(step.targetComponent)?.componentType !== "Registry") continue;
+        const called = ctx.interfaceMethodsOf(step.targetComponent).find((m) => m.name === step.targetMethod);
+        if (called?.effect === "lifecycle") add2(supervisor.id, step.targetComponent);
+      }
+    }
+  }
+  return new Map([...maintained].map(([id, set]) => [id, [...set]]));
+}
 var entrypointDepsRule = {
   name: "entrypoint-dependencies",
   judges: "design",
-  description: "Judges the edges at the system's entry points and its process layer. Portals and Observers are top-level entry points and subscribers, so nothing may depend on them \u2014 and that is the edge's one finding, which is why no other matrix rule judges it. Downward, a Portal dispatches to Orchestrators and may READ through Indexes and Repository facades but never reaches Store/Registry/Query or an Adapter, while an Observer forwards to one Orchestrator or Supervisor over a message-bus Adapter. A View stays a passive presenter. A Supervisor reaches data only through workflows, and a component depending on a live Actor must also depend on a Supervisor that supervises it.",
+  description: "Judges the edges at the system's entry points and its process layer. Portals and Observers are top-level entry points and subscribers, so nothing may depend on them \u2014 and that is the edge's one finding, which is why no other matrix rule judges it. Downward, a Portal dispatches to Orchestrators and may READ through Indexes and Repository facades but never reaches Store/Registry/Query or an Adapter, while an Observer forwards to one Orchestrator or Supervisor over a message-bus Adapter. A View stays a passive presenter. A Supervisor stays out of presentation; what it may do to the data it reaches is judged per call (supervisor-shared-data), and what it owns as its supervision state by the ownership rules. A component depending on a live Actor reaches it through the Actor's supervision: by depending on a Supervisor that supervises it, or on a Registry such a Supervisor maintains (owns, or calls with lifecycle-effect methods) \u2014 the lookup hop callers really take.",
   codes: [
     { code: "ARCHITECTURE_VIOLATION_PORTAL_DEP", defaultSeverity: "error", summary: "Component depending on a Portal/Observer" },
     { code: "ARCHITECTURE_VIOLATION_PORTAL_FORBIDDEN_DEP", defaultSeverity: "error", summary: "Portal/Observer reaching the data layer directly" },
     { code: "ARCHITECTURE_VIOLATION_VIEW_DEP", defaultSeverity: "error", summary: "View depending on persistence layers or on logic that is not pure" },
-    { code: "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP", defaultSeverity: "error", summary: "Supervisor depending on anything but Actors, Orchestrators, Adapters or other Supervisors \u2014 it reaches data only through workflows" },
-    { code: "ACTOR_REACHED_WITHOUT_SUPERVISOR", defaultSeverity: "error", summary: "Component depending on a live Actor it does not supervise, without also depending on a Supervisor that supervises it \u2014 a live Actor is reached by id through its Supervisor" }
+    { code: "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP", defaultSeverity: "error", summary: "Supervisor depending on a presentation block (View, FeatureComponent, RouterComponent) \u2014 a Supervisor manages live processes; the data it reaches is judged per call by supervisor-shared-data" },
+    { code: "ACTOR_REACHED_WITHOUT_SUPERVISOR", defaultSeverity: "error", summary: "Component depending on a live Actor it does not supervise, reaching it neither through a Supervisor that supervises it nor through a Registry such a Supervisor maintains \u2014 model the real lookup hop" }
   ],
   check(ctx) {
+    const lookups = maintainedRegistries(ctx);
     for (const edge of ctx.dependencyEdges().matrix) {
       const comp = edge.from;
       const depComp = edge.to;
@@ -18922,27 +20056,32 @@ var entrypointDepsRule = {
           edge.draftContext
         );
       }
-      if (comp.componentType === "Supervisor" && ["Store", "Registry", "Repository", "Index", "Query", "View", "FeatureComponent", "RouterComponent"].includes(depComp.componentType)) {
+      if (comp.componentType === "Supervisor" && ["View", "FeatureComponent", "RouterComponent"].includes(depComp.componentType)) {
         ctx.addIssue(
           "error",
           "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP",
-          `Architectural violation: Supervisor "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Supervisor reaches data only through workflows \u2014 depend on the Orchestrator, Actor or Adapter that does that work instead.` + storeHint,
+          `Architectural violation: Supervisor "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Supervisor manages live processes and stays out of presentation \u2014 the UI reaches the system through its Portals and workflows, never through a Supervisor's dependencies.`,
           comp.id,
           edge.draftContext
         );
       }
       if (depComp.componentType === "Actor" && comp.componentType !== "Supervisor") {
-        const reachedThroughSupervisor = comp.dependsOn.some((id) => {
-          const supervisor = ctx.componentMap.get(id);
-          return supervisor?.componentType === "Supervisor" && supervisor.dependsOn.includes(depComp.id);
-        });
-        if (!reachedThroughSupervisor) {
-          const supervisors = ctx.components.filter((c) => c.componentType === "Supervisor" && c.dependsOn.includes(depComp.id)).map((c) => `"${c.id}"`);
-          const remedy = supervisors.length > 0 ? `also depend on ${supervisors.length === 1 ? "its Supervisor" : "one of its Supervisors"} (${supervisors.join(", ")})` : `no Supervisor depends on "${depComp.id}" yet, so give the Actor a Supervisor that depends on it and depend on that Supervisor`;
+        const supervisors = ctx.components.filter((c) => c.componentType === "Supervisor" && c.dependsOn.includes(depComp.id));
+        const registries = supervisors.flatMap((s) => (lookups.get(s.id) ?? []).map((registry) => ({ registry, supervisor: s.id })));
+        const reached = supervisors.some((s) => comp.dependsOn.includes(s.id)) || registries.some((r) => comp.dependsOn.includes(r.registry));
+        if (!reached) {
+          let remedy;
+          if (registries.length > 0) {
+            remedy = `depend on ${registries.length === 1 ? "the Registry" : "one of the Registries"} its Supervisor maintains (${registries.map((r) => `"${r.registry}", kept by "${r.supervisor}"`).join("; ")}) and look the Actor up by id there`;
+          } else if (supervisors.length > 0) {
+            remedy = `${supervisors.length === 1 ? "its Supervisor" : "its Supervisors"} (${supervisors.map((s) => `"${s.id}"`).join(", ")}) maintain no Registry of its live handles yet: model that lookup as a Registry the Supervisor keeps through lifecycle-effect methods (registering and unregistering a live handle), and depend on that Registry`;
+          } else {
+            remedy = `no Supervisor depends on "${depComp.id}" yet: give it a Supervisor that depends on it and maintains a Registry of its live handles through lifecycle-effect methods, and depend on that Registry`;
+          }
           ctx.addIssue(
             "error",
             "ACTOR_REACHED_WITHOUT_SUPERVISOR",
-            `Architectural violation: ${stereotypeOf(comp)} "${comp.id}" depends on the live Actor "${depComp.id}" without a Supervisor that supervises it. A live Actor is reached by id through a Supervisor that supervises it \u2014 ${remedy}.`,
+            `Architectural violation: ${stereotypeOf(comp)} "${comp.id}" depends on the live Actor "${depComp.id}" without reaching it through its supervision. A live Actor is found by id through a Registry its Supervisor maintains, or messaged through that Supervisor \u2014 ${remedy}.`,
             comp.id,
             edge.draftContext
           );
@@ -18956,9 +20095,9 @@ var entrypointDepsRule = {
 var portalWriteShortcutRule = {
   name: "portal-write-shortcut",
   judges: "design",
-  description: "A Portal narrative call step or dispatch-table binding that reaches a write-effect method on a Repository or Index directly is the write shortcut: the Portal\u2192data-facade edge is licensed for reads only, and a write routes through an Orchestrator that owns the workflow. A dispatch step reaches its server only through a table binding, so judging every binding judges each dispatch step that takes it, once, where the route is declared. Methods that carry no effect tag are not judged.",
+  description: "A Portal narrative call step or dispatch-table binding that reaches a write- or lifecycle-effect method on a Repository or Index directly is the write shortcut: the Portal\u2192data-facade edge is licensed for reads only, and a mutation \u2014 a write, or a lifecycle change to what exists \u2014 routes through an Orchestrator that owns the workflow. A dispatch step reaches its server only through a table binding, so judging every binding judges each dispatch step that takes it, once, where the route is declared. Methods that carry no effect tag are not judged.",
   codes: [
-    { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
+    { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write- or lifecycle-effect method on a Repository/Index directly \u2014 reads may shortcut, mutations route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
   ],
   check(ctx) {
     for (const impl of ctx.implementations) {
@@ -18972,11 +20111,11 @@ var portalWriteShortcutRule = {
           const target = ctx.componentMap.get(step.targetComponent);
           if (!target || target.componentType !== "Repository" && target.componentType !== "Index") continue;
           const targetMethod = ctx.interfaceMethodsOf(target.id).find((m) => m.name === step.targetMethod);
-          if (targetMethod?.effect !== "write") continue;
+          if (targetMethod?.effect !== "write" && targetMethod?.effect !== "lifecycle") continue;
           ctx.addIssue(
             "error",
             "PORTAL_WRITE_SHORTCUT",
-            `Portal "${component.id}": step ${step.stepNumber} of "${implMethod.name}" calls write-effect method ${target.id}.${step.targetMethod} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the write through an Orchestrator that owns the workflow.`,
+            `Portal "${component.id}": step ${step.stepNumber} of "${implMethod.name}" calls ${targetMethod.effect}-effect method ${target.id}.${step.targetMethod} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the ${targetMethod.effect === "write" ? "write" : "lifecycle change"} through an Orchestrator that owns the workflow.`,
             impl.id,
             isDraftCtx || ctx.isComponentDraft(target.id)
           );
@@ -18990,11 +20129,11 @@ var portalWriteShortcutRule = {
         const target = ctx.componentMap.get(binding.component);
         if (!target || target.componentType !== "Repository" && target.componentType !== "Index") continue;
         const targetMethod = ctx.interfaceMethodsOf(target.id).find((m) => m.name === binding.method);
-        if (targetMethod?.effect !== "write") continue;
+        if (targetMethod?.effect !== "write" && targetMethod?.effect !== "lifecycle") continue;
         ctx.addIssue(
           "error",
           "PORTAL_WRITE_SHORTCUT",
-          `Portal "${comp.id}": dispatch binding "${binding.capability}" routes to write-effect method ${target.id}.${binding.method} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the write through an Orchestrator that owns the workflow.`,
+          `Portal "${comp.id}": dispatch binding "${binding.capability}" routes to ${targetMethod.effect}-effect method ${target.id}.${binding.method} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the ${targetMethod.effect === "write" ? "write" : "lifecycle change"} through an Orchestrator that owns the workflow.`,
           comp.id,
           isDraftCtx || ctx.isComponentDraft(target.id)
         );
@@ -19003,28 +20142,101 @@ var portalWriteShortcutRule = {
   }
 };
 
+// src/core/rules/doctrine/supervisor-shared-data.ts
+var DATA_COMPONENTS = /* @__PURE__ */ new Set(["Store", "Registry", "Repository", "Index", "Query"]);
+var supervisorSharedDataRule = {
+  name: "supervisor-shared-data",
+  judges: "design",
+  description: "A Supervisor keeps its own supervision state (the Stores and Registries it owns) with full read and write, but data it does not own is shared: a Supervisor narrative call step that reaches a method of a Store, Registry, Repository, Index or Query the Supervisor does not own is legal only when that method declares effect read or lifecycle. A write \u2014 or a method that declares no effect \u2014 goes through a workflow: the Supervisor depends on the Orchestrator that does it. A read on behalf of a request still passes; in practice the paired write is what forces the workflow out, and the read moves with it.",
+  codes: [
+    { code: "SUPERVISOR_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Supervisor narrative call reaches a method of a data component it does not own whose declared effect is neither read nor lifecycle \u2014 writes to shared data route through an Orchestrator" }
+  ],
+  check(ctx) {
+    const ownership = ctx.ownershipIndex();
+    for (const impl of ctx.implementations) {
+      const contract = ctx.interfaceMap.get(impl.contract);
+      const supervisor = contract ? ctx.componentMap.get(contract.component) : void 0;
+      if (!supervisor || supervisor.componentType !== "Supervisor" || isRetired(supervisor)) continue;
+      const isDraftCtx = ctx.isImplementationDraft(impl);
+      for (const implMethod of impl.methods) {
+        for (const step of implMethod.narrative) {
+          if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+          const target = ctx.componentMap.get(step.targetComponent);
+          if (!target || !DATA_COMPONENTS.has(target.componentType)) continue;
+          if (ownership.ownerOf(target.id) === supervisor.id) continue;
+          const called = ctx.interfaceMethodsOf(target.id).find((m) => m.name === step.targetMethod);
+          if (!called || called.effect === "read" || called.effect === "lifecycle") continue;
+          const what = called.effect === "write" ? "a write-effect method" : "a method that declares no effect";
+          const untaggedHint = called.effect === "write" ? "" : ` If ${target.id}.${called.name} only reads, or only changes what exists, declare its effect (read or lifecycle).`;
+          ctx.addIssue(
+            "error",
+            "SUPERVISOR_WRITE_SHORTCUT",
+            `Supervisor "${supervisor.id}": step ${step.stepNumber} of "${implMethod.name}" calls ${target.id}.${called.name}, ${what} on ${target.componentType} "${target.id}", which the Supervisor does not own. A Supervisor reads shared data and changes what exists in it (read and lifecycle effects); a write to its fields goes through a workflow \u2014 depend on the Orchestrator that does it and call that instead.${untaggedHint}`,
+            impl.id,
+            isDraftCtx || ctx.isComponentDraft(target.id)
+          );
+        }
+      }
+    }
+  }
+};
+
+// src/core/rules/doctrine/lifecycle-effect-closure.ts
+var lifecycleEffectClosureRule = {
+  name: "lifecycle-effect-closure",
+  judges: "design",
+  description: "A lifecycle-effect method may create, destroy, or (un)register an entity's existence or membership, never modify its domain fields \u2014 and the effect is closed under composition: its narrative may call only read- and lifecycle-effect methods besides its construction and local steps. A call step to a write-effect method from a lifecycle-effect method is a declaration error: the method is a write, or the write belongs to a workflow beside it. Called methods that declare no effect are not judged.",
+  codes: [
+    { code: "LIFECYCLE_CALLS_WRITE", defaultSeverity: "error", summary: "Lifecycle-effect method whose narrative calls a write-effect method \u2014 the lifecycle effect is closed under composition" }
+  ],
+  check(ctx) {
+    for (const impl of ctx.implementations) {
+      const contract = ctx.interfaceMap.get(impl.contract);
+      if (!contract) continue;
+      const declared = ctx.interfaceMethodsOf(contract.component);
+      const isDraftCtx = ctx.isImplementationDraft(impl);
+      for (const implMethod of impl.methods) {
+        if (declared.find((m) => m.name === implMethod.name)?.effect !== "lifecycle") continue;
+        for (const step of implMethod.narrative) {
+          if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+          const called = ctx.interfaceMethodsOf(step.targetComponent).find((m) => m.name === step.targetMethod);
+          if (called?.effect !== "write") continue;
+          ctx.addIssue(
+            "error",
+            "LIFECYCLE_CALLS_WRITE",
+            `"${contract.component}.${implMethod.name}" declares effect lifecycle, but step ${step.stepNumber} calls write-effect method ${step.targetComponent}.${step.targetMethod}. A lifecycle method creates, destroys or (un)registers what exists and never modifies domain fields, and the effect is closed under composition \u2014 it may call only read and lifecycle methods. Declare the method a write, or move the write to a workflow beside it.`,
+            impl.id,
+            isDraftCtx
+          );
+        }
+      }
+    }
+  }
+};
+
 // src/core/rules/doctrine/pattern-membership.ts
 var patternMembershipRule = {
   name: "pattern-membership",
   judges: "design",
-  description: "Only patterns (Repository/FeatureComponent/RouterComponent) own member blocks, and every pattern owns at least one. Each claim must name a component that exists and is itself a building block \u2014 patterns compose at the subsystem (L1) level, never by owning one another \u2014 and a block has exactly one owner, the first pattern to claim it.",
+  description: "Only patterns (Repository/FeatureComponent/RouterComponent) own member blocks, and every pattern owns at least one. The one building block that may own is a Supervisor, which owns its supervision state and may own nothing at all; what it may own is pattern-containment's question. Each claim must name a component that exists and is itself a building block \u2014 patterns compose at the subsystem (L1) level, never by owning one another \u2014 and a block has exactly one owner, the first pattern or Supervisor to claim it.",
   codes: [
     { code: "EMPTY_PATTERN", defaultSeverity: "error", summary: "Pattern with no owned member blocks" },
-    { code: "BLOCK_OWNS_MEMBERS", defaultSeverity: "error", summary: "Building block using owns" },
+    { code: "BLOCK_OWNS_MEMBERS", defaultSeverity: "error", summary: "Building block other than a Supervisor using owns" },
     { code: "INVALID_OWNED_MEMBER", defaultSeverity: "error", summary: "owns names a non-existent component" },
     { code: "PATTERN_OWNS_PATTERN", defaultSeverity: "error", summary: "Pattern owning another pattern" },
-    { code: "SHARED_OWNED_MEMBER", defaultSeverity: "error", summary: "Block owned by two patterns" }
+    { code: "SHARED_OWNED_MEMBER", defaultSeverity: "error", summary: "Block owned by two owners (patterns or Supervisors)" }
   ],
   check(ctx) {
     for (const comp of ctx.components) {
       if (isRetired(comp)) continue;
       const isDraftCtx = ctx.isComponentDraft(comp.id);
       const pattern = isPattern(comp);
+      const supervisor = comp.componentType === "Supervisor";
       if (pattern && comp.owns.length === 0) {
         ctx.addIssue("error", "EMPTY_PATTERN", `Pattern "${comp.id}" (${comp.componentType}) must own member blocks via "owns".`, comp.id, isDraftCtx);
       }
-      if (!pattern && comp.owns.length > 0) {
-        ctx.addIssue("error", "BLOCK_OWNS_MEMBERS", `Building block "${comp.id}" (${comp.componentType}) cannot own members; only patterns (${Array.from(PATTERN_TYPES).join("/")}) use "owns".`, comp.id, isDraftCtx);
+      if (!pattern && !supervisor && comp.owns.length > 0) {
+        ctx.addIssue("error", "BLOCK_OWNS_MEMBERS", `Building block "${comp.id}" (${comp.componentType}) cannot own members; only patterns (${Array.from(PATTERN_TYPES).join("/")}) use "owns", and a Supervisor for its supervision state.`, comp.id, isDraftCtx);
       }
     }
     const ownership = ctx.ownershipIndex();
@@ -19032,15 +20244,18 @@ var patternMembershipRule = {
       if (isRetired(comp)) continue;
       const isDraftCtx = ctx.isComponentDraft(comp.id);
       const pattern = isPattern(comp);
+      const supervisor = comp.componentType === "Supervisor";
       for (const memberId of comp.owns) {
         const member = ctx.componentMap.get(memberId);
         if (!member) {
           ctx.addIssue("error", "INVALID_OWNED_MEMBER", `Component "${comp.id}" owns "${memberId}" which does not exist.`, comp.id, isDraftCtx);
           continue;
         }
-        if (!pattern) continue;
+        if (!pattern && !supervisor) continue;
         if (isPattern(member)) {
-          ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
+          if (pattern) {
+            ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
+          }
           continue;
         }
         const firstOwner = ownership.ownerOf(memberId);
@@ -19054,13 +20269,15 @@ var patternMembershipRule = {
 
 // src/core/rules/doctrine/pattern-containment.ts
 var REPOSITORY_MEMBERS = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Query", "Adapter"]);
+var SUPERVISION_STATE = /* @__PURE__ */ new Set(["Store", "Registry"]);
 var patternContainmentRule = {
   name: "pattern-containment",
   judges: "design",
-  description: "Holds each pattern to the containment its definition prescribes. A Repository may own only Store, Registry, Index, Query and (optionally) Adapter, judged member by member. A FeatureComponent owns exactly one Orchestrator (the logic side) and one or more Views (its faces \u2014 list, detail, form \u2014 sharing the one logic component), and nothing else. A RouterComponent owns exactly one Portal as its facade and at least one other child to route to. A counting pattern that still owns a retired member is not judged until that member is migrated: its counts change with the migration, and STEREOTYPE_RETIRED is the one finding.",
+  description: "Holds each owner to the containment its definition prescribes. A Repository may own only Store, Registry, Index, Query and (optionally) Adapter, judged member by member. A Supervisor may own only its supervision state \u2014 Stores and Registries that are its own, one hop \u2014 judged member by member too. A FeatureComponent owns exactly one Orchestrator (the logic side) and one or more Views (its faces \u2014 list, detail, form \u2014 sharing the one logic component), and nothing else. A RouterComponent owns exactly one Portal as its facade and at least one other child to route to. A counting pattern that still owns a retired member is not judged until that member is migrated: its counts change with the migration, and STEREOTYPE_RETIRED is the one finding.",
   codes: [
     { code: "REPOSITORY_CONTAINMENT", defaultSeverity: "error", summary: "Repository owning a non Store/Registry/Index/Query/Adapter member" },
     { code: "FEATURE_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "FeatureComponent not owning exactly one Orchestrator + one or more Views" },
+    { code: "SUPERVISOR_CONTAINMENT", defaultSeverity: "error", summary: "Supervisor owning anything but a Store or Registry \u2014 a Supervisor owns only its supervision state" },
     { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent not owning exactly one Portal facade, or owning no children to route to" }
   ],
   check(ctx) {
@@ -19111,6 +20328,15 @@ var patternContainmentRule = {
         }
       }
     }
+    for (const comp of ctx.components) {
+      if (comp.componentType !== "Supervisor" || isRetired(comp)) continue;
+      const isDraftCtx = ctx.isComponentDraft(comp.id);
+      for (const memberId of comp.owns) {
+        const member = ctx.componentMap.get(memberId);
+        if (!member || isRetired(member) || SUPERVISION_STATE.has(member.componentType)) continue;
+        ctx.addIssue("error", "SUPERVISOR_CONTAINMENT", `Supervisor "${comp.id}" owns "${memberId}" of type ${member.componentType}; a Supervisor owns only its supervision state \u2014 Stores and Registries that are its own. Depend on "${memberId}" as a collaborator instead.`, comp.id, isDraftCtx);
+      }
+    }
   }
 };
 
@@ -19118,7 +20344,7 @@ var patternContainmentRule = {
 var unownedBlocksRule = {
   name: "unowned-blocks",
   judges: "design",
-  description: `Judges the data blocks no pattern owns. A Store may stand alone deliberately \u2014 the sanctioned lightweight form for genuinely simple state, acknowledged with a lint.allow \u2014 while the recommended shape stays a Repository; what must never happen is folding the state into a consuming component, where no spec, diagram or conformance check can see it again. A Registry standing alone with no Store to write to is either mistyped (the "file-backed Registry" idiom, a fused persistent store that belongs typed Store) or orphaned. A Query has no standalone form at all: it computes reads over its own Repository's Store.`,
+  description: `Judges the data blocks no owner (a pattern, or a Supervisor keeping its supervision state) owns. A Store may stand alone deliberately \u2014 the sanctioned lightweight form for genuinely simple state, acknowledged with a lint.allow \u2014 while the recommended shape stays a Repository; what must never happen is folding the state into a consuming component, where no spec, diagram or conformance check can see it again. A Registry standing alone with no Store to write to is either mistyped (the "file-backed Registry" idiom, a fused persistent store that belongs typed Store) or orphaned. A Query has no standalone form at all: it computes reads over its own Repository's Store.`,
   codes: [
     { code: "UNOWNED_STORE", defaultSeverity: "warning", summary: "Store not owned by any pattern \u2014 recommended shape is a Repository; a deliberate standalone Store needs a lint.allow" },
     { code: "REGISTRY_WITHOUT_STORE", defaultSeverity: "warning", summary: "Standalone Registry with no Store to write to \u2014 either mistyped (a fused file-backed store belongs typed Store) or orphaned" },
@@ -19164,9 +20390,10 @@ var unownedBlocksRule = {
 var memberVisibilityRule = {
   name: "member-visibility",
   judges: "design",
-  description: "A component may depend on a block within its own group (it is the owning pattern, or a sibling member of the same pattern), on any pattern facade, or on a standalone block \u2014 never on a block privately owned by ANOTHER pattern, which must be reached through that pattern's facade. A retired depending component is skipped, as everywhere in this family.",
+  description: "A component may depend on a block within its own group (it is the owner, or a sibling member of the same owner), on any pattern facade, or on a standalone block \u2014 never on a block privately owned by ANOTHER pattern, which must be reached through that pattern's facade. A Store or Registry a Supervisor owns is that Supervisor's supervision state and nobody else depends on it: a component that does is the intruder, and the finding is reported on it, naming the Supervisor and the state. A retired depending component is skipped, as everywhere in this family.",
   codes: [
-    { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" }
+    { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" },
+    { code: "SUPERVISION_STATE_INTRUSION", defaultSeverity: "error", summary: "Dependency on a Store or Registry a Supervisor owns as its supervision state \u2014 reported on the intruder, naming the Supervisor and the state" }
   ],
   check(ctx) {
     const ownership = ctx.ownershipIndex();
@@ -19177,7 +20404,12 @@ var memberVisibilityRule = {
         if (!owner) continue;
         if (owner === comp.id) continue;
         if (ownership.ownerOf(comp.id) === owner) continue;
-        ctx.addIssue("error", "VISIBILITY_VIOLATION", `Component "${comp.id}" depends on "${depId}", which is privately owned by pattern "${owner}". Depend on the facade "${owner}" instead.`, comp.id, ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(depId));
+        const isDraftCtx = ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(depId);
+        if (ctx.componentMap.get(owner)?.componentType === "Supervisor") {
+          ctx.addIssue("error", "SUPERVISION_STATE_INTRUSION", `"${comp.id}" depends on "${depId}", which Supervisor "${owner}" owns as its supervision state. Supervision state is private to its Supervisor \u2014 nobody else depends on it. If "${comp.id}" needs this data it is shared data: move "${depId}" out of "${owner}"'s owns into a data component both depend on (the Supervisor keeping it through read and lifecycle calls), or reach what "${comp.id}" needs through "${owner}".`, comp.id, isDraftCtx);
+          continue;
+        }
+        ctx.addIssue("error", "VISIBILITY_VIOLATION", `Component "${comp.id}" depends on "${depId}", which is privately owned by pattern "${owner}". Depend on the facade "${owner}" instead.`, comp.id, isDraftCtx);
       }
     }
   }
@@ -19679,6 +20911,25 @@ var packRequirementsRule = {
   }
 };
 
+// src/core/rules/extension/pack-deprecations.ts
+var packDeprecationsRule = {
+  name: "pack-deprecations",
+  judges: "design",
+  description: "A loaded pack still declaring a field wairon has deprecated (ctx.ext.deprecations \u2014 today a language's foreignBuiltins, whose foreign-builtin check is retired because contracts are written in the neutral type grammar) is told so: the field is accepted and ignored for one release and removed in the release after. A notice: it never fails the gate.",
+  codes: [
+    { code: "PACK_FIELD_DEPRECATED", defaultSeverity: "notice", summary: "A loaded pack declares a deprecated field, accepted and ignored for one release" }
+  ],
+  check(ctx) {
+    for (const deprecation of ctx.ext.deprecations) {
+      ctx.addIssue(
+        "notice",
+        "PACK_FIELD_DEPRECATED",
+        `Deprecated pack field \u2014 ${deprecation}. It is accepted and ignored in this release and removed in the next; take it out of the pack.`
+      );
+    }
+  }
+};
+
 // src/core/rules/wiring/dependency-cycles.ts
 var cyclesRule = {
   name: "dependency-cycles",
@@ -20291,9 +21542,9 @@ var durabilityRule = {
   // Stage 8: its verdict needs the whole system's specs, so a part judged alone skips it.
   needsWholeTree: true,
   judges: "design",
-  description: "A durable Store (persisted RAM projection) must carry effect-tagged contract methods, and its writes require a hydration read-back reachable from a lifecycle init entrypoint. read-through is exempt (every read IS the read-back), as are ram-projection (rebuilt not restored) and cache (evictable, loss-safe). The flagship semantic check is opt-out by declaration, never silently absent \u2014 the declaration itself is enforced by durability-declaration.",
+  description: "A durable Store (persisted RAM projection) must carry effect-tagged contract methods, and its mutations \u2014 write-effect methods, and lifecycle-effect methods, which change what exists \u2014 require a hydration read-back reachable from a lifecycle init entrypoint. read-through is exempt (every read IS the read-back), as are ram-projection (rebuilt not restored) and cache (evictable, loss-safe). The flagship semantic check is opt-out by declaration, never silently absent \u2014 the declaration itself is enforced by durability-declaration.",
   codes: [
-    { code: "MISSING_EFFECT_TAG", defaultSeverity: "warning", summary: "Durable Store contract method lacks an effect: read | write tag" },
+    { code: "MISSING_EFFECT_TAG", defaultSeverity: "warning", summary: "Durable Store contract method lacks an effect: read | write | lifecycle tag" },
     { code: "MISSING_HYDRATION", defaultSeverity: "error", summary: "Durable Store is written but no read-back is reachable from any lifecycle init entrypoint" }
   ],
   check(ctx) {
@@ -20321,7 +21572,7 @@ var durabilityRule = {
           isDraftCtx
         );
       }
-      const writes = methods.filter((method) => method.effect === "write");
+      const writes = methods.filter((method) => method.effect === "write" || method.effect === "lifecycle");
       const reads = methods.filter((method) => method.effect === "read");
       if (writes.length === 0) continue;
       const hydrated = initReach !== null && reads.some((method) => initReach.reachesMethod(comp.id, method.name));
@@ -20340,14 +21591,22 @@ var durabilityRule = {
 };
 
 // src/core/rules/wiring/untyped-seams.ts
-var BARE_SEAM_TYPES = /* @__PURE__ */ new Set(["json", "any", "unknown", "object"]);
-function namesBareType(refs) {
-  return refs.some((ref) => BARE_SEAM_TYPES.has(ref.toLowerCase()));
+var UNTYPED_SPELLINGS = /* @__PURE__ */ new Set(["any", "json", "unknown", "object"]);
+function holdsAny(expr) {
+  return expr.form === "primitive" && expr.name === "any" || expr.args.some(holdsAny);
+}
+function tokensUntyped(text3) {
+  return extractTypeIdentifiers(text3).some((ref) => UNTYPED_SPELLINGS.has(ref.toLowerCase()));
+}
+function positionUntyped(text3, position) {
+  const parse = parseTypePosition(text3, position);
+  if (parse.expression && !parse.problem) return holdsAny(parse.expression);
+  return tokensUntyped(text3);
 }
 var untypedSeamRule = {
   name: "untyped-seams",
   judges: "design",
-  description: "Methods on a subsystem's published components (its public surface) should not take or return bare Json/any/unknown/object, judged through each method's type references so a prose signature is judged like structured params: cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
+  description: "Methods on a subsystem's published components (its public surface) should not take or return `any` \u2014 the one untyped type of the grammar, which object, unknown, json and Json are canonicalised to \u2014 judged through each method's named types and parsed expressions so a prose signature is judged like structured params (its tokens still read leniently): cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
   codes: [
     { code: "UNTYPED_SEAM", defaultSeverity: "warning", summary: "Bare Json/any/unknown/object parameter or return crossing a subsystem public surface" }
   ],
@@ -20365,14 +21624,14 @@ var untypedSeamRule = {
             const offenders = [];
             if (m.params && m.params.length > 0) {
               for (const p of m.params) {
-                if (namesBareType(extractTypeIdentifiers(p.type))) {
+                if (positionUntyped(p.type, "param")) {
                   offenders.push(`param "${p.name}: ${p.type}"`);
                 }
               }
-              if (namesBareType(extractTypeIdentifiers(m.returns ?? ""))) {
+              if (m.returns && positionUntyped(m.returns, "returns")) {
                 offenders.push(`return "${m.returns}"`);
               }
-            } else if (namesBareType(methodTypeRefs(m))) {
+            } else if (methodTypeRefs(m).some((ref) => UNTYPED_SPELLINGS.has(ref.toLowerCase()))) {
               offenders.push(`signature "${m.signature}"`);
             }
             if (offenders.length) {
@@ -21616,10 +22875,37 @@ function originOf(shape) {
 function absence(optional) {
   return optional ? "may be absent" : "is always there";
 }
+function judgeNamedScalar(ctx, type, file, facts) {
+  if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") return;
+  const dialect = dialectOf(facts);
+  const holds = parseTypePosition(type.holds, "holds").expression;
+  if (!dialect || !holds) return;
+  const symbol = type.symbol ?? type.name;
+  const own = (record) => !!record && Object.prototype.hasOwnProperty.call(record, symbol);
+  let declared;
+  if (own(facts.aliasTypes)) {
+    const annotation = facts.aliasTypes[symbol];
+    if (dialect.agrees(annotation, holds, /* @__PURE__ */ new Map())) return;
+    declared = `an alias of \`${annotation}\``;
+  } else if (own(facts.typeShapes)) {
+    declared = "a record (an object shape)";
+  } else {
+    return;
+  }
+  ctx.addIssue(
+    "warning",
+    "TYPE_HOLDS_MISMATCH",
+    `Named scalar "${type.id}" holds ${type.holds}, but "${file}" declares "${symbol}" as ${declared}. Every reader of a named scalar is told what one value of it is, and the code says otherwise. Make the declaration an alias of the primitive (in TypeScript, \`type ${symbol} = ${dialect.write(holds)}\`), or change what the type holds.`,
+    type.id,
+    void 0,
+    void 0,
+    { at: symbol }
+  );
+}
 var typeShapeRule = {
   name: "type-shape",
   judges: "code",
-  description: "Code-to-contract for the DATA: a type spec's `fields` are compared, name by name, against the shape its `sourcePath` actually declares. `typeRealization` asks whether a type EXISTS in code; nothing asked whether it is the shape the spec claims, so a type spec could describe two fields of a six-field record \u2014 and call the two that are optional required \u2014 straight through a lock and a CI gate, while the ERD, the agent briefs and every implementer read it as truth. That is the worst of the code-to-spec gaps, because a wrong signature eventually breaks at a call site and a type spec that lies is only ever read by humans and agents. Two origins answer at exact grade: a DECLARED shape, whose members the file lists, and a DERIVED one, an alias followed one hop to the object literal its schema is built from, where the keys are the members \u2014 and on through a composition the same file writes out (`Base.extend({\u2026})` on a schema constant it declares), the extension's keys laid over the base's. A shape that extends another is judged on what it shows and never on what it omits, since its inherited members are not in this file to count.",
+  description: "Code-to-contract for the DATA: a type spec's `fields` are compared, name by name, against the shape its `sourcePath` actually declares. `typeRealization` asks whether a type EXISTS in code; nothing asked whether it is the shape the spec claims, so a type spec could describe two fields of a six-field record \u2014 and call the two that are optional required \u2014 straight through a lock and a CI gate, while the ERD, the agent briefs and every implementer read it as truth. That is the worst of the code-to-spec gaps, because a wrong signature eventually breaks at a call site and a type spec that lies is only ever read by humans and agents. Two origins answer at exact grade: a DECLARED shape, whose members the file lists, and a DERIVED one, an alias followed one hop to the object literal its schema is built from, where the keys are the members \u2014 and on through a composition the same file writes out (`Base.extend({\u2026})` on a schema constant it declares), the extension's keys laid over the base's. A shape that extends another is judged on what it shows and never on what it omits, since its inherited members are not in this file to count. A NAMED SCALAR (a value-object declaring `holds`) has no field list: its shape is the primitive it holds, compared with the right side of the type alias the file declares under its name, read through the file's dialect (`type PackPath = string` agrees with holds string); an object shape under that name, or an alias the dialect does not read as that primitive, is TYPE_HOLDS_MISMATCH.",
   codes: [
     {
       code: "UNREALIZED_TYPE_FIELD",
@@ -21635,6 +22921,12 @@ var typeShapeRule = {
       summary: "The shape at a type's sourcePath carries a field the type spec does not declare \u2014 data the design never described, so no diagram draws it and no brief hands it to an implementer",
       carryable: true
     },
+    {
+      code: "TYPE_HOLDS_MISMATCH",
+      defaultSeverity: "warning",
+      summary: "A named scalar's holds disagrees with what its sourcePath declares under its name \u2014 an alias of another type, or a record \u2014 so every reader is told one value of it is something the code says it is not",
+      carryable: true
+    },
     {
       code: "TYPE_FIELD_OPTIONALITY",
       defaultSeverity: "warning",
@@ -21649,6 +22941,10 @@ var typeShapeRule = {
       if (type.subsystem && ctx.isInChainedSubproject(type.subsystem)) continue;
       const file = pathKey(type.sourcePath);
       const facts = code.factsAt(file);
+      if (type.holds !== void 0) {
+        judgeNamedScalar(ctx, type, file, facts);
+        continue;
+      }
       if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
       const symbol = type.symbol ?? type.name;
       const shapes = facts.typeShapes;
@@ -21703,6 +22999,67 @@ var typeShapeRule = {
   }
 };
 
+// src/core/rules/conformance/enum-values.ts
+var enumValuesRule = {
+  name: "enum-values",
+  judges: "code",
+  description: "Code-to-contract for an ENUM: an enum type's values are compared, name by name, with the values the declaration at its sourcePath holds \u2014 a string-literal union alias, the array a z.enum constant holds, or a string enum's member values (source_file_facts.enumValues). `typeRealization` already asks whether the declaration exists; nothing asked whether it holds the values the design lists, and an enum is read by every diagram, OpenAPI document and brief as the closed set it claims. Exact grade only; a declaration the analyzer reads no values from is typeRealization's question, never this rule's. Order is not judged: languages differ on whether declaration order is observable.",
+  codes: [
+    {
+      code: "UNREALIZED_ENUM_VALUE",
+      defaultSeverity: "warning",
+      summary: "An enum type lists a value the declaration at its sourcePath does not hold \u2014 the design promises a value the code would reject",
+      carryable: true
+    },
+    {
+      code: "UNDECLARED_ENUM_VALUE",
+      defaultSeverity: "warning",
+      summary: "The declaration at an enum type's sourcePath holds a value the enum does not list \u2014 a value the design never described",
+      carryable: true
+    }
+  ],
+  check(ctx) {
+    const code = ctx.codeIndex();
+    for (const type of ctx.types) {
+      if (type.kind !== "enum" || !type.sourcePath) continue;
+      if (type.subsystem && ctx.isInChainedSubproject(type.subsystem)) continue;
+      const file = pathKey(type.sourcePath);
+      const facts = code.factsAt(file);
+      const symbol = type.symbol ?? type.name;
+      if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+      const declared = facts.enumValues;
+      if (!declared || !Object.prototype.hasOwnProperty.call(declared, symbol)) continue;
+      const held = new Set(declared[symbol]);
+      const listed = (type.values ?? []).map((value) => value.name);
+      const listedSet = new Set(listed);
+      const unrealized = listed.filter((value) => !held.has(value));
+      if (unrealized.length > 0) {
+        ctx.addIssue(
+          "warning",
+          "UNREALIZED_ENUM_VALUE",
+          `Enum type "${type.id}" lists ${unrealized.length} value(s) the declaration "${symbol}" in "${file}" does not hold \u2014 ${unrealized.map((value) => `"${value}"`).join(", ")}. The design promises a value the code would reject, and every diagram, OpenAPI document and brief offers it. Add it to the declaration, or drop it from the enum (values compare exactly: a value is data).`,
+          type.id,
+          void 0,
+          void 0,
+          { at: symbol, covers: unrealized }
+        );
+      }
+      const undeclared = declared[symbol].filter((value) => !listedSet.has(value));
+      if (undeclared.length > 0) {
+        ctx.addIssue(
+          "warning",
+          "UNDECLARED_ENUM_VALUE",
+          `The declaration "${symbol}" in "${file}" holds ${undeclared.length} value(s) enum type "${type.id}" does not list \u2014 ${undeclared.map((value) => `"${value}"`).join(", ")}. A value the design never described is one no diagram shows and no brief hands an implementer. List it on the enum, or take it out of the code.`,
+          type.id,
+          void 0,
+          void 0,
+          { at: symbol, covers: undeclared }
+        );
+      }
+    }
+  }
+};
+
 // src/core/rules/conformance/param-conformance.ts
 function omittable(optional) {
   return optional ? "may be left out" : "is required";
@@ -21753,7 +23110,7 @@ function agreed(judgements, reading) {
 var paramConformanceRule = {
   name: "param-conformance",
   judges: "code",
-  description: "Code-to-contract for the SIGNATURE, the last of the three readings a spec-driven gate never made: a contract declares `params`, and nothing ever compared them to the parameters of the function that realizes the method. A contract could promise an argument the code does not take, take one the contract never mentions \u2014 including a secret \u2014 or name the same argument two different things, and the brief handed to an implementer would carry the contract's version. Parameters are matched by POSITION against the tail of the realization's list, and the declared type is what tells a rename from a dropped argument: `seed(config: HostConfig)` realized as `bootstrapInstance(cfg: HostConfig)` is one parameter under two names, which anything matching on names alone reads as a parameter the code lost. What a realization takes BEFORE the contract's own parameters is wiring, and it is declared on the implementation as `injectedParams` rather than inferred, because an inferred prefix cannot be told from a renamed first argument. A method the named file only CALLS is left to `methodRealization`, which already reports that the body is not here.",
+  description: "Code-to-contract for the SIGNATURE, the last of the three readings a spec-driven gate never made: a contract declares `params`, and nothing ever compared them to the parameters of the function that realizes the method. A contract could promise an argument the code does not take, take one the contract never mentions \u2014 including a secret \u2014 or name the same argument two different things, and the brief handed to an implementer would carry the contract's version. Parameters are matched by POSITION against the tail of the realization's list, and the declared type is what tells a rename from a dropped argument: `seed(config: HostConfig)` realized as `bootstrapInstance(cfg: HostConfig)` is one parameter under two names, which anything matching on names alone reads as a parameter the code lost. Types agree when the code's annotation, read through the dialect of the language the file was analyzed as (type_dialect.agrees), is the contract's canonical type \u2014 so `string[]` in the code agrees with `list<string>` in the contract, TypeScript's `number` with int and float alike, and an annotation the dialect cannot read agrees with nothing. What a realization takes BEFORE the contract's own parameters is wiring, and it is declared on the implementation as `injectedParams` rather than inferred, because an inferred prefix cannot be told from a renamed first argument. A method the named file only CALLS is left to `methodRealization`, which already reports that the body is not here.",
   codes: [
     {
       code: "UNREALIZED_PARAM",
@@ -21790,13 +23147,13 @@ var paramConformanceRule = {
       codeNameOf.set(type.id, named2);
       if (type.subsystem) codeNameOf.set(`${type.subsystem}.${type.id}`, named2);
     }
-    const normalize3 = (text3) => text3.replace(/\s+/g, " ").trim();
-    const typeAgrees = (declared, realized) => {
-      if (!realized.type) return false;
-      const stated = normalize3(declared.type);
-      return stated === realized.type || codeNameOf.get(stated) === realized.type;
+    const typeAgreesIn = (dialect) => (declared, realized) => {
+      if (!realized.type || !dialect) return false;
+      const stated = parseTypePosition(declared.type, "param", !!declared.optional);
+      if (!stated.expression) return false;
+      return dialect.agrees(realized.type, stated.expression, codeNameOf);
     };
-    for (const { implementation, method, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
+    for (const { implementation, method, sourceFile, draftContext: draftContext4 } of ctx.implementationMethods()) {
       const contract = ctx.interfaceMap.get(implementation.contract);
       const declared = contract?.methods.find((m) => m.name === method.name)?.params ?? [];
       if (declared.length === 0 || !sourceFile) continue;
@@ -21809,6 +23166,7 @@ var paramConformanceRule = {
       const candidates = signatures[symbol];
       if (candidates.length === 0) continue;
       const injected = new Set(implementation.injectedParams ?? []);
+      const typeAgrees = typeAgreesIn(dialectOf(facts));
       const judgements = candidates.map((realized) => judge(declared, realized, injected, typeAgrees));
       const subject = candidates.length > 1 ? `every function called "${symbol}" in "${file}"` : `the function "${symbol}" in "${file}"`;
       const opening = subject.charAt(0).toUpperCase() + subject.slice(1);
@@ -21819,7 +23177,7 @@ var paramConformanceRule = {
           "UNREALIZED_PARAM",
           `Method "${method.name}" of contract "${implementation.contract}" declares ${unrealized.length} parameter(s) ${subject} does not take \u2014 ${unrealized.map((found) => found.told).join(", ")}. The contract is promising an argument that would go nowhere, and nothing breaks at a call site to correct it: every brief and every caller built from the contract passes one. Take the parameter in the code, or drop it from the contract.`,
           implementation.id,
-          draftContext3,
+          draftContext4,
           void 0,
           { at: method.name, covers: unrealized.map((found) => found.unit) }
         );
@@ -21831,7 +23189,7 @@ var paramConformanceRule = {
           "UNDECLARED_PARAM",
           `${opening} realizing method "${method.name}" of contract "${implementation.contract}" takes ${undeclared.length} parameter(s) the contract does not declare and no declared injection accounts for \u2014 ${undeclared.map((found) => found.told).join(", ")}. An argument a caller must supply that the design never mentions is how a credential ends up in a signature nobody has read against its contract. Declare it on the contract, name it in the implementation's \`injectedParams\` when whatever wires this component up supplies it (a LEADING run only), or take it out of the signature.`,
           implementation.id,
-          draftContext3,
+          draftContext4,
           void 0,
           { at: method.name, covers: undeclared.map((found) => found.unit) }
         );
@@ -21843,7 +23201,7 @@ var paramConformanceRule = {
           "PARAM_NAME_MISMATCH",
           `Method "${method.name}" of contract "${implementation.contract}" and ${subject} agree on position and type but not on name for ${renamed.length} parameter(s) \u2014 ${renamed.map((f) => f.told).join("; ")}. The contract, the ERD and every brief carry one word and the code answers to another, which is a rename nobody recorded rather than a different argument \u2014 the declared type agreeing is what says so. Rename one side to the other.`,
           implementation.id,
-          draftContext3,
+          draftContext4,
           void 0,
           { at: method.name, covers: renamed.map((found) => found.unit) }
         );
@@ -21855,7 +23213,7 @@ var paramConformanceRule = {
           "PARAM_OPTIONALITY",
           `Method "${method.name}" of contract "${implementation.contract}" and ${subject} disagree about whether ${disagreed.length} parameter(s) may be left out \u2014 ${disagreed.map((f) => f.told).join("; ")}. One of them is telling a caller an argument is required when it is not, or the reverse. Omittable is the code's word for it: a default value and a rest parameter make an argument omittable exactly as a question mark does.`,
           implementation.id,
-          draftContext3,
+          draftContext4,
           void 0,
           { at: method.name, covers: disagreed.map((found) => found.unit) }
         );
@@ -21864,6 +23222,62 @@ var paramConformanceRule = {
   }
 };
 
+// src/core/rules/conformance/async-conformance.ts
+var asyncConformanceRule = {
+  name: "async-conformance",
+  judges: "code",
+  description: "Code-to-contract for ASYNC: a contract method whose returns is `async T` is realized by a function that completes later, and one whose returns is not, by one that completes now \u2014 every caller in every language with async/await is shaped by the difference, so a contract that hides it misleads every implementer and translation built from it. Compared with source_file_facts.asyncFunctions for the method's realizing function (under its `symbol`), at exact grade only; where a name has several bodies only what they all agree on is reported, as param-conformance does. A method whose file only calls the function is methodRealization's finding.",
+  codes: [
+    {
+      code: "ASYNC_MISMATCH",
+      defaultSeverity: "warning",
+      summary: "A contract method and the function realizing it disagree about whether the call completes later: the returns says `async T` and the code completes now, or the code is async and the returns does not say so",
+      carryable: true
+    }
+  ],
+  check(ctx) {
+    const code = ctx.codeIndex();
+    for (const { implementation, method, sourceFile, draftContext: draftContext4 } of ctx.implementationMethods()) {
+      const contractMethod = ctx.interfaceMap.get(implementation.contract)?.methods.find((m) => m.name === method.name);
+      if (!contractMethod || typeof contractMethod.returns !== "string" || !sourceFile) continue;
+      const file = pathKey(sourceFile);
+      const facts = code.factsAt(file);
+      if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+      const symbol = method.symbol ?? method.name;
+      const signatures = facts.functionParams;
+      if (!signatures || !Object.prototype.hasOwnProperty.call(signatures, symbol)) continue;
+      const bodies = signatures[symbol].length;
+      if (bodies === 0) continue;
+      const returns = parseTypeExpression(contractMethod.returns, "returns");
+      if (!returns.expression) continue;
+      const contractAsync = returns.expression.form === "async";
+      const asyncBodies = (facts.asyncFunctions ?? []).filter((name) => name === symbol).length;
+      const subject = bodies > 1 ? `every function called "${symbol}" in "${file}"` : `the function "${symbol}" in "${file}"`;
+      if (contractAsync && asyncBodies === 0) {
+        ctx.addIssue(
+          "warning",
+          "ASYNC_MISMATCH",
+          `Method "${method.name}" of contract "${implementation.contract}" returns "${contractMethod.returns}", which completes later, but ${subject} completes now \u2014 it is neither declared async nor annotated to return a Promise. Every caller is told to await a call that answers at once. Make the code async, or drop \`async\` from the returns.`,
+          implementation.id,
+          draftContext4,
+          void 0,
+          { at: method.name }
+        );
+      } else if (!contractAsync && asyncBodies === bodies) {
+        ctx.addIssue(
+          "warning",
+          "ASYNC_MISMATCH",
+          `Method "${method.name}" of contract "${implementation.contract}" returns "${contractMethod.returns}", which completes now, but ${subject} completes later (declared async, or annotated to return a Promise). Every caller built from the contract forgets to await it. Write the returns as "async ${contractMethod.returns}" \u2014 or, if the code is async by accident, make it complete now.`,
+          implementation.id,
+          draftContext4,
+          void 0,
+          { at: method.name }
+        );
+      }
+    }
+  }
+};
+
 // src/core/rules/conformance/route-coverage.ts
 function liesUnder2(path49, prefix) {
   return path49 === prefix || path49.startsWith(prefix + "/");
@@ -21932,7 +23346,7 @@ var routeCoverageRule = {
           const routes = code.factsAt(file).functionRoutes;
           return routes && Object.prototype.hasOwnProperty.call(routes, via) ? routes[via] : [];
         });
-        const draftContext3 = ctx.isComponentDraft(listener.id) || ctx.isComponentDraft(portal.id);
+        const draftContext4 = ctx.isComponentDraft(listener.id) || ctx.isComponentDraft(portal.id);
         const where = holders.map((file) => `"${file}"`).join(", ");
         if (read2.length === 0) {
           ctx.addIssue(
@@ -21940,7 +23354,7 @@ var routeCoverageRule = {
             "UNREADABLE_ROUTER",
             `Listener "${listener.id}" mounts portal "${portal.id}" through "${via}" in ${where}, but no branch of "${via}" reads as a route \u2014 so none of its routes were checked against the contract at all. Only one idiom is read: an \`if\` whose conditions, together with those of every enclosing \`if\`, compare \`<request>.method\` with a string and \`parts[i]\` / \`parts.length\` with literals. Silence here would read as a clean router; it is only one this analysis cannot see. Write the router in that idiom, or carry this finding with the reason it cannot be.`,
             anchor,
-            draftContext3,
+            draftContext4,
             void 0,
             { at: via }
           );
@@ -21965,7 +23379,7 @@ var routeCoverageRule = {
             "UNDECLARED_ROUTE",
             `Portal "${portal.id}"'s router "${via}" (${where}), mounted by listener "${listener.id}", answers ${undeclared.length} route(s) no contract endpoint of "${portal.id}" declares \u2014 ${undeclared.map((key) => `"${key}"`).join(", ")}. A surface the code serves and the design never promised is how a write runs with no contract: no brief, no auth review, no rule reading it. Declare each as a contract method with its endpoint, or take the route out of the router.`,
             anchor,
-            draftContext3,
+            draftContext4,
             void 0,
             { at: via, covers: undeclared }
           );
@@ -21977,7 +23391,7 @@ var routeCoverageRule = {
             "UNROUTED_ENDPOINT",
             `Portal "${portal.id}" binds ${unrouted.length} HTTP endpoint(s) under listener "${listener.id}"'s mount that no route of its router "${via}" (${where}) answers \u2014 ${unrouted.map((key) => `"${key}"`).join(", ")}. The contract promises a route no request can reach. Route it in the router, or drop the endpoint from the contract.`,
             anchor,
-            draftContext3,
+            draftContext4,
             void 0,
             { at: via, covers: unrouted }
           );
@@ -22080,7 +23494,7 @@ var exportConformanceRule = {
         }
       }
     }
-    for (const { implementation, method, sourceFile, draftContext: draftContext3 } of ctx.implementationMethods()) {
+    for (const { implementation, method, sourceFile, draftContext: draftContext4 } of ctx.implementationMethods()) {
       const handle = method.exportedVia;
       if (!handle || !sourceFile) continue;
       const file = pathKey(sourceFile);
@@ -22095,7 +23509,7 @@ var exportConformanceRule = {
         "UNREALIZED_EXPORT_HANDLE",
         `Method "${method.name}" in implementation "${implementation.id}" declares exportedVia "${handle}", but "${file}" exports no such name. A handle names the export a consumer imports to REACH the method \u2014 the value that composes it, which \`symbol\` cannot name because \`symbol\` names the function inside \u2014 so one the file does not publish promises a route nobody can import. It allows nothing either: every export of this file is still read against the contracts. Name the binding the file actually exports, export it, or drop the handle.`,
         implementation.id,
-        draftContext3
+        draftContext4
       );
     }
     for (const listener of ctx.components) {
@@ -22468,82 +23882,6 @@ var couplingRule = {
   }
 };
 
-// src/core/rules/heuristic/signature-language-builtins.ts
-var LANGUAGE_MARKERS = {
-  rust: /* @__PURE__ */ new Set([
-    "u8",
-    "u16",
-    "u32",
-    "u64",
-    "u128",
-    "usize",
-    "i8",
-    "i16",
-    "i32",
-    "i64",
-    "i128",
-    "isize",
-    "f32",
-    "f64",
-    "vec",
-    "box",
-    "arc",
-    "rc",
-    "refcell",
-    "cell",
-    "mutex",
-    "rwlock",
-    "str"
-  ]),
-  typescript: /* @__PURE__ */ new Set(["any", "unknown", "never", "undefined", "promise", "record"]),
-  javascript: /* @__PURE__ */ new Set(["promise", "undefined"]),
-  python: /* @__PURE__ */ new Set(["dict", "tuple"]),
-  csharp: /* @__PURE__ */ new Set(["task"]),
-  go: /* @__PURE__ */ new Set(["chan", "rune"])
-};
-var signatureLanguageBuiltinsRule = {
-  name: "signature-language-builtins",
-  judges: "design",
-  description: "Contracts must speak the declared target language: builtin types that unambiguously belong to another language family are flagged in method signatures (e.g. `usize` in a TypeScript system, `Promise` in a Rust one). Set targetLanguage on the system (L0) or override per subsystem (L1).",
-  codes: [
-    { code: "LANGUAGE_FOREIGN_BUILTIN", defaultSeverity: "warning", summary: "Signature uses a builtin from a different language family" }
-  ],
-  check(ctx) {
-    const markersFor = (family) => {
-      const base = LANGUAGE_MARKERS[family];
-      const extra = ctx.ext.languages[family]?.foreignBuiltins;
-      if (!extra?.length) return base;
-      return /* @__PURE__ */ new Set([...base ?? [], ...extra.map((s) => s.toLowerCase())]);
-    };
-    const families = [.../* @__PURE__ */ new Set([...Object.keys(LANGUAGE_MARKERS), ...Object.keys(ctx.ext.languages)])];
-    const scans = [];
-    for (const intf of ctx.interfaces) {
-      const comp = ctx.componentMap.get(intf.component);
-      const lang = ctx.targetLanguageFor(comp?.subsystem);
-      if (!lang) continue;
-      const ownMarkers = markersFor(lang);
-      if (!ownMarkers || ownMarkers.size === 0) continue;
-      const draft = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
-      for (const method of intf.methods) {
-        for (const ref of methodTypeRefs(method)) scans.push({ intf, method, ref, lang, ownMarkers, draft });
-      }
-    }
-    for (const scan of scans) {
-      const refLower = scan.ref.toLowerCase();
-      if (scan.ownMarkers.has(refLower)) continue;
-      const foreign = families.find((family) => family !== scan.lang && markersFor(family)?.has(refLower));
-      if (!foreign) continue;
-      ctx.addIssue(
-        "warning",
-        "LANGUAGE_FOREIGN_BUILTIN",
-        `Method "${scan.method.name}" on interface "${scan.intf.id}" uses "${scan.ref}", a ${foreign} builtin, but the target language here is ${scan.lang}. Use the ${scan.lang} equivalent so implementers generate idiomatic code.`,
-        scan.intf.id,
-        scan.draft
-      );
-    }
-  }
-};
-
 // src/core/rules/heuristic/narrative-language-constructs.ts
 var UNSUPPORTED_FLOW = {
   rust: {
@@ -23469,6 +24807,11 @@ var SDD_RULES = [
   signatureSourcesRule,
   signatureTypesRule,
   signatureTextRule,
+  // The type grammar beside the signatures: how each stored type position is
+  // spelled, then what an enum and a named scalar may hold.
+  typeExpressionsRule,
+  enumTypesRule,
+  namedScalarTypesRule,
   // Contracts and the targets narratives name, in four questions with one
   // owner each: does the implementation mirror its contract, does a target
   // inside this tree resolve, does a target that leaves it pin to exactly one
@@ -23522,6 +24865,10 @@ var SDD_RULES = [
   dataBlockDepsRule,
   entrypointDepsRule,
   portalWriteShortcutRule,
+  // The process layer's data reach and the lifecycle effect's closure, both
+  // read from narratives against the callee's declared effect.
+  supervisorSharedDataRule,
+  lifecycleEffectClosureRule,
   // Patterns in four questions: who may own and what a claim must name,
   // what each pattern must contain, which data blocks are left standing
   // alone, and who may see a private member.
@@ -23633,14 +24980,17 @@ var SDD_RULES = [
   // others named.
   typeRealizationRule,
   typeShapeRule,
+  // An enum's values beside the data shape, and whether the call completes
+  // later beside the signature: the same readings, of their own facts.
+  enumValuesRule,
   paramConformanceRule,
+  asyncConformanceRule,
   routeCoverageRule,
   unclaimedSourceRule,
   exportConformanceRule,
   couplingRule,
-  // Target-language fit in two questions: what a CONTRACT may name, and what
-  // a NARRATIVE may describe.
-  signatureLanguageBuiltinsRule,
+  // Target-language fit: what a NARRATIVE may describe. What a contract may
+  // name is the neutral type grammar's (type-expressions), not a language's.
   narrativeLanguageConstructsRule,
   // The declaration before the consequences: which stereotype may bind a
   // technology at all, then where its name may appear.
@@ -23664,6 +25014,9 @@ var SDD_RULES = [
   // stage): configuration too, and the family run cannot judge a member against
   // a requirement that does not parse.
   packRequirementsRule,
+  // The fields a loaded pack still declares that wairon has deprecated: about
+  // the packs' configuration too, and only ever a notice.
+  packDeprecationsRule,
   // MUST run last, in this order: each audits what the earlier rules did
   // with a declared exception. The debt register first (which carried
   // findings the conformance family actually matched), then the allows
@@ -23706,30 +25059,6 @@ var import_module2 = require("module");
 function emptyCodeModel() {
   return { files: [], projectRoot: "", rootFiles: [] };
 }
-var EXTENSION_LANGUAGE = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".rs": "rust",
-  ".go": "go",
-  ".cs": "csharp",
-  ".java": "java",
-  ".c": "c",
-  ".h": "c",
-  ".cpp": "cpp",
-  ".cc": "cpp",
-  ".hpp": "cpp",
-  ".rb": "ruby",
-  ".php": "php",
-  ".kt": "kotlin",
-  ".swift": "swift"
-};
 var C_FAMILY_COMMENTS = { lineComments: ["//"], blockComments: [["/*", "*/"]] };
 var NAMED_IMPORT_BINDINGS_RE = /\bimport\s*\{([^}]*)\}/g;
 var JS_PATTERNS = {
@@ -23962,6 +25291,9 @@ function walkExact(ts, sourceText, fileName) {
   const typeShapes = /* @__PURE__ */ new Map();
   const functionParams = /* @__PURE__ */ new Map();
   const functionRoutes = /* @__PURE__ */ new Map();
+  const asyncFunctions = [];
+  const enumValues = /* @__PURE__ */ new Map();
+  const aliasTypes = /* @__PURE__ */ new Map();
   const mutableBindings = /* @__PURE__ */ new Set();
   const schemaConstants = /* @__PURE__ */ new Map();
   const derivedAliases = [];
@@ -24176,6 +25508,48 @@ function walkExact(ts, sourceText, fileName) {
     if (fn.body) walk2(fn.body, []);
     return routes;
   };
+  const completesLater = (fn) => {
+    const mods = fn.modifiers;
+    if (mods?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) return true;
+    const returned = fn.type;
+    return !!returned && ts.isTypeReferenceNode(returned) && ts.isIdentifier(returned.typeName) && returned.typeName.text === "Promise";
+  };
+  const stringLiteralUnion = (type) => {
+    const members = ts.isUnionTypeNode(type) ? [...type.types] : [type];
+    const values = [];
+    for (const member of members) {
+      if (!ts.isLiteralTypeNode(member) || !ts.isStringLiteral(member.literal)) return void 0;
+      values.push(member.literal.text);
+    }
+    return values;
+  };
+  const zodEnumValues = (expression) => {
+    const strings = (array, hops) => {
+      let node2 = array;
+      while (node2 && (ts.isAsExpression(node2) || ts.isParenthesizedExpression(node2) || ts.isSatisfiesExpression(node2))) node2 = node2.expression;
+      if (node2 && ts.isIdentifier(node2) && hops > 0) return strings(schemaConstants.get(node2.text), hops - 1);
+      if (!node2 || !ts.isArrayLiteralExpression(node2) || node2.elements.length === 0) return void 0;
+      const values = [];
+      for (const element of node2.elements) {
+        if (!ts.isStringLiteral(element) && !ts.isNoSubstitutionTemplateLiteral(element)) return void 0;
+        values.push(element.text);
+      }
+      return values;
+    };
+    let node = expression;
+    const walked = /* @__PURE__ */ new Set();
+    while (node && !walked.has(node)) {
+      walked.add(node);
+      if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        if (ts.isPropertyAccessExpression(callee) && callee.name.text === "enum") return strings(node.arguments[0], 1);
+        node = callee;
+      } else if (ts.isPropertyAccessExpression(node)) {
+        node = node.expression;
+      } else break;
+    }
+    return void 0;
+  };
   const visit = (node) => {
     const fnName = namedFunctionName(node);
     if (fnName && node.body) {
@@ -24187,6 +25561,7 @@ function walkExact(ts, sourceText, fileName) {
       const signatures = functionParams.get(fnName) ?? [];
       signatures.push(declaredParameters(node));
       functionParams.set(fnName, signatures);
+      if (completesLater(node)) asyncFunctions.push(fnName);
       const routes = collectRoutes(node);
       if (routes.size > 0) {
         const known = functionRoutes.get(fnName) ?? /* @__PURE__ */ new Map();
@@ -24209,10 +25584,17 @@ function walkExact(ts, sourceText, fileName) {
     } else if (ts.isTypeAliasDeclaration(node)) {
       if (ts.isTypeLiteralNode(node.type)) recordDeclaredShape(node.name.text, node.type.members, false);
       else {
+        if (!aliasTypes.has(node.name.text)) aliasTypes.set(node.name.text, node.type.getText(sf));
         const constant = inferredSchemaConstant(node.type);
         if (constant) derivedAliases.push({ name: node.name.text, constant });
+        const literals = stringLiteralUnion(node.type);
+        if (literals) enumValues.set(node.name.text, literals);
       }
     }
+    if (ts.isEnumDeclaration(node)) {
+      const values = node.members.map((member) => member.initializer && (ts.isStringLiteral(member.initializer) || ts.isNoSubstitutionTemplateLiteral(member.initializer)) ? member.initializer.text : void 0);
+      if (values.length > 0 && values.every((v) => v !== void 0)) enumValues.set(node.name.text, values);
+    }
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && !schemaConstants.has(node.name.text)) {
       schemaConstants.set(node.name.text, node.initializer);
     }
@@ -24334,8 +25716,17 @@ function walkExact(ts, sourceText, fileName) {
     if (!fields) continue;
     typeShapes.set(alias.name, { origin: "derived", fields, methods: [] });
   }
+  for (const [name, initializer] of schemaConstants) {
+    const values = zodEnumValues(initializer);
+    if (values) enumValues.set(name, values);
+  }
+  for (const alias of derivedAliases) {
+    if (enumValues.has(alias.name)) continue;
+    const values = enumValues.get(alias.constant);
+    if (values && schemaConstants.has(alias.constant)) enumValues.set(alias.name, values);
+  }
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
-  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, mutableBindings, reexportOnly };
+  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
@@ -24414,7 +25805,7 @@ function walkDeclaredRoots(roots, exclude, projectRoot) {
   const record = (absolute) => {
     const key = pathKey(path18.relative(projectRoot, absolute));
     if (seen.has(key) || isExcluded(key)) return;
-    if (!EXTENSION_LANGUAGE[path18.extname(key).toLowerCase()]) return;
+    if (!languageOfSourcePath(key)) return;
     seen.add(key);
     found.push(key);
   };
@@ -24496,7 +25887,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
       continue;
     }
     const text3 = buffer.toString("utf8");
-    const language = EXTENSION_LANGUAGE[path18.extname(sourcePath).toLowerCase()];
+    const language = languageOfSourcePath(sourcePath);
     let analyzed;
     if (language === "typescript" || language === "javascript") {
       const ts = resolveTypeScript(projectRoot);
@@ -24524,6 +25915,9 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             typeShapes: Object.fromEntries(facts.typeShapes),
             functionParams: Object.fromEntries(facts.functionParams),
             functionRoutes: Object.fromEntries([...facts.functionRoutes].map(([k, v]) => [k, [...v.values()]])),
+            asyncFunctions: [...facts.asyncFunctions],
+            enumValues: Object.fromEntries(facts.enumValues),
+            aliasTypes: Object.fromEntries(facts.aliasTypes),
             topLevelMutableBindings: [...facts.mutableBindings],
             reexportOnly: facts.reexportOnly
           };
@@ -24953,7 +26347,7 @@ function buildRuleContext(opts) {
   const authoredTypeRefs = new Set((family?.authoredReferences ?? []).filter((r) => r.position === "type" && r.binding !== "local" && memberOf(r.specId) === void 0).map((r) => r.authored));
   const isTypeResolved = (ref, generics) => {
     const refLower = ref.toLowerCase();
-    if (BUILTIN_TYPES.has(refLower)) return true;
+    if (isTypeVocabulary(refLower)) return true;
     if (generics.has(refLower)) return true;
     if (ownTypes.some((spec) => typeMatchesRef(spec, ref))) return true;
     const [first, ...rest] = ref.split(/::|\./);
@@ -25167,7 +26561,7 @@ function buildRuleContext(opts) {
     }
     return projectNaming;
   };
-  const isBuiltinType = (ref) => BUILTIN_TYPES.has(ref.toLowerCase());
+  const isBuiltinType = (ref) => isTypeVocabulary(ref);
   const getRuleSeverity = (ruleCode, defaultSeverity, isDraftContext, subsystemId) => {
     if (rules?.sddRuleSeverity?.[ruleCode]) {
       return rules.sddRuleSeverity[ruleCode];
@@ -25198,7 +26592,16 @@ function buildRuleContext(opts) {
   const sitesSeen = /* @__PURE__ */ new Map();
   const sitesReported = (specId, code) => {
     const seen = sitesSeen.get(`${specId}\0${code}`);
-    return { sites: [...seen?.sites ?? []], unsited: seen?.unsited ?? false };
+    return { sites: [...seen?.sites ?? []], unsited: seen?.unsited ?? false, errored: seen?.errored ?? false };
+  };
+  const codeDefaults = new Map(opts.issueCodeSeverities ?? []);
+  for (const a of opts.extensions?.assertions ?? []) {
+    if (!codeDefaults.has(a.fullCode)) codeDefaults.set(a.fullCode, a.severity);
+  }
+  const severityOf = (code, specId) => {
+    const defaultSeverity = codeDefaults.get(code);
+    if (!defaultSeverity) return void 0;
+    return getRuleSeverity(code, defaultSeverity, false, subsystemOfSpec.get(specId));
   };
   for (const s of subsystems) collectAllows(s.id, s.lint);
   for (const c of components) collectAllows(c.id, c.lint);
@@ -25241,9 +26644,10 @@ function buildRuleContext(opts) {
     if (specId) {
       const key = `${specId}\0${code}`;
       let seen = sitesSeen.get(key);
-      if (!seen) sitesSeen.set(key, seen = { sites: /* @__PURE__ */ new Set(), unsited: false });
+      if (!seen) sitesSeen.set(key, seen = { sites: /* @__PURE__ */ new Set(), unsited: false, errored: false });
       if (parts) seen.sites.add(parts.at);
       else seen.unsited = true;
+      if (severity === "error") seen.errored = true;
     }
     let allowClaimed = false;
     if (specId) {
@@ -25345,7 +26749,7 @@ function buildRuleContext(opts) {
     documentationConfigFor,
     namingConfigFor,
     isBuiltinType,
-    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [] },
+    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [], deprecations: extensions.deprecations ?? [] },
     variants: opts.variants ?? [],
     surfaceSnapshots,
     ...opts.projectIdentity ? { projectIdentity: opts.projectIdentity } : {},
@@ -25354,11 +26758,13 @@ function buildRuleContext(opts) {
     ...opts.projectFamily ? { projectFamily: opts.projectFamily } : {},
     ...opts.exportUsages ? { exportUsages: opts.exportUsages } : {},
     ...opts.signatureFacts ? { signatureFacts: opts.signatureFacts } : {},
+    ...opts.typeSpellingFacts ? { typeSpellingFacts: opts.typeSpellingFacts } : {},
     pinnedExternals,
     codeModel: opts.codeModel ?? emptyCodeModel(),
     roundTripIssues: opts.roundTripIssues,
     lintAllows: lintAllows2,
     sitesReported,
+    severityOf,
     knownIssueCodes: opts.knownIssueCodes,
     carriedFindings,
     carryableIssueCodes: opts.carryableIssueCodes ?? /* @__PURE__ */ new Set(),
@@ -25708,7 +27114,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
   let extensions;
   let treatAllAsComplete = false;
   let packSelections;
-  if (rulesOrOptions && ("scopeSubsystem" in rulesOrOptions || "recursive" in rulesOrOptions || "rules" in rulesOrOptions || "projectType" in rulesOrOptions || "extensions" in rulesOrOptions || "treatAllAsComplete" in rulesOrOptions || "family" in rulesOrOptions || "packSelections" in rulesOrOptions)) {
+  if (rulesOrOptions && ("scopeSubsystem" in rulesOrOptions || "memberDepth" in rulesOrOptions || "rules" in rulesOrOptions || "projectType" in rulesOrOptions || "extensions" in rulesOrOptions || "treatAllAsComplete" in rulesOrOptions || "family" in rulesOrOptions || "packSelections" in rulesOrOptions)) {
     const opts = rulesOrOptions;
     rules = opts.rules;
     projectType = opts.projectType ?? "backend";
@@ -25718,7 +27124,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
     packSelections = opts.packSelections;
   }
   extensions ??= loadProjectExtensions();
-  scanAllSpecs({ recursive: true });
+  scanAllSpecs();
   const issues = [];
   clearLoaderIssues();
   const boundConfig = boundConfiguration();
@@ -25791,11 +27197,13 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
     const carryableCodes = new Set(
       knownIssueCodes().filter((rc) => rc.carryable).map((rc) => rc.code)
     );
+    const codeSeverities = new Map(knownIssueCodes().map((rc) => [rc.code, rc.defaultSeverity]));
     const family = graph();
     const memberTables = family.nodes.filter((n) => n.namespace !== "").map((n) => resolveProjectExports(n.namespace));
     const producers = new Set(family.references.filter((r) => r.consumer === "").map((r) => r.producer));
     const exportUsages = [...producers].map((producer) => exportUsage("", producer));
     const signatures = signatureFacts();
+    const typeSpellings = typeSpellingFacts();
     const ctx = buildRuleContext({
       system,
       subsystems,
@@ -25818,6 +27226,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
       projectFamily: family,
       exportUsages,
       signatureFacts: signatures,
+      typeSpellingFacts: typeSpellings,
       pinnedExternals,
       // By-name selections only: a legacy path ref pins nothing to check. A dry
       // run supplies its candidate's; otherwise the stored ones.
@@ -25831,6 +27240,7 @@ function runOwnersGate(rulesOrOptions, projectType = "backend") {
       codeModel,
       roundTripIssues,
       knownIssueCodes: knownCodes,
+      issueCodeSeverities: codeSeverities,
       carryableIssueCodes: carryableCodes,
       issues
     });
@@ -25938,7 +27348,12 @@ function judgePartAlone(config, scopeSubsystem) {
     issues.push(issue("warning", "EXTERNAL_CHECK_UNAVAILABLE", `"${by}" names "${key}", which neither this part nor its pinned excerpt of "${parentId}" holds \u2014 used since the pin: re-pin with \`wairon externals pin\` while the parent is on disk.`, by));
   }
   const ownSignatures = signatureFacts();
-  const resolved = resolveTree(
+  const ownTypeSpellings = typeSpellingFacts();
+  const partTypeSpellings = {
+    respellings: ownTypeSpellings.respellings.filter((r) => isOwn(r.specId)),
+    problems: ownTypeSpellings.problems.filter((p) => p.specId === void 0 || isOwn(p.specId))
+  };
+  const resolved = resolveSignatures(
     [...own.interfaces, ...context.interfaces],
     [...own.components, ...context.components],
     [...own.types, ...context.types]
@@ -25977,6 +27392,7 @@ function judgePartAlone(config, scopeSubsystem) {
     projectFamily: graph(),
     exportUsages: [],
     signatureFacts: partSignatures,
+    typeSpellingFacts: partTypeSpellings,
     pinnedExternals: [],
     packSelections: packs.filter((p) => typeof p !== "string"),
     packRequirements: [],
@@ -26032,7 +27448,7 @@ function builtinProjectKinds() {
   return [...PROJECT_KINDS];
 }
 function computeGateStateId() {
-  scanAllSpecs({ recursive: true });
+  scanAllSpecs();
   const content = computeOwnStateId();
   const extensions = loadProjectExtensions();
   let gate = {};
@@ -26684,16 +28100,16 @@ function bindReferencedMembers(node, root) {
       out.push({ ...base, sourceKind: "hosted", hosted: member.source.hosted });
       continue;
     }
-    const located = root.referenced.find((r) => r.alias === member.alias);
+    const located2 = root.referenced.find((r) => r.alias === member.alias);
     const sourceKind = member.storage === "git" ? "git" : "path";
-    const directory = located?.directory ?? (member.storage === "path" ? path20.resolve(node.directory, member.source.path ?? "") : void 0);
-    const commit2 = located?.commit ?? member.source.commit;
+    const directory = located2?.directory ?? (member.storage === "path" ? path20.resolve(node.directory, member.source.path ?? "") : void 0);
+    const commit2 = located2?.commit ?? member.source.commit;
     out.push({
       ...base,
       sourceKind,
       ...directory !== void 0 ? { directory } : {},
       ...commit2 !== void 0 ? { commit: commit2 } : {},
-      ...located?.availability === "unavailable" ? { problem: located.reason } : {}
+      ...located2?.availability === "unavailable" ? { problem: located2.reason } : {}
     });
   }
   return out;
@@ -27517,7 +28933,8 @@ function emptyIndex() {
       type: {},
       group: {}
     },
-    signatures: { sources: [], staleTexts: [] }
+    signatures: { sources: [], staleTexts: [] },
+    typeSpellings: emptyTypeSpellingFacts()
   };
 }
 function isWithin(dir, file) {
@@ -27874,7 +29291,7 @@ function bareRawReferences(kind, spec) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add2 = (position, value, generics = /* @__PURE__ */ new Set()) => {
-    if (!value || value.includes("::") || BUILTIN_TYPES.has(value.toLowerCase()) || generics.has(value.toLowerCase())) return;
+    if (!value || value.includes("::") || isTypeVocabulary(value) || generics.has(value.toLowerCase())) return;
     const k = `${position}|${value}`;
     if (seen.has(k)) return;
     seen.add(k);
@@ -28294,6 +29711,49 @@ function bindImport(raw, suppliers, p) {
     }
   };
 }
+function typePositionText(spec, at) {
+  const [head2, name, member, param] = at.split(".");
+  const named2 = (list, key) => Array.isArray(list) ? list.find((x) => x?.name === key) : void 0;
+  if (head2 === "returns") return spec.returns;
+  if (head2 === "params") return named2(spec.params, name)?.type;
+  if (head2 === "fields") return named2(spec.fields, name)?.type;
+  if (head2 !== "methods") return void 0;
+  const method = named2(spec.methods, name);
+  return member === "returns" ? method?.returns : named2(method?.params, param)?.type;
+}
+function writtenSignatureTexts(raws) {
+  const texts = /* @__PURE__ */ new Map();
+  const record = (kind, specId, methods) => {
+    for (const m of methods) {
+      if (m.signatureFrom !== void 0) continue;
+      const derived = deriveMethodSignature(m);
+      if (derived !== void 0) texts.set(`${kind}|${specId}|${m.name}`, derived);
+    }
+  };
+  for (const raw of raws) {
+    for (const intf of raw.index.interfaces) record("interface", intf.id, intf.methods ?? []);
+    for (const type of raw.index.types) record("type", type.id, type.methods ?? []);
+  }
+  return texts;
+}
+function canonicalizeRootTypes(raws) {
+  const facts = emptyTypeSpellingFacts();
+  for (const raw of raws) {
+    raw.index.interfaces = raw.index.interfaces.map((intf) => {
+      const read2 = interfaceCanonicalTypes(intf);
+      facts.respellings.push(...read2.respellings);
+      facts.problems.push(...read2.problems);
+      return read2.spec;
+    });
+    raw.index.types = raw.index.types.map((type) => {
+      const read2 = typeCanonicalTypes(type);
+      facts.respellings.push(...read2.respellings);
+      facts.problems.push(...read2.problems);
+      return read2.spec;
+    });
+  }
+  return facts;
+}
 function bindRootReferences(raw, raws, readables) {
   const bound2 = /* @__PURE__ */ new Map();
   for (const p of raw.pending) {
@@ -28388,7 +29848,8 @@ function specKind(raw) {
   if ("component" in raw && Array.isArray(raw.methods)) return "interface";
   if ("contract" in raw && Array.isArray(raw.methods)) return "implementation";
   if ("kind" in raw && Array.isArray(raw.fields)) return "type";
-  if (raw.kind === "signature") return "type";
+  if (raw.kind === "signature" || raw.kind === "enum") return "type";
+  if ("kind" in raw && typeof raw.holds === "string") return "type";
   return void 0;
 }
 function rewriteSpecRefs(raw, remap) {
@@ -28686,12 +30147,12 @@ function pairSteps(before, after) {
     const gapBefore = before.slice(oi + 1, oj).map((step, k) => ({ step, at: oi + 1 + k }));
     const gapAfter = after.slice(ni + 1, nj).map((step, k) => ({ step, at: ni + 1 + k }));
     const similar = commonRun(gapBefore, gapAfter, (x, y) => recognisablySame(x.step, y.step)).map(([x, y]) => [gapBefore[x].at, gapAfter[y].at]);
-    const inner = [[oi, ni], ...similar, [oj, nj]];
-    for (let k = 0; k < inner.length - 1; k++) {
-      const [a0, b0] = inner[k];
-      const [a1, b1] = inner[k + 1];
+    const inner2 = [[oi, ni], ...similar, [oj, nj]];
+    for (let k = 0; k < inner2.length - 1; k++) {
+      const [a0, b0] = inner2[k];
+      const [a1, b1] = inner2[k + 1];
       if (a1 - a0 === b1 - b0) for (let d = 1; d < a1 - a0; d++) pairs.push([a0 + d, b0 + d]);
-      if (k < inner.length - 2) pairs.push(inner[k + 1]);
+      if (k < inner2.length - 2) pairs.push(inner2[k + 1]);
     }
     if (g < bounds.length - 2) pairs.push(bounds[g + 1]);
   }
@@ -28898,7 +30359,7 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
 var SpecWorkspace = class {
   constructor(rootDir) {
     this.cachedIndex = null;
-    this.cachedRecursive = null;
+    this.cachedDepth = null;
     this.cachedSpecDirs = [];
     this.cachedSignature = null;
     this.lastSignatureCheckMs = 0;
@@ -28927,7 +30388,7 @@ var SpecWorkspace = class {
   }
   invalidate() {
     this.cachedIndex = null;
-    this.cachedRecursive = null;
+    this.cachedDepth = null;
     this.cachedSpecDirs = [];
     this.cachedConfigFiles = [];
     this.cachedRoots = [];
@@ -28942,8 +30403,8 @@ var SpecWorkspace = class {
   // Scanning
   // -------------------------------------------------------------------------
   scanAll(options) {
-    const recursive = options?.recursive ?? true;
-    if (this.cachedIndex && this.cachedRecursive === recursive) {
+    const maxDepth = options?.memberDepth ?? Infinity;
+    if (this.cachedIndex && this.cachedDepth === maxDepth) {
       const now = Date.now();
       if (now - this.lastSignatureCheckMs <= SIGNATURE_TTL_MS) return this.cachedIndex;
       this.lastSignatureCheckMs = now;
@@ -28951,10 +30412,9 @@ var SpecWorkspace = class {
       this.invalidate();
     }
     this.loaderIssues = [];
-    this.cachedRecursive = recursive;
+    this.cachedDepth = maxDepth;
     this.scanVisitedSpecDirs = [];
     this.scanVisitedConfigFiles = [];
-    const maxDepth = typeof recursive === "number" ? recursive : recursive ? Infinity : 0;
     const scan = this.scanFamily(maxDepth);
     this.cachedIndex = scan.index;
     this.cachedRoots = scan.raws.map((raw) => raw.record);
@@ -28995,6 +30455,8 @@ var SpecWorkspace = class {
     raws.forEach((raw) => this.bindAliases(raw, raws));
     const readables = raws.map((raw) => readableOf(raw));
     resolveFamilyTables(raws);
+    const writtenTexts = writtenSignatureTexts(raws);
+    const typeSpellings = canonicalizeRootTypes(raws);
     raws.forEach((raw) => bindRootReferences(raw, raws, readables));
     const index = emptyIndex();
     for (const raw of raws) {
@@ -29009,7 +30471,11 @@ var SpecWorkspace = class {
     const signatures = resolveTree(index.interfaces, index.components, index.types, raws.flatMap((r) => r.record.authoredReferences));
     index.interfaces = signatures.interfaces;
     index.types = signatures.types;
-    index.signatures = signatures.facts;
+    index.signatures = {
+      ...signatures.facts,
+      staleTexts: signatures.facts.staleTexts.filter((stale) => writtenTexts.get(`${stale.kind}|${stale.specId}|${stale.method}`) !== stale.stored)
+    };
+    index.typeSpellings = typeSpellings;
     return { index, raws, readables };
   }
   /**
@@ -29155,26 +30621,26 @@ var SpecWorkspace = class {
       decl.kind = "project";
       return;
     }
-    const located = this.memberRoot(raw, decl);
-    if (located === null) return;
-    if ("unavailable" in located) {
+    const located2 = this.memberRoot(raw, decl);
+    if (located2 === null) return;
+    if ("unavailable" in located2) {
       if (asserted === "project" || pinnedAsMember(raw.dir, decl.alias)) {
         decl.kind = "project";
-        raw.record.referenced.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located.unavailable });
+        raw.record.referenced.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located2.unavailable });
         return;
       }
       decl.kind = "part";
-      this.memberProblem(raw, "part-unavailable", decl.alias, located.unavailable);
-      raw.record.parts.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located.unavailable });
+      this.memberProblem(raw, "part-unavailable", decl.alias, located2.unavailable);
+      raw.record.parts.push({ alias: decl.alias, storage: decl.storage, partOf: null, subsystems: [], specIds: [], availability: "unavailable", reason: located2.unavailable });
       return;
     }
-    const kind = projectContentAt(located.dir) ? "project" : "part";
+    const kind = projectContentAt(located2.dir) ? "project" : "part";
     decl.kind = kind;
     if (asserted !== void 0 && asserted !== kind) {
       this.memberProblem(raw, "kind-mismatch", decl.alias, `the member "${decl.alias}" is asserted \`as: ${asserted}\`, but its content makes it a ${kind}: ${kind === "project" ? "its tree declares an id, holds an L0 or carries a lock \u2014 drop the `as`, or remove that content with `wairon member demote`" : "its tree declares no id, holds no L0 and carries no lock \u2014 drop the `as`, or create the project content with `wairon member promote`"}`);
     }
-    if (kind === "part") this.readPart(raw, decl, located.dir, located.commit);
-    else if (decl.storage !== "contained") this.recordReferenced(raw, decl, located.dir, located.commit);
+    if (kind === "part") this.readPart(raw, decl, located2.dir, located2.commit);
+    else if (decl.storage !== "contained") this.recordReferenced(raw, decl, located2.dir, located2.commit);
   }
   /**
    * A referenced project member (stage 8): where its root is — the sibling
@@ -30073,7 +31539,8 @@ var SpecWorkspace = class {
    * the owning project.
    */
   prepareInterfaceForWrite(spec) {
-    const stored = { ...spec, methods: (spec.methods ?? []).map((m) => storedMethodSignature(m)) };
+    const canonical3 = interfaceCanonicalTypes(spec).spec;
+    const stored = { ...canonical3, methods: (canonical3.methods ?? []).map((m) => storedMethodSignature(m)) };
     return this.relativizeSpec("interface", stored);
   }
   prepareImplementationForWrite(spec, carry = true) {
@@ -30084,9 +31551,14 @@ var SpecWorkspace = class {
     const partDir = this.partHolding(this.getImplementationPath(spec.id, spec.contract))?.part.directory;
     return partDir ? partRelativeFilePaths(relative19, this.rootDir, partDir) : relative19;
   }
-  /** A type written in its stored form — every params-bearing method's text derived — relative to the owning project. */
+  /**
+   * A type written in its stored form — every type position canonical (one
+   * that is not canonical written as it stands), every params-bearing method's
+   * text derived from them — relative to the owning project.
+   */
   prepareTypeForWrite(spec) {
-    const stored = { ...spec, methods: (spec.methods ?? []).map((m) => storedTypeMethod(m)) };
+    const canonical3 = typeCanonicalTypes(spec).spec;
+    const stored = { ...canonical3, methods: (canonical3.methods ?? []).map((m) => storedTypeMethod(m)) };
     return this.relativizeSpec("type", stored);
   }
   prepareGroupForWrite(spec) {
@@ -30297,7 +31769,7 @@ var SpecWorkspace = class {
     if (!pathExists(p)) return null;
     try {
       const raw = readSpecFile(p);
-      return resolveTree([InterfaceSpecSchema.parse(raw)], index.components, index.types).interfaces[0];
+      return resolveTree([interfaceCanonicalTypes(InterfaceSpecSchema.parse(raw)).spec], index.components, index.types).interfaces[0];
     } catch (e) {
       this.loaderIssues.push({
         severity: "error",
@@ -30873,6 +32345,33 @@ var SpecWorkspace = class {
     index.listProjectRoots();
     return this.cachedIndex.signatures;
   }
+  /**
+   * A delta's merged spec with every type position canonical, IN PLACE (an
+   * interface or a type; nothing else holds type positions). Answers the
+   * respellings the write applies: each alias the merge holds — written by the
+   * delta — and each alias the stored file still holds at a position the merge
+   * kept, which the scan recorded and the save rewrites with it. A position
+   * that is not canonical stays as written.
+   */
+  canonicalizeMerged(kind, merged) {
+    if (kind !== "interface" && kind !== "type") return [];
+    const read2 = kind === "interface" ? interfaceCanonicalTypes(merged) : typeCanonicalTypes(merged);
+    Object.assign(merged, read2.spec);
+    const respelled = new Set(read2.respellings.map((r) => r.path));
+    const fromFile = this.scanAll().typeSpellings.respellings.filter((r) => r.specId === merged.id && r.kind === kind && !respelled.has(r.path) && typePositionText(merged, r.path) === r.stored);
+    return [...read2.respellings, ...fromFile];
+  }
+  /**
+   * ispec_index.typeSpellingFacts — what the current scan's type
+   * canonicalisation recorded: every stored type position that is an alias of
+   * its canonical spelling, and every one that is not canonical at all. Read
+   * from the cached scan, rescanning first when the tree changed.
+   */
+  typeSpellingFacts() {
+    const index = this;
+    index.listProjectRoots();
+    return this.cachedIndex.typeSpellings;
+  }
   snapshotSpecFiles() {
     const index = this.scanAll();
     const snapshot = /* @__PURE__ */ new Map();
@@ -31483,6 +32982,7 @@ var SpecWorkspace = class {
     const qualifiedDelta = qualifyDeltaRefs(mergeableDelta);
     const mergedResult = mergeDelta(result, qualifiedDelta);
     for (const field of unsetFields) delete mergedResult[field];
+    const respellings = this.canonicalizeMerged(kind, mergedResult);
     deriveMergedTexts(kind, mergedResult);
     const withDefaults = deltaSchema.safeParse(mergedResult);
     if (withDefaults.success) {
@@ -31523,6 +33023,7 @@ var SpecWorkspace = class {
         changes,
         ineffective,
         notices,
+        respellings: [],
         testsToRevisit: [],
         summary: `No change to ${kind} "${id}" \u2014 the delta matches what is stored, so nothing ${dryRun ? "would be" : "was"} written.`
       };
@@ -31539,6 +33040,7 @@ var SpecWorkspace = class {
         changes,
         ineffective,
         notices,
+        respellings,
         testsToRevisit: [],
         ...stripped.length ? { strippedKeys: stripped } : {},
         summary: `Dry run on ${kind} "${id}": ${changes.length} change${changes.length === 1 ? "" : "s"} would be made. Nothing was written.`
@@ -31557,6 +33059,7 @@ var SpecWorkspace = class {
       changes,
       ineffective,
       notices,
+      respellings,
       // The store never searches for tests: it holds the tree and knows
       // nothing about the rule engine that reads code. The GATED write above
       // it fills this in, which is also the only write path a human drives.
@@ -32111,6 +33614,7 @@ function moveChangeReports(edits, dryRun) {
     changes,
     ineffective: [],
     notices: [],
+    respellings: [],
     testsToRevisit: [],
     summary: edit4.before === null ? `${dryRun ? "Would create" : "Created"} ${edit4.kind} "${edit4.id}" to receive the moved methods.` : `${dryRun ? "Would move" : "Moved"} into ${edit4.kind} "${edit4.id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
   }));
@@ -32409,6 +33913,9 @@ function snapshotSpecFiles() {
 function signatureFacts() {
   return current().signatureFacts();
 }
+function typeSpellingFacts() {
+  return current().typeSpellingFacts();
+}
 function findLegacySpecFiles() {
   return current().findLegacySpecFiles();
 }
@@ -35230,6 +36737,19 @@ function composeAgentBrief(agentId) {
 ## Project guidance
 
 ${guidance.trim()}
+`;
+  }
+  const language = implementationLanguage(record);
+  const dialect = language ? typeDialectFor(language) : null;
+  const typeMapping = dialect ? dialect.mappingLines() : void 0;
+  if (typeMapping) {
+    instructions = `${instructions.trimEnd()}
+
+## Types in ${language}
+
+Contracts speak wairon's neutral type grammar; write each type in ${language} as:
+
+${typeMapping.map((line) => `- ${line}`).join("\n")}
 `;
   }
   const profile = deriveExecutionProfile(record);
@@ -35243,10 +36763,28 @@ ${guidance.trim()}
     readPaths: record.readPaths,
     instructions,
     variantGuidance: record.variantGuidance || void 0,
+    ...typeMapping ? { typeMapping } : {},
     profile: budget ? profile : void 0,
     budget
   };
 }
+function implementationLanguage(record) {
+  const owned = new Set(record.ownedPaths);
+  const implementations = loadImplementationSpecs().filter((impl) => implementationSourceFiles(impl).some((file) => owned.has(file)));
+  for (const impl of implementations) {
+    for (const technology of impl.technologies ?? []) {
+      const name = typeof technology === "string" ? technology : technology.name;
+      if (typeDialectFor(name)) return name.toLowerCase();
+    }
+  }
+  for (const impl of implementations) {
+    for (const file of implementationSourceFiles(impl)) {
+      const language = languageOfSourcePath(file);
+      if (language) return language;
+    }
+  }
+  return void 0;
+}
 function memberHop(agentId) {
   const at = agentId.indexOf("::");
   if (at < 0) return null;
@@ -35824,6 +37362,52 @@ function repairSignatures(apply3) {
   return planned;
 }
 
+// src/core/type-spelling-repair.ts
+function repairTypeSpellings(apply3) {
+  const facts = typeSpellingFacts();
+  const held = new Set(signatureFacts().sources.filter((f) => f.outcome === "restated" && f.differs).map((f) => f.interfaceId));
+  const repairs = /* @__PURE__ */ new Map();
+  const repairOf = (specId, kind) => {
+    const key = `${kind}:${specId}`;
+    let repair = repairs.get(key);
+    if (!repair) {
+      repair = { specId, kind, rewritten: [], proposals: [], authorNeeded: [] };
+      repairs.set(key, repair);
+    }
+    return repair;
+  };
+  const own = (specId) => !specId.includes("::");
+  for (const respelling of facts.respellings) {
+    if (!own(respelling.specId)) continue;
+    if (respelling.kind === "interface" && held.has(respelling.specId)) continue;
+    repairOf(respelling.specId, respelling.kind).rewritten.push(respelling);
+  }
+  for (const problem of facts.problems) {
+    if (problem.specId === void 0 || problem.kind === void 0 || !own(problem.specId)) continue;
+    const repair = repairOf(problem.specId, problem.kind);
+    const proposal = typeProblemIntProposal(problem);
+    if (proposal) repair.proposals.push(proposal);
+    else repair.authorNeeded.push(problem);
+  }
+  const planned = [...repairs.values()];
+  const rewriting = planned.filter((repair) => repair.rewritten.length > 0);
+  if (apply3 && rewriting.length > 0) {
+    const interfaces = new Map(loadInterfaceSpecs().map((i) => [i.id, i]));
+    const types = new Map(loadTypeSpecs().map((t) => [t.id, t]));
+    for (const repair of rewriting) {
+      if (repair.kind === "interface") {
+        const intf = interfaces.get(repair.specId);
+        if (intf) saveInterfaceSpec(intf);
+        continue;
+      }
+      const type = types.get(repair.specId);
+      if (type) saveSpec("type", type);
+    }
+    invalidateSpecCache();
+  }
+  return planned;
+}
+
 // src/core/approval.ts
 var crypto7 = __toESM(require("crypto"));
 var path35 = __toESM(require("path"));
@@ -36342,7 +37926,7 @@ function parentPinState(parent) {
 }
 function getStatusReport(options = {}, decor) {
   const mark = fillDecor(decor);
-  scanAllSpecs({ recursive: options.recursive ?? true });
+  scanAllSpecs({ memberDepth: options.memberDepth });
   const system = loadSystemSpec();
   const loaderErrors = getLoaderIssues();
   if (loaderErrors.length > 0) {
@@ -36532,6 +38116,11 @@ function getStatusReport(options = {}, decor) {
 }
 
 // src/core/index.ts
+function resolveSignatures(interfaces, components, types) {
+  const canonicalInterfaces = interfaces.map((intf) => interfaceCanonicalTypes(intf).spec);
+  const canonicalTypes = types.map((type) => typeCanonicalTypes(type).spec);
+  return resolveTree(canonicalInterfaces, components, canonicalTypes);
+}
 function resolveDomains2() {
   return resolveDomains();
 }
@@ -36847,12 +38436,14 @@ function noticesFrom(verdict) {
     ...verdict.notices.map((n) => `${n.code} (notice): ${n.message}`)
   ];
 }
-function componentCandidateGate(options = candidateOptions(), storedOwner) {
+function componentCandidateGate(options = candidateOptions(), storedOwner, stored) {
   return {
     gate: (kind, merged) => {
       refuseUnknownOwner(kind, merged, storedOwner);
       const restated = kind === "interface" ? restatedSources(merged.methods) : [];
       if (restated.length) throw new Error(`${restatedSourceRefusal(String(merged.id), restated)} Nothing was written.`);
+      const written = deltaWrittenTypeProblems(kind, merged, stored ?? null);
+      if (written.length) throw new Error(`${typeProblemRefusal(kind, String(merged.id), written)} Nothing was written.`);
       if (kind !== "component") return;
       const verdict = validateComponentCandidate(merged, options);
       if (verdict.errors.length) throw new Error(formatCandidateRefusal(verdict));
@@ -36860,6 +38451,22 @@ function componentCandidateGate(options = candidateOptions(), storedOwner) {
     }
   };
 }
+function canonicalTypesOf(kind, spec) {
+  if (!spec || typeof spec !== "object") return null;
+  if (kind === "interface") return interfaceCanonicalTypes(spec);
+  if (kind === "type") return typeCanonicalTypes(spec);
+  return null;
+}
+function deltaWrittenTypeProblems(kind, merged, stored) {
+  const now = canonicalTypesOf(kind, merged)?.problems ?? [];
+  if (now.length === 0) return [];
+  const before = new Set((canonicalTypesOf(kind, stored)?.problems ?? []).map((p) => `${p.path}|${p.written}`));
+  return now.filter((p) => !before.has(`${p.path}|${p.written}`));
+}
+function typeProblemRefusal(kind, id, problems) {
+  const lines = problems.map((p) => `${p.code} at ${p.path}: ${p.detail}${p.replacement ? ` \u2014 write ${p.replacement} instead` : ""}.`);
+  return `Refusing to write ${kind} "${id}": ${problems.length === 1 ? "a type position is" : `${problems.length} type positions are`} not in the neutral type grammar. ${lines.join(" ")} Aliases (string[], T | null, boolean, Promise<T>, ...) are accepted and respelled; these forms have no canonical spelling.`;
+}
 function restatedSources(methods) {
   if (!Array.isArray(methods)) return [];
   return methods.filter((m) => m && typeof m === "object" && m.signatureFrom !== void 0 && (m.params !== void 0 || m.returns !== void 0)).map((m) => String(m.name));
@@ -36965,6 +38572,11 @@ function applyRestatement(restatement, loaded, parent) {
       `Refusing to write ${restatement.kind} "${String(candidate.id)}": ${unsigned.map((n) => `"${n}"`).join(", ")} ${unsigned.length === 1 ? "states" : "state"} neither params${restatement.kind === "interface" ? ", a signatureFrom" : ""} nor a prose signature, so nothing says what the method takes. Nothing was written.`
     );
   }
+  const types = canonicalTypesOf(restatement.kind, candidate);
+  if (types && types.problems.length) {
+    return refused(restatement, replacedExisting, `${typeProblemRefusal(restatement.kind, String(candidate.id), types.problems)} Nothing was written.`);
+  }
+  if (types) Object.assign(candidate, types.spec);
   const derivedNotices = deriveStatedTexts(restatement.kind, candidate);
   const labelErrors = resolveLabelsOf(restatement.kind, candidate);
   if (labelErrors.length) {
@@ -36978,7 +38590,8 @@ function applyRestatement(restatement, loaded, parent) {
     ...status.status ? { status: status.status } : {},
     replacedExisting,
     notices: [...existing ? rewriteNotices(restatement.kind, existing, candidate, carried, cleared) : [], ...derivedNotices],
-    changedMethods: changedMethodsOf(restatement.kind, existing, candidate)
+    changedMethods: changedMethodsOf(restatement.kind, existing, candidate),
+    respellings: types?.respellings ?? []
   };
 }
 var SPEC_SCHEMA = {
@@ -37017,7 +38630,7 @@ function parseCandidate(kind, candidate) {
   };
 }
 function refused(restatement, replacedExisting, refusal2) {
-  return { spec: restatement.spec, refusal: refusal2, replacedExisting, notices: [], changedMethods: [] };
+  return { spec: restatement.spec, refusal: refusal2, replacedExisting, notices: [], changedMethods: [], respellings: [] };
 }
 function statusForCreate(restatement, existing) {
   if (!STATUSED_KINDS.has(restatement.kind)) return {};
@@ -37162,6 +38775,7 @@ function writeSpec(restatement) {
     replacedExisting: application.replacedExisting,
     ...application.status ? { status: application.status } : {},
     notices: [...gateNotices, ...persisted.notices, ...application.notices],
+    respellings: application.respellings,
     testsToRevisit
   };
 }
@@ -37217,7 +38831,7 @@ function updateSpecGated(kind, id, delta, dryRun) {
   const bound2 = candidateOptions();
   const testRoots = bound2.rules?.conformance?.testRoots ?? [];
   const stored = loadSpec(kind, id);
-  const gate = componentCandidateGate(bound2, stored?.subsystem);
+  const gate = componentCandidateGate(bound2, stored?.subsystem, stored);
   const report2 = updateSpec(kind, id, delta, gate, dryRun);
   const changed = changedMethods(report2);
   if (changed.length > 0 && testRoots.length > 0) {
@@ -40641,7 +42255,7 @@ function errText(message) {
 function errMessage(e) {
   return errText(e instanceof Error ? e.message : String(e));
 }
-var TYPE_REF_GRAMMAR = (what) => `${what}: a primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice" or "billing::Invoice"). Generics, arrays and UNIONS are all read, at any depth: "Invoice | null" (the commonest shape there is), "Invoice | undefined", "Invoice | Receipt", "Promise<Invoice | null>", "Map<string, Invoice | null>", "Invoice[] | null", "(Invoice | null)[]". Every identifier the string names must resolve \u2014 a union of two defined types means BOTH must exist. A union of string literals ("read" | "write") names no type and resolves to nothing.`;
+var TYPE_REF_GRAMMAR = (what) => `${what}, in the neutral type grammar: a primitive (string, int, float, bool, bytes, date, datetime, duration, any; void only as a whole returns), a defined type id ("billing.Invoice", "alias::name"), list<T>, set<T>, map<K, V> (K is string, int or an enum), T? (T or no value), a union of NAMED types ("Invoice | Receipt"), and on a returns only, async T ("async void"). Every named type must resolve. TypeScript spellings are accepted and respelled \u2014 "Invoice[]" \u2192 list<Invoice>, "Invoice | null" \u2192 Invoice?, boolean \u2192 bool, Record<string, V> \u2192 map<string, V>, Promise<T> \u2192 async T \u2014 and the answer lists each respelling. Refused, naming the replacement: number ("int or float?"), inline object or function types (name a value-object or a signature type), string-literal unions (name an enum), and unions mixing in a primitive or a collection.`;
 function structured(content, data) {
   return { content: [{ type: "text", text: content }], structuredContent: data };
 }
@@ -40736,6 +42350,7 @@ function renderChangeReport(report2) {
   if (report2.strippedKeys?.length) {
     lines.push("", `DROPPED FROM THE STORED FILE (${report2.dryRun ? "would be " : ""}removed \u2014 the schema does not know them):`, ...report2.strippedKeys.map((k) => `- ${k}`));
   }
+  lines.push(...renderRespellings(report2.respellings));
   lines.push(...renderTestsToRevisit(report2.testsToRevisit));
   return lines.join("\n");
 }
@@ -40763,6 +42378,17 @@ function renderTestsToRevisit(entries) {
   }
   return lines;
 }
+var typeRespellingOutput = import_zod11.z.object({
+  specId: import_zod11.z.string().describe("The interface or type holding the position."),
+  kind: import_zod11.z.enum(["interface", "type"]).describe("interface | type."),
+  path: import_zod11.z.string().describe("Where in the spec: methods.save.params.key, methods.save.returns, fields.createdAt, params.listener."),
+  written: import_zod11.z.string().describe("The text the input (or the stored file) held."),
+  stored: import_zod11.z.string().describe("The canonical spelling, which is what is stored and shown.")
+});
+function renderRespellings(entries) {
+  if (!entries.length) return [];
+  return ["", "RESPELLED (stored canonical):", ...entries.map((r) => `- ${r.path}: "${r.written}" \u2192 "${r.stored}"`)];
+}
 var specWriteReceiptOutput = {
   kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
   id: import_zod11.z.string().describe('The id the spec is stored under; "system" for the L0 singleton.'),
@@ -40776,6 +42402,9 @@ var specWriteReceiptOutput = {
   notices: import_zod11.z.array(import_zod11.z.string()).describe(
     "The notice lines the text answer lists, one per entry: what was carried forward, what a restatement removed, what an omission cleared, and every gate warning the write raised. Empty for a clean create."
   ),
+  respellings: import_zod11.z.array(typeRespellingOutput).describe(
+    "Each type position the write normalised: what the input wrote against the canonical spelling stored. Aliases are accepted, never refused, and this list is how an author learns the canonical form. Empty when every position was already canonical."
+  ),
   testsToRevisit: testsToRevisitOutput,
   ...staleServerOutput
 };
@@ -40784,8 +42413,10 @@ function writeReceipt(sentence, receipt) {
 
 NOTICE:
 - ${receipt.notices.join("\n- ")}` : "";
+  const respelledBlock = renderRespellings(receipt.respellings).join("\n");
   const testsBlock = renderTestsToRevisit(receipt.testsToRevisit).join("\n");
-  return structured(`${sentence}${noticeBlock}${testsBlock ? `
+  return structured(`${sentence}${noticeBlock}${respelledBlock ? `
+${respelledBlock}` : ""}${testsBlock ? `
 ${testsBlock}` : ""}`, receipt);
 }
 var specDeletionOutput = {
@@ -40817,6 +42448,9 @@ var specChangeReportOutput = {
     "Every path the delta named that the write did not act on, each with why. Read it: a nested typo the permissive delta cannot refuse shows up here and nowhere else."
   ),
   notices: import_zod11.z.array(import_zod11.z.string()).describe("Store placement notices, gate warnings and delta notices."),
+  respellings: import_zod11.z.array(typeRespellingOutput).describe(
+    "Each type position the write normalised (or, on a dry run, would): what the delta or the stored file wrote against the canonical spelling stored. Aliases are accepted and respelled, never refused \u2014 this is how the canonical form is taught. Empty when every position was already canonical."
+  ),
   summary: import_zod11.z.string().describe("One line for people."),
   testsToRevisit: testsToRevisitOutput,
   strippedKeys: import_zod11.z.array(import_zod11.z.string()).optional().describe(
@@ -41016,46 +42650,46 @@ function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
   const known = seen.get(schema);
   if (known !== void 0) return { ref: known };
   seen.set(schema, seen.size);
-  const inner = (s) => schemaShape(s, seen);
+  const inner2 = (s) => schemaShape(s, seen);
   const kind = String(def.typeName);
   switch (kind) {
     case "ZodObject": {
       const shape = typeof def.shape === "function" ? def.shape() : def.shape;
       return {
         kind,
-        keys: Object.keys(shape).sort().map((key) => [key, inner(shape[key])]),
+        keys: Object.keys(shape).sort().map((key) => [key, inner2(shape[key])]),
         unknownKeys: def.unknownKeys,
-        catchall: inner(def.catchall)
+        catchall: inner2(def.catchall)
       };
     }
     case "ZodArray":
-      return { kind, of: inner(def.type), min: def.minLength?.value, max: def.maxLength?.value };
+      return { kind, of: inner2(def.type), min: def.minLength?.value, max: def.maxLength?.value };
     case "ZodOptional":
     case "ZodNullable":
     case "ZodReadonly":
     case "ZodBranded":
     case "ZodCatch":
-      return { kind, of: inner(def.innerType ?? def.type) };
+      return { kind, of: inner2(def.innerType ?? def.type) };
     case "ZodDefault":
-      return { kind, of: inner(def.innerType), default: JSON.stringify(def.defaultValue?.()) };
+      return { kind, of: inner2(def.innerType), default: JSON.stringify(def.defaultValue?.()) };
     case "ZodEffects":
-      return { kind, effect: def.effect?.type, of: inner(def.schema) };
+      return { kind, effect: def.effect?.type, of: inner2(def.schema) };
     case "ZodLazy":
-      return { kind, of: inner(def.getter()) };
+      return { kind, of: inner2(def.getter()) };
     case "ZodUnion":
     case "ZodDiscriminatedUnion": {
       const options = def.options instanceof Map ? [...def.options.values()] : def.options;
-      return { kind, discriminator: def.discriminator, of: options.map(inner) };
+      return { kind, discriminator: def.discriminator, of: options.map(inner2) };
     }
     case "ZodIntersection":
-      return { kind, left: inner(def.left), right: inner(def.right) };
+      return { kind, left: inner2(def.left), right: inner2(def.right) };
     case "ZodTuple":
-      return { kind, of: def.items.map(inner), rest: inner(def.rest) };
+      return { kind, of: def.items.map(inner2), rest: inner2(def.rest) };
     case "ZodRecord":
     case "ZodMap":
-      return { kind, key: inner(def.keyType), value: inner(def.valueType) };
+      return { kind, key: inner2(def.keyType), value: inner2(def.valueType) };
     case "ZodSet":
-      return { kind, of: inner(def.valueType) };
+      return { kind, of: inner2(def.valueType) };
     case "ZodEnum":
       return { kind, values: def.values };
     case "ZodNativeEnum":
@@ -41063,7 +42697,7 @@ function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
     case "ZodLiteral":
       return { kind, value: def.value };
     case "ZodPipeline":
-      return { kind, in: inner(def.in), out: inner(def.out) };
+      return { kind, in: inner2(def.in), out: inner2(def.out) };
     default:
       return { kind, checks: def.checks?.map((c) => [c.kind, c.value ?? null]) ?? [] };
   }
@@ -41791,7 +43425,7 @@ ${renderChangeReport(report2)}`,
     type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The parameter's type")),
     description: import_zod11.z.string().optional(),
     optional: import_zod11.z.boolean().optional().describe(
-      'Whether the parameter may be OMITTED by a caller. It is not nullability: a parameter that must be passed but may be passed as nothing is a required parameter whose type is a union \u2014 "ProjectConfig | null". Say whichever is true; they are different contracts.'
+      'Whether the parameter may be OMITTED by a caller. It is not nullability: a parameter that must be passed but may be passed as nothing is a required parameter whose type says so \u2014 "ProjectConfig?". Say whichever is true; they are different contracts (both together: may be left out, and may be none).'
     )
   }).strict();
   const interfaceMethodShape = {
@@ -41806,7 +43440,7 @@ ${renderChangeReport(report2)}`,
     ),
     params: import_zod11.z.array(methodParamItem).optional().describe("Structured parameters \u2014 authoritative for type checking, and the signature text is derived from them. Strongly preferred."),
     guarantees: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
-    effect: import_zod11.z.enum(["read", "write"]).optional().describe("State-effect direction on the component's held state \u2014 required on a durable Store's contract methods so the durability round-trip rule can pair writes with hydration read-backs"),
+    effect: import_zod11.z.enum(["read", "write", "lifecycle"]).optional().describe("What the method does to the component's held state: read observes it; write modifies an entity's domain fields; lifecycle creates, destroys, or (un)registers an entity's existence or membership without modifying its fields, and calls only read and lifecycle methods (LIFECYCLE_CALLS_WRITE). Required on a durable Store's contract methods so the durability round-trip rule can pair mutations with hydration read-backs; a Supervisor may call a data component it does not own only through read and lifecycle methods (SUPERVISOR_WRITE_SHORTCUT)"),
     invokedBy: import_zod11.z.object({
       kind: import_zod11.z.enum(["runtime", "external", "sibling-subsystem"]).describe("Who owns the out-of-graph invocation: runtime (timer/signal/shutdown hook), external (a system outside this project), sibling-subsystem (a modeled sibling whose edge is not narrated here)"),
       caller: import_zod11.z.string().optional().describe("WHO invokes it and when, as reviewable prose \u2014 missing or placeholder-thin prose is INVOKED_BY_UNDESCRIBED")
@@ -42040,7 +43674,7 @@ ${renderChangeReport(report2)}`,
     }
   );
   const typeInput = {
-    kind: import_zod11.z.enum(["entity", "value-object", "signature"]).describe("entity (owned by a subsystem), value-object (often system-level shared), or signature \u2014 a named function type: params and returns, nothing else"),
+    kind: import_zod11.z.enum(["entity", "value-object", "signature", "enum"]).describe("entity (owned by a subsystem), value-object (often system-level shared), signature \u2014 a named function type: params and returns, nothing else \u2014 or enum: a closed, ordered set of named values"),
     id: import_zod11.z.string().describe("Lowercase identifier"),
     name: import_zod11.z.string().describe("Human-readable name"),
     description: import_zod11.z.string().optional(),
@@ -42074,18 +43708,23 @@ ${renderChangeReport(report2)}`,
     sourcePath: import_zod11.z.string().optional().describe("Source file holding the declaration of this type (project-relative). Naming one turns the type into a claim on code: the file must resolve and the declaration must be anchored in it (UNREALIZED_TYPE)"),
     symbol: import_zod11.z.string().optional().describe('Code-level name realizing the declaration when it differs from name, e.g. a type named "Invoice Line" declared as InvoiceLine'),
     params: import_zod11.z.array(methodParamItem).optional().describe("kind signature only: the function type's parameters, in declared order (SIGNATURE_TYPE_MEMBERS on any other kind)"),
-    returns: import_zod11.z.string().optional().describe(TYPE_REF_GRAMMAR("kind signature only, and required there: the function type's one output"))
+    returns: import_zod11.z.string().optional().describe(TYPE_REF_GRAMMAR("kind signature only, and required there: the function type's one output")),
+    values: import_zod11.z.array(import_zod11.z.object({
+      name: import_zod11.z.string().min(1).describe(`The value's name, exactly as data carries it ("stable", "local_only")`),
+      description: import_zod11.z.string().optional().describe("What the value means")
+    }).strict()).optional().describe("kind enum only, and required there: the values in declared order \u2014 the order is part of the design (a narrowest-first track list means something). Unique by name ignoring case and separators; no ordinals and no separate wire value"),
+    holds: import_zod11.z.string().optional().describe('kind value-object only: makes it a NAMED SCALAR \u2014 one primitive under a name (string, int, float, bool, bytes, date, datetime or duration), a newtype or type alias in every language (`type PackPath = string`), declared in place of fields. Not a union, not a named type, not any; fields beside it, or holds on another kind, is NAMED_SCALAR_MEMBERS. Aliases are respelled (boolean \u2192 bool) and number is refused ("int or float?")')
   };
   const typeInputFields = Object.keys(typeInput);
   reg(
     server,
     "sdd_add_type",
     {
-      description: "Define a type: an entity or value-object (the data components operate on), or a signature \u2014 a named function type. Entities are owned by a subsystem; shared value objects and signatures omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument \u2014 and a type method may carry structured params, which then derive its signature text as a contract method's do. A signature carries top-level params and returns and nothing else (no fields, methods or invariants \u2014 SIGNATURE_TYPE_MEMBERS); a contract method takes it by naming it as its signatureFrom, and a param may be typed by one (a callback). A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. An owning subsystem the tree does not have is refused, writing nothing, exactly as a component under an unknown subsystem is. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
+      description: "Define a type: an entity or value-object (the data components operate on), a signature \u2014 a named function type \u2014 or an enum: a closed, ordered set of named `values` ({name, description?}, unique by name ignoring case and separators; the name is also the value as data carries it), with optional pure methods and nothing else (no fields, params or returns). A value-object may instead be a NAMED SCALAR: it `holds` one primitive in place of fields (a newtype or type alias in every language). Every type position (a field's type, a method's params and returns, a signature's params and returns, a named scalar's holds) is written in the neutral type grammar; aliases are respelled and listed in the receipt. Entities are owned by a subsystem; shared value objects and signatures omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument \u2014 and a type method may carry structured params, which then derive its signature text as a contract method's do. A signature carries top-level params and returns and nothing else (no fields, methods or invariants \u2014 SIGNATURE_TYPE_MEMBERS); a contract method takes it by naming it as its signatureFrom, and a param may be typed by one (a callback). A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. An owning subsystem the tree does not have is refused, writing nothing, exactly as a component under an unknown subsystem is. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
       inputSchema: typeInput,
       outputSchema: specWriteReceiptOutput
     },
-    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol, params, returns }) => {
+    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol, params, returns, values, holds }) => {
       try {
         const spec = {
           kind,
@@ -42111,7 +43750,9 @@ ${renderChangeReport(report2)}`,
           ...sourcePath ? { sourcePath } : {},
           ...symbol ? { symbol } : {},
           ...params ? { params } : {},
-          ...returns ? { returns } : {}
+          ...returns ? { returns } : {},
+          ...values ? { values } : {},
+          ...holds ? { holds } : {}
         };
         const receipt = writeSpec({ kind: "type", spec, fields: typeInputFields });
         return writeReceipt(
@@ -42144,7 +43785,8 @@ ${renderChangeReport(report2)}`,
           rules: config.rules,
           projectType: config.projectType,
           scopeSubsystem: subsystem,
-          recursive: recursive ?? true,
+          // The tool's flag at the edge: recursive false is a member depth of 0.
+          ...recursive === false ? { memberDepth: 0 } : {},
           family
         };
         const result = selectsFamily(options2, declaredMembers(config).length > 0) ? validateFamily(options2) : validateProject(options2);
@@ -42279,7 +43921,7 @@ ${testsBlock}` : ""}`, deletion);
     server,
     "sdd_update_spec",
     {
-      description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Pass dryRun to be told what it would do without writing it.",
+      description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Type positions (the type of a param, a returns, the type of a field, the params and returns of a signature) are written in the neutral type grammar: an alias the delta writes (string[], T | null, boolean, Promise<T>) is stored canonical and listed under `respellings`, and a stored alias at a position the write keeps is respelled with it; a position the delta writes that has no canonical spelling (number \u2014 int or float?, an inline object or function type, a literal union, a union mixing in a primitive) is refused, naming the replacement, while one the stored spec already held is left alone. Pass dryRun to be told what it would do without writing it.",
       inputSchema: {
         kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project export table, each entry a re-export {from, component, interface, typeDef, as, name, type, details, audience: project|department|instance|partner|external} \u2014 from alone re-exports everything a subsystem exports, and a legacy {id, subsystem} reads as {as, from})"),
         id: import_zod11.z.string().describe("The ID of the spec to update (namespaced if needed)"),
@@ -42308,18 +43950,19 @@ ${testsBlock}` : ""}`, deletion);
       }
     },
     ({ subsystem, recursive }) => {
+      const memberDepth = recursive === false ? 0 : void 0;
       const banner = pendingBanner().map((line) => `\u26A0 TRANSACTION PENDING: ${line}
 `).join("");
       try {
         let approvals;
         try {
-          approvals = familyApprovals(recursive === false ? 0 : void 0);
+          approvals = familyApprovals(memberDepth);
         } catch {
           approvals = void 0;
         }
         const report2 = getStatusReport({
           subsystem,
-          recursive: recursive ?? true,
+          memberDepth,
           approvals
         });
         const family = statusFamilyContext();
@@ -42414,7 +44057,6 @@ function loadProjectConfig3() {
   AgentTemplateSchema,
   BACKEND_COMMANDS,
   BUILTIN_PROFILES,
-  BUILTIN_TYPES,
   BoundaryItemSchema,
   BuiltinTargetConfigSchema,
   BuiltinTargetSchema,
@@ -42448,6 +44090,7 @@ function loadProjectConfig3() {
   DurabilitySchema,
   EXTERNAL_ALIAS_RE,
   EndpointSchema,
+  EnumValueSchema,
   EventBindingSchema,
   ExtDataSchema,
   ExternalDeclarationSchema,
@@ -42462,6 +44105,7 @@ function loadProjectConfig3() {
   GeminiExporter,
   GroupSpecSchema,
   GuaranteeSchema,
+  HOLDABLE_PRIMITIVES,
   HttpMethodSchema,
   ImplementationSpecSchema,
   InterfaceSpecSchema,
@@ -42481,6 +44125,7 @@ function loadProjectConfig3() {
   NarrativeStepTypeSchema,
   OutputTargetSchema,
   PATTERN_TYPES,
+  PRIMITIVE_TYPES,
   PROJECT_ID_RE,
   PROJECT_KINDS,
   PUBLIC_NAME_RE,
@@ -42568,6 +44213,7 @@ function loadProjectConfig3() {
   buildRuleContext,
   callSitesOf,
   canonicalTypeRef,
+  canonicalTypeText,
   captureApprovedSpecs,
   checkDeclarativePack,
   clearLoaderIssues,
@@ -42612,6 +44258,7 @@ function loadProjectConfig3() {
   detectDomainCandidates,
   diagnoseProjectPacks,
   diagramSetIndex,
+  dialectOf,
   diffAgainstApproval,
   diffSize,
   discoverPacks,
@@ -42619,6 +44266,7 @@ function loadProjectConfig3() {
   effectiveDetail,
   effectiveProjectId,
   emptyExtensions,
+  emptyTypeSpellingFacts,
   ensureDir,
   ensureProjectInitialized,
   excerptParent,
@@ -42665,6 +44313,7 @@ function loadProjectConfig3() {
   importSpecTree,
   injectGuide,
   installPackFromDirectory,
+  interfaceCanonicalTypes,
   interfaceGenericParameters,
   internalizeMember,
   isDraftSubsystem,
@@ -42676,9 +44325,11 @@ function loadProjectConfig3() {
   isProjectInitialized,
   isProvidedBy,
   isRetired,
+  isTypeVocabulary,
   judgesCode,
   keyIn,
   landReference,
+  languageOfSourcePath,
   listDirectChainedSubprojects,
   listFiles,
   listFilesRecursive,
@@ -42721,6 +44372,7 @@ function loadProjectConfig3() {
   moveMethods,
   moveMountToMembers,
   nameKey,
+  namesAnInteger,
   narrativeStepForeignFields,
   normalizeReferences,
   ownerOf,
@@ -42732,6 +44384,8 @@ function loadProjectConfig3() {
   parseDeclarativePack,
   parseDeclaredCall,
   parseMemberSource,
+  parseTypeExpression,
+  parseTypePosition,
   parseYaml,
   passesIntentFloor,
   pathExists,
@@ -42745,6 +44399,7 @@ function loadProjectConfig3() {
   provisionProject,
   qualifiedTypeId,
   rangeProblem,
+  readCodeAnnotation,
   readFileOrNull,
   readJsonFile,
   readLockRecord,
@@ -42767,6 +44422,7 @@ function loadProjectConfig3() {
   renderDiagram,
   repairForeignStepFields,
   repairSignatures,
+  repairTypeSpellings,
   repointExternal,
   requiredPolicies,
   resolveAgentTopology,
@@ -42814,9 +44470,15 @@ function loadProjectConfig3() {
   technologyTokens,
   toMarkdown,
   typeBindingOf,
+  typeCanonicalTypes,
+  typeDialectFor,
   typeGenericParameters,
+  typeIsMany,
   typeMatchesRef,
+  typeNamedRefs,
+  typeProblemIntProposal,
   typeSourceFiles,
+  typeSpellingFacts,
   uninstallPack,
   updateMember,
   updateSpec,
@@ -42831,6 +44493,7 @@ function loadProjectConfig3() {
   writeReachDenials,
   writeReachPermits,
   writeRootGuideDelegator,
-  writeYamlFile
+  writeYamlFile,
+  writtenTypeRefs
 });
 //# sourceMappingURL=index.js.map