@githolon/dsl 0.105.5 → 0.105.6

package/src/lsp_server.ts

@@ -20,7 +20,7 @@
  * Multi-root: each document resolves to its NEAREST `nomos.project.ts` (walk up), so a repo with
  * several packages diagnoses each against its own config.
  */
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { bindEnumTypeExports } from "./enum_type.js";
@@ -45,12 +45,14 @@ import { LawSourceMap } from "./law_source_map.js";
 import {
   currentEvolveLaw,
   evolveDiff,
-  evolveLawFromInterface,
   evolveLawFromLockfile,
   type EvolveLaw,
-  type StableIdLockfile,
+  type CompilerIdentityModel,
 } from "./evolve_preview.js";
-import { parseStableIdLockfile } from "./stable_id_lockfile.js";
+import {
+  NOMOS_IDENTITY_FILENAME,
+  parseIdentityUsda,
+} from "./identity_usda.js";
 import {
   validateNomosPackageConfig,
   type NormalizedNomosPackageConfig,
@@ -194,54 +196,29 @@ async function composePackage(
   return { modules: composed, domainFiles, dependencyFindings };
 }
 
-/** Load prior evolve diagnostics from an interface sidecar/build dir/lockfile. */
+/** Load prior evolve diagnostics from the one committed typed identity layer. */
 function loadPriorEvolveLaw(arg: string, cfgDir: string): EvolveLaw | undefined {
   const abs = path.isAbsolute(arg) ? arg : path.resolve(cfgDir, arg);
   if (!existsSync(abs)) return undefined;
   let file = abs;
   if (statSync(abs).isDirectory()) {
-    const buildDir = path.join(abs, "build");
-    const scan = (d: string): string | undefined => {
-      if (!existsSync(d)) return undefined;
-      const hit = readdirSync(d).find((f) => f.endsWith(".interface.json"));
-      return hit !== undefined ? path.join(d, hit) : undefined;
-    };
-    const iface = scan(abs) ?? scan(buildDir);
-    const lock = path.join(abs, "nomos.stable-ids.json");
-    if (iface !== undefined) file = iface;
-    else if (existsSync(lock)) file = lock;
+    const identity = path.join(abs, NOMOS_IDENTITY_FILENAME);
+    if (existsSync(identity)) file = identity;
     else return undefined;
   }
-  let parsed: unknown;
   try {
-    parsed = JSON.parse(readFileSync(file, "utf8"));
+    return evolveLawFromLockfile(parseIdentityUsda(readFileSync(file, "utf8")));
   } catch {
     return undefined;
   }
-  if (path.basename(file) === "nomos.stable-ids.json") {
-    return evolveLawFromLockfile(parseStableIdLockfile(parsed));
-  }
-  const lockFile = [
-    path.join(path.dirname(file), "nomos.stable-ids.json"),
-    path.join(path.dirname(path.dirname(file)), "nomos.stable-ids.json"),
-  ].find((candidate) => existsSync(candidate));
-  let lock: StableIdLockfile | undefined;
-  if (lockFile !== undefined) {
-    try {
-      lock = parseStableIdLockfile(JSON.parse(readFileSync(lockFile, "utf8")));
-    } catch {
-      return undefined;
-    }
-  }
-  return evolveLawFromInterface(parsed as Parameters<typeof evolveLawFromInterface>[0], lock);
 }
 
-/** Read the committed `nomos.stable-ids.json` lockfile beside the config (the CURRENT identity). */
-function loadCwdLockfile(cfgDir: string): StableIdLockfile | undefined {
-  const lockPath = path.join(cfgDir, "nomos.stable-ids.json");
+/** Read the committed typed identity layer beside the config (the CURRENT identity). */
+function loadCwdLockfile(cfgDir: string): CompilerIdentityModel | undefined {
+  const lockPath = path.join(cfgDir, NOMOS_IDENTITY_FILENAME);
   if (!existsSync(lockPath)) return undefined;
   try {
-    return parseStableIdLockfile(JSON.parse(readFileSync(lockPath, "utf8")));
+    return parseIdentityUsda(readFileSync(lockPath, "utf8"));
   } catch {
     return undefined;
   }

package/src/stable_ids.ts

@@ -33,7 +33,7 @@
  * package therefore publishes one identical field-contract identity for that shared row.
  *
  * CONTINUITY (across compiles): `nomos-compile` reads the PRIOR build's identity
- * manifests / the committed `nomos.stable-ids.json` lockfile and derives a continuity
+ * manifests / the committed `nomos.identity.usda` lockfile and derives a continuity
  * table per domain — match by name first; then the UNAMBIGUOUS-PAIR rule: exactly ONE
  * disappeared name + exactly ONE same-shaped appeared name is an inferred RENAME (the
  * sid is carried, the old label recorded in `was`, and the compile summary prints the

package/src/stable_id_lockfile.ts

@@ -1,278 +0,0 @@
-import type { StableAggregateId, StableFieldId, StableIds } from "./stable_ids_types.js";
-import type { WireSchema } from "./wire.js";
-import { mintGlobalAggregateSid } from "./stable_ids.js";
-import {
-  LAW_FRAMEWORK_PARENT,
-  emptyLawIdentityRegistry,
-  lawEntityKey,
-  validateLawIdentityRegistry,
-  type LawIdentityEntity,
-  type LawIdentityRegistry,
-} from "./law_identity.js";
-
-export interface StableIdLockDomain {
-  stableIds: StableIds;
-  schemas?: Record<string, WireSchema>;
-}
-
-/** The materialized lock shape consumed inside the compiler and authoring tools. */
-export interface StableIdLockfile {
-  v: 1;
-  domains: Record<string, StableIdLockDomain>;
-  /** W4 compiler identity custody. Semantics remain exclusively in USDA. */
-  identity?: LawIdentityRegistry;
-}
-
-type CompactStableFieldId = Omit<StableFieldId, "contract" | "shape"> & {
-  contract?: string | number;
-};
-
-interface CompactStableAggregateId extends Omit<StableAggregateId, "fields"> {
-  fields: Record<string, CompactStableFieldId>;
-}
-
-interface CompactStableIds extends Omit<StableIds, "aggregates"> {
-  aggregates: Record<string, CompactStableAggregateId>;
-}
-
-interface CompactStableIdLockfile {
-  v: 2;
-  /** [contract hash, canonical contract descriptor], addressed by field.contract. */
-  contracts: readonly (readonly [string, unknown])[];
-  domains: Record<string, { stableIds: CompactStableIds }>;
-}
-
-interface IdentityStableIdLockfile {
-  v: 3;
-  identity: LawIdentityRegistry;
-  /** Temporary W4 compatibility evidence; deleted once evolution traverses prior USDA. */
-  contracts: readonly (readonly [string, unknown])[];
-  /** Temporary aggregate/field compatibility view consumed by the v2 compiler path. */
-  domains: Record<string, { stableIds: CompactStableIds }>;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function sortedJson(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(sortedJson);
-  if (!isRecord(value)) return value;
-  return Object.fromEntries(
-    Object.keys(value)
-      .sort()
-      .map((key) => [key, sortedJson(value[key])]),
-  );
-}
-
-/**
- * Read both the original verbose lock and the compact v2 wire shape. Callers always
- * receive the same fully materialized v1 object, so continuity and evolution logic
- * never needs to know how the durable file was encoded.
- */
-export function parseStableIdLockfile(value: unknown): StableIdLockfile {
-  if (!isRecord(value)) throw new Error("stable-id lock must be a JSON object");
-  if (value.v === 1) return value as unknown as StableIdLockfile;
-  if (
-    (value.v !== 2 && value.v !== 3) ||
-    !Array.isArray(value.contracts) ||
-    !isRecord(value.domains)
-  ) {
-    throw new Error("unsupported stable-id lock encoding");
-  }
-
-  let identity: LawIdentityRegistry | undefined;
-  if (value.v === 3) {
-    if (!isRecord(value.identity)) throw new Error("stable-id lock v3 identity is malformed");
-    identity = value.identity as unknown as LawIdentityRegistry;
-    validateLawIdentityRegistry(identity);
-  }
-
-  const compact = value as unknown as CompactStableIdLockfile | IdentityStableIdLockfile;
-  const contracts = compact.contracts.map((entry, index) => {
-    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") {
-      throw new Error(`stable-id lock contract ${index} is malformed`);
-    }
-    return entry;
-  });
-  const domains: StableIdLockfile["domains"] = {};
-
-  for (const [domainName, domain] of Object.entries(compact.domains)) {
-    const aggregates: StableIds["aggregates"] = {};
-    for (const [aggregateName, aggregate] of Object.entries(domain.stableIds.aggregates ?? {})) {
-      const fields: StableAggregateId["fields"] = {};
-      for (const [fieldName, field] of Object.entries(aggregate.fields ?? {})) {
-        const contractRef = field.contract;
-        const { contract: _contractRef, ...fieldWithoutContract } = field;
-        if (typeof contractRef === "number") {
-          const contract = contracts[contractRef];
-          if (contract === undefined) {
-            throw new Error(
-              `stable-id lock field ${domainName}.${aggregateName}.${fieldName} references missing contract ${contractRef}`,
-            );
-          }
-          fields[fieldName] = {
-            ...fieldWithoutContract,
-            contract: contract[0],
-            shape: contract[1],
-          };
-        } else if (typeof contractRef === "string") {
-          fields[fieldName] = { ...fieldWithoutContract, contract: contractRef };
-        } else {
-          fields[fieldName] = fieldWithoutContract;
-        }
-      }
-      aggregates[aggregateName] = { ...aggregate, fields };
-    }
-    domains[domainName] = {
-      stableIds: { ...domain.stableIds, aggregates },
-    };
-  }
-
-  return { v: 1, domains, ...(identity === undefined ? {} : { identity }) };
-}
-
-/**
- * Encode the committed lock without repeating identical contract descriptors or
- * aggregate driver schemas. Fields already retain their canonical merge driver;
- * the contract table retains the full descriptor needed to prove safe widening.
- */
-export function serializeStableIdLockfile(lock: StableIdLockfile): string {
-  if (lock.identity !== undefined) validateLawIdentityRegistry(lock.identity);
-  const contracts: [string, unknown][] = [];
-  const contractIndexes = new Map<string, number>();
-  const domains: CompactStableIdLockfile["domains"] = {};
-
-  for (const [domainName, domain] of Object.entries(lock.domains)) {
-    const aggregates: CompactStableIds["aggregates"] = {};
-    for (const [aggregateName, aggregate] of Object.entries(domain.stableIds.aggregates)) {
-      const fields: CompactStableAggregateId["fields"] = {};
-      for (const [fieldName, field] of Object.entries(aggregate.fields)) {
-        const { shape, ...withoutShape } = field;
-        if (field.contract !== undefined && shape !== undefined) {
-          let index = contractIndexes.get(field.contract);
-          if (index === undefined) {
-            index = contracts.length;
-            contracts.push([field.contract, shape]);
-            contractIndexes.set(field.contract, index);
-          }
-          fields[fieldName] = { ...withoutShape, contract: index };
-        } else {
-          fields[fieldName] = withoutShape;
-        }
-      }
-      aggregates[aggregateName] = { ...aggregate, fields };
-    }
-    domains[domainName] = {
-      stableIds: { ...domain.stableIds, aggregates },
-    };
-  }
-
-  // This is a machine-owned lockfile. Compact JSON is intentional: unlike generated
-  // law and clients, it must be committed so identity survives a clean clone.
-  const encoded =
-    lock.identity === undefined
-      ? ({ v: 2, contracts, domains } satisfies CompactStableIdLockfile)
-      : ({ v: 3, identity: lock.identity, contracts, domains } satisfies IdentityStableIdLockfile);
-  return JSON.stringify(sortedJson(encoded)) + "\n";
-}
-
-/**
- * One-time W4 import of the existing domain/aggregate/field SIDs. The legacy view has
- * already forgotten removals, so only currently present entities can be imported;
- * from this point onward the returned registry retains every retirement.
- */
-export function identityRegistryFromStableIdLockfile(
-  lock: StableIdLockfile | undefined,
-): LawIdentityRegistry {
-  if (lock?.identity !== undefined) {
-    validateLawIdentityRegistry(lock.identity);
-    return lock.identity;
-  }
-  if (lock === undefined) return emptyLawIdentityRegistry();
-
-  const entities: Record<string, LawIdentityEntity> = {};
-  const aggregateOccurrences = new Map<string, number>();
-  for (const domain of Object.values(lock.domains)) {
-    for (const aggregate of Object.values(domain.stableIds.aggregates)) {
-      aggregateOccurrences.set(aggregate.sid, (aggregateOccurrences.get(aggregate.sid) ?? 0) + 1);
-    }
-  }
-
-  for (const [domainName, domain] of Object.entries(lock.domains).sort(([a], [b]) =>
-    compareText(a, b),
-  )) {
-    const domainKey = importIdentityEntity(entities, {
-      kind: "domain",
-      sid: domain.stableIds.domain,
-      label: domainName,
-      generation: 0,
-      status: "active",
-    });
-    for (const [aggregateName, aggregate] of Object.entries(domain.stableIds.aggregates).sort(
-      ([a], [b]) => compareText(a, b),
-    )) {
-      const parent =
-        (aggregateOccurrences.get(aggregate.sid) ?? 0) > 1 ||
-        aggregate.sid === mintGlobalAggregateSid(aggregateName)
-          ? LAW_FRAMEWORK_PARENT
-          : domainKey;
-      const aggregateKey = importIdentityEntity(entities, {
-        kind: "aggregate",
-        sid: aggregate.sid,
-        parent,
-        label: aggregateName,
-        ...(aggregate.was === undefined ? {} : { priorLabels: aggregate.was }),
-        generation: 0,
-        status: "active",
-      });
-      for (const [fieldName, field] of Object.entries(aggregate.fields).sort(([a], [b]) =>
-        compareText(a, b),
-      )) {
-        importIdentityEntity(entities, {
-          kind: "field",
-          sid: field.sid,
-          parent: aggregateKey,
-          label: fieldName,
-          ...(field.was === undefined ? {} : { priorLabels: field.was }),
-          generation: 0,
-          status: "active",
-        });
-      }
-    }
-  }
-
-  const registry: LawIdentityRegistry = {
-    v: 1,
-    entities: Object.fromEntries(Object.entries(entities).sort(([a], [b]) => compareText(a, b))),
-  };
-  validateLawIdentityRegistry(registry);
-  return registry;
-}
-
-function importIdentityEntity(
-  entities: Record<string, LawIdentityEntity>,
-  entity: LawIdentityEntity,
-): string {
-  const key = lawEntityKey(entity.kind, entity.sid);
-  const prior = entities[key];
-  if (prior === undefined) {
-    entities[key] = entity;
-    return key;
-  }
-  if (
-    prior.kind !== entity.kind ||
-    prior.parent !== entity.parent ||
-    prior.label !== entity.label ||
-    JSON.stringify(prior.priorLabels ?? []) !== JSON.stringify(entity.priorLabels ?? [])
-  ) {
-    throw new Error(
-      `NMS-ID-002 legacy SID ${key} aliases incompatible ${prior.kind} '${prior.label}' and ${entity.kind} '${entity.label}'`,
-    );
-  }
-  return key;
-}
-
-function compareText(a: string, b: string): number {
-  return a < b ? -1 : a > b ? 1 : 0;
-}