@logixjs/core 0.0.1

package/dist/index.js

@@ -0,0 +1,286 @@
+import {
+  State_exports
+} from "./chunk-TQOBJYDP.js";
+import {
+  TraitLifecycle_exports
+} from "./chunk-ANLBCBDC.js";
+import {
+  Platform_exports
+} from "./chunk-ZDTRWK5F.js";
+import {
+  ReadQuery_exports
+} from "./chunk-TKZ7MEIA.js";
+import {
+  Reflection_exports
+} from "./chunk-DFNM3WX2.js";
+import {
+  Resource_exports
+} from "./chunk-4CQAV7YB.js";
+import {
+  Root_exports
+} from "./chunk-G5ZBFPNU.js";
+import {
+  Runtime_exports
+} from "./chunk-NBD3KUOZ.js";
+import {
+  ScopeRegistry_exports
+} from "./chunk-3TMODYZV.js";
+import {
+  Kernel_exports
+} from "./chunk-24VULZ7A.js";
+import {
+  Link_exports
+} from "./chunk-QCHIQWAJ.js";
+import {
+  Process_exports
+} from "./chunk-VZB726PE.js";
+import {
+  Logic_exports
+} from "./chunk-RNFE3ML2.js";
+import {
+  MatchBuilder_exports
+} from "./chunk-IPF7E66P.js";
+import "./chunk-QMM6O4CD.js";
+import {
+  Module_exports
+} from "./chunk-OGWBVHB3.js";
+import {
+  ModuleTag_exports
+} from "./chunk-76WT3HOR.js";
+import {
+  StateTrait_exports
+} from "./chunk-KIXAU3GM.js";
+import "./chunk-JCXGZRMU.js";
+import {
+  currentExecVmMode,
+  execVmModeLayer,
+  makeEnqueueTransaction
+} from "./chunk-JGIWG6SR.js";
+import "./chunk-PYOE4VSI.js";
+import {
+  ReplayLog_exports
+} from "./chunk-BABLDP24.js";
+import "./chunk-NZJKFF45.js";
+import "./chunk-KP7MUZNX.js";
+import {
+  Observability_exports
+} from "./chunk-M2RGJPXX.js";
+import {
+  BuildEnv_exports,
+  ConstructionGuard_exports,
+  RuntimeHost_exports
+} from "./chunk-M3WTHJHJ.js";
+import "./chunk-EGK3KN7B.js";
+import {
+  ProcessRuntimeTag
+} from "./chunk-PAYXCY6A.js";
+import "./chunk-ZGDVUPTM.js";
+import {
+  Action_exports
+} from "./chunk-3IYZ5IGG.js";
+import {
+  Actions_exports
+} from "./chunk-4SO6JMZL.js";
+import {
+  Bound_exports
+} from "./chunk-THATMZXD.js";
+import "./chunk-LEU6UA5J.js";
+import "./chunk-BE3HW4FY.js";
+import "./chunk-ZFLHVFUC.js";
+import "./chunk-KL5ACTCT.js";
+import "./chunk-AUIR5O6W.js";
+import "./chunk-BZ2SHDN2.js";
+import "./chunk-YS3AZQ2G.js";
+import {
+  Debug_exports,
+  appendSinks,
+  clearDevtoolsEvents,
+  devtoolsHubLayer,
+  diagnosticsLevel,
+  exportEvidencePackage,
+  getDevtoolsRunId,
+  getDevtoolsSnapshot,
+  getDevtoolsSnapshotToken,
+  getInstanceLabel,
+  getModuleFinalTraits,
+  getModuleTraits,
+  getModuleTraitsById,
+  getModuleTraitsSnapshot,
+  internal,
+  isDevtoolsEnabled,
+  layer,
+  makeModuleRuntimeCounterSink,
+  makeRingBufferSink,
+  noopLayer,
+  record,
+  replace,
+  runtimeLabel,
+  setDevtoolsRunId,
+  setInstanceLabel,
+  startDevtoolsRun,
+  subscribeDevtoolsSnapshot,
+  toRuntimeDebugEventRef,
+  traceLayer,
+  traitConvergeDiagnosticsSampling,
+  withPrettyLogger
+} from "./chunk-W3TEWHLO.js";
+import "./chunk-66ALHVEX.js";
+import "./chunk-ZFY7U2FR.js";
+import "./chunk-M3BFQ7HK.js";
+import {
+  normalizeFieldPath
+} from "./chunk-IHVBV5C2.js";
+import {
+  getRuntimeInternals
+} from "./chunk-3RMKLXHX.js";
+import {
+  Env_exports
+} from "./chunk-TAAPQVZN.js";
+import "./chunk-3QMIVH35.js";
+import {
+  Flow_exports
+} from "./chunk-EY4NZKDR.js";
+import "./chunk-NQZ2OSGR.js";
+import "./chunk-CW6T36TN.js";
+import "./chunk-DMBALCE2.js";
+import "./chunk-GMPEOUP2.js";
+import "./chunk-OFADUJWJ.js";
+import "./chunk-M7IYCTJV.js";
+import {
+  currentLinkId
+} from "./chunk-JWOYLO27.js";
+import {
+  Handle_exports
+} from "./chunk-3VG5TWQR.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/internal/InternalContracts.ts
+var InternalContracts_exports = {};
+__export(InternalContracts_exports, {
+  BuildEnv: () => BuildEnv_exports,
+  ConstructionGuard: () => ConstructionGuard_exports,
+  ReplayLog: () => ReplayLog_exports,
+  RuntimeHost: () => RuntimeHost_exports,
+  applyTransactionSnapshot: () => applyTransactionSnapshot,
+  controlProcessInstance: () => controlProcessInstance,
+  deliverProcessPlatformEvent: () => deliverProcessPlatformEvent,
+  execVmModeLayer: () => execVmModeLayer2,
+  getImportsScope: () => getImportsScope,
+  getProcessEvents: () => getProcessEvents,
+  getProcessInstallations: () => getProcessInstallations,
+  getProcessInstanceStatus: () => getProcessInstanceStatus,
+  getRowIdStore: () => getRowIdStore,
+  getStateTraitListConfigs: () => getStateTraitListConfigs,
+  getStateTransactionInstrumentation: () => getStateTransactionInstrumentation,
+  installProcess: () => installProcess,
+  makeEnqueueTransaction: () => makeEnqueueTransaction,
+  normalizeFieldPath: () => normalizeFieldPath,
+  recordStatePatch: () => recordStatePatch,
+  registerStateTraitProgram: () => registerStateTraitProgram,
+  runWithStateTransaction: () => runWithStateTransaction,
+  withCurrentLinkId: () => withCurrentLinkId,
+  withExecVmMode: () => withExecVmMode
+});
+import { Effect } from "effect";
+var getImportsScope = (runtime) => {
+  return getRuntimeInternals(runtime).imports;
+};
+var getStateTransactionInstrumentation = (runtime) => getRuntimeInternals(runtime).txn.instrumentation;
+var getRowIdStore = (runtime) => getRuntimeInternals(runtime).traits.rowIdStore;
+var getStateTraitListConfigs = (runtime) => getRuntimeInternals(runtime).traits.getListConfigs();
+var registerStateTraitProgram = (runtime, program, registerOptions) => {
+  getRuntimeInternals(runtime).traits.registerStateTraitProgram(program, registerOptions);
+};
+var recordStatePatch = (runtime, path, reason, from, to, traitNodeId, stepId) => {
+  getRuntimeInternals(runtime).txn.recordStatePatch(path, reason, from, to, traitNodeId, stepId);
+};
+var runWithStateTransaction = (runtime, origin, body) => getRuntimeInternals(runtime).txn.runWithStateTransaction(origin, body);
+var applyTransactionSnapshot = (runtime, txnId, mode) => getRuntimeInternals(runtime).txn.applyTransactionSnapshot(txnId, mode);
+var withCurrentLinkId = (linkId) => Effect.locally(currentLinkId, linkId);
+var withExecVmMode = (effect) => Effect.locally(currentExecVmMode, true)(effect);
+var execVmModeLayer2 = (enabled) => execVmModeLayer(enabled);
+var getProcessInstallations = (options) => Effect.gen(function* () {
+  const rt = yield* ProcessRuntimeTag;
+  return yield* rt.listInstallations(options);
+});
+var getProcessInstanceStatus = (processInstanceId) => Effect.gen(function* () {
+  const rt = yield* ProcessRuntimeTag;
+  return yield* rt.getInstanceStatus(processInstanceId);
+});
+var controlProcessInstance = (processInstanceId, request) => Effect.gen(function* () {
+  const rt = yield* ProcessRuntimeTag;
+  yield* rt.controlInstance(processInstanceId, request);
+});
+var deliverProcessPlatformEvent = (event) => Effect.gen(function* () {
+  const rt = yield* ProcessRuntimeTag;
+  yield* rt.deliverPlatformEvent(event);
+});
+var getProcessEvents = () => Effect.gen(function* () {
+  const rt = yield* ProcessRuntimeTag;
+  return yield* rt.getEventsSnapshot();
+});
+var installProcess = (process, options) => Effect.gen(function* () {
+  const rt = yield* ProcessRuntimeTag;
+  return yield* rt.install(process, options);
+});
+export {
+  Action_exports as Action,
+  Actions_exports as Actions,
+  Bound_exports as Bound,
+  Debug_exports as Debug,
+  Env_exports as Env,
+  Flow_exports as Flow,
+  Handle_exports as Handle,
+  InternalContracts_exports as InternalContracts,
+  Kernel_exports as Kernel,
+  Link_exports as Link,
+  Logic_exports as Logic,
+  MatchBuilder_exports as MatchBuilder,
+  Module_exports as Module,
+  ModuleTag_exports as ModuleTag,
+  Observability_exports as Observability,
+  Platform_exports as Platform,
+  Process_exports as Process,
+  ReadQuery_exports as ReadQuery,
+  Reflection_exports as Reflection,
+  Resource_exports as Resource,
+  Root_exports as Root,
+  Runtime_exports as Runtime,
+  ScopeRegistry_exports as ScopeRegistry,
+  State_exports as State,
+  StateTrait_exports as StateTrait,
+  TraitLifecycle_exports as TraitLifecycle,
+  appendSinks,
+  clearDevtoolsEvents,
+  devtoolsHubLayer,
+  diagnosticsLevel,
+  exportEvidencePackage,
+  getDevtoolsRunId,
+  getDevtoolsSnapshot,
+  getDevtoolsSnapshotToken,
+  getInstanceLabel,
+  getModuleFinalTraits,
+  getModuleTraits,
+  getModuleTraitsById,
+  getModuleTraitsSnapshot,
+  internal,
+  isDevtoolsEnabled,
+  layer,
+  makeModuleRuntimeCounterSink,
+  makeRingBufferSink,
+  noopLayer,
+  record,
+  replace,
+  runtimeLabel,
+  setDevtoolsRunId,
+  setInstanceLabel,
+  startDevtoolsRun,
+  subscribeDevtoolsSnapshot,
+  toRuntimeDebugEventRef,
+  traceLayer,
+  traitConvergeDiagnosticsSampling,
+  withPrettyLogger
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/InternalContracts.ts"],"sourcesContent":["import { Effect, Layer } from 'effect'\nimport type { ImportsScope } from './runtime/core/RuntimeInternals.js'\nimport type { StateTransactionInstrumentation } from './runtime/core/env.js'\nimport type { StatePatchPath } from './runtime/core/StateTransaction.js'\nimport * as EffectOpCore from './runtime/core/EffectOpCore.js'\nimport { getRuntimeInternals } from './runtime/core/runtimeInternalsAccessor.js'\nimport * as ProcessRuntime from './runtime/core/process/ProcessRuntime.js'\nimport type * as ProcessProtocol from './runtime/core/process/protocol.js'\nimport { currentExecVmMode, execVmModeLayer as execVmModeLayerInternal } from './state-trait/exec-vm-mode.js'\nimport type { PatchReason } from './field-path.js'\n\nexport * as BuildEnv from './platform/BuildEnv.js'\nexport * as RuntimeHost from './platform/RuntimeHost.js'\nexport * as ConstructionGuard from './platform/ConstructionGuard.js'\nexport { normalizeFieldPath } from './field-path.js'\nexport type { DirtyAllReason, DirtySet, FieldPath, FieldPathId } from './field-path.js'\nexport { makeEnqueueTransaction } from './runtime/ModuleRuntime.txnQueue.js'\nexport * as ReplayLog from './runtime/core/ReplayLog.js'\n\n/**\n * InternalContracts: the internal contract access entrypoint for in-repo integrators.\n *\n * Notes:\n * - This module replaces direct reads of `runtime.__*` magic fields.\n * - Public API/behavior remains unchanged, and business code is not required to use this by default.\n * - Exposes only minimal capabilities (ISP) to avoid leaking RuntimeInternals as a public dependency.\n */\nexport const getImportsScope = (runtime: object): ImportsScope => {\n  return getRuntimeInternals(runtime).imports\n}\n\nexport const getStateTransactionInstrumentation = (runtime: object): StateTransactionInstrumentation =>\n  getRuntimeInternals(runtime).txn.instrumentation\n\nexport const getRowIdStore = (runtime: object): unknown => getRuntimeInternals(runtime).traits.rowIdStore\n\nexport const getStateTraitListConfigs = (runtime: object): ReadonlyArray<unknown> =>\n  getRuntimeInternals(runtime).traits.getListConfigs()\n\nexport const registerStateTraitProgram = (\n  runtime: object,\n  program: unknown,\n  registerOptions?: { readonly bumpReason?: unknown },\n): void => {\n  getRuntimeInternals(runtime).traits.registerStateTraitProgram(program, registerOptions as any)\n}\n\nexport const recordStatePatch = (\n  runtime: object,\n  path: StatePatchPath,\n  reason: PatchReason,\n  from?: unknown,\n  to?: unknown,\n  traitNodeId?: string,\n  stepId?: number,\n): void => {\n  getRuntimeInternals(runtime).txn.recordStatePatch(path, reason, from, to, traitNodeId, stepId)\n}\n\nexport const runWithStateTransaction = <E, R>(\n  runtime: object,\n  origin: { readonly kind: string; readonly name?: string; readonly details?: unknown },\n  body: () => Effect.Effect<void, E, R>,\n): Effect.Effect<void, E, R> =>\n  getRuntimeInternals(runtime).txn.runWithStateTransaction(origin as any, body as any) as any\n\nexport const applyTransactionSnapshot = (\n  runtime: object,\n  txnId: string,\n  mode: 'before' | 'after',\n): Effect.Effect<void, never, any> => getRuntimeInternals(runtime).txn.applyTransactionSnapshot(txnId, mode)\n\nexport const withCurrentLinkId = (linkId: string) => Effect.locally(EffectOpCore.currentLinkId, linkId)\n\n/** 049: Exec VM (core-ng) switch: enable the Exec VM hot path within the current Effect scope. */\nexport const withExecVmMode = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n  Effect.locally(currentExecVmMode, true)(effect)\n\n/** 049: Exec VM (core-ng) switch: enable/disable the Exec VM hot path within the current runtime scope. */\nexport const execVmModeLayer = (enabled: boolean): Layer.Layer<any, never, never> =>\n  execVmModeLayerInternal(enabled) as Layer.Layer<any, never, never>\n\nexport const getProcessInstallations = (options?: {\n  readonly scopeType?: import('./runtime/core/process/protocol.js').ProcessScope['type']\n  readonly scopeKey?: string\n}): Effect.Effect<\n  ReadonlyArray<import('./runtime/core/process/protocol.js').ProcessInstallation>,\n  never,\n  ProcessRuntime.ProcessRuntimeTag\n> =>\n  Effect.gen(function* () {\n    const rt = yield* ProcessRuntime.ProcessRuntimeTag\n    return yield* rt.listInstallations(options)\n  })\n\nexport const getProcessInstanceStatus = (\n  processInstanceId: string,\n): Effect.Effect<\n  import('./runtime/core/process/protocol.js').ProcessInstanceStatus | undefined,\n  never,\n  ProcessRuntime.ProcessRuntimeTag\n> =>\n  Effect.gen(function* () {\n    const rt = yield* ProcessRuntime.ProcessRuntimeTag\n    return yield* rt.getInstanceStatus(processInstanceId)\n  })\n\nexport const controlProcessInstance = (\n  processInstanceId: string,\n  request: import('./runtime/core/process/protocol.js').ProcessControlRequest,\n): Effect.Effect<void, never, ProcessRuntime.ProcessRuntimeTag> =>\n  Effect.gen(function* () {\n    const rt = yield* ProcessRuntime.ProcessRuntimeTag\n    yield* rt.controlInstance(processInstanceId, request)\n  })\n\nexport const deliverProcessPlatformEvent = (\n  event: import('./runtime/core/process/protocol.js').ProcessPlatformEvent,\n): Effect.Effect<void, never, ProcessRuntime.ProcessRuntimeTag> =>\n  Effect.gen(function* () {\n    const rt = yield* ProcessRuntime.ProcessRuntimeTag\n    yield* rt.deliverPlatformEvent(event)\n  })\n\nexport const getProcessEvents = (): Effect.Effect<\n  ReadonlyArray<import('./runtime/core/process/protocol.js').ProcessEvent>,\n  never,\n  ProcessRuntime.ProcessRuntimeTag\n> =>\n  Effect.gen(function* () {\n    const rt = yield* ProcessRuntime.ProcessRuntimeTag\n    return yield* rt.getEventsSnapshot()\n  })\n\nexport const installProcess = <E, R>(\n  process: Effect.Effect<void, E, R>,\n  options: {\n    readonly scope: ProcessProtocol.ProcessScope\n    readonly enabled?: boolean\n    readonly installedAt?: string\n    readonly mode?: 'switch' | 'exhaust'\n  },\n): Effect.Effect<ProcessProtocol.ProcessInstallation | undefined, never, ProcessRuntime.ProcessRuntimeTag | R> =>\n  Effect.gen(function* () {\n    const rt = yield* ProcessRuntime.ProcessRuntimeTag\n    return yield* rt.install(process, options)\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAS,cAAqB;AA2BvB,IAAM,kBAAkB,CAAC,YAAkC;AAChE,SAAO,oBAAoB,OAAO,EAAE;AACtC;AAEO,IAAM,qCAAqC,CAAC,YACjD,oBAAoB,OAAO,EAAE,IAAI;AAE5B,IAAM,gBAAgB,CAAC,YAA6B,oBAAoB,OAAO,EAAE,OAAO;AAExF,IAAM,2BAA2B,CAAC,YACvC,oBAAoB,OAAO,EAAE,OAAO,eAAe;AAE9C,IAAM,4BAA4B,CACvC,SACA,SACA,oBACS;AACT,sBAAoB,OAAO,EAAE,OAAO,0BAA0B,SAAS,eAAsB;AAC/F;AAEO,IAAM,mBAAmB,CAC9B,SACA,MACA,QACA,MACA,IACA,aACA,WACS;AACT,sBAAoB,OAAO,EAAE,IAAI,iBAAiB,MAAM,QAAQ,MAAM,IAAI,aAAa,MAAM;AAC/F;AAEO,IAAM,0BAA0B,CACrC,SACA,QACA,SAEA,oBAAoB,OAAO,EAAE,IAAI,wBAAwB,QAAe,IAAW;AAE9E,IAAM,2BAA2B,CACtC,SACA,OACA,SACoC,oBAAoB,OAAO,EAAE,IAAI,yBAAyB,OAAO,IAAI;AAEpG,IAAM,oBAAoB,CAAC,WAAmB,OAAO,QAAqB,eAAe,MAAM;AAG/F,IAAM,iBAAiB,CAAU,WACtC,OAAO,QAAQ,mBAAmB,IAAI,EAAE,MAAM;AAGzC,IAAMC,mBAAkB,CAAC,YAC9B,gBAAwB,OAAO;AAE1B,IAAM,0BAA0B,CAAC,YAQtC,OAAO,IAAI,aAAa;AACtB,QAAM,KAAK,OAAsB;AACjC,SAAO,OAAO,GAAG,kBAAkB,OAAO;AAC5C,CAAC;AAEI,IAAM,2BAA2B,CACtC,sBAMA,OAAO,IAAI,aAAa;AACtB,QAAM,KAAK,OAAsB;AACjC,SAAO,OAAO,GAAG,kBAAkB,iBAAiB;AACtD,CAAC;AAEI,IAAM,yBAAyB,CACpC,mBACA,YAEA,OAAO,IAAI,aAAa;AACtB,QAAM,KAAK,OAAsB;AACjC,SAAO,GAAG,gBAAgB,mBAAmB,OAAO;AACtD,CAAC;AAEI,IAAM,8BAA8B,CACzC,UAEA,OAAO,IAAI,aAAa;AACtB,QAAM,KAAK,OAAsB;AACjC,SAAO,GAAG,qBAAqB,KAAK;AACtC,CAAC;AAEI,IAAM,mBAAmB,MAK9B,OAAO,IAAI,aAAa;AACtB,QAAM,KAAK,OAAsB;AACjC,SAAO,OAAO,GAAG,kBAAkB;AACrC,CAAC;AAEI,IAAM,iBAAiB,CAC5B,SACA,YAOA,OAAO,IAAI,aAAa;AACtB,QAAM,KAAK,OAAsB;AACjC,SAAO,OAAO,GAAG,QAAQ,SAAS,OAAO;AAC3C,CAAC;","names":["execVmModeLayer","execVmModeLayer"]}

package/dist/ir-BMP7yxJJ.d.cts

@@ -0,0 +1,39 @@
+import { F as FieldPath$1 } from './module-B8CBqIZ_.cjs';
+
+type FieldPath = FieldPath$1;
+interface StaticIrNode {
+    readonly nodeId: string;
+    readonly kind: string;
+    readonly reads: ReadonlyArray<FieldPath>;
+    readonly writes: ReadonlyArray<FieldPath>;
+    readonly writesUnknown?: boolean;
+    readonly policy?: Record<string, unknown>;
+    readonly meta?: {
+        readonly label?: string;
+        readonly description?: string;
+        readonly tags?: ReadonlyArray<string>;
+        readonly group?: string;
+        readonly docsUrl?: string;
+        readonly cacheGroup?: string;
+        readonly annotations?: Record<string, unknown>;
+    };
+}
+interface StaticIrEdge {
+    readonly edgeId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly kind: string;
+}
+interface StaticIr {
+    readonly version: string;
+    readonly moduleId: string;
+    /**
+     * Stable digest (for drift detection / diffing): determined solely by the current export structure.
+     */
+    readonly digest: string;
+    readonly nodes: ReadonlyArray<StaticIrNode>;
+    readonly edges: ReadonlyArray<StaticIrEdge>;
+    readonly conflicts?: ReadonlyArray<unknown>;
+}
+
+export type { StaticIr as S };

package/dist/ir-DUOz6H-5.d.ts

@@ -0,0 +1,39 @@
+import { F as FieldPath$1 } from './module-k7m3txak.js';
+
+type FieldPath = FieldPath$1;
+interface StaticIrNode {
+    readonly nodeId: string;
+    readonly kind: string;
+    readonly reads: ReadonlyArray<FieldPath>;
+    readonly writes: ReadonlyArray<FieldPath>;
+    readonly writesUnknown?: boolean;
+    readonly policy?: Record<string, unknown>;
+    readonly meta?: {
+        readonly label?: string;
+        readonly description?: string;
+        readonly tags?: ReadonlyArray<string>;
+        readonly group?: string;
+        readonly docsUrl?: string;
+        readonly cacheGroup?: string;
+        readonly annotations?: Record<string, unknown>;
+    };
+}
+interface StaticIrEdge {
+    readonly edgeId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly kind: string;
+}
+interface StaticIr {
+    readonly version: string;
+    readonly moduleId: string;
+    /**
+     * Stable digest (for drift detection / diffing): determined solely by the current export structure.
+     */
+    readonly digest: string;
+    readonly nodes: ReadonlyArray<StaticIrNode>;
+    readonly edges: ReadonlyArray<StaticIrEdge>;
+    readonly conflicts?: ReadonlyArray<unknown>;
+}
+
+export type { StaticIr as S };