@logixjs/core 0.0.1

package/dist/chunk-DFNM3WX2.js

@@ -0,0 +1,632 @@
+import {
+  KernelContractMetaAllowlist,
+  evaluateFullCutoverGate,
+  getKernelImplementationRef,
+  getRuntimeServicesEvidence
+} from "./chunk-24VULZ7A.js";
+import {
+  exportStaticIr,
+  extractManifest,
+  trialRun
+} from "./chunk-M3WTHJHJ.js";
+import {
+  normalizeKernelImplementationRef
+} from "./chunk-ZGDVUPTM.js";
+import {
+  record
+} from "./chunk-DMBALCE2.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-GMPEOUP2.js";
+import {
+  EffectOpMiddlewareTag
+} from "./chunk-JWOYLO27.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Reflection.ts
+var Reflection_exports = {};
+__export(Reflection_exports, {
+  diffManifest: () => diffManifest2,
+  exportStaticIr: () => exportStaticIr2,
+  extractManifest: () => extractManifest2,
+  verifyFullCutoverGate: () => verifyFullCutoverGate,
+  verifyKernelContract: () => verifyKernelContract2
+});
+import { Context as Context2, Effect as Effect2, Exit as Exit2, Layer as Layer2 } from "effect";
+
+// src/internal/reflection/diff.ts
+var SEVERITY_RANK = {
+  BREAKING: 0,
+  RISKY: 1,
+  INFO: 2
+};
+var uniqSorted = (input) => {
+  const out = Array.from(new Set(input.filter((x) => typeof x === "string" && x.length > 0)));
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+};
+var diffStringKeys = (before, after) => {
+  const beforeSet = new Set(uniqSorted(before ?? []));
+  const afterSet = new Set(uniqSorted(after ?? []));
+  const removed = [];
+  for (const k of beforeSet) {
+    if (!afterSet.has(k)) removed.push(k);
+  }
+  removed.sort((a, b) => a.localeCompare(b));
+  const added = [];
+  for (const k of afterSet) {
+    if (!beforeSet.has(k)) added.push(k);
+  }
+  added.sort((a, b) => a.localeCompare(b));
+  return { removed, added };
+};
+var eqJsonValue = (a, b) => stableStringify(a) === stableStringify(b);
+var indexLogicUnits = (input) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const unit of input ?? []) {
+    if (!unit || typeof unit !== "object") continue;
+    const id = unit.id;
+    if (typeof id !== "string" || id.length === 0) continue;
+    map.set(id, unit);
+  }
+  return map;
+};
+var diffManifest = (before, after, options) => {
+  const changes = [];
+  if (before.moduleId !== after.moduleId) {
+    changes.push({
+      severity: "BREAKING",
+      code: "moduleId.changed",
+      message: `moduleId changed (${before.moduleId} -> ${after.moduleId})`,
+      pointer: "/moduleId",
+      details: {
+        before: before.moduleId,
+        after: after.moduleId
+      }
+    });
+  }
+  if (before.manifestVersion !== after.manifestVersion) {
+    changes.push({
+      severity: "INFO",
+      code: "manifestVersion.changed",
+      message: `manifestVersion changed (${before.manifestVersion} -> ${after.manifestVersion})`,
+      pointer: "/manifestVersion",
+      details: {
+        before: before.manifestVersion,
+        after: after.manifestVersion
+      }
+    });
+  }
+  {
+    const { removed, added } = diffStringKeys(before.actionKeys, after.actionKeys);
+    if (removed.length > 0 || added.length > 0) {
+      changes.push({
+        severity: removed.length > 0 ? "BREAKING" : "INFO",
+        code: "actionKeys.changed",
+        message: removed.length > 0 ? `actionKeys removed: ${removed.join(", ")}` : `actionKeys added: ${added.join(", ")}`,
+        pointer: "/actionKeys",
+        details: { removed, added }
+      });
+    }
+  }
+  {
+    const { removed, added } = diffStringKeys(before.schemaKeys, after.schemaKeys);
+    if (removed.length > 0 || added.length > 0) {
+      changes.push({
+        severity: removed.length > 0 ? "BREAKING" : "INFO",
+        code: "schemaKeys.changed",
+        message: removed.length > 0 ? `schemaKeys removed: ${removed.join(", ")}` : `schemaKeys added: ${added.join(", ")}`,
+        pointer: "/schemaKeys",
+        details: { removed, added }
+      });
+    }
+  }
+  {
+    const beforeById = indexLogicUnits(before.logicUnits);
+    const afterById = indexLogicUnits(after.logicUnits);
+    const removed = [];
+    const added = [];
+    const kindChanged = [];
+    const riskyChanged = [];
+    for (const id of beforeById.keys()) {
+      if (!afterById.has(id)) removed.push(id);
+    }
+    for (const id of afterById.keys()) {
+      if (!beforeById.has(id)) added.push(id);
+    }
+    removed.sort((a, b) => a.localeCompare(b));
+    added.sort((a, b) => a.localeCompare(b));
+    for (const id of beforeById.keys()) {
+      const b = beforeById.get(id);
+      const a = afterById.get(id);
+      if (!b || !a) continue;
+      const fields = [];
+      if (b.kind !== a.kind) {
+        kindChanged.push({ id, before: b.kind, after: a.kind });
+        continue;
+      }
+      if (b.name !== a.name) fields.push("name");
+      if (b.derived !== a.derived) fields.push("derived");
+      if (fields.length > 0) riskyChanged.push({ id, fields });
+    }
+    kindChanged.sort((x, y) => x.id.localeCompare(y.id));
+    riskyChanged.sort((x, y) => x.id.localeCompare(y.id));
+    if (removed.length > 0) {
+      changes.push({
+        severity: "BREAKING",
+        code: "logicUnits.removed",
+        message: `logicUnits removed: ${removed.join(", ")}`,
+        pointer: "/logicUnits",
+        details: { removed }
+      });
+    }
+    if (kindChanged.length > 0) {
+      changes.push({
+        severity: "BREAKING",
+        code: "logicUnits.kindChanged",
+        message: `logicUnits kind changed: ${kindChanged.map((x) => x.id).join(", ")}`,
+        pointer: "/logicUnits",
+        details: { kindChanged }
+      });
+    }
+    if (added.length > 0) {
+      changes.push({
+        severity: "INFO",
+        code: "logicUnits.added",
+        message: `logicUnits added: ${added.join(", ")}`,
+        pointer: "/logicUnits",
+        details: { added }
+      });
+    }
+    if (riskyChanged.length > 0) {
+      changes.push({
+        severity: "RISKY",
+        code: "logicUnits.changed",
+        message: `logicUnits changed: ${riskyChanged.map((x) => x.id).join(", ")}`,
+        pointer: "/logicUnits",
+        details: { changed: riskyChanged }
+      });
+    }
+  }
+  {
+    const beforeDigest = before.staticIr?.digest;
+    const afterDigest = after.staticIr?.digest;
+    if (beforeDigest !== afterDigest) {
+      changes.push({
+        severity: "RISKY",
+        code: "staticIr.digestChanged",
+        message: "staticIr.digest changed",
+        pointer: "/staticIr/digest",
+        details: {
+          before: beforeDigest ?? null,
+          after: afterDigest ?? null
+        }
+      });
+    }
+  }
+  {
+    const metaBefore = before.meta ?? {};
+    const metaAfter = after.meta ?? {};
+    const allowlist = options?.metaAllowlist;
+    const keys = allowlist != null ? uniqSorted(allowlist) : uniqSorted([...Object.keys(metaBefore), ...Object.keys(metaAfter)]);
+    const changed = [];
+    for (const key of keys) {
+      const b = key in metaBefore ? metaBefore[key] : void 0;
+      const a = key in metaAfter ? metaAfter[key] : void 0;
+      if (!eqJsonValue(b, a)) {
+        changed.push({
+          key,
+          before: b ?? null,
+          after: a ?? null
+        });
+      }
+    }
+    if (changed.length > 0) {
+      changes.push({
+        severity: "RISKY",
+        code: "meta.changed",
+        message: "meta changed",
+        pointer: "/meta",
+        details: {
+          keys: changed.map((x) => x.key),
+          changed
+        }
+      });
+    }
+  }
+  {
+    const b = before.source;
+    const a = after.source;
+    if (!eqJsonValue(b ?? null, a ?? null)) {
+      changes.push({
+        severity: "INFO",
+        code: "source.changed",
+        message: "source changed",
+        pointer: "/source",
+        details: {
+          before: b ?? null,
+          after: a ?? null
+        }
+      });
+    }
+  }
+  changes.sort((a, b) => {
+    const ra = SEVERITY_RANK[a.severity];
+    const rb = SEVERITY_RANK[b.severity];
+    if (ra !== rb) return ra - rb;
+    const ca = a.code.localeCompare(b.code);
+    if (ca !== 0) return ca;
+    const pa = a.pointer ?? "";
+    const pb = b.pointer ?? "";
+    return pa.localeCompare(pb);
+  });
+  const summary = {
+    breaking: changes.filter((c) => c.severity === "BREAKING").length,
+    risky: changes.filter((c) => c.severity === "RISKY").length,
+    info: changes.filter((c) => c.severity === "INFO").length
+  };
+  const verdict = summary.breaking > 0 ? "FAIL" : summary.risky > 0 ? "WARN" : "PASS";
+  return {
+    version: "025",
+    moduleId: after.moduleId,
+    before: {
+      digest: before.digest,
+      manifestVersion: before.manifestVersion
+    },
+    after: {
+      digest: after.digest,
+      manifestVersion: after.manifestVersion
+    },
+    verdict,
+    changes,
+    summary
+  };
+};
+
+// src/internal/reflection/kernelContract.ts
+import { Context, Effect, Exit, Layer } from "effect";
+var resolveRootImpl = (root) => root?._tag === "ModuleImpl" ? root : root?.impl;
+var asNonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var asNonNegInt = (value, fallback = 0) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const n = Math.floor(value);
+  return n >= 0 ? n : fallback;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var makeTraceEffectOpObserver = () => {
+  return (op) => Effect.gen(function* () {
+    if (op.meta?.policy?.disableObservers) {
+      return yield* op.effect;
+    }
+    const meta = op.meta ?? {};
+    const slimOp = {
+      id: op.id,
+      kind: op.kind,
+      name: op.name,
+      payload: op.payload,
+      meta: op.meta
+    };
+    yield* record({
+      type: "trace:effectop",
+      moduleId: typeof meta.moduleId === "string" ? meta.moduleId : void 0,
+      instanceId: typeof meta.instanceId === "string" ? meta.instanceId : void 0,
+      runtimeLabel: typeof meta.runtimeLabel === "string" ? meta.runtimeLabel : void 0,
+      txnSeq: typeof meta.txnSeq === "number" && Number.isFinite(meta.txnSeq) ? Math.floor(meta.txnSeq) : void 0,
+      data: slimOp
+    });
+    return yield* op.effect;
+  });
+};
+var extractRuntimeSummary = (evidence) => {
+  const summary = evidence.summary;
+  const runtime = summary?.runtime;
+  const kernelImplementationRefRaw = runtime?.kernelImplementationRef;
+  const kernelImplementationRef = normalizeKernelImplementationRef(kernelImplementationRefRaw);
+  const services = runtime?.services;
+  return {
+    kernelImplementationRef,
+    runtimeServicesEvidence: services
+  };
+};
+var canonicalizeOpMeta = (opMetaRaw) => {
+  if (!isRecord(opMetaRaw)) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(opMetaRaw)) {
+    if (k === "instanceId" || k === "txnId" || k === "runtimeLabel" || k === "linkId") continue;
+    if ((k === "deps" || k === "trace" || k === "tags") && Array.isArray(v) && v.every((x) => typeof x === "string")) {
+      out[k] = v.slice().sort((a, b) => a.localeCompare(b));
+      continue;
+    }
+    out[k] = v;
+  }
+  return out;
+};
+var extractKernelContractTraceOps = (evidence) => {
+  const instanceMap = /* @__PURE__ */ new Map();
+  let nextInstanceIndex = 0;
+  const mapInstanceId = (raw) => {
+    if (raw === "unknown") return "unknown";
+    const existing = instanceMap.get(raw);
+    if (existing) return existing;
+    nextInstanceIndex += 1;
+    const next = `i${nextInstanceIndex}`;
+    instanceMap.set(raw, next);
+    return next;
+  };
+  const ops = [];
+  for (const e of evidence.events) {
+    if (e.type !== "debug:event") continue;
+    const payload = e.payload;
+    if (!isRecord(payload)) continue;
+    const meta = payload.meta;
+    const opMeta = meta?.meta;
+    const opSeq = asNonNegInt(opMeta?.opSeq, -1);
+    if (opSeq < 0) continue;
+    const instanceIdRaw = asNonEmptyString(payload.instanceId) ?? "unknown";
+    const instanceId = mapInstanceId(instanceIdRaw);
+    const txnSeq = asNonNegInt(payload.txnSeq, 0);
+    const moduleId = asNonEmptyString(payload.moduleId) ?? "unknown";
+    const kind = asNonEmptyString(meta?.kind) ?? asNonEmptyString(payload.kind) ?? "unknown";
+    const name = asNonEmptyString(meta?.name) ?? asNonEmptyString(payload.label) ?? "effectop";
+    ops.push({
+      anchor: { instanceId, txnSeq, opSeq },
+      moduleId,
+      kind,
+      name,
+      meta: canonicalizeOpMeta(opMeta)
+    });
+  }
+  ops.sort((a, b) => {
+    if (a.anchor.instanceId !== b.anchor.instanceId) return a.anchor.instanceId.localeCompare(b.anchor.instanceId);
+    if (a.anchor.txnSeq !== b.anchor.txnSeq) return a.anchor.txnSeq - b.anchor.txnSeq;
+    return a.anchor.opSeq - b.anchor.opSeq;
+  });
+  return ops;
+};
+var anchorKey = (a) => `${a.instanceId}::t${a.txnSeq}::o${a.opSeq}`;
+var diffKernelContractTraceOps = (before, after) => {
+  const changes = [];
+  const beforeByKey = /* @__PURE__ */ new Map();
+  const afterByKey = /* @__PURE__ */ new Map();
+  for (const op of before) {
+    beforeByKey.set(anchorKey(op.anchor), op);
+  }
+  for (const op of after) {
+    afterByKey.set(anchorKey(op.anchor), op);
+  }
+  const allKeys = Array.from(/* @__PURE__ */ new Set([...beforeByKey.keys(), ...afterByKey.keys()])).sort((a, b) => a.localeCompare(b));
+  for (const key of allKeys) {
+    const b = beforeByKey.get(key);
+    const a = afterByKey.get(key);
+    if (!b && a) {
+      changes.push({
+        code: "op.added",
+        anchor: a.anchor,
+        after: a
+      });
+      continue;
+    }
+    if (b && !a) {
+      changes.push({
+        code: "op.removed",
+        anchor: b.anchor,
+        before: b
+      });
+      continue;
+    }
+    if (!b || !a) continue;
+    const bJson = stableStringify(b);
+    const aJson = stableStringify(a);
+    if (bJson !== aJson) {
+      changes.push({
+        code: "op.changed",
+        anchor: b.anchor,
+        before: b,
+        after: a
+      });
+    }
+  }
+  const summary = {
+    added: changes.filter((c) => c.code === "op.added").length,
+    removed: changes.filter((c) => c.code === "op.removed").length,
+    changed: changes.filter((c) => c.code === "op.changed").length
+  };
+  return { changes, summary };
+};
+var VERSION = "v1";
+var runOnce = (rootImpl, run, options) => Effect.gen(function* () {
+  const interaction = run?.interaction;
+  const program = Effect.gen(function* () {
+    const ctx = yield* rootImpl.layer.pipe(Layer.build);
+    const runtime = Context.get(ctx, rootImpl.module);
+    if (interaction) {
+      yield* interaction(runtime);
+    }
+    return runtime.instanceId;
+  });
+  const traceLayer = Layer.succeed(EffectOpMiddlewareTag, {
+    stack: [makeTraceEffectOpObserver()]
+  });
+  const extraLayer = run?.layer ? Layer.mergeAll(traceLayer, run.layer) : traceLayer;
+  const result = yield* trialRun(program, {
+    runId: run?.runId,
+    diagnosticsLevel: options.diagnosticsLevel ?? "light",
+    maxEvents: options.maxEvents,
+    layer: extraLayer,
+    runtimeServicesInstanceOverrides: run?.runtimeServicesInstanceOverrides
+  });
+  const ok = Exit.isSuccess(result.exit);
+  const error = Exit.isFailure(result.exit) && result.exit.cause != null ? (() => {
+    const failure = Exit.isFailure(result.exit) ? result.exit.cause : void 0;
+    const err = failure?._tag === "Die" ? failure.defect : failure;
+    if (err instanceof Error) {
+      return { name: err.name, message: err.message };
+    }
+    return { name: "UnknownError", message: String(err ?? "unknown") };
+  })() : void 0;
+  const runtimeSummary = extractRuntimeSummary(result.evidence);
+  const traceOps = extractKernelContractTraceOps(result.evidence);
+  const traceDigest = fnv1a32(stableStringify(traceOps));
+  return {
+    summary: {
+      ok,
+      kernelImplementationRef: runtimeSummary.kernelImplementationRef,
+      runtimeServicesEvidence: runtimeSummary.runtimeServicesEvidence,
+      trace: { digest: traceDigest, opCount: traceOps.length },
+      ...error ? { error } : {}
+    },
+    traceOps
+  };
+});
+var verifyKernelContract = (root, options) => Effect.gen(function* () {
+  const rootImpl = resolveRootImpl(root);
+  const beforeRun = yield* runOnce(rootImpl, options?.before, {
+    diagnosticsLevel: options?.diagnosticsLevel,
+    maxEvents: options?.maxEvents
+  });
+  const afterRun = yield* runOnce(rootImpl, options?.after, {
+    diagnosticsLevel: options?.diagnosticsLevel,
+    maxEvents: options?.maxEvents
+  });
+  const hasRunFailure = !beforeRun.summary.ok || !afterRun.summary.ok;
+  const diff = hasRunFailure ? { changes: [{ code: "run.failure" }], summary: { added: 0, removed: 0, changed: 0 } } : diffKernelContractTraceOps(beforeRun.traceOps, afterRun.traceOps);
+  const verdict = hasRunFailure || diff.changes.length > 0 ? "FAIL" : "PASS";
+  return {
+    version: VERSION,
+    verdict,
+    before: beforeRun.summary,
+    after: afterRun.summary,
+    changes: diff.changes,
+    summary: diff.summary
+  };
+});
+
+// src/Reflection.ts
+var resolveRootImpl2 = (root) => root?._tag === "ModuleImpl" ? root : root?.impl;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var stableJson = (value) => JSON.stringify(value) ?? "";
+var diffMetaKeys = (before, after) => {
+  const b = isRecord2(before) ? before : {};
+  const a = isRecord2(after) ? after : {};
+  const keys = Array.from(/* @__PURE__ */ new Set([...Object.keys(b), ...Object.keys(a)])).sort((x, y) => x.localeCompare(y));
+  const changed = [];
+  for (const k of keys) {
+    if (stableJson(b[k]) !== stableJson(a[k])) {
+      changed.push(k);
+    }
+  }
+  return changed;
+};
+var tryAllowlistKernelContractDiff = (args) => {
+  if (args.allowlist.length === 0) {
+    return { verdict: args.result.verdict, allowedDiffs: [] };
+  }
+  const allow = /* @__PURE__ */ new Map();
+  for (const item of args.allowlist) {
+    allow.set(item.metaKey, item.reason);
+  }
+  const allowedCounts = /* @__PURE__ */ new Map();
+  for (const change of args.result.changes) {
+    if (change.code !== "op.changed") {
+      return { verdict: "FAIL", allowedDiffs: [] };
+    }
+    const before = change.before;
+    const after = change.after;
+    if (!isRecord2(before) || !isRecord2(after)) {
+      return { verdict: "FAIL", allowedDiffs: [] };
+    }
+    const anchorBefore = before.anchor;
+    const anchorAfter = after.anchor;
+    if (stableJson(anchorBefore) !== stableJson(anchorAfter)) {
+      return { verdict: "FAIL", allowedDiffs: [] };
+    }
+    if (stableJson(before.moduleId) !== stableJson(after.moduleId)) {
+      return { verdict: "FAIL", allowedDiffs: [] };
+    }
+    if (stableJson(before.kind) !== stableJson(after.kind)) {
+      return { verdict: "FAIL", allowedDiffs: [] };
+    }
+    if (stableJson(before.name) !== stableJson(after.name)) {
+      return { verdict: "FAIL", allowedDiffs: [] };
+    }
+    const changed = diffMetaKeys(before.meta, after.meta);
+    for (const metaKey of changed) {
+      if (!allow.has(metaKey)) {
+        return { verdict: "FAIL", allowedDiffs: [] };
+      }
+      allowedCounts.set(metaKey, (allowedCounts.get(metaKey) ?? 0) + 1);
+    }
+  }
+  const allowedDiffs = Array.from(allowedCounts.entries()).map(([metaKey, count]) => ({
+    metaKey,
+    count,
+    ...allow.get(metaKey) ? { reason: allow.get(metaKey) } : {}
+  })).sort((a, b) => a.metaKey.localeCompare(b.metaKey));
+  return { verdict: "PASS", allowedDiffs };
+};
+var extractManifest2 = (module, options) => extractManifest(module, options);
+var diffManifest2 = (before, after, options) => diffManifest(before, after, options);
+var exportStaticIr2 = (module) => exportStaticIr(module);
+var verifyKernelContract2 = (module, options) => verifyKernelContract(module, options);
+var verifyFullCutoverGate = (module, options) => Effect2.gen(function* () {
+  const rootImpl = resolveRootImpl2(module);
+  const contractDiagnosticsLevel = options?.diagnosticsLevel === "off" ? "light" : options?.diagnosticsLevel ?? "light";
+  const contract = yield* verifyKernelContract(module, {
+    ...options,
+    diagnosticsLevel: contractDiagnosticsLevel
+  });
+  const allowlistEnabled = options?.enableContractMetaAllowlist === true;
+  const allowlist = allowlistEnabled ? KernelContractMetaAllowlist : [];
+  const contractAllowed = tryAllowlistKernelContractDiff({ result: contract, allowlist });
+  const contractVerdict = allowlistEnabled ? contractAllowed.verdict : contract.verdict;
+  const gateRun = options?.gateAfter ?? options?.after;
+  const gateProgram = Effect2.gen(function* () {
+    const ctx = yield* rootImpl.layer.pipe(Layer2.build);
+    const runtime = Context2.get(ctx, rootImpl.module);
+    if (gateRun?.interaction) {
+      yield* gateRun.interaction(runtime);
+    }
+    return {
+      kernelImplementationRef: getKernelImplementationRef(runtime),
+      runtimeServicesEvidence: getRuntimeServicesEvidence(runtime)
+    };
+  });
+  const gateResult = yield* trialRun(gateProgram, {
+    runId: gateRun?.runId,
+    diagnosticsLevel: options?.gateDiagnosticsLevel ?? "off",
+    layer: gateRun?.layer,
+    runtimeServicesInstanceOverrides: gateRun?.runtimeServicesInstanceOverrides
+  });
+  const gateValue = Exit2.isSuccess(gateResult.exit) ? gateResult.exit.value : (() => {
+    const msg = Exit2.isFailure(gateResult.exit) ? String(gateResult.exit.cause ?? "trial-run failed") : "trial-run failed";
+    throw new Error(msg);
+  })();
+  const gate = evaluateFullCutoverGate({
+    mode: options?.mode ?? "fullCutover",
+    requestedKernelId: gateValue.kernelImplementationRef.kernelId,
+    runtimeServicesEvidence: gateValue.runtimeServicesEvidence,
+    diagnosticsLevel: options?.gateDiagnosticsLevel ?? "off"
+  });
+  const verdict = gate.verdict === "PASS" && contractVerdict === "PASS" ? "PASS" : "FAIL";
+  return {
+    version: "v1",
+    verdict,
+    gate,
+    contract,
+    contractVerdict,
+    ...allowlistEnabled ? { allowedDiffs: contractAllowed.allowedDiffs } : {}
+  };
+});
+
+export {
+  extractManifest2 as extractManifest,
+  diffManifest2 as diffManifest,
+  exportStaticIr2 as exportStaticIr,
+  verifyKernelContract2 as verifyKernelContract,
+  verifyFullCutoverGate,
+  Reflection_exports
+};
+//# sourceMappingURL=chunk-DFNM3WX2.js.map