@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,317 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+
+// ../logix-core/src/internal/runtime/core/EffectOpCore.ts
+import { Context, Effect, FiberRef } from "../effect.js";
+var currentLinkId = FiberRef.unsafeMake(void 0);
+var makeOperationRejected = (params) => ({
+  _tag: "OperationRejected",
+  message: params.message,
+  kind: params.kind,
+  name: params.name,
+  linkId: params.linkId,
+  details: params.details
+});
+var EffectOpMiddlewareTag = class extends Context.Tag("Logix/EffectOpMiddleware")() {
+};
+var composeMiddleware = (stack) => {
+  return (op) => stack.reduceRight(
+    (eff, mw) => mw({ ...op, effect: eff }),
+    op.effect
+  );
+};
+var runWithMiddleware = (op, stack) => {
+  return Effect.gen(function* () {
+    const existing = yield* FiberRef.get(currentLinkId);
+    const metaLinkId = op.meta?.linkId;
+    const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
+    const nextOp = {
+      ...op,
+      meta: {
+        ...op.meta ?? {},
+        linkId
+      }
+    };
+    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
+    return yield* Effect.locally(currentLinkId, linkId)(program);
+  });
+};
+
+// ../logix-core/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 keys = Object.keys(input).sort();
+  const limit = Math.min(keys.length, options.maxObjectKeys);
+  const out = {};
+  for (let i = 0; i < limit; i++) {
+    const rawKey = keys[i];
+    const rawValue = input[rawKey];
+    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 (keys.length > limit) {
+    stats.oversized += 1;
+    out.__truncatedKeys = keys.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
+  };
+};
+
+// ../logix-core/src/internal/observability/evidence.ts
+var OBSERVABILITY_PROTOCOL_VERSION = "v1";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var asPositiveInt = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n >= 1 ? n : void 0;
+};
+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
+  };
+};
+var importEvidencePackage = (input) => {
+  const fallback = {
+    protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,
+    runId: "unknown",
+    createdAt: Date.now(),
+    source: { host: "unknown" },
+    events: []
+  };
+  if (!isRecord(input)) return fallback;
+  const protocolVersion = asNonEmptyString(input.protocolVersion) ?? fallback.protocolVersion;
+  const runId = asNonEmptyString(input.runId) ?? fallback.runId;
+  const createdAt = asFiniteNumber(input.createdAt) ?? fallback.createdAt;
+  const sourceRaw = input.source;
+  const source = isRecord(sourceRaw) ? {
+    host: asNonEmptyString(sourceRaw.host) ?? "unknown",
+    label: typeof sourceRaw.label === "string" ? sourceRaw.label : void 0
+  } : fallback.source;
+  const eventsRaw = Array.isArray(input.events) ? input.events : [];
+  const events = [];
+  for (const e of eventsRaw) {
+    if (!isRecord(e)) continue;
+    const seq = asPositiveInt(e.seq);
+    const timestamp = asFiniteNumber(e.timestamp);
+    const type = asNonEmptyString(e.type);
+    const payloadRaw = e.payload;
+    if (!seq || timestamp === void 0 || !type || !isJsonValue(payloadRaw)) {
+      continue;
+    }
+    events.push({
+      protocolVersion: asNonEmptyString(e.protocolVersion) ?? protocolVersion,
+      runId: asNonEmptyString(e.runId) ?? runId,
+      seq,
+      timestamp,
+      type,
+      payload: payloadRaw
+    });
+  }
+  const summary = isJsonValue(input.summary) ? input.summary : void 0;
+  return {
+    protocolVersion,
+    runId,
+    createdAt,
+    source,
+    events: events.sort((a, b) => a.seq - b.seq),
+    summary
+  };
+};
+
+export {
+  isJsonValue,
+  projectJsonValue,
+  currentLinkId,
+  makeOperationRejected,
+  EffectOpMiddlewareTag,
+  composeMiddleware,
+  runWithMiddleware,
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage,
+  importEvidencePackage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/EffectOpCore.ts", "../../../../logix-core/src/internal/observability/jsonValue.ts", "../../../../logix-core/src/internal/observability/evidence.ts"],
  "sourcesContent": ["// EffectOp core model and middleware composition logic.\n// For higher-level Runtime / Devtools integration, see:\n// specs/000-module-traits-runtime/references/effectop-and-middleware.md\n\nimport { Context, Effect, FiberRef } from 'effect'\n\n/**\n * currentLinkId\uFF1A\n * - Stores the current operation chain id (linkId) in a FiberRef.\n * - Used to correlate multiple boundary ops within the same chain (can be shared across modules via the same FiberRef).\n */\nexport const currentLinkId = FiberRef.unsafeMake<string | undefined>(undefined)\n\n/**\n * OperationPolicy\uFF1A\n * - Local policy markers (intent only; no rule logic attached).\n *\n * Constraints (enforced by Runtime/middleware together):\n * - Only observation-only capabilities (Observer) may be disabled; global guards must not be disabled.\n */\nexport interface OperationPolicy {\n  readonly disableObservers?: boolean\n}\n\n/**\n * OperationRejected\uFF1A\n * - Unified failure result when a guard rejects execution.\n * - Semantics: explicit failure with no business side effects (rejection must happen before user code executes).\n */\nexport interface OperationRejected {\n  readonly _tag: 'OperationRejected'\n  readonly message: string\n  readonly kind?: EffectOp['kind']\n  readonly name?: string\n  readonly linkId?: string\n  readonly details?: unknown\n}\n\n/**\n * OperationError\uFF1A\n * - Any boundary operation executed via EffectOp may be explicitly rejected by Guard middleware.\n * - Therefore, the middleware error channel must allow OperationRejected to be added.\n */\nexport type OperationError<E> = E | OperationRejected\n\nexport const makeOperationRejected = (params: {\n  readonly message: string\n  readonly kind?: EffectOp['kind']\n  readonly name?: string\n  readonly linkId?: string\n  readonly details?: unknown\n}): OperationRejected => ({\n  _tag: 'OperationRejected',\n  message: params.message,\n  kind: params.kind,\n  name: params.name,\n  linkId: params.linkId,\n  details: params.details,\n})\n\n/**\n * EffectOp: a unified representation of an Effect execution at an \"observable boundary\".\n *\n * - Out / Err / Env are the generic parameters of the underlying Effect.\n * - meta carries structured context needed by Devtools / Middleware.\n */\nexport interface EffectOp<Out = unknown, Err = unknown, Env = unknown> {\n  readonly id: string\n  readonly kind:\n    | 'action'\n    | 'flow'\n    | 'state'\n    | 'service'\n    | 'lifecycle'\n    | 'trait-computed'\n    | 'trait-link'\n    | 'trait-source'\n    | 'devtools'\n  readonly name: string\n  readonly payload?: unknown\n  readonly meta?: {\n    /**\n     * linkId\uFF1A\n     * - Operation chain id: multiple boundary ops in the same chain must share it.\n     * - Runtime ensures this field is populated on all boundary ops.\n     */\n    linkId?: string\n    moduleId?: string\n    instanceId?: string\n    runtimeLabel?: string\n    txnId?: string\n    txnSeq?: number\n    opSeq?: number\n    fieldPath?: string\n    deps?: ReadonlyArray<string>\n    from?: string\n    to?: string\n    traitNodeId?: string\n    stepId?: string\n    resourceId?: string\n    key?: unknown\n    trace?: ReadonlyArray<string>\n    tags?: ReadonlyArray<string>\n    policy?: OperationPolicy\n    // Reserved extension slot for middleware/devtools to attach extra information.\n    readonly [k: string]: unknown\n  }\n  readonly effect: Effect.Effect<Out, Err, Env>\n}\n\n/**\n * Middleware: the general middleware model for observing / wrapping / guarding EffectOps.\n */\nexport type Middleware = <A, E, R>(op: EffectOp<A, E, R>) => Effect.Effect<A, OperationError<E>, R>\n\nexport type MiddlewareStack = ReadonlyArray<Middleware>\n\n/**\n * EffectOpMiddlewareEnv\uFF1A\n * - A Service in Effect Env that carries the current Runtime's MiddlewareStack.\n * - Injected by Runtime.ts when constructing a ManagedRuntime.\n * - Runtime code (e.g. StateTrait.install) uses this Service to decide which MiddlewareStack to use.\n */\nexport interface EffectOpMiddlewareEnv {\n  readonly stack: MiddlewareStack\n}\n\nexport class EffectOpMiddlewareTag extends Context.Tag('Logix/EffectOpMiddleware')<\n  EffectOpMiddlewareTag,\n  EffectOpMiddlewareEnv\n>() {}\n\n/**\n * composeMiddleware\uFF1A\n * - Composes Middleware from \"outer to inner\" in declaration order:\n *   - stack = [mw1, mw2] => mw1 -> mw2 -> effect -> mw2 -> mw1\n * - Matches the reduceRight example in the reference docs.\n */\nexport const composeMiddleware = (stack: MiddlewareStack): Middleware => {\n  return <A, E, R>(op: EffectOp<A, E, R>): Effect.Effect<A, OperationError<E>, R> =>\n    stack.reduceRight<Effect.Effect<A, OperationError<E>, R>>(\n      (eff, mw) => mw({ ...op, effect: eff } as any) as any,\n      op.effect as Effect.Effect<A, OperationError<E>, R>,\n    )\n}\n\n/**\n * runWithMiddleware\uFF1A\n * - Executes a given EffectOp with a MiddlewareStack according to the composition rules.\n * - If the stack is empty, returns op.effect directly.\n */\nexport const runWithMiddleware = <A, E, R>(op: EffectOp<A, E, R>, stack: MiddlewareStack): Effect.Effect<A, E, R> => {\n  return Effect.gen(function* () {\n    const existing = yield* FiberRef.get(currentLinkId)\n    const metaLinkId = (op.meta as any)?.linkId\n    const linkId = typeof metaLinkId === 'string' && metaLinkId.length > 0 ? metaLinkId : (existing ?? op.id)\n\n    const nextOp: EffectOp<A, E, R> = {\n      ...op,\n      meta: {\n        ...(op.meta ?? {}),\n        linkId,\n      },\n    }\n\n    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect\n\n    // linkId is created at the boundary root and reused for nested ops (the FiberRef is the global single source of truth).\n    // NOTE: middleware may explicitly reject with OperationRejected.\n    return yield* Effect.locally(currentLinkId, linkId)(program as any)\n  }) as Effect.Effect<A, E, R>\n}\n", "export type JsonValue =\n  | null\n  | boolean\n  | number\n  | string\n  | ReadonlyArray<JsonValue>\n  | { readonly [key: string]: JsonValue }\n\nexport type DowngradeReason = 'non_serializable' | 'oversized' | 'unknown'\n\nexport const isJsonValue = (input: unknown): input is JsonValue => {\n  const seen = new WeakSet<object>()\n\n  const loop = (value: unknown, depth: number): value is JsonValue => {\n    if (depth > 64) return false\n    if (value === null) return true\n\n    switch (typeof value) {\n      case 'string':\n      case 'boolean':\n        return true\n      case 'number':\n        return Number.isFinite(value)\n      case 'object': {\n        if (Array.isArray(value)) {\n          if (seen.has(value)) return false\n          seen.add(value)\n          for (const item of value) {\n            if (!loop(item, depth + 1)) return false\n          }\n          return true\n        }\n\n        if (!isPlainRecord(value)) return false\n        if (seen.has(value)) return false\n        seen.add(value)\n\n        for (const v of Object.values(value)) {\n          if (!loop(v, depth + 1)) return false\n        }\n\n        return true\n      }\n      default:\n        return false\n    }\n  }\n\n  return loop(input, 0)\n}\n\nexport interface JsonValueProjectionStats {\n  readonly dropped: number\n  readonly oversized: number\n  readonly nonSerializable: number\n}\n\nexport interface JsonValueProjection {\n  readonly value: JsonValue\n  readonly stats: JsonValueProjectionStats\n  readonly downgrade?: DowngradeReason\n}\n\nexport interface JsonValueProjectOptions {\n  readonly maxDepth?: number\n  readonly maxObjectKeys?: number\n  readonly maxArrayLength?: number\n  readonly maxStringLength?: number\n  readonly maxJsonBytes?: number\n  readonly oversizedPreviewBytes?: number\n}\n\nconst defaultOptions: Required<JsonValueProjectOptions> = {\n  maxDepth: 6,\n  maxObjectKeys: 32,\n  maxArrayLength: 32,\n  maxStringLength: 256,\n  maxJsonBytes: 4 * 1024,\n  oversizedPreviewBytes: 256,\n}\n\nconst truncateString = (value: string, maxLen: number, stats: MutableStats): string => {\n  if (value.length <= maxLen) return value\n  stats.oversized += 1\n  return value.slice(0, maxLen)\n}\n\ntype MutableStats = {\n  dropped: number\n  oversized: number\n  nonSerializable: number\n}\n\nconst mergeDowngrade = (current: DowngradeReason | undefined, next: DowngradeReason): DowngradeReason => {\n  if (!current) return next\n  if (current === 'non_serializable' || next === 'non_serializable') return 'non_serializable'\n  if (current === 'oversized' || next === 'oversized') return 'oversized'\n  return 'unknown'\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== 'object' || value === null) return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\nconst asNumber = (value: number, stats: MutableStats): JsonValue => {\n  if (Number.isFinite(value)) return value\n  stats.nonSerializable += 1\n  return String(value)\n}\n\nconst toJsonValueInternal = (\n  input: unknown,\n  options: Required<JsonValueProjectOptions>,\n  stats: MutableStats,\n  seen: WeakSet<object>,\n  depth: number,\n): JsonValue => {\n  if (input === null) return null\n\n  switch (typeof input) {\n    case 'string':\n      return truncateString(input, options.maxStringLength, stats)\n    case 'number':\n      return asNumber(input, stats)\n    case 'boolean':\n      return input\n    case 'bigint':\n      stats.nonSerializable += 1\n      return truncateString(input.toString(), options.maxStringLength, stats)\n    case 'symbol':\n      stats.nonSerializable += 1\n      return truncateString(input.toString(), options.maxStringLength, stats)\n    case 'function':\n      stats.nonSerializable += 1\n      return '[Function]'\n    case 'undefined':\n      stats.dropped += 1\n      return null\n  }\n\n  // object\n  if (depth >= options.maxDepth) {\n    stats.oversized += 1\n    return '[Truncated]'\n  }\n\n  if (input instanceof Date) {\n    return input.toISOString()\n  }\n\n  if (input instanceof Error) {\n    stats.nonSerializable += 1\n    return {\n      name: truncateString(input.name, options.maxStringLength, stats),\n      message: truncateString(input.message, options.maxStringLength, stats),\n    }\n  }\n\n  if (typeof input === 'object') {\n    if (seen.has(input)) {\n      stats.nonSerializable += 1\n      return '[Circular]'\n    }\n    seen.add(input)\n  }\n\n  if (Array.isArray(input)) {\n    const out: Array<JsonValue> = []\n    const limit = Math.min(input.length, options.maxArrayLength)\n    for (let i = 0; i < limit; i++) {\n      out.push(toJsonValueInternal(input[i], options, stats, seen, depth + 1))\n    }\n    if (input.length > limit) {\n      stats.oversized += 1\n      out.push(`[...${input.length - limit} more]`)\n    }\n    return out\n  }\n\n  if (!isPlainRecord(input)) {\n    stats.nonSerializable += 1\n    return truncateString(String(input), options.maxStringLength, stats)\n  }\n\n  const keys = Object.keys(input).sort()\n  const limit = Math.min(keys.length, options.maxObjectKeys)\n  const out: Record<string, JsonValue> = {}\n\n  for (let i = 0; i < limit; i++) {\n    const rawKey = keys[i]!\n    const rawValue = (input as any)[rawKey]\n    const key = truncateString(rawKey, options.maxStringLength, stats)\n    if (rawValue === undefined) {\n      stats.dropped += 1\n      continue\n    }\n    out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1)\n  }\n\n  if (keys.length > limit) {\n    stats.oversized += 1\n    out.__truncatedKeys = keys.length - limit\n  }\n\n  return out\n}\n\nexport const projectJsonValue = (input: unknown, options?: JsonValueProjectOptions): JsonValueProjection => {\n  const resolved: Required<JsonValueProjectOptions> = { ...defaultOptions, ...(options ?? {}) }\n  const stats: MutableStats = { dropped: 0, oversized: 0, nonSerializable: 0 }\n  const seen = new WeakSet<object>()\n\n  let downgrade: DowngradeReason | undefined\n  const value = toJsonValueInternal(input, resolved, stats, seen, 0)\n\n  if (stats.nonSerializable > 0) {\n    downgrade = mergeDowngrade(downgrade, 'non_serializable')\n  }\n  if (stats.oversized > 0) {\n    downgrade = mergeDowngrade(downgrade, 'oversized')\n  }\n\n  // Hard gate: ensure JSON.stringify never throws and respect the max byte budget.\n  try {\n    const json = JSON.stringify(value)\n    if (json.length > resolved.maxJsonBytes) {\n      downgrade = mergeDowngrade(downgrade, 'oversized')\n      const preview = json.slice(0, Math.min(resolved.oversizedPreviewBytes, resolved.maxJsonBytes))\n      return {\n        value: {\n          _tag: 'oversized',\n          bytes: json.length,\n          preview,\n        },\n        stats: {\n          dropped: stats.dropped,\n          oversized: stats.oversized + 1,\n          nonSerializable: stats.nonSerializable,\n        },\n        downgrade,\n      }\n    }\n  } catch {\n    downgrade = mergeDowngrade(downgrade, 'non_serializable')\n    return {\n      value: '[Unserializable]',\n      stats: {\n        dropped: stats.dropped,\n        oversized: stats.oversized,\n        nonSerializable: stats.nonSerializable + 1,\n      },\n      downgrade,\n    }\n  }\n\n  return {\n    value,\n    stats: {\n      dropped: stats.dropped,\n      oversized: stats.oversized,\n      nonSerializable: stats.nonSerializable,\n    },\n    downgrade,\n  }\n}\n", "import { isJsonValue, type JsonValue } from './jsonValue.js'\n\nexport const OBSERVABILITY_PROTOCOL_VERSION = 'v1'\n\nexport interface ObservationEnvelope {\n  readonly protocolVersion: string\n  readonly runId: string\n  readonly seq: number\n  readonly timestamp: number\n  readonly type: string\n  readonly payload: JsonValue\n}\n\nexport interface EvidencePackageSource {\n  readonly host: string\n  readonly label?: string\n}\n\nexport interface EvidencePackage {\n  readonly protocolVersion: string\n  readonly runId: string\n  readonly createdAt: number\n  readonly source: EvidencePackageSource\n  readonly events: ReadonlyArray<ObservationEnvelope>\n  readonly summary?: JsonValue\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nconst asNonEmptyString = (value: unknown): string | undefined =>\n  typeof value === 'string' && value.length > 0 ? value : undefined\n\nconst asFiniteNumber = (value: unknown): number | undefined =>\n  typeof value === 'number' && Number.isFinite(value) ? value : undefined\n\nconst asPositiveInt = (value: unknown): number | undefined => {\n  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined\n  const n = Math.floor(value)\n  return n >= 1 ? n : undefined\n}\n\nexport const exportEvidencePackage = (options: {\n  readonly runId: string\n  readonly source: EvidencePackageSource\n  readonly events: ReadonlyArray<ObservationEnvelope>\n  readonly createdAt?: number\n  readonly protocolVersion?: string\n  readonly summary?: JsonValue\n}): EvidencePackage => {\n  const protocolVersion = options.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION\n  return {\n    protocolVersion,\n    runId: options.runId,\n    createdAt: options.createdAt ?? Date.now(),\n    source: options.source,\n    events: options.events.slice().sort((a, b) => a.seq - b.seq),\n    summary: options.summary,\n  }\n}\n\nexport const importEvidencePackage = (input: unknown): EvidencePackage => {\n  const fallback: EvidencePackage = {\n    protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,\n    runId: 'unknown',\n    createdAt: Date.now(),\n    source: { host: 'unknown' },\n    events: [],\n  }\n\n  if (!isRecord(input)) return fallback\n\n  const protocolVersion = asNonEmptyString(input.protocolVersion) ?? fallback.protocolVersion\n  const runId = asNonEmptyString(input.runId) ?? fallback.runId\n  const createdAt = asFiniteNumber(input.createdAt) ?? fallback.createdAt\n\n  const sourceRaw = input.source\n  const source: EvidencePackageSource = isRecord(sourceRaw)\n    ? {\n        host: asNonEmptyString(sourceRaw.host) ?? 'unknown',\n        label: typeof sourceRaw.label === 'string' ? sourceRaw.label : undefined,\n      }\n    : fallback.source\n\n  const eventsRaw = Array.isArray(input.events) ? input.events : []\n  const events: ObservationEnvelope[] = []\n\n  for (const e of eventsRaw) {\n    if (!isRecord(e)) continue\n\n    const seq = asPositiveInt(e.seq)\n    const timestamp = asFiniteNumber(e.timestamp)\n    const type = asNonEmptyString(e.type)\n    const payloadRaw = e.payload\n\n    if (!seq || timestamp === undefined || !type || !isJsonValue(payloadRaw)) {\n      continue\n    }\n\n    events.push({\n      protocolVersion: asNonEmptyString(e.protocolVersion) ?? protocolVersion,\n      runId: asNonEmptyString(e.runId) ?? runId,\n      seq,\n      timestamp,\n      type,\n      payload: payloadRaw,\n    })\n  }\n\n  const summary = isJsonValue(input.summary) ? input.summary : undefined\n\n  return {\n    protocolVersion,\n    runId,\n    createdAt,\n    source,\n    events: events.sort((a, b) => a.seq - b.seq),\n    summary,\n  }\n}\n"],
  "mappings": "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",
  "names": ["out", "limit"]
}


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

