@logixjs/core 0.0.1

package/dist/chunk-JWOYLO27.js

@@ -0,0 +1,241 @@
+// src/internal/runtime/core/EffectOpCore.ts
+import { Context, Effect, FiberRef } from "effect";
+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);
+  });
+};
+
+// 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
+  };
+};
+
+export {
+  isJsonValue,
+  projectJsonValue,
+  currentLinkId,
+  makeOperationRejected,
+  EffectOpMiddlewareTag,
+  composeMiddleware,
+  runWithMiddleware
+};
+//# sourceMappingURL=chunk-JWOYLO27.js.map

package/dist/chunk-JWOYLO27.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/core/EffectOpCore.ts","../src/internal/observability/jsonValue.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：\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：\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：\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：\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：\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：\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：\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：\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 entries = Object.entries(input)\n  const limit = Math.min(entries.length, options.maxObjectKeys)\n  const out: Record<string, JsonValue> = {}\n\n  for (let i = 0; i < limit; i++) {\n    const [rawKey, rawValue] = entries[i]!\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 (entries.length > limit) {\n    stats.oversized += 1\n    out.__truncatedKeys = entries.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"],"mappings":";AAIA,SAAS,SAAS,QAAQ,gBAAgB;AAOnC,IAAM,gBAAgB,SAAS,WAA+B,MAAS;AAkCvE,IAAM,wBAAwB,CAAC,YAMZ;AAAA,EACxB,MAAM;AAAA,EACN,SAAS,OAAO;AAAA,EAChB,MAAM,OAAO;AAAA,EACb,MAAM,OAAO;AAAA,EACb,QAAQ,OAAO;AAAA,EACf,SAAS,OAAO;AAClB;AAqEO,IAAM,wBAAN,cAAoC,QAAQ,IAAI,0BAA0B,EAG/E,EAAE;AAAC;AAQE,IAAM,oBAAoB,CAAC,UAAuC;AACvE,SAAO,CAAU,OACf,MAAM;AAAA,IACJ,CAAC,KAAK,OAAO,GAAG,EAAE,GAAG,IAAI,QAAQ,IAAI,CAAQ;AAAA,IAC7C,GAAG;AAAA,EACL;AACJ;AAOO,IAAM,oBAAoB,CAAU,IAAuB,UAAmD;AACnH,SAAO,OAAO,IAAI,aAAa;AAC7B,UAAM,WAAW,OAAO,SAAS,IAAI,aAAa;AAClD,UAAM,aAAc,GAAG,MAAc;AACrC,UAAM,SAAS,OAAO,eAAe,YAAY,WAAW,SAAS,IAAI,aAAc,YAAY,GAAG;AAEtG,UAAM,SAA4B;AAAA,MAChC,GAAG;AAAA,MACH,MAAM;AAAA,QACJ,GAAI,GAAG,QAAQ,CAAC;AAAA,QAChB;AAAA,MACF;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,SAAS,kBAAkB,KAAK,EAAE,MAAM,IAAI,OAAO;AAIzE,WAAO,OAAO,OAAO,QAAQ,eAAe,MAAM,EAAE,OAAc;AAAA,EACpE,CAAC;AACH;;;ACjKO,IAAM,cAAc,CAAC,UAAuC;AACjE,QAAM,OAAO,oBAAI,QAAgB;AAEjC,QAAM,OAAO,CAAC,OAAgB,UAAsC;AAClE,QAAI,QAAQ,GAAI,QAAO;AACvB,QAAI,UAAU,KAAM,QAAO;AAE3B,YAAQ,OAAO,OAAO;AAAA,MACpB,KAAK;AAAA,MACL,KAAK;AACH,eAAO;AAAA,MACT,KAAK;AACH,eAAO,OAAO,SAAS,KAAK;AAAA,MAC9B,KAAK,UAAU;AACb,YAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,cAAI,KAAK,IAAI,KAAK,EAAG,QAAO;AAC5B,eAAK,IAAI,KAAK;AACd,qBAAW,QAAQ,OAAO;AACxB,gBAAI,CAAC,KAAK,MAAM,QAAQ,CAAC,EAAG,QAAO;AAAA,UACrC;AACA,iBAAO;AAAA,QACT;AAEA,YAAI,CAAC,cAAc,KAAK,EAAG,QAAO;AAClC,YAAI,KAAK,IAAI,KAAK,EAAG,QAAO;AAC5B,aAAK,IAAI,KAAK;AAEd,mBAAW,KAAK,OAAO,OAAO,KAAK,GAAG;AACpC,cAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,EAAG,QAAO;AAAA,QAClC;AAEA,eAAO;AAAA,MACT;AAAA,MACA;AACE,eAAO;AAAA,IACX;AAAA,EACF;AAEA,SAAO,KAAK,OAAO,CAAC;AACtB;AAuBA,IAAM,iBAAoD;AAAA,EACxD,UAAU;AAAA,EACV,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,cAAc,IAAI;AAAA,EAClB,uBAAuB;AACzB;AAEA,IAAM,iBAAiB,CAAC,OAAe,QAAgB,UAAgC;AACrF,MAAI,MAAM,UAAU,OAAQ,QAAO;AACnC,QAAM,aAAa;AACnB,SAAO,MAAM,MAAM,GAAG,MAAM;AAC9B;AAQA,IAAM,iBAAiB,CAAC,SAAsC,SAA2C;AACvG,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI,YAAY,sBAAsB,SAAS,mBAAoB,QAAO;AAC1E,MAAI,YAAY,eAAe,SAAS,YAAa,QAAO;AAC5D,SAAO;AACT;AAEA,SAAS,cAAc,OAAkD;AACvE,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,QAAQ,OAAO,eAAe,KAAK;AACzC,SAAO,UAAU,OAAO,aAAa,UAAU;AACjD;AAEA,IAAM,WAAW,CAAC,OAAe,UAAmC;AAClE,MAAI,OAAO,SAAS,KAAK,EAAG,QAAO;AACnC,QAAM,mBAAmB;AACzB,SAAO,OAAO,KAAK;AACrB;AAEA,IAAM,sBAAsB,CAC1B,OACA,SACA,OACA,MACA,UACc;AACd,MAAI,UAAU,KAAM,QAAO;AAE3B,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK;AACH,aAAO,eAAe,OAAO,QAAQ,iBAAiB,KAAK;AAAA,IAC7D,KAAK;AACH,aAAO,SAAS,OAAO,KAAK;AAAA,IAC9B,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,YAAM,mBAAmB;AACzB,aAAO,eAAe,MAAM,SAAS,GAAG,QAAQ,iBAAiB,KAAK;AAAA,IACxE,KAAK;AACH,YAAM,mBAAmB;AACzB,aAAO,eAAe,MAAM,SAAS,GAAG,QAAQ,iBAAiB,KAAK;AAAA,IACxE,KAAK;AACH,YAAM,mBAAmB;AACzB,aAAO;AAAA,IACT,KAAK;AACH,YAAM,WAAW;AACjB,aAAO;AAAA,EACX;AAGA,MAAI,SAAS,QAAQ,UAAU;AAC7B,UAAM,aAAa;AACnB,WAAO;AAAA,EACT;AAEA,MAAI,iBAAiB,MAAM;AACzB,WAAO,MAAM,YAAY;AAAA,EAC3B;AAEA,MAAI,iBAAiB,OAAO;AAC1B,UAAM,mBAAmB;AACzB,WAAO;AAAA,MACL,MAAM,eAAe,MAAM,MAAM,QAAQ,iBAAiB,KAAK;AAAA,MAC/D,SAAS,eAAe,MAAM,SAAS,QAAQ,iBAAiB,KAAK;AAAA,IACvE;AAAA,EACF;AAEA,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,KAAK,IAAI,KAAK,GAAG;AACnB,YAAM,mBAAmB;AACzB,aAAO;AAAA,IACT;AACA,SAAK,IAAI,KAAK;AAAA,EAChB;AAEA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,UAAMA,OAAwB,CAAC;AAC/B,UAAMC,SAAQ,KAAK,IAAI,MAAM,QAAQ,QAAQ,cAAc;AAC3D,aAAS,IAAI,GAAG,IAAIA,QAAO,KAAK;AAC9B,MAAAD,KAAI,KAAK,oBAAoB,MAAM,CAAC,GAAG,SAAS,OAAO,MAAM,QAAQ,CAAC,CAAC;AAAA,IACzE;AACA,QAAI,MAAM,SAASC,QAAO;AACxB,YAAM,aAAa;AACnB,MAAAD,KAAI,KAAK,OAAO,MAAM,SAASC,MAAK,QAAQ;AAAA,IAC9C;AACA,WAAOD;AAAA,EACT;AAEA,MAAI,CAAC,cAAc,KAAK,GAAG;AACzB,UAAM,mBAAmB;AACzB,WAAO,eAAe,OAAO,KAAK,GAAG,QAAQ,iBAAiB,KAAK;AAAA,EACrE;AAEA,QAAM,UAAU,OAAO,QAAQ,KAAK;AACpC,QAAM,QAAQ,KAAK,IAAI,QAAQ,QAAQ,QAAQ,aAAa;AAC5D,QAAM,MAAiC,CAAC;AAExC,WAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC9B,UAAM,CAAC,QAAQ,QAAQ,IAAI,QAAQ,CAAC;AACpC,UAAM,MAAM,eAAe,QAAQ,QAAQ,iBAAiB,KAAK;AACjE,QAAI,aAAa,QAAW;AAC1B,YAAM,WAAW;AACjB;AAAA,IACF;AACA,QAAI,GAAG,IAAI,oBAAoB,UAAU,SAAS,OAAO,MAAM,QAAQ,CAAC;AAAA,EAC1E;AAEA,MAAI,QAAQ,SAAS,OAAO;AAC1B,UAAM,aAAa;AACnB,QAAI,kBAAkB,QAAQ,SAAS;AAAA,EACzC;AAEA,SAAO;AACT;AAEO,IAAM,mBAAmB,CAAC,OAAgB,YAA2D;AAC1G,QAAM,WAA8C,EAAE,GAAG,gBAAgB,GAAI,WAAW,CAAC,EAAG;AAC5F,QAAM,QAAsB,EAAE,SAAS,GAAG,WAAW,GAAG,iBAAiB,EAAE;AAC3E,QAAM,OAAO,oBAAI,QAAgB;AAEjC,MAAI;AACJ,QAAM,QAAQ,oBAAoB,OAAO,UAAU,OAAO,MAAM,CAAC;AAEjE,MAAI,MAAM,kBAAkB,GAAG;AAC7B,gBAAY,eAAe,WAAW,kBAAkB;AAAA,EAC1D;AACA,MAAI,MAAM,YAAY,GAAG;AACvB,gBAAY,eAAe,WAAW,WAAW;AAAA,EACnD;AAGA,MAAI;AACF,UAAM,OAAO,KAAK,UAAU,KAAK;AACjC,QAAI,KAAK,SAAS,SAAS,cAAc;AACvC,kBAAY,eAAe,WAAW,WAAW;AACjD,YAAM,UAAU,KAAK,MAAM,GAAG,KAAK,IAAI,SAAS,uBAAuB,SAAS,YAAY,CAAC;AAC7F,aAAO;AAAA,QACL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,OAAO,KAAK;AAAA,UACZ;AAAA,QACF;AAAA,QACA,OAAO;AAAA,UACL,SAAS,MAAM;AAAA,UACf,WAAW,MAAM,YAAY;AAAA,UAC7B,iBAAiB,MAAM;AAAA,QACzB;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF,QAAQ;AACN,gBAAY,eAAe,WAAW,kBAAkB;AACxD,WAAO;AAAA,MACL,OAAO;AAAA,MACP,OAAO;AAAA,QACL,SAAS,MAAM;AAAA,QACf,WAAW,MAAM;AAAA,QACjB,iBAAiB,MAAM,kBAAkB;AAAA,MAC3C;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,OAAO;AAAA,MACL,SAAS,MAAM;AAAA,MACf,WAAW,MAAM;AAAA,MACjB,iBAAiB,MAAM;AAAA,IACzB;AAAA,IACA;AAAA,EACF;AACF;","names":["out","limit"]}

package/dist/chunk-KIXAU3GM.js

@@ -0,0 +1,137 @@
+import {
+  build,
+  installSourceRefresh
+} from "./chunk-PYOE4VSI.js";
+import {
+  getAtPath
+} from "./chunk-BABLDP24.js";
+import {
+  exportStaticIr
+} from "./chunk-ZFY7U2FR.js";
+import {
+  getBoundInternals
+} from "./chunk-3RMKLXHX.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/StateTrait.ts
+var StateTrait_exports = {};
+__export(StateTrait_exports, {
+  $root: () => $root,
+  build: () => build2,
+  computed: () => computed,
+  exportStaticIr: () => exportStaticIr2,
+  from: () => from,
+  install: () => install2,
+  link: () => link,
+  list: () => list,
+  node: () => node,
+  source: () => source
+});
+
+// src/internal/state-trait/install.ts
+import { Effect } from "effect";
+var buildEntryIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list2 = index.get(entry.fieldPath) ?? [];
+    list2.push(entry);
+    index.set(entry.fieldPath, list2);
+  }
+  return index;
+};
+var install = (bound, program) => {
+  try {
+    const internals = getBoundInternals(bound);
+    internals.traits.registerStateTraitProgram(program, {
+      bumpReason: "logic_installed"
+    });
+  } catch {
+  }
+  const entryIndex = buildEntryIndex(program.entries);
+  const installStep = (step) => {
+    if (!step.targetFieldPath) {
+      return Effect.void;
+    }
+    if (step.kind !== "source-refresh") {
+      return Effect.void;
+    }
+    const candidates = entryIndex.get(step.targetFieldPath);
+    if (!candidates || candidates.length === 0) {
+      return Effect.void;
+    }
+    const entry = candidates.find((e) => e.kind === "source");
+    if (!entry) {
+      return Effect.void;
+    }
+    return installSourceRefresh(bound, step, entry);
+  };
+  return Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(Effect.asVoid);
+};
+
+// src/StateTrait.ts
+var $root = "$root";
+var from = (_schema) => (spec) => spec;
+var node = (spec) => ({
+  _tag: "StateTraitNode",
+  ...spec
+});
+var list = (spec) => ({
+  _tag: "StateTraitList",
+  ...spec
+});
+var computed = (input) => {
+  const derive = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.get(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "computed",
+    meta: {
+      deps: input.deps,
+      derive,
+      equals: input.equals,
+      ...input.scheduling ? { scheduling: input.scheduling } : {}
+    }
+  };
+};
+var source = (input) => {
+  const key = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.key(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "source",
+    meta: { ...input, key }
+  };
+};
+var link = (meta) => ({
+  fieldPath: void 0,
+  kind: "link",
+  meta: { ...meta, ...meta.scheduling ? { scheduling: meta.scheduling } : {} }
+});
+var build2 = (stateSchema, spec) => build(stateSchema, spec);
+var install2 = (bound, program) => install(bound, program);
+var exportStaticIr2 = (program, moduleId, options) => exportStaticIr({
+  program,
+  moduleId,
+  version: options?.version
+});
+
+export {
+  $root,
+  from,
+  node,
+  list,
+  computed,
+  source,
+  link,
+  build2 as build,
+  install2 as install,
+  exportStaticIr2 as exportStaticIr,
+  StateTrait_exports
+};
+//# sourceMappingURL=chunk-KIXAU3GM.js.map

