@logixjs/core 0.0.1

package/dist/Reflection.cjs

@@ -0,0 +1,2954 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Reflection.ts
+var Reflection_exports = {};
+__export(Reflection_exports, {
+  diffManifest: () => diffManifest2,
+  exportStaticIr: () => exportStaticIr3,
+  extractManifest: () => extractManifest2,
+  verifyFullCutoverGate: () => verifyFullCutoverGate,
+  verifyKernelContract: () => verifyKernelContract2
+});
+module.exports = __toCommonJS(Reflection_exports);
+var import_effect37 = require("effect");
+
+// src/internal/reflection/manifest.ts
+var import_effect3 = require("effect");
+
+// src/internal/action.ts
+var import_effect = require("effect");
+var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect.Schema.isSchema(value.schema);
+
+// src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record2 = value;
+    const keys = Object.keys(record2).sort((a, b) => a.localeCompare(b));
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record2[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
+// src/internal/observability/jsonValue.ts
+var isJsonValue = (input) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const loop = (value, depth) => {
+    if (depth > 64) return false;
+    if (value === null) return true;
+    switch (typeof value) {
+      case "string":
+      case "boolean":
+        return true;
+      case "number":
+        return Number.isFinite(value);
+      case "object": {
+        if (Array.isArray(value)) {
+          if (seen.has(value)) return false;
+          seen.add(value);
+          for (const item of value) {
+            if (!loop(item, depth + 1)) return false;
+          }
+          return true;
+        }
+        if (!isPlainRecord(value)) return false;
+        if (seen.has(value)) return false;
+        seen.add(value);
+        for (const v of Object.values(value)) {
+          if (!loop(v, depth + 1)) return false;
+        }
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
+  return loop(input, 0);
+};
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+var truncateString = (value, maxLen, stats) => {
+  if (value.length <= maxLen) return value;
+  stats.oversized += 1;
+  return value.slice(0, maxLen);
+};
+var mergeDowngrade = (current, next) => {
+  if (!current) return next;
+  if (current === "non_serializable" || next === "non_serializable") return "non_serializable";
+  if (current === "oversized" || next === "oversized") return "oversized";
+  return "unknown";
+};
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var asNumber = (value, stats) => {
+  if (Number.isFinite(value)) return value;
+  stats.nonSerializable += 1;
+  return String(value);
+};
+var toJsonValueInternal = (input, options, stats, seen, depth) => {
+  if (input === null) return null;
+  switch (typeof input) {
+    case "string":
+      return truncateString(input, options.maxStringLength, stats);
+    case "number":
+      return asNumber(input, stats);
+    case "boolean":
+      return input;
+    case "bigint":
+      stats.nonSerializable += 1;
+      return truncateString(input.toString(), options.maxStringLength, stats);
+    case "symbol":
+      stats.nonSerializable += 1;
+      return truncateString(input.toString(), options.maxStringLength, stats);
+    case "function":
+      stats.nonSerializable += 1;
+      return "[Function]";
+    case "undefined":
+      stats.dropped += 1;
+      return null;
+  }
+  if (depth >= options.maxDepth) {
+    stats.oversized += 1;
+    return "[Truncated]";
+  }
+  if (input instanceof Date) {
+    return input.toISOString();
+  }
+  if (input instanceof Error) {
+    stats.nonSerializable += 1;
+    return {
+      name: truncateString(input.name, options.maxStringLength, stats),
+      message: truncateString(input.message, options.maxStringLength, stats)
+    };
+  }
+  if (typeof input === "object") {
+    if (seen.has(input)) {
+      stats.nonSerializable += 1;
+      return "[Circular]";
+    }
+    seen.add(input);
+  }
+  if (Array.isArray(input)) {
+    const out2 = [];
+    const limit2 = Math.min(input.length, options.maxArrayLength);
+    for (let i = 0; i < limit2; i++) {
+      out2.push(toJsonValueInternal(input[i], options, stats, seen, depth + 1));
+    }
+    if (input.length > limit2) {
+      stats.oversized += 1;
+      out2.push(`[...${input.length - limit2} more]`);
+    }
+    return out2;
+  }
+  if (!isPlainRecord(input)) {
+    stats.nonSerializable += 1;
+    return truncateString(String(input), options.maxStringLength, stats);
+  }
+  const entries = Object.entries(input);
+  const limit = Math.min(entries.length, options.maxObjectKeys);
+  const out = {};
+  for (let i = 0; i < limit; i++) {
+    const [rawKey, rawValue] = entries[i];
+    const key = truncateString(rawKey, options.maxStringLength, stats);
+    if (rawValue === void 0) {
+      stats.dropped += 1;
+      continue;
+    }
+    out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1);
+  }
+  if (entries.length > limit) {
+    stats.oversized += 1;
+    out.__truncatedKeys = entries.length - limit;
+  }
+  return out;
+};
+var projectJsonValue = (input, options) => {
+  const resolved = { ...defaultOptions, ...options ?? {} };
+  const stats = { dropped: 0, oversized: 0, nonSerializable: 0 };
+  const seen = /* @__PURE__ */ new WeakSet();
+  let downgrade;
+  const value = toJsonValueInternal(input, resolved, stats, seen, 0);
+  if (stats.nonSerializable > 0) {
+    downgrade = mergeDowngrade(downgrade, "non_serializable");
+  }
+  if (stats.oversized > 0) {
+    downgrade = mergeDowngrade(downgrade, "oversized");
+  }
+  try {
+    const json = JSON.stringify(value);
+    if (json.length > resolved.maxJsonBytes) {
+      downgrade = mergeDowngrade(downgrade, "oversized");
+      const preview = json.slice(0, Math.min(resolved.oversizedPreviewBytes, resolved.maxJsonBytes));
+      return {
+        value: {
+          _tag: "oversized",
+          bytes: json.length,
+          preview
+        },
+        stats: {
+          dropped: stats.dropped,
+          oversized: stats.oversized + 1,
+          nonSerializable: stats.nonSerializable
+        },
+        downgrade
+      };
+    }
+  } catch {
+    downgrade = mergeDowngrade(downgrade, "non_serializable");
+    return {
+      value: "[Unserializable]",
+      stats: {
+        dropped: stats.dropped,
+        oversized: stats.oversized,
+        nonSerializable: stats.nonSerializable + 1
+      },
+      downgrade
+    };
+  }
+  return {
+    value,
+    stats: {
+      dropped: stats.dropped,
+      oversized: stats.oversized,
+      nonSerializable: stats.nonSerializable
+    },
+    downgrade
+  };
+};
+
+// src/internal/runtime/core/env.ts
+var import_effect2 = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/runtime/core/runtimeInternalsAccessor.ts
+var MODULE_TRAITS_PROGRAM = /* @__PURE__ */ Symbol.for("@logixjs/core/moduleTraitsProgram");
+var getModuleTraitsProgram = (module2) => {
+  if (!module2) return void 0;
+  if (typeof module2 !== "object" && typeof module2 !== "function") return void 0;
+  return module2[MODULE_TRAITS_PROGRAM];
+};
+
+// src/internal/field-path.ts
+var isFieldPathSegment = (seg) => {
+  if (!seg) return false;
+  if (seg === "*") return false;
+  if (/^\d+$/.test(seg)) return false;
+  if (seg.includes("[") || seg.includes("]")) return false;
+  return true;
+};
+var normalizeFieldPath = (input) => {
+  if (typeof input === "string") {
+    const segs = splitSegments(input);
+    if (!segs || segs.length === 0) return void 0;
+    const normalized2 = segs.filter(isFieldPathSegment);
+    return normalized2.length > 0 ? normalized2 : void 0;
+  }
+  if (input.length === 0) return void 0;
+  let needsFilter = false;
+  for (const seg of input) {
+    if (!isFieldPathSegment(seg)) {
+      needsFilter = true;
+      break;
+    }
+  }
+  if (!needsFilter) return input;
+  const normalized = input.filter(isFieldPathSegment);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var splitSegments = (path) => {
+  if (!path) return void 0;
+  if (path === "*") return void 0;
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part === "*") {
+      return void 0;
+    }
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      segs.push(bracket[1]);
+      continue;
+    }
+    if (/^\d+$/.test(part)) {
+      continue;
+    }
+    if (part.includes("[") || part.includes("]")) {
+      return void 0;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+
+// src/internal/state-trait/ir.ts
+var normalizeFieldPaths = (paths) => {
+  if (!paths || paths.length === 0) return [];
+  const out = [];
+  for (const path of paths) {
+    const normalized = normalizeFieldPath(path);
+    if (normalized) out.push(normalized);
+  }
+  return out;
+};
+var normalizeFieldPath2 = (path) => path ? normalizeFieldPath(path) : void 0;
+var toNodeKind = (step) => {
+  switch (step.kind) {
+    case "computed-update":
+      return "computed";
+    case "link-propagate":
+      return "link";
+    case "source-refresh":
+      return "source";
+    case "check-validate":
+      return "check";
+  }
+};
+var findEntryForStep = (program, step) => {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return void 0;
+  const kind = toNodeKind(step);
+  return program.entries.find(
+    (e) => e.fieldPath === fieldPath && (e.kind === kind || kind === "check" && e.kind === "check" || kind === "source" && e.kind === "source" || kind === "link" && e.kind === "link" || kind === "computed" && e.kind === "computed")
+  );
+};
+var getReadsForEntry = (entry) => {
+  if (!entry) return void 0;
+  if (entry.kind === "computed") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "source") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "link") {
+    const from = entry.meta.from;
+    return from ? [from] : [];
+  }
+  if (entry.kind === "check") {
+    const rules = entry.meta?.rules ?? {};
+    const out = [];
+    for (const name of Object.keys(rules)) {
+      const rule = rules[name];
+      const deps = rule?.deps;
+      if (deps) out.push(...deps);
+    }
+    return out;
+  }
+  return void 0;
+};
+var exportStaticIr = (params) => {
+  const moduleId = params.moduleId;
+  const version = params.version ?? "009";
+  const metaByField = /* @__PURE__ */ new Map();
+  for (const node of params.program.graph.nodes) {
+    const meta = node.meta;
+    if (!meta || typeof meta !== "object") continue;
+    const label = typeof meta.label === "string" ? meta.label : void 0;
+    const description = typeof meta.description === "string" ? meta.description : void 0;
+    const tags = Array.isArray(meta.tags) && meta.tags.every((t) => typeof t === "string") ? meta.tags : void 0;
+    const group = typeof meta.group === "string" ? meta.group : void 0;
+    const docsUrl = typeof meta.docsUrl === "string" ? meta.docsUrl : void 0;
+    const cacheGroup = typeof meta.cacheGroup === "string" ? meta.cacheGroup : void 0;
+    const annotationsRaw = meta.annotations;
+    const annotations = annotationsRaw && typeof annotationsRaw === "object" && !Array.isArray(annotationsRaw) ? annotationsRaw : void 0;
+    if (label || description || tags || group || docsUrl || cacheGroup || annotations) {
+      metaByField.set(node.id, {
+        label,
+        description,
+        tags,
+        group,
+        docsUrl,
+        cacheGroup,
+        annotations
+      });
+    }
+  }
+  const nodes = params.program.plan.steps.map((step) => {
+    const kind = toNodeKind(step);
+    const entry = findEntryForStep(params.program, step);
+    const reads = normalizeFieldPaths(getReadsForEntry(entry));
+    const target = step.targetFieldPath;
+    const write = normalizeFieldPath2(target);
+    const writes = write ? [write] : [];
+    const meta = target ? metaByField.get(target) : void 0;
+    const base2 = {
+      nodeId: step.id,
+      kind,
+      reads,
+      writes: kind === "check" ? [] : writes,
+      meta
+    };
+    if (kind !== "check" && target && !write) {
+      return { ...base2, writesUnknown: true };
+    }
+    return base2;
+  });
+  const edges = params.program.graph.edges.map((edge) => ({
+    edgeId: edge.id,
+    from: edge.from,
+    to: edge.to,
+    kind: edge.kind
+  }));
+  const base = {
+    version,
+    moduleId,
+    nodes,
+    edges
+  };
+  const digest = `stir:${version}:${fnv1a32(stableStringify(base))}`;
+  return {
+    ...base,
+    digest
+  };
+};
+
+// 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 = (module2) => {
+  const tag = resolveModuleTag(module2);
+  if (!tag) return void 0;
+  const program = getModuleTraitsProgram(tag);
+  if (!program) return void 0;
+  return exportStaticIr({
+    program,
+    moduleId: resolveModuleId(module2)
+  });
+};
+
+// 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 resolveDevSource = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const file = input.file;
+  const line = input.line;
+  const column = input.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 resolveTokenSource = (token) => {
+  if (!token || typeof token !== "object" && typeof token !== "function") return void 0;
+  return resolveDevSource(token.source);
+};
+var resolveActions = (input) => {
+  const tag = isModuleImpl2(input) ? input.module : input?.tag;
+  const actionMap = tag?.shape?.actionMap;
+  if (!isRecord2(actionMap)) return [];
+  const moduleSource = resolveSource(input);
+  const reducers = isRecord2(tag?.reducers) ? tag.reducers : void 0;
+  const actionTags = Object.keys(actionMap).sort();
+  const out = [];
+  for (const actionTag of actionTags) {
+    const token = actionMap[actionTag];
+    const source = resolveTokenSource(token) ?? moduleSource;
+    const payloadKind = isActionToken(token) && import_effect3.Schema.isSchema(token.schema) ? token.schema === import_effect3.Schema.Void ? "void" : "nonVoid" : "unknown";
+    const primaryReducer = reducers && typeof reducers[actionTag] === "function" ? { kind: "declared" } : void 0;
+    out.push({
+      actionTag,
+      payload: { kind: payloadKind },
+      ...primaryReducer ? { primaryReducer } : {},
+      ...source ? { source } : {}
+    });
+  }
+  return out;
+};
+var MODULE_DECLARED_EFFECTS = /* @__PURE__ */ Symbol.for("logix.module.effects.declared");
+var resolveEffects = (input) => {
+  const tag = isModuleImpl2(input) ? input.module : input?.tag;
+  const actionMap = tag?.shape?.actionMap;
+  if (!isRecord2(actionMap)) return void 0;
+  const effectsRaw = tag?.[MODULE_DECLARED_EFFECTS];
+  if (!isRecord2(effectsRaw)) return void 0;
+  const source = resolveSource(input);
+  const logicUnitId = "__logix_internal:effects:declared";
+  const handlerIds = /* @__PURE__ */ new WeakMap();
+  let nextHandlerSeq = 0;
+  const out = [];
+  for (const actionTag of Object.keys(effectsRaw).sort()) {
+    if (!(actionTag in actionMap)) continue;
+    const handlers = effectsRaw[actionTag];
+    if (!Array.isArray(handlers)) continue;
+    for (const handler of handlers) {
+      if (typeof handler !== "function") continue;
+      let handlerId = handlerIds.get(handler);
+      if (!handlerId) {
+        nextHandlerSeq += 1;
+        handlerId = `h${nextHandlerSeq}`;
+        handlerIds.set(handler, handlerId);
+      }
+      const sourceKey = `${logicUnitId}::${handlerId}`;
+      out.push({
+        actionTag,
+        sourceKey,
+        kind: "declared",
+        ...source ? { source } : {}
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const item of out) {
+    const key = `${item.actionTag}\0${item.sourceKey}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+  }
+  deduped.sort(
+    (a, b) => a.actionTag < b.actionTag ? -1 : a.actionTag > b.actionTag ? 1 : a.sourceKey.localeCompare(b.sourceKey)
+  );
+  return deduped.length > 0 ? deduped : void 0;
+};
+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;
+  return resolveDevSource(dev?.source);
+};
+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:067:${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 markTruncatedArray = (name) => {
+    if (!truncatedArrays.includes(name)) {
+      truncatedArrays.push(name);
+    }
+  };
+  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;
+  dropField("effects");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  const truncateActionsToFit = () => {
+    const total = next.actions.length;
+    if (total <= 1) return;
+    let lo = 1;
+    let hi = total;
+    let best = 1;
+    while (lo <= hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      const candidate = withMarker({
+        ...next,
+        actions: next.actions.slice(0, mid),
+        actionKeys: next.actionKeys.slice(0, mid)
+      });
+      if (utf8ByteLength(candidate) <= maxBytes) {
+        best = mid;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    if (best < total) {
+      markTruncatedArray("actions");
+      markTruncatedArray("actionKeys");
+      next = withMarker({
+        ...next,
+        actions: next.actions.slice(0, best),
+        actionKeys: next.actionKeys.slice(0, best)
+      });
+    }
+  };
+  while (utf8ByteLength(next) > maxBytes) {
+    const beforeLen = next.actions.length;
+    truncateActionsToFit();
+    if (next.actions.length === beforeLen) {
+      break;
+    }
+  }
+  return next;
+};
+var extractManifest = (module2, options) => {
+  const manifestVersion = "067";
+  const moduleId = resolveModuleId2(module2);
+  const actionKeys = resolveActionKeys(module2);
+  const actions = resolveActions(module2);
+  const effects = resolveEffects(module2);
+  const schemaKeys = resolveSchemaKeys(module2);
+  const logicUnits = resolveLogicUnits(module2);
+  const source = resolveSource(module2);
+  const meta = resolveMeta(module2);
+  const staticIr = options?.includeStaticIr ? exportStaticIr2(module2) : void 0;
+  const digestBase = {
+    manifestVersion,
+    moduleId,
+    actionKeys,
+    actions,
+    effects,
+    schemaKeys,
+    logicUnits,
+    staticIrDigest: staticIr?.digest
+  };
+  const digest = digestOf(digestBase);
+  const manifest = {
+    manifestVersion,
+    moduleId,
+    actionKeys,
+    actions,
+    effects,
+    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;
+};
+
+// 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
+var import_effect34 = require("effect");
+
+// src/internal/observability/trialRun.ts
+var import_effect33 = require("effect");
+
+// src/internal/observability/evidenceCollector.ts
+var import_effect8 = require("effect");
+
+// src/internal/observability/runSession.ts
+var import_effect4 = require("effect");
+
+// src/internal/observability/evidence.ts
+var OBSERVABILITY_PROTOCOL_VERSION = "v1";
+var exportEvidencePackage = (options) => {
+  const protocolVersion = options.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+  return {
+    protocolVersion,
+    runId: options.runId,
+    createdAt: options.createdAt ?? Date.now(),
+    source: options.source,
+    events: options.events.slice().sort((a, b) => a.seq - b.seq),
+    summary: options.summary
+  };
+};
+
+// src/internal/observability/runSession.ts
+var RunSessionTagImpl = class extends import_effect4.Context.Tag("@logixjs/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+var NEXT_RUN_SEQ_KEY = /* @__PURE__ */ Symbol.for("@logixjs/core/runSession/nextRunSeq");
+var fallbackNextRunSeq = 0;
+var nextRunSeq = () => {
+  try {
+    const g = globalThis;
+    const prev = typeof g[NEXT_RUN_SEQ_KEY] === "number" ? g[NEXT_RUN_SEQ_KEY] : 0;
+    const next = prev + 1;
+    g[NEXT_RUN_SEQ_KEY] = next;
+    return next;
+  } catch {
+    fallbackNextRunSeq += 1;
+    return fallbackNextRunSeq;
+  }
+};
+var makeRunId = (startedAt) => `run-${startedAt}.${nextRunSeq()}`;
+var makeRunSessionLocalState = () => {
+  const onceKeys = /* @__PURE__ */ new Set();
+  const seqByNamespace = /* @__PURE__ */ new Map();
+  return {
+    once: (key) => {
+      if (onceKeys.has(key)) return false;
+      onceKeys.add(key);
+      return true;
+    },
+    nextSeq: (namespace, key) => {
+      const byKey = seqByNamespace.get(namespace) ?? /* @__PURE__ */ new Map();
+      if (!seqByNamespace.has(namespace)) seqByNamespace.set(namespace, byKey);
+      const prev = byKey.get(key) ?? 0;
+      const next = prev + 1;
+      byKey.set(key, next);
+      return next;
+    },
+    clear: () => {
+      onceKeys.clear();
+      seqByNamespace.clear();
+    }
+  };
+};
+var makeRunSession = (options) => {
+  const startedAt = options?.startedAt ?? Date.now();
+  return {
+    runId: options?.runId ?? makeRunId(startedAt),
+    source: options?.source ?? { host: "unknown" },
+    startedAt,
+    local: options?.local ?? makeRunSessionLocalState()
+  };
+};
+var makeEvidenceSink = (session) => {
+  const events = [];
+  let nextSeq = 1;
+  return {
+    record: (type, payload, options) => {
+      events.push({
+        protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,
+        runId: session.runId,
+        seq: nextSeq++,
+        timestamp: options?.timestamp ?? Date.now(),
+        type,
+        payload
+      });
+    },
+    export: (options) => {
+      const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+      const maxEvents = options?.maxEvents;
+      const selected = typeof maxEvents === "number" && Number.isFinite(maxEvents) && maxEvents > 0 ? events.slice(Math.max(0, events.length - Math.floor(maxEvents))) : events.slice();
+      return exportEvidencePackage({
+        protocolVersion,
+        runId: session.runId,
+        source: session.source,
+        createdAt: options?.createdAt,
+        events: selected,
+        summary: options?.summary
+      });
+    },
+    clear: () => {
+      events.length = 0;
+      nextSeq = 1;
+    }
+  };
+};
+var runSessionLayer = (session) => import_effect4.Layer.succeed(RunSessionTag, session ?? makeRunSession());
+
+// src/internal/runtime/core/DebugSink.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect5 = require("effect");
+var truncate = (value, maxLen) => {
+  if (value.length <= maxLen) return { value, truncated: false };
+  return { value: value.slice(0, maxLen), truncated: true };
+};
+var safeStringify = (value) => {
+  try {
+    return { ok: true, json: JSON.stringify(value) };
+  } catch {
+    return { ok: false };
+  }
+};
+var getMessageFromUnknown = (cause) => {
+  if (typeof cause === "string") return cause;
+  if (typeof cause === "number" || typeof cause === "boolean" || typeof cause === "bigint") return String(cause);
+  if (cause instanceof Error) return cause.message || cause.name || "Error";
+  if (cause && typeof cause === "object" && "message" in cause && typeof cause.message === "string") {
+    return cause.message;
+  }
+  try {
+    const pretty = import_effect5.Cause.pretty(cause, { renderErrorCause: true });
+    if (typeof pretty === "string" && pretty.length > 0) return pretty;
+  } catch {
+  }
+  return "Unknown error";
+};
+var toSerializableErrorSummary = (cause, options) => {
+  const maxMessageLength = options?.maxMessageLength ?? 256;
+  const messageRaw = getMessageFromUnknown(cause);
+  const { value: message, truncated } = truncate(messageRaw, maxMessageLength);
+  const summary = {
+    message
+  };
+  if (cause instanceof Error) {
+    if (cause.name && cause.name !== "Error") summary.name = cause.name;
+    const anyCause = cause;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    else if (typeof anyCause.code === "number" && Number.isFinite(anyCause.code)) summary.code = String(anyCause.code);
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+    return {
+      errorSummary: summary,
+      downgrade: truncated ? "oversized" : void 0
+    };
+  }
+  if (cause && typeof cause === "object") {
+    const anyCause = cause;
+    if (typeof anyCause.name === "string" && anyCause.name.length > 0) summary.name = anyCause.name;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+  }
+  const stringifyResult = safeStringify(cause);
+  if (!stringifyResult.ok) {
+    return {
+      errorSummary: summary,
+      downgrade: "non_serializable"
+    };
+  }
+  if (truncated) {
+    return {
+      errorSummary: summary,
+      downgrade: "oversized"
+    };
+  }
+  if (message === "Unknown error") {
+    return {
+      errorSummary: summary,
+      downgrade: "unknown"
+    };
+  }
+  return { errorSummary: summary };
+};
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect6 = require("effect");
+var currentLinkId = import_effect6.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect6.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+
+// src/internal/runtime/core/DebugSink.ts
+var currentDebugSinks = import_effect7.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect7.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect7.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect7.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect7.FiberRef.unsafeMake("off");
+var diagnosticsLevel = (level) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var currentTraitConvergeDiagnosticsSampling = import_effect7.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var appendSinks = (sinks) => import_effect7.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [...current, ...sinks]);
+var nextGlobalEventSeq = 0;
+var nextEventSeq = () => {
+  nextGlobalEventSeq += 1;
+  return nextGlobalEventSeq;
+};
+var makeEventId = (instanceId, eventSeq) => `${instanceId}::e${eventSeq}`;
+var mergeDowngrade2 = (current, next) => {
+  if (!current) return next;
+  if (!next) return current;
+  if (current === "non_serializable" || next === "non_serializable") return "non_serializable";
+  if (current === "oversized" || next === "oversized") return "oversized";
+  return "unknown";
+};
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lastTxnByInstance = /* @__PURE__ */ new Map();
+var pendingTxnAlignmentByInstance = /* @__PURE__ */ new Map();
+var enqueuePendingTxnAlignment = (instanceId, ref) => {
+  const list = pendingTxnAlignmentByInstance.get(instanceId);
+  if (!list) {
+    pendingTxnAlignmentByInstance.set(instanceId, [ref]);
+    return;
+  }
+  list.push(ref);
+  if (list.length > 64) {
+    list.shift();
+  }
+};
+var backfillPendingTxnAlignment = (instanceId, txn) => {
+  const pending = pendingTxnAlignmentByInstance.get(instanceId);
+  if (!pending || pending.length === 0) {
+    pendingTxnAlignmentByInstance.delete(instanceId);
+    return;
+  }
+  for (const ref of pending) {
+    const anyRef = ref;
+    if (anyRef.txnId == null) {
+      anyRef.txnId = txn.txnId;
+    }
+    if (typeof anyRef.txnSeq !== "number" || anyRef.txnSeq <= 0) {
+      anyRef.txnSeq = txn.txnSeq;
+    }
+  }
+  pendingTxnAlignmentByInstance.delete(instanceId);
+};
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect7.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect7.Effect.logError(message).pipe(
+    import_effect7.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect7.Effect.logWarning(msg) : event.severity === "info" ? import_effect7.Effect.logInfo(msg) : import_effect7.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect7.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect7.Effect.void
+};
+var errorOnlyLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
+var consoleSink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect7.Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect7.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect7.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect7.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect7.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect7.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect7.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect7.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect7.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect7.Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect7.Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = import_effect7.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect7.Logger.replace(
+  import_effect7.Logger.defaultLogger,
+  import_effect7.Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => import_effect7.Effect.gen(function* () {
+  const sinks = yield* import_effect7.FiberRef.get(currentDebugSinks);
+  if (isErrorOnlyOnlySinks(sinks)) {
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      if (event.severity !== "info") {
+        yield* diagnosticLog(event);
+      } else {
+        yield* import_effect7.Effect.void;
+      }
+      return;
+    }
+    yield* import_effect7.Effect.void;
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+        return;
+      }
+      yield* import_effect7.Effect.void;
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect7.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel2 = yield* import_effect7.FiberRef.get(currentDiagnosticsLevel);
+  let now;
+  const getNow = () => {
+    if (now === void 0) now = Date.now();
+    return now;
+  };
+  if (enriched.timestamp === void 0 && (diagnosticsLevel2 !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel2 !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel = yield* import_effect7.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect7.FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel2 !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* import_effect7.FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect7.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+var toRuntimeDebugEventRef = (event, options) => {
+  const diagnosticsLevel2 = options?.diagnosticsLevel ?? "full";
+  if (diagnosticsLevel2 === "off") {
+    return void 0;
+  }
+  const isLightLike = diagnosticsLevel2 === "light" || diagnosticsLevel2 === "sampled";
+  const timestamp = typeof event.timestamp === "number" && Number.isFinite(event.timestamp) ? event.timestamp : Date.now();
+  const moduleIdRaw = event.moduleId;
+  const moduleId = typeof moduleIdRaw === "string" && moduleIdRaw.length > 0 ? moduleIdRaw : "unknown";
+  const instanceIdRaw = event.instanceId;
+  const instanceId = typeof instanceIdRaw === "string" && instanceIdRaw.length > 0 ? instanceIdRaw : "unknown";
+  const runtimeLabelRaw = event.runtimeLabel;
+  const runtimeLabel = typeof runtimeLabelRaw === "string" && runtimeLabelRaw.length > 0 ? runtimeLabelRaw : void 0;
+  const txnSeqRaw = event.txnSeq;
+  const txnSeq = typeof txnSeqRaw === "number" && Number.isFinite(txnSeqRaw) && txnSeqRaw >= 0 ? Math.floor(txnSeqRaw) : 0;
+  const txnIdRaw = event.txnId;
+  const txnId = typeof txnIdRaw === "string" && txnIdRaw.length > 0 ? txnIdRaw : txnSeq > 0 ? `${instanceId}::t${txnSeq}` : void 0;
+  const linkId = (() => {
+    const linkIdRaw = event.linkId;
+    if (typeof linkIdRaw === "string" && linkIdRaw.length > 0) return linkIdRaw;
+    if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+      return void 0;
+    }
+    const data = event.data;
+    const meta = data?.meta;
+    const linkIdFromMeta = meta?.linkId;
+    if (typeof linkIdFromMeta === "string" && linkIdFromMeta.length > 0) return linkIdFromMeta;
+    return void 0;
+  })();
+  const eventSeqRaw = options?.eventSeq;
+  const eventSeq = typeof eventSeqRaw === "number" && Number.isFinite(eventSeqRaw) && eventSeqRaw > 0 ? Math.floor(eventSeqRaw) : nextEventSeq();
+  const eventId = makeEventId(instanceId, eventSeq);
+  const base = {
+    eventId,
+    eventSeq,
+    moduleId,
+    instanceId,
+    runtimeLabel,
+    txnSeq,
+    txnId,
+    linkId,
+    timestamp
+  };
+  let downgrade;
+  const withDowngrade = (ref) => {
+    if (!downgrade) return ref;
+    return { ...ref, downgrade: { reason: downgrade } };
+  };
+  switch (event.type) {
+    case "module:init":
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: "module:init"
+      });
+    case "module:destroy":
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: "module:destroy"
+      });
+    case "lifecycle:phase": {
+      const e = event;
+      const metaInput = isLightLike ? { type: "lifecycle:phase", phase: e.phase, name: e.name } : { type: "lifecycle:phase", phase: e.phase, name: e.name, payload: e.payload };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: e.name,
+        meta: metaProjection.value
+      });
+    }
+    case "action:dispatch": {
+      const action = event.action;
+      const actionTagRaw = event.actionTag;
+      const tag = typeof actionTagRaw === "string" && actionTagRaw.length > 0 ? actionTagRaw : action?._tag ?? action?.type;
+      const label = String(tag ?? "action:dispatch");
+      const labelNormalized = label.length > 0 ? label : "unknown";
+      const unknownAction = event.unknownAction === true ? true : void 0;
+      const metaInput = isLightLike ? { actionTag: labelNormalized, ...unknownAction ? { unknownAction: true } : {} } : { action, ...unknownAction ? { unknownAction: true } : {} };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      if (unknownAction) {
+        downgrade = mergeDowngrade2(downgrade, "unknown");
+      }
+      return withDowngrade({
+        ...base,
+        kind: "action",
+        label: labelNormalized,
+        meta: metaProjection.value
+      });
+    }
+    case "state:update": {
+      const e = event;
+      const resolveDirtySetRootPaths = () => {
+        const resolve2 = options?.resolveConvergeStaticIr;
+        if (!resolve2) return void 0;
+        const digest = e.staticIrDigest;
+        if (typeof digest !== "string" || digest.length === 0) return void 0;
+        const dirtySet = e.dirtySet;
+        if (!dirtySet || typeof dirtySet !== "object" || Array.isArray(dirtySet)) return void 0;
+        const rootIds = dirtySet.rootIds;
+        if (!Array.isArray(rootIds) || rootIds.length === 0) return void 0;
+        const ir = resolve2(digest);
+        const fieldPaths = ir?.fieldPaths;
+        if (!Array.isArray(fieldPaths) || fieldPaths.length === 0) return void 0;
+        const out = [];
+        for (const rawId of rootIds) {
+          if (typeof rawId !== "number" || !Number.isFinite(rawId)) continue;
+          const id = Math.floor(rawId);
+          if (id < 0) continue;
+          const path = fieldPaths[id];
+          if (!Array.isArray(path) || path.length === 0) continue;
+          if (!path.every((seg) => typeof seg === "string" && seg.length > 0)) continue;
+          out.push(path);
+        }
+        return out.length > 0 ? out : void 0;
+      };
+      const dirtySetWithRootPaths = (() => {
+        const rootPaths = resolveDirtySetRootPaths();
+        if (!rootPaths) return e.dirtySet;
+        const dirtySet = e.dirtySet;
+        if (!dirtySet || typeof dirtySet !== "object" || Array.isArray(dirtySet)) return e.dirtySet;
+        return { ...dirtySet, rootPaths };
+      })();
+      const metaInput = isLightLike ? {
+        state: e.state,
+        dirtySet: dirtySetWithRootPaths,
+        patchCount: e.patchCount,
+        patchesTruncated: e.patchesTruncated,
+        patchesTruncatedReason: e.patchesTruncatedReason,
+        staticIrDigest: e.staticIrDigest,
+        commitMode: e.commitMode,
+        priority: e.priority,
+        originKind: e.originKind,
+        originName: e.originName
+      } : {
+        state: e.state,
+        dirtySet: dirtySetWithRootPaths,
+        patchCount: e.patchCount,
+        patchesTruncated: e.patchesTruncated,
+        patchesTruncatedReason: e.patchesTruncatedReason,
+        staticIrDigest: e.staticIrDigest,
+        commitMode: e.commitMode,
+        priority: e.priority,
+        originKind: e.originKind,
+        originName: e.originName,
+        traitSummary: e.traitSummary,
+        replayEvent: e.replayEvent
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      if (txnId) {
+        lastTxnByInstance.set(instanceId, { txnId, txnSeq });
+        backfillPendingTxnAlignment(instanceId, { txnId, txnSeq });
+      }
+      return withDowngrade({
+        ...base,
+        kind: "state",
+        label: "state:update",
+        meta: metaProjection.value
+      });
+    }
+    case "process:start":
+    case "process:stop":
+    case "process:restart":
+    case "process:trigger":
+    case "process:dispatch":
+    case "process:error": {
+      const e = event;
+      const ts2 = typeof e.timestampMs === "number" && Number.isFinite(e.timestampMs) ? e.timestampMs : timestamp;
+      const metaInput = {
+        identity: e.identity,
+        severity: e.severity,
+        eventSeq: e.eventSeq,
+        timestampMs: e.timestampMs,
+        trigger: e.trigger,
+        dispatch: e.dispatch,
+        error: e.error
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      const errorSummary = e.type === "process:error" || e.type === "process:restart" ? e.error : void 0;
+      return withDowngrade({
+        ...base,
+        timestamp: ts2,
+        kind: "process",
+        label: e.type,
+        meta: metaProjection.value,
+        errorSummary
+      });
+    }
+    case "lifecycle:error": {
+      const e = event;
+      const summary = toSerializableErrorSummary(e.cause);
+      downgrade = mergeDowngrade2(downgrade, summary.downgrade);
+      const metaInput = isLightLike ? { type: "lifecycle:error", phase: e.phase, name: e.hook } : {
+        type: "lifecycle:error",
+        phase: e.phase,
+        name: e.hook,
+        hook: e.hook,
+        taskId: e.taskId,
+        origin: e.origin,
+        txnSeq: e.txnSeq,
+        opSeq: e.opSeq
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "lifecycle",
+        label: "lifecycle:error",
+        meta: metaProjection.value,
+        errorSummary: summary.errorSummary
+      });
+    }
+    case "diagnostic": {
+      const e = event;
+      const metaInput = {
+        code: e.code,
+        severity: e.severity,
+        message: e.message,
+        hint: e.hint,
+        actionTag: e.actionTag,
+        kind: e.kind,
+        trigger: e.trigger
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.code,
+        meta: metaProjection.value
+      });
+    }
+    default: {
+      if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
+        return void 0;
+      }
+      if (event.type === "trace:txn-lane") {
+        const data = event.data;
+        const evidence = data?.evidence ?? data;
+        const metaProjection2 = projectJsonValue(evidence);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        const label = typeof evidence?.kind === "string" && evidence.kind.length > 0 ? String(evidence.kind) : "txn-lane";
+        return withDowngrade({
+          ...base,
+          kind: "txn-lane",
+          label,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:react-render" || event.type === "trace:react-selector") {
+        const data = event.data;
+        const metaProjection2 = projectJsonValue(
+          isLightLike ? {
+            componentLabel: data?.componentLabel,
+            selectorKey: data?.selectorKey,
+            fieldPaths: data?.fieldPaths,
+            selectorId: data?.selectorId,
+            lane: data?.lane,
+            producer: data?.producer,
+            fallbackReason: data?.fallbackReason,
+            readsDigest: data?.readsDigest,
+            equalsKind: data?.equalsKind,
+            strictModePhase: data?.strictModePhase
+          } : {
+            componentLabel: data?.componentLabel,
+            selectorKey: data?.selectorKey,
+            fieldPaths: data?.fieldPaths,
+            selectorId: data?.selectorId,
+            lane: data?.lane,
+            producer: data?.producer,
+            fallbackReason: data?.fallbackReason,
+            readsDigest: data?.readsDigest,
+            equalsKind: data?.equalsKind,
+            strictModePhase: data?.strictModePhase,
+            meta: data?.meta
+          }
+        );
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        const label = typeof data?.componentLabel === "string" && data.componentLabel.length > 0 ? data.componentLabel : event.type === "trace:react-selector" ? "react-selector" : "react-render";
+        const last = lastTxnByInstance.get(instanceId);
+        const txnSeqFromMeta = typeof data?.meta?.txnSeq === "number" && Number.isFinite(data.meta.txnSeq) && data.meta.txnSeq >= 0 ? Math.floor(data.meta.txnSeq) : void 0;
+        const txnIdFromMeta = typeof data?.meta?.txnId === "string" && data.meta.txnId.length > 0 ? data.meta.txnId : void 0;
+        const txnIdAligned = txnIdFromMeta ?? base.txnId ?? last?.txnId;
+        const txnSeqAligned = txnSeqFromMeta ?? (base.txnSeq > 0 ? base.txnSeq : last?.txnSeq ?? base.txnSeq);
+        const ref = withDowngrade({
+          ...base,
+          txnId: txnIdAligned,
+          txnSeq: txnSeqAligned,
+          kind: event.type === "trace:react-selector" ? "react-selector" : "react-render",
+          label,
+          meta: metaProjection2.value
+        });
+        if (instanceId !== "unknown" && (ref.txnId == null || ref.txnSeq <= 0)) {
+          enqueuePendingTxnAlignment(instanceId, ref);
+        }
+        return ref;
+      }
+      if (event.type === "trace:selector:eval") {
+        const data = event.data;
+        const metaInput = {
+          selectorId: data?.selectorId,
+          lane: data?.lane,
+          producer: data?.producer,
+          fallbackReason: data?.fallbackReason,
+          readsDigest: data?.readsDigest,
+          equalsKind: data?.equalsKind,
+          changed: data?.changed,
+          evalMs: data?.evalMs
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:exec-vm") {
+        const data = event.data;
+        const metaInput = {
+          version: data?.version,
+          stage: data?.stage,
+          hit: data?.hit,
+          reasonCode: data?.reasonCode ?? data?.reason,
+          reasonDetail: data?.reasonDetail,
+          execIrVersion: data?.execIrVersion,
+          execIrHash: data?.execIrHash,
+          serviceId: data?.serviceId,
+          implId: data?.implId
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:trait:converge") {
+        const resolveDirtyRootPaths = (args) => {
+          const resolve2 = options?.resolveConvergeStaticIr;
+          if (!resolve2) return void 0;
+          const digest = args.staticIrDigest;
+          if (typeof digest !== "string" || digest.length === 0) return void 0;
+          const rootIds = args.rootIds;
+          if (!Array.isArray(rootIds) || rootIds.length === 0) return void 0;
+          const ir = resolve2(digest);
+          const fieldPaths = ir?.fieldPaths;
+          if (!Array.isArray(fieldPaths) || fieldPaths.length === 0) return void 0;
+          const out = [];
+          for (const id of rootIds) {
+            if (typeof id !== "number" || !Number.isFinite(id)) continue;
+            const idx = Math.floor(id);
+            if (idx < 0 || idx >= fieldPaths.length) continue;
+            const path = fieldPaths[idx];
+            if (Array.isArray(path)) {
+              out.push(path);
+            }
+          }
+          return out.length > 0 ? out : void 0;
+        };
+        const enrichDirtyRootPaths = (value) => {
+          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+          const anyValue = value;
+          const dirty = anyValue.dirty;
+          if (!dirty || typeof dirty !== "object" || Array.isArray(dirty)) return value;
+          const dirtyRootPaths = resolveDirtyRootPaths({
+            staticIrDigest: anyValue.staticIrDigest,
+            rootIds: dirty?.rootIds
+          });
+          if (!dirtyRootPaths) return value;
+          return {
+            ...anyValue,
+            dirty: {
+              ...dirty,
+              rootPaths: dirtyRootPaths
+            }
+          };
+        };
+        const stripHeavyLight = (value) => {
+          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+          const anyValue = value;
+          const dirty = anyValue.dirty;
+          const dirtyRootPaths = resolveDirtyRootPaths({
+            staticIrDigest: anyValue.staticIrDigest,
+            rootIds: dirty?.rootIds
+          });
+          const dirtySlim = dirty && typeof dirty === "object" && !Array.isArray(dirty) ? {
+            dirtyAll: dirty.dirtyAll,
+            ...typeof dirty.reason === "string" ? { reason: dirty.reason } : null,
+            ...Array.isArray(dirty.rootIds) ? { rootIds: dirty.rootIds } : null,
+            ...typeof dirty.rootIdsTruncated === "boolean" ? { rootIdsTruncated: dirty.rootIdsTruncated } : null,
+            ...dirtyRootPaths ? { rootPaths: dirtyRootPaths } : null
+          } : void 0;
+          const { top3, dirtyRoots, ...rest } = anyValue;
+          return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
+        };
+        const stripHeavySampled = (value) => {
+          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+          const anyValue = value;
+          const dirty = anyValue.dirty;
+          const dirtySlim = dirty && typeof dirty === "object" && !Array.isArray(dirty) ? {
+            dirtyAll: dirty.dirtyAll,
+            ...typeof dirty.reason === "string" ? { reason: dirty.reason } : null
+          } : void 0;
+          const { dirtyRoots, ...rest } = anyValue;
+          return dirtySlim ? { ...rest, dirty: dirtySlim } : rest;
+        };
+        const data = event.data;
+        const metaInput = diagnosticsLevel2 === "light" ? stripHeavyLight(data) : diagnosticsLevel2 === "sampled" ? stripHeavySampled(data) : enrichDirtyRootPaths(data);
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "trait:converge",
+          label: "trait:converge",
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:trait:check") {
+        const stripHeavy = (value) => {
+          if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+          const anyValue = value;
+          const degraded = anyValue.degraded;
+          const degradedSlim = degraded && typeof degraded === "object" && !Array.isArray(degraded) ? { kind: degraded.kind } : void 0;
+          const { degraded: _degraded, ...rest } = anyValue;
+          return degradedSlim ? { ...rest, degraded: degradedSlim } : rest;
+        };
+        const data = event.data;
+        const metaInput = isLightLike ? stripHeavy(data) : data;
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "trait:check",
+          label: "trait:check",
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:trait:validate") {
+        const data = event.data;
+        const metaProjection2 = projectJsonValue(data);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "trait:validate",
+          label: "trait:validate",
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:module:traits") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          digest: data?.digest,
+          count: data?.count
+        } : {
+          digest: data?.digest,
+          count: data?.count,
+          traits: data?.traits,
+          provenanceIndex: data?.provenanceIndex
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:module:traits:conflict") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          conflictCount: data?.conflictCount,
+          traitIds: data?.traitIds
+        } : {
+          conflictCount: data?.conflictCount,
+          conflicts: data?.conflicts
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:module:descriptor") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          id: data?.id,
+          traits: data?.traits,
+          source: data?.source
+        } : { data };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
+      if (event.type === "trace:effectop") {
+        const data = event.data;
+        const opMeta = data?.meta;
+        const opKind = data?.kind ?? "service";
+        const label = typeof data?.name === "string" ? data.name : "effectop";
+        const moduleId2 = typeof opMeta?.moduleId === "string" ? opMeta.moduleId : moduleId;
+        const txnId2 = typeof opMeta?.txnId === "string" && opMeta.txnId.length > 0 ? opMeta.txnId : base.txnId;
+        const txnSeq2 = typeof opMeta?.txnSeq === "number" && Number.isFinite(opMeta.txnSeq) && opMeta.txnSeq >= 0 ? Math.floor(opMeta.txnSeq) : base.txnSeq;
+        const metaInput = isLightLike ? {
+          id: data?.id,
+          kind: data?.kind,
+          name: data?.name,
+          meta: opMeta
+        } : {
+          id: data?.id,
+          kind: data?.kind,
+          name: data?.name,
+          payload: data?.payload,
+          meta: opMeta
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          moduleId: moduleId2,
+          txnId: txnId2,
+          txnSeq: txnSeq2,
+          kind: opKind,
+          label,
+          meta: metaProjection2.value
+        });
+      }
+      const metaProjection = projectJsonValue(
+        isLightLike ? {
+          data: void 0
+        } : {
+          data: event.data
+        }
+      );
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "devtools",
+        label: event.type,
+        meta: metaProjection.value
+      });
+    }
+  }
+};
+
+// src/internal/observability/evidenceCollector.ts
+var EvidenceCollectorTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/EvidenceCollector")() {
+};
+var EvidenceCollectorTag = EvidenceCollectorTagImpl;
+var evidenceCollectorLayer = (collector) => import_effect8.Layer.succeed(EvidenceCollectorTag, collector);
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var makeEvidenceCollector = (session) => {
+  const sink = makeEvidenceSink(session);
+  const convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+  let kernelImplementationRef;
+  let runtimeServicesEvidence;
+  const exportBudget = {
+    dropped: 0,
+    oversized: 0,
+    nonSerializable: 0
+  };
+  const debugSink = {
+    record: (event) => import_effect8.Effect.gen(function* () {
+      const level = yield* import_effect8.FiberRef.get(currentDiagnosticsLevel);
+      const instanceIdRaw = event.instanceId;
+      const instanceId = typeof instanceIdRaw === "string" && instanceIdRaw.length > 0 ? instanceIdRaw : "unknown";
+      const eventSeq = level === "off" ? void 0 : session.local.nextSeq("eventSeq", instanceId);
+      const ref = toRuntimeDebugEventRef(event, {
+        diagnosticsLevel: level,
+        eventSeq,
+        onMetaProjection: ({ stats }) => {
+          exportBudget.dropped += stats.dropped;
+          exportBudget.oversized += stats.oversized;
+        }
+      });
+      if (!ref) return;
+      const projected = projectJsonValue(ref);
+      exportBudget.dropped += projected.stats.dropped;
+      exportBudget.oversized += projected.stats.oversized;
+      exportBudget.nonSerializable += projected.stats.nonSerializable;
+      sink.record("debug:event", projected.value, {
+        timestamp: ref.timestamp
+      });
+    })
+  };
+  const registerConvergeStaticIr = (staticIr) => {
+    if (!isRecord3(staticIr)) return;
+    const digest = staticIr.staticIrDigest;
+    if (typeof digest !== "string" || digest.length === 0) return;
+    const projected = projectJsonValue(staticIr);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    convergeStaticIrByDigest.set(digest, projected.value);
+  };
+  const setKernelImplementationRef = (ref) => {
+    const projected = projectJsonValue(ref);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    kernelImplementationRef = projected.value;
+  };
+  const setRuntimeServicesEvidence = (evidence) => {
+    const projected = projectJsonValue(evidence);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    runtimeServicesEvidence = projected.value;
+  };
+  const exportEvidencePackage2 = (options) => {
+    const convergeSummary = convergeStaticIrByDigest.size > 0 ? {
+      staticIrByDigest: Object.fromEntries(convergeStaticIrByDigest)
+    } : void 0;
+    const runtimeSummary = kernelImplementationRef != null || runtimeServicesEvidence != null ? {
+      ...kernelImplementationRef != null ? { kernelImplementationRef } : {},
+      ...runtimeServicesEvidence != null ? { services: runtimeServicesEvidence } : {}
+    } : void 0;
+    const summary = convergeSummary != null || runtimeSummary != null ? {
+      ...convergeSummary != null ? { converge: convergeSummary } : {},
+      ...runtimeSummary != null ? { runtime: runtimeSummary } : {}
+    } : void 0;
+    return sink.export({
+      maxEvents: options?.maxEvents,
+      summary
+    });
+  };
+  const clear = () => {
+    sink.clear();
+    convergeStaticIrByDigest.clear();
+    kernelImplementationRef = void 0;
+    runtimeServicesEvidence = void 0;
+    exportBudget.dropped = 0;
+    exportBudget.oversized = 0;
+    exportBudget.nonSerializable = 0;
+  };
+  return {
+    session,
+    debugSink,
+    registerConvergeStaticIr,
+    setKernelImplementationRef,
+    setRuntimeServicesEvidence,
+    exportEvidencePackage: exportEvidencePackage2,
+    clear
+  };
+};
+
+// src/internal/runtime/core/RuntimeKernel.ts
+var import_effect9 = require("effect");
+var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
+};
+var RuntimeServicesProviderOverridesTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
+};
+var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
+};
+var RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl;
+var FullCutoverGateModeTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
+};
+var RuntimeServicesRegistryTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
+};
+var RUNTIME_SERVICES_EVIDENCE = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeServicesEvidence");
+var formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getRuntimeServicesEvidence = (runtime) => {
+  const scope = runtime;
+  const evidence = runtime[RUNTIME_SERVICES_EVIDENCE];
+  if (!evidence) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeServicesEvidence] Runtime services evidence not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make assembles RuntimeKernel and attaches evidence (020 US2).",
+      "- If you created a mock runtime for tests, attach evidence or avoid calling evidence-only APIs."
+    ].join("\n") : "Runtime services evidence not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== evidence.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeServicesEvidence] Runtime services evidence instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `evidence: ${formatScope(evidence.moduleId, evidence.instanceId)}`
+      ].join("\n") : "Runtime services evidence mismatch"
+    );
+  }
+  return evidence;
+};
+
+// src/internal/runtime/core/ConvergeStaticIrCollector.ts
+var import_effect10 = require("effect");
+var currentConvergeStaticIrCollectors = import_effect10.FiberRef.unsafeMake([]);
+var appendConvergeStaticIrCollectors = (collectors) => import_effect10.Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
+  ...current,
+  ...collectors
+]);
+
+// src/internal/observability/trialRunModule.ts
+var import_effect32 = require("effect");
+
+// src/internal/platform/BuildEnv.ts
+var import_effect13 = require("effect");
+
+// src/internal/platform/ConstructionGuard.ts
+var import_effect11 = require("effect");
+
+// src/internal/platform/RuntimeHost.ts
+var import_effect12 = require("effect");
+var detectKind = () => {
+  const isBrowser2 = typeof window !== "undefined" && typeof document !== "undefined";
+  if (isBrowser2) return "browser";
+  const isNode = typeof process !== "undefined" && typeof process?.versions?.node === "string";
+  if (isNode) return "node";
+  return "unknown";
+};
+var make = (kind) => ({
+  kind,
+  isNode: kind === "node",
+  isBrowser: kind === "browser"
+});
+var RuntimeHost = class extends import_effect12.Context.Tag("@logixjs/RuntimeHost")() {
+};
+var layer = (service) => import_effect12.Layer.succeed(RuntimeHost, service);
+var defaultLayer = layer(make(detectKind()));
+
+// src/internal/runtime/core/KernelRef.ts
+var import_effect14 = require("effect");
+var isKernelId = (value) => typeof value === "string" && value.length > 0 && /^[a-z0-9-]+$/.test(value);
+var defaultKernelImplementationRef = {
+  kernelId: "core",
+  packageName: "@logixjs/core"
+};
+var normalizeKernelImplementationRef = (value, fallback = defaultKernelImplementationRef) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return fallback;
+  const v = value;
+  if (!isKernelId(v.kernelId)) return fallback;
+  if (typeof v.packageName !== "string" || v.packageName.length === 0) return fallback;
+  return {
+    kernelId: v.kernelId,
+    packageName: v.packageName,
+    ...typeof v.packageVersion === "string" && v.packageVersion.length > 0 ? { packageVersion: v.packageVersion } : {},
+    ...typeof v.buildId === "string" && v.buildId.length > 0 ? { buildId: v.buildId } : {},
+    ...Array.isArray(v.capabilities) && v.capabilities.every((c) => typeof c === "string") ? { capabilities: v.capabilities } : {}
+  };
+};
+var KernelImplementationRefTagImpl = class extends import_effect14.Context.Tag("@logixjs/core/KernelImplementationRef")() {
+};
+var KERNEL_IMPLEMENTATION_REF = /* @__PURE__ */ Symbol.for("@logixjs/core/kernelImplementationRef");
+var formatScope2 = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getKernelImplementationRef = (runtime) => {
+  const scope = runtime;
+  const ref = runtime[KERNEL_IMPLEMENTATION_REF];
+  if (!ref) {
+    const msg = isDevEnv() ? [
+      "[MissingKernelImplementationRef] KernelImplementationRef not installed on ModuleRuntime instance.",
+      `scope: ${formatScope2(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make installs KernelImplementationRef (045 kernel contract).",
+      "- If you created a mock runtime for tests, attach KernelImplementationRef or avoid calling kernel-only APIs."
+    ].join("\n") : "KernelImplementationRef not installed";
+    throw new Error(msg);
+  }
+  return ref;
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.kernel.ts
+var import_effect27 = require("effect");
+
+// src/internal/runtime/core/BoundApiRuntime.ts
+var import_effect24 = require("effect");
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect15 = require("effect");
+var inSyncTransactionFiber = import_effect15.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect15.FiberRef.unsafeMake(false);
+
+// src/internal/runtime/core/mutativePatches.ts
+var import_mutative = require("mutative");
+
+// src/internal/runtime/core/FlowRuntime.ts
+var import_effect17 = require("effect");
+
+// src/internal/effect-op.ts
+var import_effect16 = require("effect");
+
+// src/internal/runtime/core/MatchBuilder.ts
+var import_effect18 = require("effect");
+
+// src/internal/runtime/core/Platform.ts
+var import_effect19 = require("effect");
+var Tag = import_effect19.Context.GenericTag("@logixjs/Platform");
+
+// src/internal/runtime/core/Lifecycle.ts
+var import_effect20 = require("effect");
+var LifecycleContext = import_effect20.Context.GenericTag("@logixjs/LifecycleManager");
+
+// src/internal/runtime/core/LogicDiagnostics.ts
+var import_effect21 = require("effect");
+var LogicPhaseServiceTag = import_effect21.Context.GenericTag("@logixjs/LogicPhaseService");
+var LogicUnitServiceTag = class extends import_effect21.Context.Tag("@logixjs/LogicUnitService")() {
+};
+
+// src/internal/root.ts
+var import_effect23 = require("effect");
+
+// src/internal/runtime/core/RootContext.ts
+var import_effect22 = require("effect");
+var RootContextTagImpl = class extends import_effect22.Context.Tag("@logixjs/core/RootContext")() {
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
+var import_effect25 = require("effect");
+
+// src/internal/runtime/core/runner/ProgramRunner.signals.ts
+var import_effect26 = require("effect");
+
+// src/internal/runtime/Runtime.ts
+var import_effect31 = require("effect");
+
+// src/internal/runtime/AppRuntime.ts
+var import_effect30 = require("effect");
+
+// src/internal/runtime/core/process/ProcessRuntime.ts
+var import_effect29 = require("effect");
+
+// src/internal/runtime/core/process/concurrency.ts
+var import_effect28 = require("effect");
+
+// src/internal/runtime/core/process/events.ts
+var PROCESS_EVENT_MAX_BYTES = 4 * 1024;
+
+// src/internal/runtime/core/process/selectorSchema.ts
+var SchemaAST = __toESM(require("effect/SchemaAST"), 1);
+
+// src/internal/runtime/core/process/ProcessRuntime.ts
+var ProcessRuntimeTag = class extends import_effect29.Context.Tag("@logixjs/core/ProcessRuntime")() {
+};
+var currentProcessTrigger = import_effect29.FiberRef.unsafeMake(void 0);
+var currentProcessEventBudget = import_effect29.FiberRef.unsafeMake(
+  void 0
+);
+
+// src/internal/observability/artifacts/collect.ts
+var defaultArtifactBudgetBytes = 50 * 1024;
+
+// src/internal/observability/trialRun.ts
+var defaultHost = () => {
+  if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+  return "node";
+};
+var trialRun = (program, options) => import_effect33.Effect.gen(function* () {
+  const session = makeRunSession({
+    runId: options?.runId,
+    source: options?.source ?? { host: defaultHost(), label: "trial-run" },
+    startedAt: options?.startedAt
+  });
+  const collector = makeEvidenceCollector(session);
+  const convergeCollector = {
+    register: (ir) => {
+      collector.registerConvergeStaticIr(ir);
+    }
+  };
+  const sinksLayer = appendSinks([collector.debugSink]);
+  const diagnosticsLayer = diagnosticsLevel(options?.diagnosticsLevel ?? "light");
+  const convergeLayer = appendConvergeStaticIrCollectors([convergeCollector]);
+  const collectorLayer = evidenceCollectorLayer(collector);
+  const sessionLayer = runSessionLayer(session);
+  const overridesLayer = options?.runtimeServicesInstanceOverrides != null ? import_effect33.Layer.succeed(
+    RuntimeServicesInstanceOverridesTag,
+    options.runtimeServicesInstanceOverrides
+  ) : import_effect33.Layer.empty;
+  const trialLayer = import_effect33.Layer.mergeAll(
+    options?.layer ?? import_effect33.Layer.empty,
+    sessionLayer,
+    collectorLayer,
+    overridesLayer,
+    diagnosticsLayer,
+    sinksLayer,
+    convergeLayer
+  );
+  const scope = yield* import_effect33.Scope.make();
+  const exit = yield* import_effect33.Effect.exit(program).pipe(import_effect33.Effect.provideService(import_effect33.Scope.Scope, scope), import_effect33.Effect.provide(trialLayer));
+  yield* import_effect33.Scope.close(scope, exit);
+  const evidence = collector.exportEvidencePackage({
+    maxEvents: options?.maxEvents
+  });
+  return { session, exit, evidence };
+});
+
+// src/internal/reflection/kernelContract.ts
+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 isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var makeTraceEffectOpObserver = () => {
+  return (op) => import_effect34.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 (!isRecord4(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 (!isRecord4(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, run2, options) => import_effect34.Effect.gen(function* () {
+  const interaction = run2?.interaction;
+  const program = import_effect34.Effect.gen(function* () {
+    const ctx = yield* rootImpl.layer.pipe(import_effect34.Layer.build);
+    const runtime = import_effect34.Context.get(ctx, rootImpl.module);
+    if (interaction) {
+      yield* interaction(runtime);
+    }
+    return runtime.instanceId;
+  });
+  const traceLayer = import_effect34.Layer.succeed(EffectOpMiddlewareTag, {
+    stack: [makeTraceEffectOpObserver()]
+  });
+  const extraLayer = run2?.layer ? import_effect34.Layer.mergeAll(traceLayer, run2.layer) : traceLayer;
+  const result = yield* trialRun(program, {
+    runId: run2?.runId,
+    diagnosticsLevel: options.diagnosticsLevel ?? "light",
+    maxEvents: options.maxEvents,
+    layer: extraLayer,
+    runtimeServicesInstanceOverrides: run2?.runtimeServicesInstanceOverrides
+  });
+  const ok = import_effect34.Exit.isSuccess(result.exit);
+  const error = import_effect34.Exit.isFailure(result.exit) && result.exit.cause != null ? (() => {
+    const failure = import_effect34.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) => import_effect34.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/Kernel.ts
+var import_effect36 = require("effect");
+
+// src/internal/runtime/core/FullCutoverGate.ts
+var CutoverCoverageMatrix = {
+  version: "v1",
+  requiredServiceIds: ["txnQueue", "operationRunner", "transaction", "dispatch"]
+};
+var expectedImplIdForKernel = (kernelId) => kernelId === "core" ? "builtin" : kernelId;
+var parseFallbackServiceIds = (overridesApplied) => {
+  const out = /* @__PURE__ */ new Set();
+  for (const entry of overridesApplied) {
+    if (!entry.includes("(fallback=")) continue;
+    const colon = entry.indexOf(":");
+    if (colon < 0) continue;
+    const eq = entry.indexOf("=", colon + 1);
+    if (eq < 0) continue;
+    const serviceId = entry.slice(colon + 1, eq);
+    if (serviceId.length > 0) out.add(serviceId);
+  }
+  return Array.from(out).sort((a, b) => a.localeCompare(b));
+};
+var collectMissingServiceIds = (args) => {
+  const bindingByServiceId = /* @__PURE__ */ new Map();
+  for (const b of args.bindings) {
+    bindingByServiceId.set(b.serviceId, b);
+  }
+  const missing = [];
+  for (const serviceId of args.requiredServiceIds) {
+    const binding = bindingByServiceId.get(serviceId);
+    const implId = binding?.implId;
+    if (!implId || implId !== args.expectedImplId) {
+      missing.push(serviceId);
+    }
+  }
+  return missing;
+};
+var evaluateFullCutoverGate = (args) => {
+  const expectedImplId = expectedImplIdForKernel(args.requestedKernelId);
+  const matrix = args.coverageMatrix ?? CutoverCoverageMatrix;
+  const fallbackServiceIds = parseFallbackServiceIds(args.runtimeServicesEvidence.overridesApplied);
+  const missingServiceIds = collectMissingServiceIds({
+    expectedImplId,
+    requiredServiceIds: matrix.requiredServiceIds,
+    bindings: args.runtimeServicesEvidence.bindings
+  });
+  const fullyActivated = missingServiceIds.length === 0 && fallbackServiceIds.length === 0;
+  const verdict = args.mode === "fullCutover" ? fullyActivated ? "PASS" : "FAIL" : "PASS";
+  const moduleIdRaw = args.runtimeServicesEvidence.moduleId;
+  const moduleId = typeof moduleIdRaw === "string" && moduleIdRaw.length > 0 ? moduleIdRaw : "unknown";
+  const anchor = {
+    moduleId,
+    instanceId: args.runtimeServicesEvidence.instanceId,
+    txnSeq: 0
+  };
+  const level = args.diagnosticsLevel ?? "off";
+  return {
+    version: "v1",
+    mode: args.mode,
+    requestedKernelId: args.requestedKernelId,
+    verdict,
+    fullyActivated,
+    missingServiceIds,
+    fallbackServiceIds,
+    anchor,
+    ...level === "off" ? {} : {
+      details: {
+        expectedImplId,
+        bindings: args.runtimeServicesEvidence.bindings,
+        overridesApplied: args.runtimeServicesEvidence.overridesApplied
+      }
+    }
+  };
+};
+
+// src/internal/runtime/core/RuntimeServiceBuiltins.ts
+var import_effect35 = require("effect");
+var RuntimeServiceBuiltinsTag = class extends import_effect35.Context.Tag("@logixjs/core/RuntimeServiceBuiltins")() {
+};
+
+// src/Kernel.ts
+var evaluateFullCutoverGate2 = (args) => {
+  return evaluateFullCutoverGate({
+    mode: args.mode,
+    requestedKernelId: args.requestedKernelId,
+    runtimeServicesEvidence: args.runtimeServicesEvidence,
+    coverageMatrix: args.coverageMatrix,
+    diagnosticsLevel: args.diagnosticsLevel
+  });
+};
+var KernelContractMetaAllowlist = [];
+var getRuntimeServicesEvidence2 = getRuntimeServicesEvidence;
+var getKernelImplementationRef2 = getKernelImplementationRef;
+
+// src/Reflection.ts
+var resolveRootImpl2 = (root) => root?._tag === "ModuleImpl" ? root : root?.impl;
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var stableJson = (value) => JSON.stringify(value) ?? "";
+var diffMetaKeys = (before, after) => {
+  const b = isRecord5(before) ? before : {};
+  const a = isRecord5(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 (!isRecord5(before) || !isRecord5(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 = (module2, options) => extractManifest(module2, options);
+var diffManifest2 = (before, after, options) => diffManifest(before, after, options);
+var exportStaticIr3 = (module2) => exportStaticIr2(module2);
+var verifyKernelContract2 = (module2, options) => verifyKernelContract(module2, options);
+var verifyFullCutoverGate = (module2, options) => import_effect37.Effect.gen(function* () {
+  const rootImpl = resolveRootImpl2(module2);
+  const contractDiagnosticsLevel = options?.diagnosticsLevel === "off" ? "light" : options?.diagnosticsLevel ?? "light";
+  const contract = yield* verifyKernelContract(module2, {
+    ...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 = import_effect37.Effect.gen(function* () {
+    const ctx = yield* rootImpl.layer.pipe(import_effect37.Layer.build);
+    const runtime = import_effect37.Context.get(ctx, rootImpl.module);
+    if (gateRun?.interaction) {
+      yield* gateRun.interaction(runtime);
+    }
+    return {
+      kernelImplementationRef: getKernelImplementationRef2(runtime),
+      runtimeServicesEvidence: getRuntimeServicesEvidence2(runtime)
+    };
+  });
+  const gateResult = yield* trialRun(gateProgram, {
+    runId: gateRun?.runId,
+    diagnosticsLevel: options?.gateDiagnosticsLevel ?? "off",
+    layer: gateRun?.layer,
+    runtimeServicesInstanceOverrides: gateRun?.runtimeServicesInstanceOverrides
+  });
+  const gateValue = import_effect37.Exit.isSuccess(gateResult.exit) ? gateResult.exit.value : (() => {
+    const msg = import_effect37.Exit.isFailure(gateResult.exit) ? String(gateResult.exit.cause ?? "trial-run failed") : "trial-run failed";
+    throw new Error(msg);
+  })();
+  const gate = evaluateFullCutoverGate2({
+    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 } : {}
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffManifest,
+  exportStaticIr,
+  extractManifest,
+  verifyFullCutoverGate,
+  verifyKernelContract
+});
+//# sourceMappingURL=Reflection.cjs.map