@@ -0,0 +1,86 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/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
+      }
+    }
+  };
+};
+
+// ../logix-core/src/internal/runtime/core/RuntimeServiceBuiltins.ts
+import { Context } from "../effect.js";
+var RuntimeServiceBuiltinsTag = class extends Context.Tag("@logix/core/RuntimeServiceBuiltins")() {
+};
+
+export {
+  CutoverCoverageMatrix,
+  evaluateFullCutoverGate,
+  RuntimeServiceBuiltinsTag
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/FullCutoverGate.ts", "../../../../logix-core/src/internal/runtime/core/RuntimeServiceBuiltins.ts"],
  "sourcesContent": ["import type { KernelId } from './KernelRef.js'\nimport type { RuntimeServiceBinding, RuntimeServicesEvidence } from './RuntimeKernel.js'\n\nexport interface CutoverCoverageMatrix {\n  readonly version: 'v1'\n  readonly requiredServiceIds: ReadonlyArray<string>\n}\n\nexport const CutoverCoverageMatrix = {\n  version: 'v1',\n  requiredServiceIds: ['txnQueue', 'operationRunner', 'transaction', 'dispatch'],\n} as const satisfies CutoverCoverageMatrix\n\nexport type FullCutoverGateMode = 'trial' | 'fullCutover'\n\nexport interface FullCutoverGateAnchor {\n  readonly moduleId: string\n  readonly instanceId: string\n  /**\n   * \u7EA6\u5B9A\uFF1AtxnSeq=0 \u4EE3\u8868 assembly\uFF08\u88C5\u914D\u671F\u5931\u8D25\u951A\u70B9\uFF09\u3002\n   * Full Cutover Gate \u9ED8\u8BA4\u5728\u88C5\u914D\u671F\u5224\u5B9A\uFF0C\u56E0\u6B64\u4E0D\u4F1A\u4F9D\u8D56\u771F\u5B9E txn\u3002\n   */\n  readonly txnSeq: number\n}\n\nexport type FullCutoverGateVerdict = 'PASS' | 'FAIL'\n\nexport interface FullCutoverGateResult {\n  readonly version: 'v1'\n  readonly mode: FullCutoverGateMode\n  readonly requestedKernelId: KernelId\n  readonly verdict: FullCutoverGateVerdict\n  /**\n   * fullyActivated\uFF1A\u66F4\u4E25\u683C\u7684\u201C\u5168\u5957\u5207\u6362\u201D\u771F\u503C\u3002\n   * - \u8981\u6C42 coverage matrix \u5185\u7684\u6240\u6709 serviceId \u90FD\u7ED1\u5B9A\u5230\u671F\u671B implId\uFF1B\n   * - \u4E14\u6CA1\u6709 fallback\uFF08overridesApplied \u4E2D\u5305\u542B fallback= \u89C6\u4E3A\u672A\u8FBE\u6807\uFF09\u3002\n   *\n   * \u6CE8\u610F\uFF1Atrial \u6A21\u5F0F\u4E0B verdict \u5141\u8BB8 PASS\uFF0C\u4F46 fullyActivated \u4ECD\u53EF\u4E3A false\u3002\n   */\n  readonly fullyActivated: boolean\n  readonly missingServiceIds: ReadonlyArray<string>\n  readonly fallbackServiceIds: ReadonlyArray<string>\n  readonly anchor: FullCutoverGateAnchor\n  /**\n   * diagnostics=off \u65F6\u5FC5\u987B\u4FDD\u6301 Slim\uFF08\u907F\u514D\u5E38\u9A7B\u6210\u672C\uFF09\u3002\n   * light/full \u4E0B\u5141\u8BB8\u8865\u5145\u53EF\u89E3\u91CA\u4FE1\u606F\uFF08\u4ECD\u5FC5\u987B\u53EF\u5E8F\u5217\u5316\uFF09\u3002\n   */\n  readonly details?: {\n    readonly expectedImplId: string\n    readonly bindings: ReadonlyArray<RuntimeServiceBinding>\n    readonly overridesApplied: ReadonlyArray<string>\n  }\n}\n\nconst expectedImplIdForKernel = (kernelId: KernelId): string => (kernelId === 'core' ? 'builtin' : kernelId)\n\nconst parseFallbackServiceIds = (overridesApplied: ReadonlyArray<string>): ReadonlyArray<string> => {\n  const out = new Set<string>()\n  for (const entry of overridesApplied) {\n    if (!entry.includes('(fallback=')) continue\n    const colon = entry.indexOf(':')\n    if (colon < 0) continue\n    const eq = entry.indexOf('=', colon + 1)\n    if (eq < 0) continue\n    const serviceId = entry.slice(colon + 1, eq)\n    if (serviceId.length > 0) out.add(serviceId)\n  }\n  return Array.from(out).sort((a, b) => a.localeCompare(b))\n}\n\nconst collectMissingServiceIds = (args: {\n  readonly expectedImplId: string\n  readonly requiredServiceIds: ReadonlyArray<string>\n  readonly bindings: ReadonlyArray<RuntimeServiceBinding>\n}): ReadonlyArray<string> => {\n  const bindingByServiceId = new Map<string, RuntimeServiceBinding>()\n  for (const b of args.bindings) {\n    bindingByServiceId.set(b.serviceId, b)\n  }\n\n  const missing: string[] = []\n  for (const serviceId of args.requiredServiceIds) {\n    const binding = bindingByServiceId.get(serviceId)\n    const implId = binding?.implId\n    if (!implId || implId !== args.expectedImplId) {\n      missing.push(serviceId)\n    }\n  }\n\n  return missing\n}\n\nexport const evaluateFullCutoverGate = (args: {\n  readonly mode: FullCutoverGateMode\n  readonly requestedKernelId: KernelId\n  readonly runtimeServicesEvidence: RuntimeServicesEvidence\n  readonly coverageMatrix?: CutoverCoverageMatrix\n  readonly diagnosticsLevel?: 'off' | 'light' | 'full' | 'sampled'\n}): FullCutoverGateResult => {\n  const expectedImplId = expectedImplIdForKernel(args.requestedKernelId)\n  const matrix = args.coverageMatrix ?? CutoverCoverageMatrix\n\n  const fallbackServiceIds = parseFallbackServiceIds(args.runtimeServicesEvidence.overridesApplied)\n  const missingServiceIds = collectMissingServiceIds({\n    expectedImplId,\n    requiredServiceIds: matrix.requiredServiceIds,\n    bindings: args.runtimeServicesEvidence.bindings,\n  })\n\n  const fullyActivated = missingServiceIds.length === 0 && fallbackServiceIds.length === 0\n\n  const verdict: FullCutoverGateVerdict =\n    args.mode === 'fullCutover' ? (fullyActivated ? 'PASS' : 'FAIL') : 'PASS'\n\n  const moduleIdRaw = args.runtimeServicesEvidence.moduleId\n  const moduleId = typeof moduleIdRaw === 'string' && moduleIdRaw.length > 0 ? moduleIdRaw : 'unknown'\n\n  const anchor: FullCutoverGateAnchor = {\n    moduleId,\n    instanceId: args.runtimeServicesEvidence.instanceId,\n    txnSeq: 0,\n  }\n\n  const level = args.diagnosticsLevel ?? 'off'\n\n  return {\n    version: 'v1',\n    mode: args.mode,\n    requestedKernelId: args.requestedKernelId,\n    verdict,\n    fullyActivated,\n    missingServiceIds,\n    fallbackServiceIds,\n    anchor,\n    ...(level === 'off'\n      ? {}\n      : {\n          details: {\n            expectedImplId,\n            bindings: args.runtimeServicesEvidence.bindings,\n            overridesApplied: args.runtimeServicesEvidence.overridesApplied,\n          },\n        }),\n  }\n}\n", "import { Context, Effect } from 'effect'\n\nexport interface RuntimeServiceBuiltins {\n  /**\n   * \u8FD4\u56DE builtin \u5B9E\u73B0\u7684 make Effect\uFF08\u7531 ModuleRuntime \u5728\u88C5\u914D\u671F\u63D0\u4F9B\uFF0C\u907F\u514D\u5916\u90E8\u5B9E\u73B0\u6355\u83B7\u5185\u90E8\u95ED\u5305/\u72B6\u6001\uFF09\u3002\n   * - \u4EC5\u7528\u4E8E kernel implementor\uFF08\u4F8B\u5982 core-ng\uFF09\u5B9E\u73B0\u201C\u884C\u4E3A\u7B49\u4EF7\u7684\u66FF\u6362\u201D\u6216\u8584\u5C01\u88C5\uFF1B\n   * - \u4E0D\u4F5C\u4E3A\u4E1A\u52A1\u4FA7\u5951\u7EA6\uFF1B\u4E0D\u5F97\u5728\u4E1A\u52A1 Flow/Logic \u4E2D\u4F9D\u8D56\u3002\n   */\n  readonly getBuiltinMake: (serviceId: string) => Effect.Effect<unknown, never, any>\n}\n\nexport class RuntimeServiceBuiltinsTag extends Context.Tag('@logix/core/RuntimeServiceBuiltins')<\n  RuntimeServiceBuiltinsTag,\n  RuntimeServiceBuiltins\n>() {}\n"],
  "mappings": ";;;;AAQO,IAAM,wBAAwB;AAAA,EACnC,SAAS;AAAA,EACT,oBAAoB,CAAC,YAAY,mBAAmB,eAAe,UAAU;AAC/E;AA2CA,IAAM,0BAA0B,CAAC,aAAgC,aAAa,SAAS,YAAY;AAEnG,IAAM,0BAA0B,CAAC,qBAAmE;AAClG,QAAM,MAAM,oBAAI,IAAY;AAC5B,aAAW,SAAS,kBAAkB;AACpC,QAAI,CAAC,MAAM,SAAS,YAAY,EAAG;AACnC,UAAM,QAAQ,MAAM,QAAQ,GAAG;AAC/B,QAAI,QAAQ,EAAG;AACf,UAAM,KAAK,MAAM,QAAQ,KAAK,QAAQ,CAAC;AACvC,QAAI,KAAK,EAAG;AACZ,UAAM,YAAY,MAAM,MAAM,QAAQ,GAAG,EAAE;AAC3C,QAAI,UAAU,SAAS,EAAG,KAAI,IAAI,SAAS;AAAA,EAC7C;AACA,SAAO,MAAM,KAAK,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC;AAC1D;AAEA,IAAM,2BAA2B,CAAC,SAIL;AAC3B,QAAM,qBAAqB,oBAAI,IAAmC;AAClE,aAAW,KAAK,KAAK,UAAU;AAC7B,uBAAmB,IAAI,EAAE,WAAW,CAAC;AAAA,EACvC;AAEA,QAAM,UAAoB,CAAC;AAC3B,aAAW,aAAa,KAAK,oBAAoB;AAC/C,UAAM,UAAU,mBAAmB,IAAI,SAAS;AAChD,UAAM,SAAS,SAAS;AACxB,QAAI,CAAC,UAAU,WAAW,KAAK,gBAAgB;AAC7C,cAAQ,KAAK,SAAS;AAAA,IACxB;AAAA,EACF;AAEA,SAAO;AACT;AAEO,IAAM,0BAA0B,CAAC,SAMX;AAC3B,QAAM,iBAAiB,wBAAwB,KAAK,iBAAiB;AACrE,QAAM,SAAS,KAAK,kBAAkB;AAEtC,QAAM,qBAAqB,wBAAwB,KAAK,wBAAwB,gBAAgB;AAChG,QAAM,oBAAoB,yBAAyB;AAAA,IACjD;AAAA,IACA,oBAAoB,OAAO;AAAA,IAC3B,UAAU,KAAK,wBAAwB;AAAA,EACzC,CAAC;AAED,QAAM,iBAAiB,kBAAkB,WAAW,KAAK,mBAAmB,WAAW;AAEvF,QAAM,UACJ,KAAK,SAAS,gBAAiB,iBAAiB,SAAS,SAAU;AAErE,QAAM,cAAc,KAAK,wBAAwB;AACjD,QAAM,WAAW,OAAO,gBAAgB,YAAY,YAAY,SAAS,IAAI,cAAc;AAE3F,QAAM,SAAgC;AAAA,IACpC;AAAA,IACA,YAAY,KAAK,wBAAwB;AAAA,IACzC,QAAQ;AAAA,EACV;AAEA,QAAM,QAAQ,KAAK,oBAAoB;AAEvC,SAAO;AAAA,IACL,SAAS;AAAA,IACT,MAAM,KAAK;AAAA,IACX,mBAAmB,KAAK;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,UAAU,QACV,CAAC,IACD;AAAA,MACE,SAAS;AAAA,QACP;AAAA,QACA,UAAU,KAAK,wBAAwB;AAAA,QACvC,kBAAkB,KAAK,wBAAwB;AAAA,MACjD;AAAA,IACF;AAAA,EACN;AACF;;;AChJA,SAAS,eAAuB;AAWzB,IAAM,4BAAN,cAAwC,QAAQ,IAAI,oCAAoC,EAG7F,EAAE;AAAC;",
  "names": []
}


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