package/dist/chunk-KIXAU3GM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/StateTrait.ts","../src/internal/state-trait/install.ts"],"sourcesContent":["// StateTrait namespace module (@logixjs/core/StateTrait):\n// - Provides a DSL for trait specs (from/node/list/computed/source/link).\n// - build: normalizes the spec and produces Program/Graph/Plan.\n// - install: installs a Program into the runtime (registers source.refresh, runs converge/validate in txn windows).\n\nimport type { Schema } from 'effect'\nimport { Effect } from 'effect'\nimport type { BoundApi } from './Bound.js'\nimport * as Model from './internal/state-trait/model.js'\nimport * as FieldPath from './internal/state-trait/field-path.js'\nimport * as RowId from './internal/state-trait/rowid.js'\nimport * as InternalBuild from './internal/state-trait/build.js'\nimport * as InternalInstall from './internal/state-trait/install.js'\nimport * as InternalIr from './internal/state-trait/ir.js'\n\n// Public type aliases.\nexport type StateTraitSpec<S> = Model.StateTraitSpec<S>\nexport type StateTraitEntry<S = unknown, P extends string = string> = Model.StateTraitEntry<S, P>\nexport type StateTraitProgram<S> = Model.StateTraitProgram<S>\nexport type StateTraitGraph = Model.StateTraitGraph\nexport type StateTraitPlan = Model.StateTraitPlan\nexport type StateTraitNode<Input = unknown, Ctx = unknown> = Model.StateTraitNode<Input, Ctx>\nexport type StateTraitList<Item = unknown> = Model.StateTraitList<Item>\nexport type CheckRule<Input = unknown, Ctx = unknown> = Model.CheckRule<Input, Ctx>\n\nexport type StateFieldPath<S> = FieldPath.StateFieldPath<S>\nexport type StateAtPath<S, P> = FieldPath.StateAtPath<S, P>\n\nexport const $root = '$root' as const\n\ntype DepsArgs<S extends object, Deps extends ReadonlyArray<StateFieldPath<S>>> = {\n  readonly [K in keyof Deps]: StateAtPath<S, Deps[K]>\n}\n\n/**\n * StateTrait.from:\n * - Narrows available field paths based on the state Schema, adding type constraints to trait specs.\n * - At runtime this returns the raw spec object; normalization is handled by internal layers.\n */\nexport const from =\n  <S extends object, I>(_schema: Schema.Schema<S, I>) =>\n  (spec: StateTraitSpec<S>): StateTraitSpec<S> =>\n    spec\n\nexport const node = <Input = unknown, Ctx = unknown>(\n  spec: Omit<Model.StateTraitNode<Input, Ctx>, '_tag'>,\n): Model.StateTraitNode<Input, Ctx> => ({\n  _tag: 'StateTraitNode',\n  ...spec,\n})\n\nexport const list = <Item = unknown>(spec: Omit<Model.StateTraitList<Item>, '_tag'>): Model.StateTraitList<Item> => ({\n  _tag: 'StateTraitList',\n  ...spec,\n})\n\n/**\n * StateTrait.computed:\n * - Declares computed semantics for a field.\n * - Uses explicit deps as the single source of truth for dependencies (diagnostics / reverse-closure / incremental sched).\n */\nexport const computed = <\n  S extends object,\n  P extends StateFieldPath<S>,\n  const Deps extends ReadonlyArray<StateFieldPath<S>>,\n>(input: {\n  readonly deps: Deps\n  readonly get: (...depsValues: DepsArgs<S, Deps>) => StateAtPath<S, P>\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  /**\n   * 043: explicit converge time-slicing scheduling.\n   * - unset: immediate (default behavior unchanged)\n   * - deferred: can be postponed and merged into later windows (requires runtime time-slicing enabled)\n   */\n  readonly scheduling?: Model.TraitConvergeScheduling\n}): StateTraitEntry<S, P> => {\n  const derive = (state: Readonly<S>): StateAtPath<S, P> => {\n    const args = (input.deps as ReadonlyArray<string>).map((dep) => RowId.getAtPath(state as any, dep))\n    return (input.get as any)(...args)\n  }\n  return {\n    fieldPath: undefined as unknown as P,\n    kind: 'computed',\n    meta: {\n      deps: input.deps,\n      derive,\n      equals: input.equals,\n      ...(input.scheduling ? { scheduling: input.scheduling } : {}),\n    },\n  } as StateTraitEntry<S, P>\n}\n\n/**\n * StateTrait.source:\n * - Declares an external resource source for a field (Resource / Query integration is implemented in later phases).\n * - The kernel owns keyHash gating / concurrency / ReplayMode behavior.\n */\nexport const source = <\n  S extends object,\n  P extends StateFieldPath<S>,\n  const Deps extends ReadonlyArray<StateFieldPath<S>>,\n>(input: {\n  readonly resource: string\n  readonly deps: Deps\n  readonly key: (...depsValues: DepsArgs<S, Deps>) => unknown\n  readonly triggers?: ReadonlyArray<'onMount' | 'onKeyChange' | 'manual'>\n  readonly debounceMs?: number\n  readonly concurrency?: 'switch' | 'exhaust-trailing'\n  /**\n   * Serializable metadata for Devtools/docs (whitelisted fields are extracted during build).\n   */\n  readonly meta?: Record<string, unknown>\n}): StateTraitEntry<S, P> => {\n  const key = (state: Readonly<S>): unknown => {\n    const args = (input.deps as ReadonlyArray<string>).map((dep) => RowId.getAtPath(state as any, dep))\n    return (input.key as any)(...args)\n  }\n  return {\n    fieldPath: undefined as unknown as P,\n    kind: 'source',\n    meta: { ...input, key },\n  } as StateTraitEntry<S, P>\n}\n\n/**\n * StateTrait.link:\n * - Declares a linkage from another field into the target field.\n * - `meta.from` is also constrained by `StateFieldPath<S>`.\n */\nexport const link = <S extends object, P extends StateFieldPath<S>>(meta: {\n  from: StateFieldPath<S>\n  /**\n   * 043: explicit converge time-slicing scheduling.\n   * - unset: immediate (default behavior unchanged)\n   * - deferred: can be postponed and merged into later windows (requires runtime time-slicing enabled)\n   */\n  scheduling?: Model.TraitConvergeScheduling\n}): StateTraitEntry<S, P> =>\n  ({\n    fieldPath: undefined as unknown as P,\n    kind: 'link',\n    meta: { ...meta, ...(meta.scheduling ? { scheduling: meta.scheduling } : {}) },\n  }) as StateTraitEntry<S, P>\n\n/**\n * StateTrait.build:\n * - Normalizes the spec into an executable Program (including Graph/Plan).\n * - When DSL and build constraints differ, build is the final authority (e.g. requiring explicit deps).\n */\nexport const build = <S extends object>(\n  stateSchema: Schema.Schema<S, any>,\n  spec: StateTraitSpec<S>,\n): StateTraitProgram<S> => InternalBuild.build(stateSchema, spec)\n\n/**\n * StateTrait.install:\n * - Installs Program-defined behavior (computed/link/source/check, etc.) on top of a Bound API.\n * - Each PlanStep corresponds to a long-lived Effect mounted into the runtime Scope.\n */\nexport const install = <S extends object>(\n  bound: BoundApi<any, any>,\n  program: StateTraitProgram<S>,\n): Effect.Effect<void, never, any> => InternalInstall.install(bound, program)\n\n/**\n * StateTrait.exportStaticIr:\n * - Exports minimal Static IR (aligned with 009 canonical FieldPath constraints) for Devtools / Alignment Lab.\n * - The return value must be JSON-stringifiable (evidence packages / replay pipeline).\n */\nexport type StaticIr = InternalIr.StaticIr\n\nexport const exportStaticIr = (\n  program: StateTraitProgram<any>,\n  moduleId: string,\n  options?: {\n    readonly version?: string\n  },\n): StaticIr =>\n  InternalIr.exportStaticIr({\n    program,\n    moduleId,\n    version: options?.version,\n  })\n","import { Effect } from 'effect'\nimport type { BoundApi } from '../runtime/core/module.js'\nimport { getBoundInternals } from '../runtime/core/runtimeInternalsAccessor.js'\nimport * as SourceRuntime from './source.js'\nimport type {\n  StateTraitProgram,\n  StateTraitPlanStep,\n  StateTraitEntry,\n  TraitConvergeGenerationBumpReason,\n} from './model.js'\n\nconst buildEntryIndex = <S>(\n  entries: ReadonlyArray<StateTraitEntry<S, string>>,\n): Map<string, Array<StateTraitEntry<S, string>>> => {\n  const index = new Map<string, Array<StateTraitEntry<S, string>>>()\n  for (const entry of entries) {\n    const list = index.get(entry.fieldPath) ?? []\n    list.push(entry)\n    index.set(entry.fieldPath, list)\n  }\n  return index\n}\n\n/**\n * Install behaviors described by StateTraitProgram onto the given Bound API.\n *\n * - Phase 2 minimal implementation:\n *   - Register watchers for computed fields: recompute target fields when State changes.\n *   - Register watchers for link fields: sync target fields when source fields change.\n *   - Reserve refresh entrypoints for source fields (no external calls yet).\n *\n * Notes:\n * - All watchers are installed via Bound API `$`, without directly depending on ModuleRuntime.\n * - Each PlanStep corresponds to a long-lived Effect and is mounted into the Runtime Scope via forkScoped.\n */\nexport const install = <S>(\n  bound: BoundApi<any, any>,\n  program: StateTraitProgram<S>,\n): Effect.Effect<void, never, any> => {\n  // Register the program to Runtime first (the converge engine runs computed/link/check before txn commit).\n  try {\n    const internals = getBoundInternals(bound as any)\n    ;(internals.traits.registerStateTraitProgram as any)(program, {\n      bumpReason: 'logic_installed' as TraitConvergeGenerationBumpReason,\n    })\n  } catch {\n    // no-op for legacy/mocked bound\n  }\n\n  const entryIndex = buildEntryIndex(program.entries as any)\n\n  const installStep = (step: StateTraitPlanStep): Effect.Effect<void, never, any> => {\n    if (!step.targetFieldPath) {\n      return Effect.void\n    }\n\n    if (step.kind !== 'source-refresh') {\n      // computed/link/check are handled by the runtime core within the transaction window; install keeps only source.refresh entrypoints.\n      return Effect.void\n    }\n\n    const candidates = entryIndex.get(step.targetFieldPath)\n    if (!candidates || candidates.length === 0) {\n      // The plan references a missing spec: treat it as a build-time bug and ignore the step here.\n      return Effect.void\n    }\n\n    const entry = candidates.find((e) => e.kind === 'source')\n\n    if (!entry) {\n      return Effect.void\n    }\n\n    return SourceRuntime.installSourceRefresh(bound, step, entry as any)\n  }\n\n  return Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(Effect.asVoid)\n}\n"],"mappings":"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","names":["build","exportStaticIr","install","list","build","install","exportStaticIr"]}

