@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-MXE7HIBM.js

@@ -0,0 +1,474 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  exportStaticIr,
+  fnv1a32,
+  stableStringify
+} from "./chunk-QGIM3FQK.js";
+import {
+  getModuleTraitsProgram
+} from "./chunk-6FKWRVP4.js";
+import {
+  isJsonValue
+} from "./chunk-RYSSJBGX.js";
+
+// ../logix-core/src/internal/reflection/staticIr.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isModuleImpl = (value) => isRecord(value) && value._tag === "ModuleImpl" && isRecord(value.module);
+var resolveModuleId = (input) => {
+  if (isModuleImpl(input)) {
+    const id = input.module.id;
+    return typeof id === "string" && id.length > 0 ? id : "unknown";
+  }
+  if (isRecord(input)) {
+    const id = input.id;
+    if (typeof id === "string" && id.length > 0) return id;
+    const tag = input.tag;
+    if (tag && (typeof tag === "object" || typeof tag === "function")) {
+      const tagId = tag.id;
+      if (typeof tagId === "string" && tagId.length > 0) return tagId;
+    }
+  }
+  return "unknown";
+};
+var resolveModuleTag = (input) => {
+  if (isModuleImpl(input)) return input.module;
+  if (isRecord(input) && input.tag) return input.tag;
+  return void 0;
+};
+var exportStaticIr2 = (module) => {
+  const tag = resolveModuleTag(module);
+  if (!tag) return void 0;
+  const program = getModuleTraitsProgram(tag);
+  if (!program) return void 0;
+  return exportStaticIr({
+    program,
+    moduleId: resolveModuleId(module)
+  });
+};
+
+// ../logix-core/src/internal/reflection/manifest.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isModuleImpl2 = (value) => isRecord2(value) && value._tag === "ModuleImpl" && isRecord2(value.module);
+var resolveModuleId2 = (input) => {
+  if (isModuleImpl2(input)) {
+    const id = input.module.id;
+    return typeof id === "string" && id.length > 0 ? id : "unknown";
+  }
+  if (isRecord2(input)) {
+    const id = input.id;
+    if (typeof id === "string" && id.length > 0) return id;
+    const tag = input.tag;
+    if (tag && (typeof tag === "object" || typeof tag === "function")) {
+      const tagId = tag.id;
+      if (typeof tagId === "string" && tagId.length > 0) return tagId;
+    }
+  }
+  return "unknown";
+};
+var resolveActionKeys = (input) => {
+  const tag = isModuleImpl2(input) ? input.module : input?.tag;
+  const actionMap = tag?.shape?.actionMap;
+  if (!isRecord2(actionMap)) return [];
+  return Object.keys(actionMap).sort();
+};
+var resolveSchemaKeys = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const schemas = input.schemas;
+  if (!isRecord2(schemas)) return void 0;
+  return Object.keys(schemas).sort();
+};
+var resolveSource = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const dev = input.dev;
+  const source = dev?.source;
+  if (!isRecord2(source)) return void 0;
+  const file = source.file;
+  const line = source.line;
+  const column = source.column;
+  if (typeof file !== "string" || file.length === 0) return void 0;
+  if (typeof line !== "number" || !Number.isInteger(line) || line < 1) return void 0;
+  if (typeof column !== "number" || !Number.isInteger(column) || column < 1) return void 0;
+  return { file, line, column };
+};
+var resolveMeta = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const meta = input.meta;
+  if (!isRecord2(meta)) return void 0;
+  const out = {};
+  for (const key of Object.keys(meta).sort()) {
+    const value = meta[key];
+    if (isJsonValue(value)) {
+      out[key] = value;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var MODULE_INTERNAL = /* @__PURE__ */ Symbol.for("logix.module.internal");
+var resolveLogicUnits = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const internal = input[MODULE_INTERNAL];
+  const mounted = internal?.mounted;
+  if (!Array.isArray(mounted)) return void 0;
+  const out = [];
+  for (const unit of mounted) {
+    if (!isRecord2(unit)) continue;
+    const kind = unit.kind;
+    const id = unit.id;
+    if (typeof kind !== "string" || kind.length === 0) continue;
+    if (typeof id !== "string" || id.length === 0) continue;
+    const derived = unit.derived === true ? true : void 0;
+    const name = typeof unit.name === "string" ? unit.name : void 0;
+    out.push({ kind, id, derived, name });
+  }
+  out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : a.kind.localeCompare(b.kind));
+  return out.length > 0 ? out : void 0;
+};
+var digestOf = (base) => `manifest:025:${fnv1a32(stableStringify(base))}`;
+var utf8ByteLength = (value) => {
+  const json = JSON.stringify(value);
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(json).length;
+  }
+  return json.length;
+};
+var applyMaxBytes = (manifest, maxBytes) => {
+  const originalBytes = utf8ByteLength(manifest);
+  if (originalBytes <= maxBytes) return manifest;
+  const dropped = [];
+  const truncatedArrays = [];
+  const baseMarker = () => ({
+    truncated: true,
+    maxBytes,
+    originalBytes,
+    dropped,
+    truncatedArrays
+  });
+  const withMarker = (next2) => {
+    const meta = {
+      __logix: baseMarker()
+    };
+    return { ...next2, meta };
+  };
+  let next = withMarker(manifest);
+  const dropField = (field) => {
+    if (next[field] !== void 0) {
+      dropped.push(String(field));
+      next = withMarker({ ...next, [field]: void 0 });
+    }
+  };
+  dropField("meta");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("source");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("staticIr");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("logicUnits");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("schemaKeys");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  while (utf8ByteLength(next) > maxBytes && next.actionKeys.length > 1) {
+    truncatedArrays.push("actionKeys");
+    next = withMarker({
+      ...next,
+      actionKeys: next.actionKeys.slice(0, Math.ceil(next.actionKeys.length / 2))
+    });
+  }
+  return next;
+};
+var extractManifest = (module, options) => {
+  const manifestVersion = "025";
+  const moduleId = resolveModuleId2(module);
+  const actionKeys = resolveActionKeys(module);
+  const schemaKeys = resolveSchemaKeys(module);
+  const logicUnits = resolveLogicUnits(module);
+  const source = resolveSource(module);
+  const meta = resolveMeta(module);
+  const staticIr = options?.includeStaticIr ? exportStaticIr2(module) : void 0;
+  const digestBase = {
+    manifestVersion,
+    moduleId,
+    actionKeys,
+    schemaKeys,
+    logicUnits,
+    staticIrDigest: staticIr?.digest
+  };
+  const digest = digestOf(digestBase);
+  const manifest = {
+    manifestVersion,
+    moduleId,
+    actionKeys,
+    schemaKeys,
+    logicUnits,
+    source,
+    meta,
+    staticIr,
+    digest
+  };
+  const maxBytes = options?.budgets?.maxBytes;
+  if (typeof maxBytes === "number" && Number.isFinite(maxBytes) && maxBytes > 0) {
+    return applyMaxBytes(manifest, maxBytes);
+  }
+  return manifest;
+};
+
+// ../logix-core/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
+  };
+};
+
+// ../logix-core/src/Reflection.ts
+var extractManifest2 = (module, options) => extractManifest(module, options);
+var diffManifest2 = (before, after, options) => diffManifest(before, after, options);
+var exportStaticIr3 = (module) => exportStaticIr2(module);
+
+export {
+  extractManifest2 as extractManifest,
+  diffManifest2 as diffManifest,
+  exportStaticIr3 as exportStaticIr
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/reflection/staticIr.ts", "../../../../logix-core/src/internal/reflection/manifest.ts", "../../../../logix-core/src/internal/reflection/diff.ts", "../../../../logix-core/src/Reflection.ts"],
  "sourcesContent": ["import type { AnyModuleShape, ModuleImpl } from \"../runtime/core/module.js\"\nimport { getModuleTraitsProgram } from \"../runtime/core/runtimeInternalsAccessor.js\"\nimport type { StaticIr } from \"../state-trait/ir.js\"\nimport type { StateTraitProgram } from \"../state-trait/model.js\"\nimport { exportStaticIr as exportStateTraitStaticIr } from \"../state-trait/ir.js\"\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nconst isModuleImpl = (value: unknown): value is ModuleImpl<any, AnyModuleShape, any> =>\n  isRecord(value) && value._tag === \"ModuleImpl\" && isRecord(value.module)\n\nconst resolveModuleId = (input: unknown): string => {\n  if (isModuleImpl(input)) {\n    const id = (input.module as any).id\n    return typeof id === \"string\" && id.length > 0 ? id : \"unknown\"\n  }\n\n  if (isRecord(input)) {\n    const id = input.id\n    if (typeof id === \"string\" && id.length > 0) return id\n    const tag = (input as any).tag\n    if (tag && (typeof tag === \"object\" || typeof tag === \"function\")) {\n      const tagId = (tag as any).id\n      if (typeof tagId === \"string\" && tagId.length > 0) return tagId\n    }\n  }\n\n  return \"unknown\"\n}\n\nconst resolveModuleTag = (input: unknown): unknown => {\n  if (isModuleImpl(input)) return input.module\n  if (isRecord(input) && (input as any).tag) return (input as any).tag\n  return undefined\n}\n\nexport const exportStaticIr = (module: unknown): StaticIr | undefined => {\n  const tag = resolveModuleTag(module)\n  if (!tag) return undefined\n\n  const program = getModuleTraitsProgram(tag) as StateTraitProgram<any> | undefined\n  if (!program) return undefined\n\n  return exportStateTraitStaticIr({\n    program,\n    moduleId: resolveModuleId(module),\n  })\n}\n\n", "import type { AnyModuleShape, ModuleImpl } from \"../runtime/core/module.js\"\nimport { stableStringify, fnv1a32 } from \"../digest.js\"\nimport { isJsonValue, type JsonValue } from \"../observability/jsonValue.js\"\nimport { exportStaticIr } from \"./staticIr.js\"\n\nexport interface ManifestBudgets {\n  readonly maxBytes?: number\n}\n\nexport interface ExtractManifestOptions {\n  readonly includeStaticIr?: boolean\n  readonly budgets?: ManifestBudgets\n}\n\nexport interface ModuleManifestLogicUnit {\n  readonly kind: string\n  readonly id: string\n  readonly derived?: boolean\n  readonly name?: string\n}\n\nexport interface ModuleManifest {\n  readonly manifestVersion: string\n  readonly moduleId: string\n  readonly actionKeys: ReadonlyArray<string>\n  readonly schemaKeys?: ReadonlyArray<string>\n  readonly logicUnits?: ReadonlyArray<ModuleManifestLogicUnit>\n  readonly source?: {\n    readonly file: string\n    readonly line: number\n    readonly column: number\n  }\n  readonly meta?: Record<string, JsonValue>\n  readonly staticIr?: ReturnType<typeof exportStaticIr>\n  readonly digest: string\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nconst isModuleImpl = (value: unknown): value is ModuleImpl<any, AnyModuleShape, any> =>\n  isRecord(value) && value._tag === \"ModuleImpl\" && isRecord(value.module)\n\nconst resolveModuleId = (input: unknown): string => {\n  if (isModuleImpl(input)) {\n    const id = (input.module as any).id\n    return typeof id === \"string\" && id.length > 0 ? id : \"unknown\"\n  }\n\n  if (isRecord(input)) {\n    const id = input.id\n    if (typeof id === \"string\" && id.length > 0) return id\n    const tag = (input as any).tag\n    if (tag && (typeof tag === \"object\" || typeof tag === \"function\")) {\n      const tagId = (tag as any).id\n      if (typeof tagId === \"string\" && tagId.length > 0) return tagId\n    }\n  }\n\n  return \"unknown\"\n}\n\nconst resolveActionKeys = (input: unknown): ReadonlyArray<string> => {\n  const tag = isModuleImpl(input) ? (input.module as any) : (input as any)?.tag\n  const actionMap = tag?.shape?.actionMap\n  if (!isRecord(actionMap)) return []\n  return Object.keys(actionMap).sort()\n}\n\nconst resolveSchemaKeys = (input: unknown): ReadonlyArray<string> | undefined => {\n  if (!isRecord(input)) return undefined\n  const schemas = (input as any).schemas\n  if (!isRecord(schemas)) return undefined\n  return Object.keys(schemas).sort()\n}\n\nconst resolveSource = (input: unknown): ModuleManifest[\"source\"] | undefined => {\n  if (!isRecord(input)) return undefined\n  const dev = (input as any).dev\n  const source = dev?.source\n  if (!isRecord(source)) return undefined\n  const file = source.file\n  const line = source.line\n  const column = source.column\n  if (typeof file !== \"string\" || file.length === 0) return undefined\n  if (typeof line !== \"number\" || !Number.isInteger(line) || line < 1) return undefined\n  if (typeof column !== \"number\" || !Number.isInteger(column) || column < 1) return undefined\n  return { file, line, column }\n}\n\nconst resolveMeta = (input: unknown): Record<string, JsonValue> | undefined => {\n  if (!isRecord(input)) return undefined\n  const meta = (input as any).meta\n  if (!isRecord(meta)) return undefined\n\n  const out: Record<string, JsonValue> = {}\n  for (const key of Object.keys(meta).sort()) {\n    const value = meta[key]\n    if (isJsonValue(value)) {\n      out[key] = value\n    }\n  }\n  return Object.keys(out).length > 0 ? out : undefined\n}\n\nconst MODULE_INTERNAL = Symbol.for(\"logix.module.internal\")\n\nconst resolveLogicUnits = (\n  input: unknown,\n): ReadonlyArray<ModuleManifestLogicUnit> | undefined => {\n  if (!isRecord(input)) return undefined\n  const internal = (input as any)[MODULE_INTERNAL]\n  const mounted = internal?.mounted\n  if (!Array.isArray(mounted)) return undefined\n\n  const out: Array<ModuleManifestLogicUnit> = []\n  for (const unit of mounted) {\n    if (!isRecord(unit)) continue\n    const kind = unit.kind\n    const id = unit.id\n    if (typeof kind !== \"string\" || kind.length === 0) continue\n    if (typeof id !== \"string\" || id.length === 0) continue\n\n    const derived = unit.derived === true ? true : undefined\n    const name = typeof unit.name === \"string\" ? unit.name : undefined\n    out.push({ kind, id, derived, name })\n  }\n\n  out.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : a.kind.localeCompare(b.kind)))\n  return out.length > 0 ? out : undefined\n}\n\ntype DigestBase = {\n  readonly manifestVersion: string\n  readonly moduleId: string\n  readonly actionKeys: ReadonlyArray<string>\n  readonly schemaKeys?: ReadonlyArray<string>\n  readonly logicUnits?: ReadonlyArray<ModuleManifestLogicUnit>\n  readonly staticIrDigest?: string\n}\n\nconst digestOf = (base: DigestBase): string =>\n  `manifest:025:${fnv1a32(stableStringify(base))}`\n\nconst utf8ByteLength = (value: unknown): number => {\n  const json = JSON.stringify(value)\n  if (typeof TextEncoder !== \"undefined\") {\n    return new TextEncoder().encode(json).length\n  }\n  return json.length\n}\n\nconst applyMaxBytes = (manifest: ModuleManifest, maxBytes: number): ModuleManifest => {\n  const originalBytes = utf8ByteLength(manifest)\n  if (originalBytes <= maxBytes) return manifest\n\n  const dropped: Array<string> = []\n  const truncatedArrays: Array<string> = []\n\n  const baseMarker = (): JsonValue => ({\n    truncated: true,\n    maxBytes,\n    originalBytes,\n    dropped,\n    truncatedArrays,\n  })\n\n  const withMarker = (next: ModuleManifest): ModuleManifest => {\n    const meta: Record<string, JsonValue> = {\n      __logix: baseMarker(),\n    }\n    return { ...next, meta }\n  }\n\n  let next: ModuleManifest = withMarker(manifest)\n\n  const dropField = (field: keyof ModuleManifest): void => {\n    if ((next as any)[field] !== undefined) {\n      dropped.push(String(field))\n      next = withMarker({ ...(next as any), [field]: undefined })\n    }\n  }\n\n  // Deterministic trimming order (least valuable first).\n  dropField(\"meta\")\n  if (utf8ByteLength(next) <= maxBytes) return next\n\n  dropField(\"source\")\n  if (utf8ByteLength(next) <= maxBytes) return next\n\n  dropField(\"staticIr\")\n  if (utf8ByteLength(next) <= maxBytes) return next\n\n  dropField(\"logicUnits\")\n  if (utf8ByteLength(next) <= maxBytes) return next\n\n  dropField(\"schemaKeys\")\n  if (utf8ByteLength(next) <= maxBytes) return next\n\n  // Last resort: truncate actionKeys (still deterministic, but signals truncation).\n  while (utf8ByteLength(next) > maxBytes && next.actionKeys.length > 1) {\n    truncatedArrays.push(\"actionKeys\")\n    next = withMarker({\n      ...next,\n      actionKeys: next.actionKeys.slice(0, Math.ceil(next.actionKeys.length / 2)),\n    })\n  }\n\n  return next\n}\n\nexport const extractManifest = (\n  module: unknown,\n  options?: ExtractManifestOptions,\n): ModuleManifest => {\n  const manifestVersion = \"025\"\n  const moduleId = resolveModuleId(module)\n  const actionKeys = resolveActionKeys(module)\n\n  const schemaKeys = resolveSchemaKeys(module)\n  const logicUnits = resolveLogicUnits(module)\n  const source = resolveSource(module)\n  const meta = resolveMeta(module)\n\n  const staticIr = options?.includeStaticIr ? exportStaticIr(module) : undefined\n\n  const digestBase: DigestBase = {\n    manifestVersion,\n    moduleId,\n    actionKeys,\n    schemaKeys,\n    logicUnits,\n    staticIrDigest: staticIr?.digest,\n  }\n\n  const digest = digestOf(digestBase)\n\n  const manifest: ModuleManifest = {\n    manifestVersion,\n    moduleId,\n    actionKeys,\n    schemaKeys,\n    logicUnits,\n    source,\n    meta,\n    staticIr,\n    digest,\n  }\n\n  const maxBytes = options?.budgets?.maxBytes\n  if (typeof maxBytes === \"number\" && Number.isFinite(maxBytes) && maxBytes > 0) {\n    return applyMaxBytes(manifest, maxBytes)\n  }\n\n  return manifest\n}\n", "import { stableStringify } from \"../digest.js\"\nimport type { JsonValue } from \"../observability/jsonValue.js\"\nimport type { ModuleManifest, ModuleManifestLogicUnit } from \"./manifest.js\"\n\nexport type ManifestDiffSeverity = \"BREAKING\" | \"RISKY\" | \"INFO\"\nexport type ManifestDiffVerdict = \"PASS\" | \"WARN\" | \"FAIL\"\n\nexport interface ModuleManifestDiffChange {\n  readonly severity: ManifestDiffSeverity\n  readonly code: string\n  readonly message?: string\n  readonly pointer?: string\n  readonly details?: JsonValue\n}\n\nexport interface ModuleManifestDiffSummary {\n  readonly breaking: number\n  readonly risky: number\n  readonly info: number\n}\n\nexport interface ModuleManifestDiff {\n  readonly version: string\n  readonly moduleId: string\n  readonly before: {\n    readonly digest: string\n    readonly manifestVersion?: string\n  }\n  readonly after: {\n    readonly digest: string\n    readonly manifestVersion?: string\n  }\n  readonly verdict: ManifestDiffVerdict\n  readonly changes: ReadonlyArray<ModuleManifestDiffChange>\n  readonly summary: ModuleManifestDiffSummary\n}\n\nexport interface DiffManifestOptions {\n  /**\n   * metaAllowlist\uFF1A\n   * - \u4E0D\u63D0\u4F9B\uFF1Ameta \u5168\u91CF\u5BF9\u6BD4\uFF08\u9ED8\u8BA4\u90FD\u89C6\u4E3A RISKY\uFF09\u3002\n   * - \u63D0\u4F9B\uFF1A\u4EC5\u5BF9 allowlist \u5185 key \u505A meta diff\uFF08\u5176\u4F59\u5FFD\u7565\uFF09\u3002\n   */\n  readonly metaAllowlist?: ReadonlyArray<string>\n}\n\nconst SEVERITY_RANK: Record<ManifestDiffSeverity, number> = {\n  BREAKING: 0,\n  RISKY: 1,\n  INFO: 2,\n}\n\nconst uniqSorted = (input: ReadonlyArray<string>): ReadonlyArray<string> => {\n  const out = Array.from(new Set(input.filter((x) => typeof x === \"string\" && x.length > 0)))\n  out.sort((a, b) => a.localeCompare(b))\n  return out\n}\n\nconst diffStringKeys = (\n  before: ReadonlyArray<string> | undefined,\n  after: ReadonlyArray<string> | undefined,\n): { readonly removed: ReadonlyArray<string>; readonly added: ReadonlyArray<string> } => {\n  const beforeSet = new Set(uniqSorted(before ?? []))\n  const afterSet = new Set(uniqSorted(after ?? []))\n\n  const removed: string[] = []\n  for (const k of beforeSet) {\n    if (!afterSet.has(k)) removed.push(k)\n  }\n  removed.sort((a, b) => a.localeCompare(b))\n\n  const added: string[] = []\n  for (const k of afterSet) {\n    if (!beforeSet.has(k)) added.push(k)\n  }\n  added.sort((a, b) => a.localeCompare(b))\n\n  return { removed, added }\n}\n\nconst eqJsonValue = (a: unknown, b: unknown): boolean => stableStringify(a) === stableStringify(b)\n\nconst indexLogicUnits = (\n  input: ReadonlyArray<ModuleManifestLogicUnit> | undefined,\n): ReadonlyMap<string, ModuleManifestLogicUnit> => {\n  const map = new Map<string, ModuleManifestLogicUnit>()\n  for (const unit of input ?? []) {\n    if (!unit || typeof unit !== \"object\") continue\n    const id = (unit as any).id\n    if (typeof id !== \"string\" || id.length === 0) continue\n    map.set(id, unit)\n  }\n  return map\n}\n\nexport const diffManifest = (\n  before: ModuleManifest,\n  after: ModuleManifest,\n  options?: DiffManifestOptions,\n): ModuleManifestDiff => {\n  const changes: ModuleManifestDiffChange[] = []\n\n  // Identity / protocol\n  if (before.moduleId !== after.moduleId) {\n    changes.push({\n      severity: \"BREAKING\",\n      code: \"moduleId.changed\",\n      message: `moduleId changed (${before.moduleId} -> ${after.moduleId})`,\n      pointer: \"/moduleId\",\n      details: {\n        before: before.moduleId,\n        after: after.moduleId,\n      },\n    })\n  }\n\n  if (before.manifestVersion !== after.manifestVersion) {\n    changes.push({\n      severity: \"INFO\",\n      code: \"manifestVersion.changed\",\n      message: `manifestVersion changed (${before.manifestVersion} -> ${after.manifestVersion})`,\n      pointer: \"/manifestVersion\",\n      details: {\n        before: before.manifestVersion,\n        after: after.manifestVersion,\n      },\n    })\n  }\n\n  // actionKeys\n  {\n    const { removed, added } = diffStringKeys(before.actionKeys, after.actionKeys)\n    if (removed.length > 0 || added.length > 0) {\n      changes.push({\n        severity: removed.length > 0 ? \"BREAKING\" : \"INFO\",\n        code: \"actionKeys.changed\",\n        message:\n          removed.length > 0\n            ? `actionKeys removed: ${removed.join(\", \")}`\n            : `actionKeys added: ${added.join(\", \")}`,\n        pointer: \"/actionKeys\",\n        details: { removed, added },\n      })\n    }\n  }\n\n  // schemaKeys\n  {\n    const { removed, added } = diffStringKeys(before.schemaKeys, after.schemaKeys)\n    if (removed.length > 0 || added.length > 0) {\n      changes.push({\n        severity: removed.length > 0 ? \"BREAKING\" : \"INFO\",\n        code: \"schemaKeys.changed\",\n        message:\n          removed.length > 0\n            ? `schemaKeys removed: ${removed.join(\", \")}`\n            : `schemaKeys added: ${added.join(\", \")}`,\n        pointer: \"/schemaKeys\",\n        details: { removed, added },\n      })\n    }\n  }\n\n  // logicUnits (slots)\n  {\n    const beforeById = indexLogicUnits(before.logicUnits)\n    const afterById = indexLogicUnits(after.logicUnits)\n\n    const removed: string[] = []\n    const added: string[] = []\n    const kindChanged: Array<{ readonly id: string; readonly before: string; readonly after: string }> =\n      []\n    const riskyChanged: Array<{ readonly id: string; readonly fields: ReadonlyArray<string> }> = []\n\n    for (const id of beforeById.keys()) {\n      if (!afterById.has(id)) removed.push(id)\n    }\n    for (const id of afterById.keys()) {\n      if (!beforeById.has(id)) added.push(id)\n    }\n\n    removed.sort((a, b) => a.localeCompare(b))\n    added.sort((a, b) => a.localeCompare(b))\n\n    for (const id of beforeById.keys()) {\n      const b = beforeById.get(id)\n      const a = afterById.get(id)\n      if (!b || !a) continue\n\n      const fields: string[] = []\n      if (b.kind !== a.kind) {\n        kindChanged.push({ id, before: b.kind, after: a.kind })\n        continue\n      }\n      if (b.name !== a.name) fields.push(\"name\")\n      if (b.derived !== a.derived) fields.push(\"derived\")\n      if (fields.length > 0) riskyChanged.push({ id, fields })\n    }\n\n    kindChanged.sort((x, y) => x.id.localeCompare(y.id))\n    riskyChanged.sort((x, y) => x.id.localeCompare(y.id))\n\n    if (removed.length > 0) {\n      changes.push({\n        severity: \"BREAKING\",\n        code: \"logicUnits.removed\",\n        message: `logicUnits removed: ${removed.join(\", \")}`,\n        pointer: \"/logicUnits\",\n        details: { removed },\n      })\n    }\n\n    if (kindChanged.length > 0) {\n      changes.push({\n        severity: \"BREAKING\",\n        code: \"logicUnits.kindChanged\",\n        message: `logicUnits kind changed: ${kindChanged.map((x) => x.id).join(\", \")}`,\n        pointer: \"/logicUnits\",\n        details: { kindChanged },\n      })\n    }\n\n    if (added.length > 0) {\n      changes.push({\n        severity: \"INFO\",\n        code: \"logicUnits.added\",\n        message: `logicUnits added: ${added.join(\", \")}`,\n        pointer: \"/logicUnits\",\n        details: { added },\n      })\n    }\n\n    if (riskyChanged.length > 0) {\n      changes.push({\n        severity: \"RISKY\",\n        code: \"logicUnits.changed\",\n        message: `logicUnits changed: ${riskyChanged.map((x) => x.id).join(\", \")}`,\n        pointer: \"/logicUnits\",\n        details: { changed: riskyChanged },\n      })\n    }\n  }\n\n  // staticIr.digest\n  {\n    const beforeDigest = before.staticIr?.digest\n    const afterDigest = after.staticIr?.digest\n    if (beforeDigest !== afterDigest) {\n      changes.push({\n        severity: \"RISKY\",\n        code: \"staticIr.digestChanged\",\n        message: \"staticIr.digest changed\",\n        pointer: \"/staticIr/digest\",\n        details: {\n          before: beforeDigest ?? null,\n          after: afterDigest ?? null,\n        },\n      })\n    }\n  }\n\n  // meta (default: RISKY, allowlist supported)\n  {\n    const metaBefore = before.meta ?? {}\n    const metaAfter = after.meta ?? {}\n\n    const allowlist = options?.metaAllowlist\n    const keys =\n      allowlist != null\n        ? uniqSorted(allowlist)\n        : uniqSorted([...Object.keys(metaBefore), ...Object.keys(metaAfter)])\n\n    const changed: Array<{ readonly key: string; readonly before: JsonValue | null; readonly after: JsonValue | null }> =\n      []\n\n    for (const key of keys) {\n      const b = key in metaBefore ? (metaBefore as any)[key] : undefined\n      const a = key in metaAfter ? (metaAfter as any)[key] : undefined\n      if (!eqJsonValue(b, a)) {\n        changed.push({\n          key,\n          before: (b ?? null) as JsonValue | null,\n          after: (a ?? null) as JsonValue | null,\n        })\n      }\n    }\n\n    if (changed.length > 0) {\n      changes.push({\n        severity: \"RISKY\",\n        code: \"meta.changed\",\n        message: \"meta changed\",\n        pointer: \"/meta\",\n        details: {\n          keys: changed.map((x) => x.key),\n          changed,\n        },\n      })\n    }\n  }\n\n  // source (default: INFO)\n  {\n    const b = before.source\n    const a = after.source\n    if (!eqJsonValue(b ?? null, a ?? null)) {\n      changes.push({\n        severity: \"INFO\",\n        code: \"source.changed\",\n        message: \"source changed\",\n        pointer: \"/source\",\n        details: {\n          before: b ?? null,\n          after: a ?? null,\n        },\n      })\n    }\n  }\n\n  changes.sort((a, b) => {\n    const ra = SEVERITY_RANK[a.severity]\n    const rb = SEVERITY_RANK[b.severity]\n    if (ra !== rb) return ra - rb\n    const ca = a.code.localeCompare(b.code)\n    if (ca !== 0) return ca\n    const pa = a.pointer ?? \"\"\n    const pb = b.pointer ?? \"\"\n    return pa.localeCompare(pb)\n  })\n\n  const summary: ModuleManifestDiffSummary = {\n    breaking: changes.filter((c) => c.severity === \"BREAKING\").length,\n    risky: changes.filter((c) => c.severity === \"RISKY\").length,\n    info: changes.filter((c) => c.severity === \"INFO\").length,\n  }\n\n  const verdict: ManifestDiffVerdict =\n    summary.breaking > 0 ? \"FAIL\" : summary.risky > 0 ? \"WARN\" : \"PASS\"\n\n  return {\n    version: \"025\",\n    moduleId: after.moduleId,\n    before: {\n      digest: before.digest,\n      manifestVersion: before.manifestVersion,\n    },\n    after: {\n      digest: after.digest,\n      manifestVersion: after.manifestVersion,\n    },\n    verdict,\n    changes,\n    summary,\n  }\n}\n\n", "import type { AnyModuleShape, ModuleImpl } from \"./internal/module.js\"\nimport type { AnyModule } from \"./Module.js\"\nimport type { StaticIr } from \"./internal/state-trait/ir.js\"\nimport type { ExtractManifestOptions, ModuleManifest } from \"./internal/reflection/manifest.js\"\nimport * as Manifest from \"./internal/reflection/manifest.js\"\nimport * as StaticIrExport from \"./internal/reflection/staticIr.js\"\nimport type {\n  DiffManifestOptions,\n  ModuleManifestDiff,\n} from \"./internal/reflection/diff.js\"\nimport * as ManifestDiff from \"./internal/reflection/diff.js\"\n\nexport type {\n  ModuleManifest,\n  ExtractManifestOptions,\n  ModuleManifestDiff,\n  DiffManifestOptions,\n}\n\n/**\n * Reflection.extractManifest\n *\n * \u4ECE\u6700\u7EC8\u6A21\u5757\u5BF9\u8C61\uFF08`AnyModule` / `ModuleImpl`\uFF09\u63D0\u53D6\u5E73\u53F0\u53EF\u6D88\u8D39\u7684 Manifest IR\uFF08JSON\uFF0C\u53EF diff\uFF09\u3002\n */\nexport const extractManifest = (\n  module: ModuleImpl<any, AnyModuleShape, any> | AnyModule,\n  options?: ExtractManifestOptions,\n): ModuleManifest => Manifest.extractManifest(module, options)\n\n/**\n * Reflection.diffManifest\n *\n * \u5BF9\u6BD4\u4E24\u4EFD Manifest\uFF0C\u4EA7\u51FA\u7A33\u5B9A\u3001\u53EF\u673A\u8BFB\u7684\u5DEE\u5F02\u6458\u8981\uFF08CI Contract Guard / UI \u590D\u7528\uFF09\u3002\n */\nexport const diffManifest = (\n  before: ModuleManifest,\n  after: ModuleManifest,\n  options?: DiffManifestOptions,\n): ModuleManifestDiff => ManifestDiff.diffManifest(before, after, options)\n\n/**\n * Reflection.exportStaticIr\n *\n * \u82E5 module \u542B StateTrait program\uFF0C\u5219\u5BFC\u51FA canonical StaticIR\uFF08\u590D\u7528 StateTrait.exportStaticIr \u7684\u5F62\u6001\u4E0E digest\uFF09\u3002\n */\nexport const exportStaticIr = (\n  module: ModuleImpl<any, AnyModuleShape, any> | AnyModule,\n): StaticIr | undefined => StaticIrExport.exportStaticIr(module)\n"],
  "mappings": "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",
  "names": ["exportStaticIr", "isRecord", "isModuleImpl", "resolveModuleId", "next", "exportStaticIr", "extractManifest", "diffManifest", "exportStaticIr"]
}
