@githolon/dsl 0.103.12 → 0.103.13

package/src/compile_package_main.ts

@@ -63,6 +63,7 @@ import {
   type PermissionVocabulary,
 } from "./codegen_dart.js";
 import type { ContractHandle } from "./contract.js";
+import { bindEnumTypeExports } from "./enum_type.js";
 import { generateDartBridgeClient } from "./codegen_dart_client.js";
 import {
   dartApplicationClassName,
@@ -179,10 +180,11 @@ import {
 import {
   validateNomosPackageConfig,
   type NomosPackageConfig,
-  type NomosPackageDomainConfig,
+  type NormalizedNomosPackageDomainConfig,
 } from "./package_config.js";
 import { assertUsdaRelationshipIntegrity } from "./usda_relationship_integrity.js";
 import { assertPublicPackageImports } from "./package_source_imports.js";
+import { assertPackageFeatureTopology } from "./package_feature_topology.js";
 import { packageDependencyUsageFindings } from "./package_dependency_usage.js";
 import {
   PlanSourceSliceProgram,
@@ -224,7 +226,7 @@ const BUSINESS_BIRTH_FRAMEWORK_PLAN_SOURCES: Readonly<Record<string, PlanSourceS
 };
 const BUSINESS_BIRTH_FRAMEWORK_PLAN_DOMAIN = "__nomos_birth_genesis_plan_v1";
 
-interface DomainConfig extends NomosPackageDomainConfig {
+interface DomainConfig extends NormalizedNomosPackageDomainConfig {
   readonly key: string;
   readonly name?: string;
   readonly modules: readonly string[];
@@ -821,7 +823,7 @@ const DART_SUPPORT_CORE_SRC = [
   "foreign_ref.dart",
   "activity.dart",
   "nomos_ref.dart",
-  // Immutable publication pin + stable series and the required freshness sum
+  // Immutable publication pin + stable series and the required version-status sum
   // type. Pure data; the generated application owns the effectful check.
   "versioned_nomos_ref.dart",
   // Optional first-class references are explicit required choices in generated
@@ -1583,8 +1585,8 @@ function emitDart(
     // The generated clients import their runtime support directly. Keeping it out of the public barrel is
     // the surface firewall: a tenant import receives business types and application APIs, never raw runtime.
     supportImport === "vendored"
-      ? `export '${genRel}/src/${VENDORED_TYPES_SHIM}' show NomosRef, NomosOptionalRef, VersionedNomosRef, ReferenceFreshness, ReferenceCurrent, ReferenceStale, ReferenceFreshnessUnavailable${sha256DigestExport}${gitObjectIdExport};`
-      : `export 'package:nomos_types/nomos_types.dart' show NomosRef, NomosOptionalRef, VersionedNomosRef, ReferenceFreshness, ReferenceCurrent, ReferenceStale, ReferenceFreshnessUnavailable${sha256DigestExport}${gitObjectIdExport};`,
+      ? `export '${genRel}/src/${VENDORED_TYPES_SHIM}' show NomosRef, NomosOptionalRef, VersionedNomosRef, ReferenceVersionStatus, ReferenceVersionCurrent, ReferenceVersionOutdated, ReferenceVersionUnavailable${sha256DigestExport}${gitObjectIdExport};`
+      : `export 'package:nomos_types/nomos_types.dart' show NomosRef, NomosOptionalRef, VersionedNomosRef, ReferenceVersionStatus, ReferenceVersionCurrent, ReferenceVersionOutdated, ReferenceVersionUnavailable${sha256DigestExport}${gitObjectIdExport};`,
     ...(contractsImportUri !== undefined
       ? tenantDartExport(`${genRel}/${CONTRACTS_FILE}.dart`, sourceByFile.get(CONTRACTS_FILE) ?? "")
       : []),
@@ -1650,8 +1652,8 @@ const NOMOS_TYPES_DEP = "^0.8.4";
 // 0.48.x: session-bound clients (XClient.bind/NomosClientInterface/DomainClientSessionMismatch/
 //         DomainNotInstalledForSession, engine.follow, pendingConflicts lanes) — the generated client
 //         REQUIRES this surface. 0.48.1 fixes NomosSession.watchPendingConflicts delegation.
-const NOMOS_CLIENT_DEP = "^0.64.13";
-const NOMOS_FLUTTER_DEP = "^0.63.16";
+const NOMOS_CLIENT_DEP = "^0.64.14";
+const NOMOS_FLUTTER_DEP = "^0.63.17";
 // DRIFT TRIPWIRE: pubspec_pins.test.ts asserts these equal the CURRENT versions in dsl/dart/pubspec.yaml
 // and dsl/dart_types/pubspec.yaml — a Dart release without this bump fails the suite, so tenants never
 // land back in dependency_overrides (the exact co2 report this closes, third occurrence).
@@ -2028,9 +2030,22 @@ function dartAliasLines(names: Readonly<Record<string, string>> | undefined, dec
   ];
   for (const [generated, alias] of Object.entries(names).sort(([a], [b]) => (a < b ? -1 : 1))) {
     if (!declared.has(generated)) {
+      const semanticTail = generated.match(/[A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)?$/u)?.[0];
+      const nearby = [...declared]
+        .filter((name) =>
+          name.includes("AssetFieldRequirement") ||
+          (generated.endsWith("FieldType") && name.endsWith("FieldType")) ||
+          (semanticTail !== undefined && name.endsWith(semanticTail)))
+        .sort((left, right) => {
+          const leftExactKind = generated.endsWith("FieldType") && left.endsWith("FieldType") ? 0 : 1;
+          const rightExactKind = generated.endsWith("FieldType") && right.endsWith("FieldType") ? 0 : 1;
+          return leftExactKind - rightExactKind || left.localeCompare(right);
+        })
+        .slice(0, 20);
       fail(
         `dart.names: '${generated}' is not a generated public type in this package's TYPES surface — ` +
-          `check the spelling against the emitted src/generated/*.dart (aliases cover types, not client classes)`,
+          `check the spelling against the emitted src/generated/*.dart (aliases cover types, not client classes)` +
+          (nearby.length === 0 ? "" : `; nearby generated types: ${nearby.join(", ")}`),
       );
     }
     if (!/^[A-Z][A-Za-z0-9_]*$/.test(alias)) {
@@ -2294,7 +2309,18 @@ function emitDartPackages(
       ...(dd.modForDart.dartImports ?? []),
       ...[...frImports].filter((uri) => !(dd.modForDart.dartImports ?? []).some((i) => i.uri === uri)).sort().map((uri) => ({ uri })),
     ];
-    const modForTypes = merged.length > 0 ? { ...dd.modForDart, dartImports: merged } : dd.modForDart;
+    const typedDomain = merged.length > 0
+      ? { ...dd.modForDart, dartImports: merged }
+      : dd.modForDart;
+    // A capability declaration is canonical law, but its provider dispatcher is
+    // effectful runtime machinery (TaskProvider, HostClock, NomosIntent). Layered
+    // packages deliberately keep the types package pure, so never inject that
+    // adapter into a frontend data library merely because the law can emit an
+    // obligation. Provider SDKs belong to an explicitly selected provider target;
+    // flat/legacy generation retains its existing opt-in behavior.
+    const modForTypes = (typedDomain.impureCapabilities?.length ?? 0) === 0
+      ? typedDomain
+      : { ...typedDomain, impureCapabilities: [] };
     writeTypes(
       mod.name,
       generateDartDomain(modForTypes, {
@@ -2372,7 +2398,7 @@ function emitDartPackages(
     businessSharedPath,
     [
       "// GENERATED by nomos-compile — shared business values and activity; no runtime machinery.",
-      `export 'package:nomos_types/nomos_types.dart' show NomosRef, NomosOptionalRef, VersionedNomosRef, ReferenceFreshness, ReferenceCurrent, ReferenceStale, ReferenceFreshnessUnavailable${sha256DigestExport}${gitObjectIdExport}, Identity, User, Recipient, Invitation, ActivityEvent, ActivityRef, ActivitySeverity, SurfacedObservation, SurfacedValue, SurfacedResolved, SurfacedPending, SurfacedEvolutionRequired;`,
+      `export 'package:nomos_types/nomos_types.dart' show NomosRef, NomosOptionalRef, VersionedNomosRef, ReferenceVersionStatus, ReferenceVersionCurrent, ReferenceVersionOutdated, ReferenceVersionUnavailable${sha256DigestExport}${gitObjectIdExport}, Identity, User, Recipient, Invitation, ActivityEvent, ActivityRef, ActivitySeverity, SurfacedObservation, SurfacedValue, SurfacedResolved, SurfacedPending, SurfacedEvolutionRequired;`,
       ...(sharedBusinessTypeNames.length === 0
         ? []
         : [`export '${FRAMEWORK_FILE}.dart' show ${sharedBusinessTypeNames.join(", ")};`]),
@@ -2870,13 +2896,31 @@ async function main(): Promise<void> {
   if (Object.prototype.hasOwnProperty.call(cfg, "layered")) {
     fail("nomos.project.ts no longer accepts 'layered': every law closure is layered, with no alternate compile lane");
   }
+  let sourceTopologyDiagnostics: ReturnType<typeof assertPackageFeatureTopology> = [];
   try {
+    sourceTopologyDiagnostics = assertPackageFeatureTopology(cfg.domains, cfgDir);
     assertPublicPackageImports(
       cfg.domains.flatMap((domain) => domain.modules.map((module) => path.resolve(cfgDir, module))),
     );
   } catch (error) {
     fail(`package import boundary refused: ${(error as Error).message}`);
   }
+  if (sourceTopologyDiagnostics.length > 0) {
+    const heading =
+      `nomos-compile: ${sourceTopologyDiagnostics.length} unacknowledged source-shape warning(s)`;
+    const lines = sourceTopologyDiagnostics.map((diagnostic) =>
+      `  ⚠ [${diagnostic.rule}] ${diagnostic.domain}/${diagnostic.feature} ` +
+        `${diagnostic.source}: ${diagnostic.message} — fix: ${diagnostic.fix}`
+    );
+    if (preflightFlag) {
+      console.error(`${heading}; preflight requires an explicit fix or per-file acknowledgement`);
+      for (const line of lines) console.error(line);
+      process.exitCode = 1;
+      return;
+    }
+    console.warn(heading);
+    for (const line of lines) console.warn(line);
+  }
   // EVERY PUBLISHED APPLICATION IS A COMPLETE PRODUCT ENTRYPOINT. `rootPart` is the explicit OpenUSD
   // application/package boundary: only that independently published root privately receives the authority
   // bootstrap law which turns verified credential evidence into durable device authorship. Ordinary law
@@ -2920,6 +2964,7 @@ async function main(): Promise<void> {
       const abs = path.resolve(cfgDir, rel);
       if (!existsSync(abs)) fail(`domain '${domain.key}': module not found: ${abs}`);
       const imported = await import(pathToFileURL(abs).href) as Mod;
+      bindEnumTypeExports(imported, abs);
       authored = { ...authored, ...imported };
       for (const [exportName, value] of Object.entries(imported)) {
         if (value !== cfg.application?.homeGenesis || !isApplicationHomeGenesis(value)) continue;
@@ -2949,6 +2994,10 @@ async function main(): Promise<void> {
       ? []
       : [{
           key: APPLICATION_HOME_DOMAIN,
+          features: [{
+            key: "application-home",
+            modules: [path.join(DSL_DIR, "src", "framework", "application_home.ts")],
+          }],
           modules: [path.join(DSL_DIR, "src", "framework", "application_home.ts")],
         }]),
   ];
@@ -3088,6 +3137,7 @@ async function main(): Promise<void> {
       const abs = path.resolve(cfgDir, rel);
       if (!existsSync(abs)) fail(`domain '${d.key}': module not found: ${abs}`);
       const m = (await import(pathToFileURL(abs).href)) as Mod;
+      bindEnumTypeExports(m, abs);
       mods.push(m);
       sourceExprs.push(`() => require(${JSON.stringify(abs)})`);
       for (const [exportName, value] of Object.entries(m)) {
@@ -4055,9 +4105,15 @@ async function main(): Promise<void> {
     planInputDigestCache.set(absolute, digest);
     return digest;
   };
+  const planSourceSliceImplementation = fileURLToPath(new URL("./plan_source_slice.ts", import.meta.url));
   const planCompilerIdentity = planBytesDigest(Buffer.concat([
     Buffer.from("nomos.plan-compiler.v1\0", "utf8"),
     readFileSync(fileURLToPath(import.meta.url)),
+    // The slicer decides which bindings and imports enter every cached plan. A slicer fix without
+    // this input otherwise replays bytecode produced by the old dependency closure indefinitely.
+    ...(existsSync(planSourceSliceImplementation)
+      ? [Buffer.from("\0plan-source-slice\0", "utf8"), readFileSync(planSourceSliceImplementation)]
+      : []),
     Buffer.from(`\0esbuild:${esbuildMod.version}\0`, "utf8"),
   ]));
   let planSequence = 0;
@@ -5039,6 +5095,7 @@ async function main(): Promise<void> {
   const requiresKernel = ((): string[] => {
     const probes: FeatureProbeModule[] = domainModules.map((m) => ({
       ...(m.queries ? { queries: m.queries } : {}),
+      ...(m.deriveds ? { deriveds: m.deriveds } : {}),
       ...(m.surfacedResolvers ? { surfacedResolvers: m.surfacedResolvers } : {}),
       ...(m.aggregates ? { aggregates: m.aggregates } : {}),
     }));
@@ -5177,7 +5234,7 @@ async function main(): Promise<void> {
   const temporaryDeclarationPath = temporaryClientPath.replace(/\.ts$/, ".d.ts");
   const runtimeTypesSource = [
     `export declare function nomosInternalOpenGeneratedApplication<T extends object>(`,
-    `  options: { cloud: string; application: string; signIn: (request?: { readonly deviceChallenge?: string }) => Promise<string>; onPerformance?: (sample: { readonly operation: "open" | "offer" | "birth" | "read" | "sync" | "maintenance"; readonly name: string; readonly durationMs: number; readonly domain?: string; readonly directive?: string }) => void; lawHash: string },`,
+    `  options: { cloud: string; application: string; signIn: (request?: { readonly deviceChallenge?: string }) => Promise<string>; onPerformance?: (sample: { readonly operation: "open" | "offer" | "birth" | "read" | "sync" | "maintenance"; readonly name: string; readonly durationMs: number; readonly domain?: string; readonly directive?: string }) => void; lawHash: string; readyCommands?: readonly { readonly domain: string; readonly packageHash: string; readonly directiveId: string }[] },`,
     `  bind: (holon: unknown, user: { readonly identityId: string; readonly identityAddress: string }) => T,`,
     `): Promise<T & {`,
     `  currentStatus(): Promise<any>;`,

package/src/derived.ts

@@ -33,6 +33,7 @@
  */
 import type { z } from "zod";
 import type { AggregateHandle } from "./aggregate.js";
+import type { TemporalEnumTransition } from "./fields.js";
 
 /**
  * The pure derive function: maps ONE aggregate's folded fields (a plain JSON object — the
@@ -59,6 +60,22 @@ export interface DerivedDecl {
   readonly fn: DeriveFn;
 }
 
+/** A clock-aware enum projection compiled entirely as typed data and evaluated natively by the
+ * kernel. It deliberately has no function body: source, missing state and monotone thresholds are
+ * the complete executable algebra. Instances are synthesized from `t.timestamp().temporalEnum(...)`. */
+export interface TemporalEnumDecl {
+  readonly kind: "temporalEnum";
+  readonly id: string;
+  readonly of: string;
+  readonly sourceField: string;
+  readonly missing: string;
+  readonly initial: string;
+  readonly transitions: readonly TemporalEnumTransition[];
+  readonly returns: z.ZodTypeAny;
+}
+
+export type AnyDerivedDecl = DerivedDecl | TemporalEnumDecl;
+
 /**
  * The {@link DerivedOf} BUILDER: it has named its `of`-type, so `.as(...)` (which fixes
  * the pure fn and yields the finished {@link DerivedDecl}) is available. This is the ONLY

package/src/directive.ts

@@ -24,6 +24,7 @@ import type { Ports } from "./ctx.js";
 import type { RelationDecl } from "./relation.js";
 import type { QueryDecl } from "./query.js";
 import { normalizeActivity, type ActivityInput, type ActivityDescriptor } from "./activity.js";
+import { idOfMetaOf } from "./value_object.js";
 import { BIRTH_METER_QUERIES } from "./birth_meter.js";
 import { zodDef, zodKind, zodObjectShape } from "./zod_introspection.js";
 import {
@@ -50,6 +51,16 @@ import {
 
 export type ReferentialMarker = "creates" | "mutates" | "ensures" | "archives";
 
+/**
+ * The existing record selected by a mutation/archive. This is application-shape
+ * metadata, not law: custody still carries the ordinary typed payload field,
+ * while generated clients expose the reference separately from business facts.
+ */
+export interface DirectiveTargetBinding {
+  readonly field: string;
+  readonly aggregateId: string;
+}
+
 /**
  * A DECLARATIVE WRITE-PATH PRECONDITION (the precondition-primitives arc). One descriptor per
  * `.requiresExisting` / `.creates(Agg).payload(...).withId(idFn)` create-once / `.where` marker on a directive. Each
@@ -217,6 +228,8 @@ export interface Directive<P = unknown> {
   readonly manifestOnly?: true;
   /** Typed declaration target retained for compiler composition; omitted by every wire/law serializer. */
   readonly aggregate?: AggregateHandle;
+  /** Generated-API target binding. Omitted from canonical law/wire output. */
+  readonly targetBinding?: DirectiveTargetBinding;
   /**
    * Business-result cardinality for the primary marker target. The default is
    * exactly one; `.affectsMany()` and `.affectsOptional()` opt into the other
@@ -795,6 +808,7 @@ class DirectivePlanStep<Id extends string, P> {
     private readonly payloadSchema: z.ZodType<P>,
     private readonly createOnceIdField?: (payload: unknown) => string,
     private readonly preconditions: PreconditionDescriptor[] = [],
+    private readonly targetField?: string,
   ) {}
 
   /** Non-destructive copy carrying one more precondition (and/or the create-once id field). */
@@ -809,6 +823,38 @@ class DirectivePlanStep<Id extends string, P> {
       this.payloadSchema,
       createOnceIdField ?? this.createOnceIdField,
       desc !== undefined ? [...this.preconditions, desc] : this.preconditions,
+      this.targetField,
+    );
+  }
+
+  /**
+   * Select the existing aggregate reference targeted by this mutation/archive.
+   * Normally unnecessary: a single top-level `idOf(Target)` field is inferred.
+   * Use this only when the payload carries more than one reference to the same
+   * aggregate and the compiler cannot choose without domain knowledge.
+   */
+  target<K extends Extract<keyof P, string>>(field: K): DirectivePlanStep<Id, P> {
+    if (this.marker !== "mutates" && this.marker !== "archives") {
+      throw new Error(
+        `directive('${this.id}').target(...) is only valid on .mutates(...) or .archives(...)`,
+      );
+    }
+    const shape = zodObjectShape(this.payloadSchema);
+    const schema = shape[field];
+    const actual = schema === undefined ? undefined : idOfMetaOf(schema);
+    if (actual !== this.aggregate.id) {
+      throw new Error(
+        `directive('${this.id}').target('${field}') must name an idOf(${shortName(this.aggregate.id)}) payload field`,
+      );
+    }
+    return new DirectivePlanStep(
+      this.id,
+      this.marker,
+      this.aggregate,
+      this.payloadSchema,
+      this.createOnceIdField,
+      this.preconditions,
+      field,
     );
   }
 
@@ -968,10 +1014,28 @@ class DirectivePlanStep<Id extends string, P> {
         ...this.preconditions.slice(0, -1),
         { ...last, declassify: trimmed },
       ],
+      this.targetField,
     );
   }
 
   plan(fn: (payload: P, ctx: Ports) => PlannedOp[]): RequirableDirective<P> {
+    let targetBinding: DirectiveTargetBinding | undefined;
+    if (this.marker === "mutates" || this.marker === "archives") {
+      const shape = zodObjectShape(this.payloadSchema);
+      const candidates = Object.entries(shape)
+        .filter(([, schema]) => idOfMetaOf(schema) === this.aggregate.id)
+        .map(([field]) => field);
+      const field = this.targetField ?? (candidates.length === 1 ? candidates[0] : undefined);
+      if (this.targetField === undefined && candidates.length > 1) {
+        throw new Error(
+          `directive('${this.id}') has several idOf(${shortName(this.aggregate.id)}) payload fields; ` +
+            `select the mutation target with .target('field') before .plan(...)`,
+        );
+      }
+      if (field !== undefined) {
+        targetBinding = { field, aggregateId: this.aggregate.id };
+      }
+    }
     return makeRequirable({
       id: this.id,
       marker: this.marker,
@@ -979,6 +1043,7 @@ class DirectivePlanStep<Id extends string, P> {
       aggregate: this.aggregate,
       payloadSchema: this.payloadSchema,
       plan: fn,
+      ...(targetBinding === undefined ? {} : { targetBinding }),
       declaredReads: [],
       declaredQueryReads: [],
       declaredEmits: {},

package/src/engine_entry.ts

@@ -52,7 +52,7 @@
  * tenant package for the long-form rationale of each branch.
  */
 import { executeDirectiveToIntent } from "./wire_encode.js";
-import { expandCapabilityExports } from "./capability_exports.js";
+import { expandCapabilityExports, isCapabilityDecl } from "./capability_exports.js";
 import { RelationTuple, __setDispatchContext } from "./framework/relations.js";
 import { BIRTH_METER_AGGREGATES } from "./birth_meter.js";
 import { AuthProvider as FrameworkAuthProvider, setAuthProvider as frameworkSetAuthProvider } from "./framework/auth_provider_law.js";
@@ -193,7 +193,8 @@ function aggregatesOf(mod: DomainModuleExports): Map<string, AggregateHandle> {
     if (
       v &&
       typeof v === "object" &&
-      (v as { __isAggregateHandle?: boolean }).__isAggregateHandle === true
+      (v as { __isAggregateHandle?: boolean }).__isAggregateHandle === true &&
+      (v as { __isForwardRef?: boolean }).__isForwardRef !== true
     ) {
       const h = v as AggregateHandle;
       out.set(h.id, h);
@@ -332,6 +333,25 @@ function buildDomainSlice(mod: DomainModuleExports, domain: string): DomainSlice
   const executableDirectives = applicationLanguage === undefined
     ? discoveredDirectives
     : executableDirectivesForLanguage(applicationLanguage, discoveredDirectives, domain);
+  // Closed application languages hide their private consequence fragments from
+  // generated tenant clients. Capability lifecycle plans are nevertheless
+  // kernel-executable law: an atomic public action can create an obligation and
+  // a provider must later author its typed receipt. Mirror package composition
+  // by retaining the exact framework-derived lifecycle here as well.
+  for (const value of Object.values(mod)) {
+    if (!isCapabilityDecl(value)) continue;
+    for (const directive of [
+      value.obligation,
+      value.complete,
+      value.fail,
+      value.block,
+      value.deadLetter,
+    ] as Directive<unknown>[]) {
+      if (!executableDirectives.some((candidate) => candidate.id === directive.id)) {
+        executableDirectives.push(directive);
+      }
+    }
+  }
   const dirs = new Map(executableDirectives.map((directive) => [directive.id, directive]));
   // A directive already owns the typed aggregate handle it targets. Retain that
   // link unconditionally in the EXECUTABLE slice instead of requiring a second

package/src/enum_type.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+
+const NOMOS_ENUM_TYPE_NAME = Symbol.for("nomos.enumType.name");
+
+export interface EnumType<E extends readonly [string, ...string[]]> {
+  readonly __isEnumType: true;
+  readonly values: E;
+  readonly zod: z.ZodType<E[number]>;
+}
+
+/**
+ * One scalar vocabulary reused across fields, payloads and value objects.
+ *
+ * Its canonical name is the exported TypeScript binding. Authors do not repeat that binding as a
+ * string: `export const CustomFieldType = enumType([...])` is the declaration and the compiler
+ * binds `CustomFieldType` while loading the configured source module.
+ */
+export function enumType<const E extends readonly [string, ...string[]]>(
+  values: E,
+): EnumType<E> {
+  const schema = z.enum(values) as unknown as z.ZodType<E[number]>;
+  return Object.freeze({ __isEnumType: true as const, values, zod: schema });
+}
+
+export function enumTypeNameOf(schema: z.ZodTypeAny): string | undefined {
+  const name = (schema as unknown as Record<symbol, unknown>)[NOMOS_ENUM_TYPE_NAME];
+  return typeof name === "string" ? name : undefined;
+}
+
+export function isEnumType(value: unknown): value is EnumType<readonly [string, ...string[]]> {
+  return value !== null && typeof value === "object" &&
+    (value as { __isEnumType?: unknown }).__isEnumType === true;
+}
+
+/** Compiler/LSP seam: bind semantic identity from the language's own exported symbol table. */
+export function bindEnumTypeExport(
+  value: unknown,
+  exportName: string,
+  source = "configured law module",
+): void {
+  if (!isEnumType(value)) return;
+  if (!/^[A-Z][A-Za-z0-9]*$/u.test(exportName)) {
+    throw new Error(
+      `${source} exports enumType(...) as '${exportName}'; semantic type exports must be UpperCamelCase`,
+    );
+  }
+  const existing = enumTypeNameOf(value.zod);
+  if (existing !== undefined && existing !== exportName) {
+    throw new Error(
+      `${source} exports one enumType(...) as both '${existing}' and '${exportName}'; ` +
+        "a semantic type has one canonical exported identity",
+    );
+  }
+  if (existing === undefined) {
+    Object.defineProperty(value.zod, NOMOS_ENUM_TYPE_NAME, {
+      value: exportName,
+      enumerable: false,
+      configurable: false,
+      writable: false,
+    });
+  }
+}
+
+export function bindEnumTypeExports(
+  exports: Record<string, unknown>,
+  source = "configured law module",
+): void {
+  for (const [exportName, value] of Object.entries(exports)) {
+    bindEnumTypeExport(value, exportName, source);
+  }
+}