package/dist/chunk-KL5ACTCT.js

@@ -0,0 +1,8 @@
+// src/internal/runtime/core/Platform.ts
+import { Context } from "effect";
+var Tag = Context.GenericTag("@logixjs/Platform");
+
+export {
+  Tag
+};
+//# sourceMappingURL=chunk-KL5ACTCT.js.map

package/dist/chunk-KL5ACTCT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/core/Platform.ts"],"sourcesContent":["import { Context, Effect } from 'effect'\n\nexport interface Service {\n  readonly lifecycle: {\n    readonly onSuspend: (eff: Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>\n    readonly onResume: (eff: Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>\n    readonly onReset?: (eff: Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>\n  }\n\n  /**\n   * Platform signal broadcaster (for host integration and tests): triggers registered lifecycle handlers.\n   *\n   * Notes:\n   * - The default implementation should be a safe no-op.\n   * - Failure policy is decided by the platform implementation; the runtime should ensure \"do not terminate the instance by default\".\n   */\n  readonly emitSuspend: () => Effect.Effect<void, never, any>\n  readonly emitResume: () => Effect.Effect<void, never, any>\n  readonly emitReset: () => Effect.Effect<void, never, any>\n}\n\nexport const Tag = Context.GenericTag<Service>('@logixjs/Platform')\n"],"mappings":";AAAA,SAAS,eAAuB;AAqBzB,IAAM,MAAM,QAAQ,WAAoB,mBAAmB;","names":[]}

package/dist/chunk-KP7MUZNX.js

@@ -0,0 +1,83 @@
+// 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
+import { Context } from "effect";
+var RuntimeServiceBuiltinsTag = class extends Context.Tag("@logixjs/core/RuntimeServiceBuiltins")() {
+};
+
+export {
+  CutoverCoverageMatrix,
+  evaluateFullCutoverGate,
+  RuntimeServiceBuiltinsTag
+};
+//# sourceMappingURL=chunk-KP7MUZNX.js.map

package/dist/chunk-KP7MUZNX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/core/FullCutoverGate.ts","../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   * Convention: txnSeq=0 denotes assembly (a wiring-time failure anchor).\n   * Full Cutover Gate is evaluated during assembly by default, so it does not depend on a real txn.\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: a stricter \"full cutover\" truth value.\n   * - Requires every serviceId in the coverage matrix to be bound to the expected implId.\n   * - Requires no fallback (any `fallback=` in overridesApplied means not fully activated).\n   *\n   * Note: in trial mode the verdict may be PASS while fullyActivated can still be false.\n   */\n  readonly fullyActivated: boolean\n  readonly missingServiceIds: ReadonlyArray<string>\n  readonly fallbackServiceIds: ReadonlyArray<string>\n  readonly anchor: FullCutoverGateAnchor\n  /**\n   * When diagnostics=off, it must stay slim (avoid permanent overhead).\n   * In light/full, additional explainable info is allowed (still must be serializable).\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 = 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   * Returns the make Effect of a builtin implementation (provided by ModuleRuntime during assembly, avoiding external code\n   * capturing internal closures/state).\n   * - For kernel implementors only (e.g. core-ng) to implement behavior-equivalent replacements or thin wrappers.\n   * - Not an app-facing contract; must not be depended on from business Flow/Logic.\n   */\n  readonly getBuiltinMake: (serviceId: string) => Effect.Effect<unknown, never, any>\n}\n\nexport class RuntimeServiceBuiltinsTag extends Context.Tag('@logixjs/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,UAAkC,KAAK,SAAS,gBAAiB,iBAAiB,SAAS,SAAU;AAE3G,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;;;AC/IA,SAAS,eAAuB;AAYzB,IAAM,4BAAN,cAAwC,QAAQ,IAAI,sCAAsC,EAG/F,EAAE;AAAC;","names":[]}

package/dist/chunk-LEU6UA5J.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-LEU6UA5J.js.map

package/dist/chunk-LEU6UA5J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-M2RGJPXX.js

@@ -0,0 +1,35 @@
+import {
+  registerTrialRunArtifactExporter,
+  trialRun,
+  trialRunModule
+} from "./chunk-M3WTHJHJ.js";
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage,
+  importEvidencePackage
+} from "./chunk-M7IYCTJV.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Observability.ts
+var Observability_exports = {};
+__export(Observability_exports, {
+  exportEvidencePackage: () => exportEvidencePackage2,
+  importEvidencePackage: () => importEvidencePackage2,
+  protocolVersion: () => protocolVersion,
+  registerTrialRunArtifactExporter: () => registerTrialRunArtifactExporter,
+  trialRun: () => trialRun,
+  trialRunModule: () => trialRunModule
+});
+var protocolVersion = OBSERVABILITY_PROTOCOL_VERSION;
+var exportEvidencePackage2 = exportEvidencePackage;
+var importEvidencePackage2 = importEvidencePackage;
+
+export {
+  protocolVersion,
+  exportEvidencePackage2 as exportEvidencePackage,
+  importEvidencePackage2 as importEvidencePackage,
+  Observability_exports
+};
+//# sourceMappingURL=chunk-M2RGJPXX.js.map

package/dist/chunk-M2RGJPXX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Observability.ts"],"sourcesContent":["// Observability Protocol (@logixjs/core/Observability).\n\nimport * as Evidence from './internal/observability/evidence.js'\nexport * from './internal/observability/trialRun.js'\n\nexport type { JsonValue } from './internal/observability/jsonValue.js'\nexport type { ArtifactEnvelope, ArtifactKey, TrialRunArtifacts } from './internal/observability/artifacts/model.js'\nexport type {\n  TrialRunArtifactExporter,\n  TrialRunArtifactInspectionContext,\n} from './internal/observability/artifacts/exporter.js'\nexport { registerTrialRunArtifactExporter } from './internal/observability/artifacts/registry.js'\n\nexport const protocolVersion = Evidence.OBSERVABILITY_PROTOCOL_VERSION\n\nexport interface ObservationEnvelope extends Evidence.ObservationEnvelope {}\nexport interface EvidencePackageSource extends Evidence.EvidencePackageSource {}\nexport interface EvidencePackage extends Evidence.EvidencePackage {}\n\nexport const exportEvidencePackage = Evidence.exportEvidencePackage\nexport const importEvidencePackage = Evidence.importEvidencePackage\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAAA;AAAA,EAAA,6BAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAaO,IAAM,kBAA2B;AAMjC,IAAMC,yBAAiC;AACvC,IAAMC,yBAAiC;","names":["exportEvidencePackage","importEvidencePackage","exportEvidencePackage","importEvidencePackage"]}

package/dist/chunk-M3BFQ7HK.js

@@ -0,0 +1,13 @@
+// src/internal/runtime/core/ConvergeStaticIrCollector.ts
+import { FiberRef, Layer } from "effect";
+var currentConvergeStaticIrCollectors = FiberRef.unsafeMake([]);
+var appendConvergeStaticIrCollectors = (collectors) => Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
+  ...current,
+  ...collectors
+]);
+
+export {
+  currentConvergeStaticIrCollectors,
+  appendConvergeStaticIrCollectors
+};
+//# sourceMappingURL=chunk-M3BFQ7HK.js.map

