@githolon/dsl 0.103.12 → 0.103.13

package/src/aggregate.ts

@@ -196,6 +196,8 @@ export interface AggregateHandle<
   readonly hasMany: HasManyFields<F>;
   /** Brand so a plain string is never accepted where a handle is required. */
   readonly __isAggregateHandle: true;
+  /** Name-only dependency handle. Export-safe, but never itself discoverable as domain law. */
+  readonly __isForwardRef?: true;
   /** DOMAIN CONTRACTS this aggregate `.implements(...)` — the stable public shapes it satisfies (compile-
    *  checked). Codegen marks the aggregate as implementing them so cross-domain refs can target the CONTRACT
    *  instead of this concrete type. Additive metadata (not hashed law). OMITTED when it implements none. */
@@ -730,5 +732,5 @@ export function instance<Id extends string, F extends Record<string, Field>>(
  * and every forward ref keeps compiling for free.
  */
 export function forwardRef<const Id extends string>(id: Id): AggregateHandle<Id, Record<string, never>> {
-  return { id, fields: {}, hasMany: {}, __isAggregateHandle: true };
+  return { id, fields: {}, hasMany: {}, __isAggregateHandle: true, __isForwardRef: true };
 }

package/src/build_package.ts

@@ -24,6 +24,7 @@
  * removed so tenant tooling cannot accidentally create a second law representation.
  */
 import { createHash } from "node:crypto";
+import { z } from "zod";
 
 import type { AggregateHandle } from "./aggregate.js";
 import type { Directive } from "./directive.js";
@@ -33,7 +34,7 @@ import type { QueryDecl } from "./query.js";
 import type { SpatialDecl } from "./spatial.js";
 import type { AnySum } from "./sum.js";
 import type { AnyExtremum } from "./extremum.js";
-import type { DerivedDecl } from "./derived.js";
+import type { AnyDerivedDecl, DerivedDecl, TemporalEnumDecl } from "./derived.js";
 import type { CombinedDecl } from "./combined.js";
 import type { ImpureCapabilityDecl } from "./codegen_provider_dart.js";
 import type { WorkspaceTypeDecl } from "./workspace_type.js";
@@ -68,7 +69,7 @@ import {
   type RelationTypeDecl,
 } from "./relation_schema.js";
 import { collectValueObjectDescriptors } from "./value_object.js";
-import { expandCapabilityExports } from "./capability_exports.js";
+import { expandCapabilityExports, isCapabilityDecl } from "./capability_exports.js";
 import { RelationTuple, relationTuplesByObject } from "./framework/relations.js";
 import { signerDelegationByUser } from "./framework/signing_identity.js";
 import { AuthProvider, setAuthProvider, authProvider } from "./framework/workspaces.js";
@@ -111,7 +112,8 @@ export function aggregatesOf(mod: Mod): AggregateHandle[] {
     if (
       v &&
       typeof v === "object" &&
-      (v as { __isAggregateHandle?: boolean }).__isAggregateHandle === true
+      (v as { __isAggregateHandle?: boolean }).__isAggregateHandle === true &&
+      (v as { __isForwardRef?: boolean }).__isForwardRef !== true
     ) {
       out.push(v as AggregateHandle);
     }
@@ -215,6 +217,17 @@ export function composeDomainModule(spec: DomainModuleSpec): DomainModule {
   // `capability()` bundles expand into discoverable entries (the package plane's
   // merge point) — the quartet validation below then passes without re-exports.
   merged = expandCapabilityExports(merged);
+  const capabilityByAggregate = new Map<string, ImpureCapabilityDecl>();
+  for (const value of Object.values(merged)) {
+    if (isCapabilityDecl(value)) {
+      const capability = value as unknown as ImpureCapabilityDecl;
+      capabilityByAggregate.set(capability.aggregate.id, capability);
+    }
+  }
+  for (const capability of spec.impureCapabilities ?? []) {
+    capabilityByAggregate.set(capability.aggregate.id, capability);
+  }
+  const declaredCapabilities = [...capabilityByAggregate.values()];
   // METERED BIRTH: inject the sanctioning `nomosBirthRecordEnsure` directive + meter aggregates
   // into a `.births()`-declaring domain at the SAME seam the engine merge applies it — the
   // Ensure→NomosBirthRecord manifest declaration is what admits the auto-appended record through
@@ -272,6 +285,27 @@ export function composeDomainModule(spec: DomainModuleSpec): DomainModule {
       : executableDirectivesForLanguage(applicationLanguage, discoveredDirectives, domain),
     conflictPolicies,
   );
+  // A business intent may direct a capability obligation as one private,
+  // atomic consequence. Language closure deliberately removes private effect
+  // directives from the application write surface; capability lifecycle law is
+  // different: the task declaration must retain its complete quartet so the
+  // kernel can seal the obligation and later judge provider receipts. Re-seat
+  // those exact framework-derived directives after closure. Generated tenant
+  // clients still expose only the declared language intents.
+  for (const capability of declaredCapabilities) {
+    const lifecycleDirectives = [
+      capability.obligation,
+      capability.complete,
+      capability.fail,
+      capability.block,
+      capability.deadLetter,
+    ] as unknown as Directive<any>[];
+    for (const directive of lifecycleDirectives) {
+      if (!directives.some((candidate) => candidate.id === directive.id)) {
+        directives.push(directive);
+      }
+    }
+  }
   // Invitations are ordinary, replayed law hidden behind the generated application. Each sharing
   // policy contributes one possession-proof redemption directive; it is injected after the tenant
   // language has been closed so it cannot become a second public lane.
@@ -492,7 +526,7 @@ export function composeDomainModule(spec: DomainModuleSpec): DomainModule {
     domain,
   );
   const directiveIds = new Set(directives.map((d) => d.id));
-  for (const task of spec.impureCapabilities ?? []) {
+  for (const task of declaredCapabilities) {
     for (const directive of [task.obligation, task.complete, task.fail, task.block, task.deadLetter]) {
       if (!directiveIds.has(directive.id)) {
         throw new Error(
@@ -516,9 +550,46 @@ export function composeDomainModule(spec: DomainModuleSpec): DomainModule {
   }
   const counts = [...(spec.counts ?? [])];
   const spatials = [...(spec.spatials ?? [])];
-  const deriveds = [...(spec.deriveds ?? [])];
+  const temporalEnums: TemporalEnumDecl[] = aggregates.flatMap((aggregate) =>
+    Object.entries(aggregate.fields).flatMap(([sourceField, field]) =>
+      (field.temporalEnums ?? []).map((declaration) => {
+        if (field.isTimestamp !== true) {
+          throw new Error(
+            `domain '${domain}' temporal enum '${declaration.id}' targets ${aggregate.id}.${sourceField}, ` +
+              "which is not a t.timestamp() field",
+          );
+        }
+        const values = [
+          declaration.missing,
+          declaration.initial,
+          ...declaration.transitions.map((transition) => transition.value),
+        ] as [string, ...string[]];
+        return {
+          kind: "temporalEnum" as const,
+          id: declaration.id,
+          of: aggregate.id,
+          sourceField,
+          missing: declaration.missing,
+          initial: declaration.initial,
+          transitions: declaration.transitions,
+          returns: z.enum(values),
+        };
+      }),
+    ),
+  );
+  const derivedById = new Map<string, AnyDerivedDecl>();
+  for (const declaration of [...(spec.deriveds ?? []), ...temporalEnums]) {
+    const existing = derivedById.get(declaration.id);
+    if (existing !== undefined) {
+      throw new Error(
+        `domain '${domain}' declares read '${declaration.id}' more than once; temporal and generic derived reads share one namespace`,
+      );
+    }
+    derivedById.set(declaration.id, declaration);
+  }
+  const deriveds = [...derivedById.values()];
   const combineds = [...(spec.combineds ?? [])];
-  const impureCapabilities = [...(spec.impureCapabilities ?? [])];
+  const impureCapabilities = declaredCapabilities;
   const sums = [...(spec.sums ?? [])];
   const mins = [...(spec.mins ?? [])];
   const maxes = [...(spec.maxes ?? [])];

package/src/check_package_main.ts

@@ -16,6 +16,7 @@ import { pathToFileURL } from "node:url";
 
 import { composeDomainModule, type Mod } from "./build_package.js";
 import type { DomainModule } from "./codegen_dart.js";
+import { bindEnumTypeExports } from "./enum_type.js";
 import { checkDomainModules, formatFindings, hasRefusal, type Finding } from "./law_check.js";
 import { LawSourceMap } from "./law_source_map.js";
 import {
@@ -29,17 +30,18 @@ import {
 import { parseStableIdLockfile } from "./stable_id_lockfile.js";
 import {
   validateNomosPackageConfig,
-  type NomosPackageConfig,
+  type NormalizedNomosPackageConfig,
+  type NormalizedNomosPackageDomainConfig,
 } from "./package_config.js";
 import { assertPublicPackageImports } from "./package_source_imports.js";
+import {
+  assertPackageFeatureTopology,
+  packageFeatureTopologyFindings,
+} from "./package_feature_topology.js";
 import { packageDependencyUsageFindings } from "./package_dependency_usage.js";
 
-interface DomainConfig {
-  key: string;
-  name?: string;
-  modules: string[];
-}
-interface PackageConfig extends NomosPackageConfig {
+interface DomainConfig extends NormalizedNomosPackageDomainConfig {}
+interface PackageConfig extends NormalizedNomosPackageConfig {
   readonly domains: readonly DomainConfig[];
 }
 
@@ -87,6 +89,15 @@ export async function loadComposedModulesWithSources(
   }
   const composed: DomainModule[] = [];
   const domainFiles = new Map<string, string[]>();
+  let sourceTopologyFindings: readonly Finding[] = [];
+  try {
+    sourceTopologyFindings = packageFeatureTopologyFindings(
+      assertPackageFeatureTopology(cfg.domains, cfgDir),
+      cfgDir,
+    );
+  } catch (error) {
+    fail(`package feature topology refused: ${(error as Error).message}`);
+  }
   for (const d of cfg.domains) {
     const mods: Mod[] = [];
     const files: string[] = [];
@@ -102,7 +113,9 @@ export async function loadComposedModulesWithSources(
     }
     for (const abs of files) {
       // Cache-bust so a re-import (the LSP re-check after an edit) re-evaluates the edited module.
-      mods.push((await import(`${pathToFileURL(abs).href}?t=${Date.now()}`)) as Mod);
+      const mod = (await import(`${pathToFileURL(abs).href}?t=${Date.now()}`)) as Mod;
+      bindEnumTypeExports(mod, abs);
+      mods.push(mod);
     }
     domainFiles.set(d.key, files);
     composed.push(composeDomainModule({ name: d.name ?? d.key, domain: d.key, modules: mods }));
@@ -110,12 +123,15 @@ export async function loadComposedModulesWithSources(
   return {
     modules: composed,
     domainFiles,
-    dependencyFindings: packageDependencyUsageFindings({
-      packageName: cfg.name,
-      exportedDomains: cfg.domains.map((domain) => domain.key),
-      runtimeDependencies,
-      modules: composed,
-    }),
+    dependencyFindings: [
+      ...sourceTopologyFindings,
+      ...packageDependencyUsageFindings({
+        packageName: cfg.name,
+        exportedDomains: cfg.domains.map((domain) => domain.key),
+        runtimeDependencies,
+        modules: composed,
+      }),
+    ],
   };
 }
 
@@ -240,14 +256,21 @@ async function main(): Promise<void> {
   if (asJson) {
     const srcMap = new LawSourceMap(domainFiles);
     const out = findings.map((f) => {
-      const loc = srcMap.locate(f.domain, f.directiveId);
+      const loc = f.source ?? srcMap.locate(f.domain, f.directiveId);
       return {
         domain: f.domain,
         ...(f.directiveId !== undefined ? { directiveId: f.directiveId } : {}),
         level: f.level,
         what: f.what,
         fix: f.fix,
-        ...(loc !== undefined ? { file: loc.file, line: loc.line, column: loc.column, fallback: loc.fallback } : {}),
+        ...(loc !== undefined
+          ? {
+              file: loc.file,
+              line: loc.line,
+              column: loc.column,
+              ...("fallback" in loc ? { fallback: loc.fallback } : {}),
+            }
+          : {}),
       };
     });
     process.stdout.write(JSON.stringify(out) + "\n");