@@ -0,0 +1,42 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  exportStaticIr
+} from "./chunk-QGIM3FQK.js";
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/internal/debug/ModuleTraitsRegistry.ts
+var programsByIdAndDigest = /* @__PURE__ */ new Map();
+var latestDigestById = /* @__PURE__ */ new Map();
+var MAX_VERSIONS_PER_MODULE = 8;
+var registerModuleProgram = (moduleId, program) => {
+  if (!isDevEnv()) {
+    return;
+  }
+  const ir = exportStaticIr({ program, moduleId, version: "009" });
+  const digest = ir.digest;
+  let versions = programsByIdAndDigest.get(moduleId);
+  if (!versions) {
+    versions = /* @__PURE__ */ new Map();
+    programsByIdAndDigest.set(moduleId, versions);
+  }
+  versions.set(digest, program);
+  latestDigestById.set(moduleId, digest);
+  if (versions.size > MAX_VERSIONS_PER_MODULE) {
+    const oldest = versions.keys().next().value;
+    if (oldest) versions.delete(oldest);
+  }
+};
+var getModuleProgramById = (moduleId) => {
+  const latestDigest = latestDigestById.get(moduleId);
+  if (!latestDigest) return void 0;
+  return programsByIdAndDigest.get(moduleId)?.get(latestDigest);
+};
+
+export {
+  registerModuleProgram,
+  getModuleProgramById
+};
+//# sourceMappingURL=data:application/json;base64,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