package/dist/chunk-M3BFQ7HK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/core/ConvergeStaticIrCollector.ts"],"sourcesContent":["import { FiberRef, Layer } from 'effect'\nimport type { ConvergeStaticIrExport } from '../../state-trait/converge-ir.js'\n\n/**\n * ConvergeStaticIrCollector：\n * - Consumer interface for collecting ConvergeStaticIrExport (de-duplicated/indexed by staticIrDigest); an internal injectable capability.\n * - Typical implementations: DevtoolsHub (process-level) / EvidenceCollector (RunSession-level).\n *\n * Notes:\n * - Uses FiberRef<ReadonlyArray<...>> to allow appending multiple collectors within the same scope (similar to Debug sinks).\n * - ModuleRuntime reads the FiberRef value during installation and captures it in a closure, avoiding Env lookup on hot paths.\n */\nexport interface ConvergeStaticIrCollector {\n  readonly register: (ir: ConvergeStaticIrExport) => void\n}\n\nexport const currentConvergeStaticIrCollectors = FiberRef.unsafeMake<ReadonlyArray<ConvergeStaticIrCollector>>([])\n\nexport const appendConvergeStaticIrCollectors = (\n  collectors: ReadonlyArray<ConvergeStaticIrCollector>,\n): Layer.Layer<any, never, never> =>\n  Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [\n    ...current,\n    ...collectors,\n  ]) as Layer.Layer<any, never, never>\n"],"mappings":";AAAA,SAAS,UAAU,aAAa;AAgBzB,IAAM,oCAAoC,SAAS,WAAqD,CAAC,CAAC;AAE1G,IAAM,mCAAmC,CAC9C,eAEA,MAAM,0BAA0B,mCAAmC,CAAC,YAAY;AAAA,EAC9E,GAAG;AAAA,EACH,GAAG;AACL,CAAC;","names":[]}