@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-6FKWRVP4.js

@@ -0,0 +1,85 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/internal/runtime/core/runtimeInternalsAccessor.ts
+var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logix/core/runtimeInternals");
+var BOUND_INTERNALS = /* @__PURE__ */ Symbol.for("@logix/core/boundInternals");
+var MODULE_TRAITS_PROGRAM = /* @__PURE__ */ Symbol.for("@logix/core/moduleTraitsProgram");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var setRuntimeInternals = (runtime, internals) => {
+  defineHidden(runtime, RUNTIME_INTERNALS, internals);
+};
+var setBoundInternals = (bound, internals) => {
+  defineHidden(bound, BOUND_INTERNALS, internals);
+};
+var setModuleTraitsProgram = (module, program) => {
+  defineHidden(module, MODULE_TRAITS_PROGRAM, program);
+};
+var getModuleTraitsProgram = (module) => {
+  if (!module) return void 0;
+  if (typeof module !== "object" && typeof module !== "function") return void 0;
+  return module[MODULE_TRAITS_PROGRAM];
+};
+var formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getRuntimeInternals = (runtime) => {
+  const scope = runtime;
+  const internals = runtime[RUNTIME_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeInternals] Runtime internals not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make calls internalHooks.installInternalHooks (020 foundation).",
+      "- If you created a mock runtime for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Runtime internals not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== internals.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeInternals] Runtime internals instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `internals: ${formatScope(internals.moduleId, internals.instanceId)}`
+      ].join("\n") : "Runtime internals mismatch"
+    );
+  }
+  return internals;
+};
+var getBoundInternals = (bound) => {
+  const internals = bound[BOUND_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingBoundInternals] Bound internals not installed on Bound API instance.",
+      "fix:",
+      "- Ensure BoundApiRuntime attaches internals (020 foundation).",
+      "- If you created a mock bound for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Bound internals not installed";
+    throw new Error(msg);
+  }
+  return internals;
+};
+
+export {
+  setRuntimeInternals,
+  setBoundInternals,
+  setModuleTraitsProgram,
+  getModuleTraitsProgram,
+  getRuntimeInternals,
+  getBoundInternals
+};
+//# sourceMappingURL=data:application/json;base64,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

package/public/sandbox/chunks/chunk-6JRP52YT.js

@@ -0,0 +1,34 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record = value;
+    const keys = Object.keys(record).sort((a, b) => a.localeCompare(b));
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
+export {
+  stableStringify,
+  fnv1a32
+};
+//# sourceMappingURL=data:application/json;base64,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

package/public/sandbox/chunks/chunk-6JYAC3G6.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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

package/public/sandbox/chunks/chunk-6TUOP63Q.js

@@ -0,0 +1,86 @@
+// @logixjs/core subpath bundles for @logixjs/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();
+};
+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("@logixjs/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   * 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()\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;AAC9B;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/public/sandbox/chunks/{chunk-A6JFUNQQ.js → chunk-74C5VW7Z.js}

@@ -2,10 +2,10 @@
 
 import {
   exportStaticIr
-} from "./chunk-ON2LY6HJ.js";
+} from "./chunk-4MY35XR3.js";
 import {
   isDevEnv
-} from "./chunk-CZRI7MHA.js";
+} from "./chunk-YMVMZA3U.js";
 
 // ../logix-core/src/internal/debug/ModuleTraitsRegistry.ts
 var programsByIdAndDigest = /* @__PURE__ */ new Map();

package/public/sandbox/chunks/chunk-75DQFC5M.js

@@ -0,0 +1,16 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/runtime/core/ConvergeStaticIrCollector.ts
+import { FiberRef, Layer } from "../effect.js";
+var currentConvergeStaticIrCollectors = FiberRef.unsafeMake([]);
+var appendConvergeStaticIrCollectors = (collectors) => Layer.fiberRefLocallyScopedWith(
+  currentConvergeStaticIrCollectors,
+  (current) => [...current, ...collectors]
+);
+
+export {
+  currentConvergeStaticIrCollectors,
+  appendConvergeStaticIrCollectors
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvaW50ZXJuYWwvcnVudGltZS9jb3JlL0NvbnZlcmdlU3RhdGljSXJDb2xsZWN0b3IudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImltcG9ydCB7IEZpYmVyUmVmLCBMYXllciB9IGZyb20gXCJlZmZlY3RcIlxuaW1wb3J0IHR5cGUgeyBDb252ZXJnZVN0YXRpY0lyRXhwb3J0IH0gZnJvbSBcIi4uLy4uL3N0YXRlLXRyYWl0L2NvbnZlcmdlLWlyLmpzXCJcblxuLyoqXG4gKiBDb252ZXJnZVN0YXRpY0lyQ29sbGVjdG9yXHVGRjFBXG4gKiAtIFx1NzUyOFx1NEU4RVx1NjUzNlx1OTZDNiBDb252ZXJnZVN0YXRpY0lyRXhwb3J0XHVGRjA4XHU2MzA5IHN0YXRpY0lyRGlnZXN0IFx1NTNCQlx1OTFDRC9cdTdEMjJcdTVGMTVcdUZGMDlcdTc2ODQgY29uc3VtZXIgXHU2M0E1XHU1M0UzXHVGRjFCXHU1QzVFXHU0RThFXHU1MTg1XHU5MEU4XHU1M0VGXHU2Q0U4XHU1MTY1XHU4MEZEXHU1MjlCXHUzMDAyXG4gKiAtIFx1NTE3OFx1NTc4Qlx1NUI5RVx1NzNCMFx1RkYxQURldnRvb2xzSHViXHVGRjA4XHU4RkRCXHU3QTBCXHU3RUE3XHVGRjA5LyBFdmlkZW5jZUNvbGxlY3Rvclx1RkYwOFJ1blNlc3Npb24gXHU3RUE3XHVGRjA5XHUzMDAyXG4gKlxuICogXHU4QkY0XHU2NjBFXHVGRjFBXG4gKiAtIFx1OTFDN1x1NzUyOCBGaWJlclJlZjxSZWFkb25seUFycmF5PC4uLj4+IFx1NEVFNVx1NjUyRlx1NjMwMVx1NTcyOFx1NTQwQ1x1NEUwMFx1NEY1Q1x1NzUyOFx1NTdERlx1NTE4NVx1OEZGRFx1NTJBMFx1NTkxQVx1NEUyQSBjb2xsZWN0b3JcdUZGMDhcdTdDN0JcdTRGM0MgRGVidWcgc2lua3NcdUZGMDlcdTMwMDJcbiAqIC0gTW9kdWxlUnVudGltZSBcdTU3MjhcdTVCOUVcdTRGOEJcdTVCODlcdTg4QzVcdTk2MzZcdTZCQjVcdTRGMUFcdThCRkJcdTUzRDZcdTVGNTNcdTUyNEQgRmliZXJSZWYgXHU1MDNDXHU1RTc2XHU5NUVEXHU1MzA1XHU2MzU1XHU4M0I3XHVGRjBDXHU5MDdGXHU1MTREXHU3MEVEXHU4REVGXHU1Rjg0XHU2QkNGXHU2QjIxIEVudiBcdTY3RTVcdTYyN0VcdTMwMDJcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDb252ZXJnZVN0YXRpY0lyQ29sbGVjdG9yIHtcbiAgcmVhZG9ubHkgcmVnaXN0ZXI6IChpcjogQ29udmVyZ2VTdGF0aWNJckV4cG9ydCkgPT4gdm9pZFxufVxuXG5leHBvcnQgY29uc3QgY3VycmVudENvbnZlcmdlU3RhdGljSXJDb2xsZWN0b3JzID0gRmliZXJSZWYudW5zYWZlTWFrZTxcbiAgUmVhZG9ubHlBcnJheTxDb252ZXJnZVN0YXRpY0lyQ29sbGVjdG9yPlxuPihbXSlcblxuZXhwb3J0IGNvbnN0IGFwcGVuZENvbnZlcmdlU3RhdGljSXJDb2xsZWN0b3JzID0gKFxuICBjb2xsZWN0b3JzOiBSZWFkb25seUFycmF5PENvbnZlcmdlU3RhdGljSXJDb2xsZWN0b3I+LFxuKTogTGF5ZXIuTGF5ZXI8YW55LCBuZXZlciwgbmV2ZXI+ID0+XG4gIExheWVyLmZpYmVyUmVmTG9jYWxseVNjb3BlZFdpdGgoXG4gICAgY3VycmVudENvbnZlcmdlU3RhdGljSXJDb2xsZWN0b3JzLFxuICAgIChjdXJyZW50KSA9PiBbLi4uY3VycmVudCwgLi4uY29sbGVjdG9yc10sXG4gICkgYXMgTGF5ZXIuTGF5ZXI8YW55LCBuZXZlciwgbmV2ZXI+XG5cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7QUFBQSxTQUFTLFVBQVUsYUFBYTtBQWdCekIsSUFBTSxvQ0FBb0MsU0FBUyxXQUV4RCxDQUFDLENBQUM7QUFFRyxJQUFNLG1DQUFtQyxDQUM5QyxlQUVBLE1BQU07QUFBQSxFQUNKO0FBQUEsRUFDQSxDQUFDLFlBQVksQ0FBQyxHQUFHLFNBQVMsR0FBRyxVQUFVO0FBQ3pDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/public/sandbox/chunks/{chunk-UCFEP3BH.js → chunk-7GPAF2UK.js}

@@ -2,7 +2,7 @@
 
 import {
   isDevEnv
-} from "./chunk-CZRI7MHA.js";
+} from "./chunk-YMVMZA3U.js";
 
 // ../logix-core/src/internal/runtime/core/runtimeInternalsAccessor.ts
 var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeInternals");

package/public/sandbox/chunks/chunk-7KQFTS2Y.js

@@ -0,0 +1,135 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  normalizeFieldPath
+} from "./chunk-BCEO3MGD.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-6JRP52YT.js";
+
+// ../logix-core/src/internal/state-trait/ir.ts
+var normalizeFieldPaths = (paths) => {
+  if (!paths || paths.length === 0) return [];
+  const out = [];
+  for (const path of paths) {
+    const normalized = normalizeFieldPath(path);
+    if (normalized) out.push(normalized);
+  }
+  return out;
+};
+var normalizeFieldPath2 = (path) => path ? normalizeFieldPath(path) : void 0;
+var toNodeKind = (step) => {
+  switch (step.kind) {
+    case "computed-update":
+      return "computed";
+    case "link-propagate":
+      return "link";
+    case "source-refresh":
+      return "source";
+    case "check-validate":
+      return "check";
+  }
+};
+var findEntryForStep = (program, step) => {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return void 0;
+  const kind = toNodeKind(step);
+  return program.entries.find(
+    (e) => e.fieldPath === fieldPath && (e.kind === kind || kind === "check" && e.kind === "check" || kind === "source" && e.kind === "source" || kind === "link" && e.kind === "link" || kind === "computed" && e.kind === "computed")
+  );
+};
+var getReadsForEntry = (entry) => {
+  if (!entry) return void 0;
+  if (entry.kind === "computed") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "source") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "link") {
+    const from = entry.meta.from;
+    return from ? [from] : [];
+  }
+  if (entry.kind === "check") {
+    const rules = entry.meta?.rules ?? {};
+    const out = [];
+    for (const name of Object.keys(rules)) {
+      const rule = rules[name];
+      const deps = rule?.deps;
+      if (deps) out.push(...deps);
+    }
+    return out;
+  }
+  return void 0;
+};
+var exportStaticIr = (params) => {
+  const moduleId = params.moduleId;
+  const version = params.version ?? "009";
+  const metaByField = /* @__PURE__ */ new Map();
+  for (const node of params.program.graph.nodes) {
+    const meta = node.meta;
+    if (!meta || typeof meta !== "object") continue;
+    const label = typeof meta.label === "string" ? meta.label : void 0;
+    const description = typeof meta.description === "string" ? meta.description : void 0;
+    const tags = Array.isArray(meta.tags) && meta.tags.every((t) => typeof t === "string") ? meta.tags : void 0;
+    const group = typeof meta.group === "string" ? meta.group : void 0;
+    const docsUrl = typeof meta.docsUrl === "string" ? meta.docsUrl : void 0;
+    const cacheGroup = typeof meta.cacheGroup === "string" ? meta.cacheGroup : void 0;
+    const annotationsRaw = meta.annotations;
+    const annotations = annotationsRaw && typeof annotationsRaw === "object" && !Array.isArray(annotationsRaw) ? annotationsRaw : void 0;
+    if (label || description || tags || group || docsUrl || cacheGroup || annotations) {
+      metaByField.set(node.id, {
+        label,
+        description,
+        tags,
+        group,
+        docsUrl,
+        cacheGroup,
+        annotations
+      });
+    }
+  }
+  const nodes = params.program.plan.steps.map((step) => {
+    const kind = toNodeKind(step);
+    const entry = findEntryForStep(params.program, step);
+    const reads = normalizeFieldPaths(getReadsForEntry(entry));
+    const target = step.targetFieldPath;
+    const write = normalizeFieldPath2(target);
+    const writes = write ? [write] : [];
+    const meta = target ? metaByField.get(target) : void 0;
+    const base2 = {
+      nodeId: step.id,
+      kind,
+      reads,
+      writes: kind === "check" ? [] : writes,
+      meta
+    };
+    if (kind !== "check" && target && !write) {
+      return { ...base2, writesUnknown: true };
+    }
+    return base2;
+  });
+  const edges = params.program.graph.edges.map((edge) => ({
+    edgeId: edge.id,
+    from: edge.from,
+    to: edge.to,
+    kind: edge.kind
+  }));
+  const base = {
+    version,
+    moduleId,
+    nodes,
+    edges
+  };
+  const digest = `stir:${version}:${fnv1a32(stableStringify(base))}`;
+  return {
+    ...base,
+    digest
+  };
+};
+
+export {
+  exportStaticIr
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/ir.ts"],
  "sourcesContent": ["import type { StateTraitEntry, StateTraitPlanStep, StateTraitProgram } from './model.js'\nimport * as CanonicalFieldPath from '../field-path.js'\nimport { fnv1a32, stableStringify } from '../digest.js'\n\nexport type FieldPath = CanonicalFieldPath.FieldPath\n\nexport interface StaticIrNode {\n  readonly nodeId: string\n  readonly kind: string\n  readonly reads: ReadonlyArray<FieldPath>\n  readonly writes: ReadonlyArray<FieldPath>\n  readonly writesUnknown?: boolean\n  readonly policy?: Record<string, unknown>\n  readonly meta?: {\n    readonly label?: string\n    readonly description?: string\n    readonly tags?: ReadonlyArray<string>\n    readonly group?: string\n    readonly docsUrl?: string\n    readonly cacheGroup?: string\n    readonly annotations?: Record<string, unknown>\n  }\n}\n\nexport interface StaticIrEdge {\n  readonly edgeId: string\n  readonly from: string\n  readonly to: string\n  readonly kind: string\n}\n\nexport interface StaticIr {\n  readonly version: string\n  readonly moduleId: string\n  /**\n   * \u7A33\u5B9A\u6458\u8981\uFF08\u7528\u4E8E drift detection / \u5BF9\u6BD4\uFF09\uFF1A\u4EC5\u7531\u5F53\u524D\u5BFC\u51FA\u7ED3\u6784\u51B3\u5B9A\u3002\n   */\n  readonly digest: string\n  readonly nodes: ReadonlyArray<StaticIrNode>\n  readonly edges: ReadonlyArray<StaticIrEdge>\n  readonly conflicts?: ReadonlyArray<unknown>\n}\n\nconst normalizeFieldPaths = (paths: ReadonlyArray<string> | undefined): ReadonlyArray<FieldPath> => {\n  if (!paths || paths.length === 0) return []\n  const out: Array<FieldPath> = []\n  for (const path of paths) {\n    const normalized = CanonicalFieldPath.normalizeFieldPath(path)\n    if (normalized) out.push(normalized)\n  }\n  return out\n}\n\nconst normalizeFieldPath = (path: string | undefined): FieldPath | undefined =>\n  path ? CanonicalFieldPath.normalizeFieldPath(path) : undefined\n\nconst toNodeKind = (step: StateTraitPlanStep): string => {\n  switch (step.kind) {\n    case 'computed-update':\n      return 'computed'\n    case 'link-propagate':\n      return 'link'\n    case 'source-refresh':\n      return 'source'\n    case 'check-validate':\n      return 'check'\n  }\n}\n\nconst findEntryForStep = (\n  program: StateTraitProgram<any>,\n  step: StateTraitPlanStep,\n): StateTraitEntry<any, string> | undefined => {\n  const fieldPath = step.targetFieldPath\n  if (!fieldPath) return undefined\n  const kind = toNodeKind(step)\n  return program.entries.find(\n    (e) =>\n      e.fieldPath === fieldPath &&\n      (e.kind === kind ||\n        (kind === 'check' && e.kind === 'check') ||\n        (kind === 'source' && e.kind === 'source') ||\n        (kind === 'link' && e.kind === 'link') ||\n        (kind === 'computed' && e.kind === 'computed')),\n  )\n}\n\nconst getReadsForEntry = (entry: StateTraitEntry<any, string> | undefined): ReadonlyArray<string> | undefined => {\n  if (!entry) return undefined\n  if (entry.kind === 'computed') {\n    return (entry.meta as any).deps as ReadonlyArray<string> | undefined\n  }\n  if (entry.kind === 'source') {\n    return (entry.meta as any).deps as ReadonlyArray<string> | undefined\n  }\n  if (entry.kind === 'link') {\n    const from = (entry.meta as any).from as string | undefined\n    return from ? [from] : []\n  }\n  if (entry.kind === 'check') {\n    const rules = ((entry.meta as any)?.rules ?? {}) as Record<string, any>\n    const out: Array<string> = []\n    for (const name of Object.keys(rules)) {\n      const rule = rules[name]\n      const deps = rule?.deps as ReadonlyArray<string> | undefined\n      if (deps) out.push(...deps)\n    }\n    return out\n  }\n  return undefined\n}\n\nexport const exportStaticIr = (params: {\n  readonly program: StateTraitProgram<any>\n  readonly moduleId: string\n  readonly version?: string\n}): StaticIr => {\n  const moduleId = params.moduleId\n  const version = params.version ?? '009'\n\n  const metaByField = new Map<\n    string,\n    {\n      readonly label?: string\n      readonly description?: string\n      readonly tags?: ReadonlyArray<string>\n      readonly group?: string\n      readonly docsUrl?: string\n      readonly cacheGroup?: string\n      readonly annotations?: Record<string, unknown>\n    }\n  >()\n  for (const node of params.program.graph.nodes) {\n    const meta = node.meta as any\n    if (!meta || typeof meta !== 'object') continue\n    const label = typeof meta.label === 'string' ? meta.label : undefined\n    const description = typeof meta.description === 'string' ? meta.description : undefined\n    const tags =\n      Array.isArray(meta.tags) && meta.tags.every((t: unknown) => typeof t === 'string')\n        ? (meta.tags as ReadonlyArray<string>)\n        : undefined\n    const group = typeof meta.group === 'string' ? meta.group : undefined\n    const docsUrl = typeof meta.docsUrl === 'string' ? meta.docsUrl : undefined\n    const cacheGroup = typeof meta.cacheGroup === 'string' ? meta.cacheGroup : undefined\n\n    const annotationsRaw = meta.annotations\n    const annotations =\n      annotationsRaw && typeof annotationsRaw === 'object' && !Array.isArray(annotationsRaw)\n        ? (annotationsRaw as Record<string, unknown>)\n        : undefined\n\n    if (label || description || tags || group || docsUrl || cacheGroup || annotations) {\n      metaByField.set(node.id, {\n        label,\n        description,\n        tags,\n        group,\n        docsUrl,\n        cacheGroup,\n        annotations,\n      })\n    }\n  }\n\n  const nodes: Array<StaticIrNode> = params.program.plan.steps.map((step) => {\n    const kind = toNodeKind(step)\n    const entry = findEntryForStep(params.program, step)\n    const reads = normalizeFieldPaths(getReadsForEntry(entry))\n\n    const target = step.targetFieldPath\n    const write = normalizeFieldPath(target)\n    const writes = write ? [write] : []\n\n    const meta = target ? metaByField.get(target) : undefined\n\n    const base: StaticIrNode = {\n      nodeId: step.id,\n      kind,\n      reads,\n      writes: kind === 'check' ? [] : writes,\n      meta,\n    }\n\n    if (kind !== 'check' && target && !write) {\n      return { ...base, writesUnknown: true }\n    }\n    return base\n  })\n\n  const edges: Array<StaticIrEdge> = params.program.graph.edges.map((edge) => ({\n    edgeId: edge.id,\n    from: edge.from,\n    to: edge.to,\n    kind: edge.kind,\n  }))\n\n  const base = {\n    version,\n    moduleId,\n    nodes,\n    edges,\n  } as const\n\n  const digest = `stir:${version}:${fnv1a32(stableStringify(base))}`\n\n  return {\n    ...base,\n    digest,\n  }\n}\n"],
  "mappings": "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",
  "names": ["normalizeFieldPath", "base"]
}


package/public/sandbox/chunks/chunk-7POKWYE3.js

@@ -0,0 +1,112 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/Resource.ts
+import { Context, Layer } from "../effect.js";
+var stableStringify = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const encode = (input) => {
+    if (input === null) return null;
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+      return input;
+    }
+    if (typeof input === "bigint") return input.toString();
+    if (typeof input === "undefined") return "__undefined__";
+    if (typeof input === "symbol") return `__symbol__:${String(input)}`;
+    if (typeof input === "function") return "__function__";
+    if (Array.isArray(input)) {
+      return input.map((v) => encode(v));
+    }
+    if (input instanceof Date) {
+      return `__date__:${input.toISOString()}`;
+    }
+    if (input instanceof Error) {
+      return {
+        _tag: "Error",
+        name: input.name,
+        message: input.message
+      };
+    }
+    if (input && typeof input === "object") {
+      const obj = input;
+      if (seen.has(obj)) return "__cycle__";
+      seen.add(obj);
+      const record = input;
+      const keys = Object.keys(record).sort();
+      const out = {};
+      for (const k of keys) {
+        out[k] = encode(record[k]);
+      }
+      return out;
+    }
+    return String(input);
+  };
+  try {
+    return JSON.stringify(encode(value));
+  } catch {
+    return String(value);
+  }
+};
+var keyHash = (key) => stableStringify(key);
+var Snapshot = {
+  idle: () => ({
+    status: "idle",
+    keyHash: void 0,
+    data: void 0,
+    error: void 0
+  }),
+  loading: (params) => ({
+    status: "loading",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: void 0
+  }),
+  success: (params) => ({
+    status: "success",
+    keyHash: params.keyHash,
+    data: params.data,
+    error: void 0
+  }),
+  error: (params) => ({
+    status: "error",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: params.error
+  })
+};
+var ResourceRegistryTag = class extends Context.Tag(
+  "@logix/core/ResourceRegistry"
+)() {
+};
+var internal = {
+  ResourceRegistryTag
+};
+var make = (spec) => spec;
+var layer = (specs) => Layer.succeed(
+  ResourceRegistryTag,
+  (() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const spec of specs) {
+      if (isDevEnv() && map.has(spec.id) && map.get(spec.id) !== spec) {
+        throw new Error(
+          `[Resource.layer] Duplicate resource id "${spec.id}" detected in the same runtime scope`
+        );
+      }
+      map.set(spec.id, spec);
+    }
+    return { specs: map };
+  })()
+);
+
+export {
+  keyHash,
+  Snapshot,
+  ResourceRegistryTag,
+  internal,
+  make,
+  layer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Resource.ts"],
  "sourcesContent": ["// Resource \u6A21\u5757\uFF1A\n// - \u5B9A\u4E49\u903B\u8F91\u8D44\u6E90\u89C4\u683C ResourceSpec\uFF1B\n// - \u901A\u8FC7 Resource.layer \u5728 Runtime Env \u4E2D\u6CE8\u518C\u8D44\u6E90\u8868\uFF1B\n// - \u5185\u90E8\u901A\u8FC7 ResourceRegistryTag \u627F\u8F7D\u5F53\u524D\u4F5C\u7528\u57DF\u5185\u53EF\u7528\u7684\u8D44\u6E90\u96C6\u5408\u3002\n//\n// \u8BBE\u8BA1\u7EA6\u675F\uFF08\u89C1 specs/000-module-traits-runtime/references/resource-and-query.md\uFF09\uFF1A\n// - StateTrait / Module \u56FE\u7EB8\u5C42\u53EA\u77E5\u9053 resourceId + key \u89C4\u5219\uFF0C\u4E0D\u76F4\u63A5\u63A5\u89E6 ResourceSpec \u7C7B\u578B\uFF1B\n// - ResourceSpec \u4FDD\u6301 Effect-Native\uFF1Aload \u4F7F\u7528 Effect.Effect \u8868\u8FBE\uFF1B\n// - Resource.layer \u5728\u5355\u4E2A Runtime \u4F5C\u7528\u57DF\u5185\u6CE8\u518C\u4E00\u7EC4\u8D44\u6E90\uFF0C\u5E76\u5728 dev \u4E0B\u5BF9\u91CD\u590D id \u505A\u57FA\u672C\u6821\u9A8C\u3002\n\nimport { Context, Effect, Layer, Schema } from \"effect\"\nimport { isDevEnv } from \"./internal/runtime/core/env.js\"\n\n/**\n * ResourceSpec \u63CF\u8FF0\u201C\u4E00\u4E2A\u903B\u8F91\u8D44\u6E90\u957F\u4EC0\u4E48\u6837\u3001\u5982\u4F55\u8BBF\u95EE\u201D\u3002\n *\n * - Key: \u7528 Schema \u63CF\u8FF0\u7684 key \u5F62\u72B6\uFF08\u7C7B\u4F3C\u5F3A\u7C7B\u578B queryKey\uFF09\uFF1B\n * - load: \u57FA\u4E8E key \u8BBF\u95EE\u8D44\u6E90\u7684 Effect\uFF1B\n * - meta: \u9884\u7559\u6269\u5C55\u4F4D\uFF08cacheGroup/\u63CF\u8FF0\u4FE1\u606F\u7B49\uFF09\u3002\n */\nexport interface ResourceSpec<Key, Out, Err, Env> {\n  readonly id: string\n  readonly keySchema: Schema.Schema<Key, any>\n  readonly load: (key: Key) => Effect.Effect<Out, Err, Env>\n  readonly meta?: {\n    readonly cacheGroup?: string\n    readonly description?: string\n    readonly [k: string]: unknown\n  }\n}\n\nexport type AnyResourceSpec = ResourceSpec<any, any, any, any>\n\nexport type ResourceStatus = \"idle\" | \"loading\" | \"success\" | \"error\"\n\nexport interface ResourceSnapshot<Data = unknown, Err = unknown> {\n  readonly status: ResourceStatus\n  readonly keyHash?: string\n  readonly data?: Data\n  readonly error?: Err\n}\n\nconst stableStringify = (value: unknown): string => {\n  const seen = new WeakSet<object>()\n  const encode = (input: unknown): unknown => {\n    if (input === null) return null\n    if (\n      typeof input === \"string\" ||\n      typeof input === \"number\" ||\n      typeof input === \"boolean\"\n    ) {\n      return input\n    }\n    if (typeof input === \"bigint\") return input.toString()\n    if (typeof input === \"undefined\") return \"__undefined__\"\n    if (typeof input === \"symbol\") return `__symbol__:${String(input)}`\n    if (typeof input === \"function\") return \"__function__\"\n\n    if (Array.isArray(input)) {\n      return input.map((v) => encode(v))\n    }\n    if (input instanceof Date) {\n      return `__date__:${input.toISOString()}`\n    }\n    if (input instanceof Error) {\n      return {\n        _tag: \"Error\",\n        name: input.name,\n        message: input.message,\n      }\n    }\n    if (input && typeof input === \"object\") {\n      const obj = input as object\n      if (seen.has(obj)) return \"__cycle__\"\n      seen.add(obj)\n\n      const record = input as Record<string, unknown>\n      const keys = Object.keys(record).sort()\n      const out: Record<string, unknown> = {}\n      for (const k of keys) {\n        out[k] = encode(record[k])\n      }\n      return out\n    }\n    return String(input)\n  }\n\n  try {\n    return JSON.stringify(encode(value))\n  } catch {\n    return String(value)\n  }\n}\n\nexport const keyHash = (key: unknown): string => stableStringify(key)\n\nexport const Snapshot = {\n  idle: <Data = never, Err = never>(): ResourceSnapshot<Data, Err> => ({\n    status: \"idle\",\n    keyHash: undefined,\n    data: undefined,\n    error: undefined,\n  }),\n  loading: <Data = never, Err = never>(params: {\n    readonly keyHash: string\n  }): ResourceSnapshot<Data, Err> => ({\n    status: \"loading\",\n    keyHash: params.keyHash,\n    data: undefined,\n    error: undefined,\n  }),\n  success: <Data>(params: {\n    readonly keyHash: string\n    readonly data: Data\n  }): ResourceSnapshot<Data, never> => ({\n    status: \"success\",\n    keyHash: params.keyHash,\n    data: params.data,\n    error: undefined,\n  }),\n  error: <Err>(params: {\n    readonly keyHash: string\n    readonly error: Err\n  }): ResourceSnapshot<never, Err> => ({\n    status: \"error\",\n    keyHash: params.keyHash,\n    data: undefined,\n    error: params.error,\n  }),\n} as const\n\n/**\n * ResourceRegistry\uFF1A\n * - \u4F5C\u4E3A Env \u4E2D\u7684\u4E00\u9879 Service\uFF0C\u7EF4\u62A4\u5F53\u524D\u4F5C\u7528\u57DF\u5185\u7684\u8D44\u6E90\u89C4\u683C\u8868\uFF1B\n * - key \u4E3A\u903B\u8F91\u8D44\u6E90 ID\uFF08\u5982 \"user/profile\"\uFF09\u3002\n */\nexport interface ResourceRegistry {\n  readonly specs: ReadonlyMap<string, AnyResourceSpec>\n}\n\nexport class ResourceRegistryTag extends Context.Tag(\n  \"@logix/core/ResourceRegistry\",\n)<ResourceRegistryTag, ResourceRegistry>() {}\n\n/**\n * internal\uFF1A\u4EC5\u4F9B\u5185\u90E8\u6A21\u5757\uFF08\u5982 Query \u4E2D\u95F4\u4EF6\uFF09\u4F7F\u7528\u7684 Tag \u5BFC\u51FA\u3002\n * - \u4E0D\u5728 index.ts \u505A\u518D\u6B21 re-export\uFF0C\u907F\u514D\u76F4\u63A5\u66B4\u9732\u7ED9\u6700\u7EC8\u7528\u6237\uFF1B\n * - \u6D4B\u8BD5\u4E0E\u5185\u90E8\u8FD0\u884C\u65F6\u4EE3\u7801\u53EF\u901A\u8FC7 `Resource.internal.ResourceRegistryTag` \u8BBF\u95EE\u3002\n */\nexport const internal = {\n  ResourceRegistryTag,\n}\n\n/**\n * Resource.Spec\uFF1A\n * - ResourceSpec \u7684\u7C7B\u578B\u522B\u540D\uFF0C\u65B9\u4FBF\u5728\u8C03\u7528\u65B9\u4EE3\u7801\u4E2D\u5F15\u7528\uFF1B\n * - \u5E95\u5C42\u4ECD\u7136\u4F7F\u7528 ResourceSpec \u63A5\u53E3\u3002\n */\nexport type Spec<Key, Out, Err, Env> = ResourceSpec<Key, Out, Err, Env>\n\n/**\n * make\uFF1A\n * - \u7528\u4E8E\u5B9A\u4E49\u4E00\u6761\u903B\u8F91\u8D44\u6E90\u89C4\u683C\uFF1B\n * - \u76EE\u524D\u4EC5\u505A\u7B80\u5355 identity\uFF0C\u4E3B\u8981\u627F\u8F7D\u7C7B\u578B\u63A8\u5BFC\u4E0E\u8BED\u4E49\u6807\u8BB0\u3002\n */\nexport const make = <Key, Out, Err, Env>(\n  spec: ResourceSpec<Key, Out, Err, Env>,\n): ResourceSpec<Key, Out, Err, Env> => spec\n\n/**\n * layer\uFF1A\n * - \u5728\u5F53\u524D Runtime \u4F5C\u7528\u57DF\u5185\u6CE8\u518C\u4E00\u7EC4 ResourceSpec\uFF1B\n * - \u82E5 Env \u4E2D\u5DF2\u5B58\u5728 ResourceRegistry\uFF0C\u5219\u5728\u5176\u57FA\u7840\u4E0A\u53E0\u52A0\uFF1B\n * - \u5728 dev \u73AF\u5883\u4E0B\u5BF9\u91CD\u590D id \u505A\u57FA\u672C\u6821\u9A8C\uFF08\u907F\u514D\u65E0\u58F0\u8986\u76D6\uFF09\u3002\n *\n * \u8BF4\u660E\uFF1A\n * - \u4E0D\u8D1F\u8D23\u8DE8\u4F5C\u7528\u57DF\u51B2\u7A81\u5904\u7406\uFF1A\u4E0D\u540C RuntimeProvider \u5B50\u6811\u53EF\u4EE5\u4E3A\u540C\u4E00 id \u63D0\u4F9B\u4E0D\u540C\u5B9E\u73B0\uFF1B\n * - \u82E5\u5728\u540C\u4E00\u4F5C\u7528\u57DF\u5185\u91CD\u590D\u6CE8\u518C\u540C\u4E00 id \u4E14\u5B9E\u73B0\u4E0D\u4E00\u81F4\uFF0C\u5728 dev \u4E0B\u4F1A\u629B\u9519\u3002\n */\nexport const layer = (\n  specs: ReadonlyArray<AnyResourceSpec>,\n): Layer.Layer<ResourceRegistryTag, never, never> =>\n  Layer.succeed(\n    ResourceRegistryTag,\n    (() => {\n      const map = new Map<string, AnyResourceSpec>()\n      for (const spec of specs) {\n        if (isDevEnv() && map.has(spec.id) && map.get(spec.id) !== spec) {\n          throw new Error(\n            `[Resource.layer] Duplicate resource id \"${spec.id}\" detected in the same runtime scope`,\n          )\n        }\n        map.set(spec.id, spec)\n      }\n      return { specs: map }\n    })(),\n  )\n"],
  "mappings": ";;;;;;;AAUA,SAAS,SAAiB,aAAqB;AAgC/C,IAAM,kBAAkB,CAAC,UAA2B;AAClD,QAAM,OAAO,oBAAI,QAAgB;AACjC,QAAM,SAAS,CAAC,UAA4B;AAC1C,QAAI,UAAU,KAAM,QAAO;AAC3B,QACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,WACjB;AACA,aAAO;AAAA,IACT;AACA,QAAI,OAAO,UAAU,SAAU,QAAO,MAAM,SAAS;AACrD,QAAI,OAAO,UAAU,YAAa,QAAO;AACzC,QAAI,OAAO,UAAU,SAAU,QAAO,cAAc,OAAO,KAAK,CAAC;AACjE,QAAI,OAAO,UAAU,WAAY,QAAO;AAExC,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO,MAAM,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAAA,IACnC;AACA,QAAI,iBAAiB,MAAM;AACzB,aAAO,YAAY,MAAM,YAAY,CAAC;AAAA,IACxC;AACA,QAAI,iBAAiB,OAAO;AAC1B,aAAO;AAAA,QACL,MAAM;AAAA,QACN,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,MACjB;AAAA,IACF;AACA,QAAI,SAAS,OAAO,UAAU,UAAU;AACtC,YAAM,MAAM;AACZ,UAAI,KAAK,IAAI,GAAG,EAAG,QAAO;AAC1B,WAAK,IAAI,GAAG;AAEZ,YAAM,SAAS;AACf,YAAM,OAAO,OAAO,KAAK,MAAM,EAAE,KAAK;AACtC,YAAM,MAA+B,CAAC;AACtC,iBAAW,KAAK,MAAM;AACpB,YAAI,CAAC,IAAI,OAAO,OAAO,CAAC,CAAC;AAAA,MAC3B;AACA,aAAO;AAAA,IACT;AACA,WAAO,OAAO,KAAK;AAAA,EACrB;AAEA,MAAI;AACF,WAAO,KAAK,UAAU,OAAO,KAAK,CAAC;AAAA,EACrC,QAAQ;AACN,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;AAEO,IAAM,UAAU,CAAC,QAAyB,gBAAgB,GAAG;AAE7D,IAAM,WAAW;AAAA,EACtB,MAAM,OAA+D;AAAA,IACnE,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,SAAS,CAA4B,YAED;AAAA,IAClC,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,SAAS,CAAO,YAGsB;AAAA,IACpC,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM,OAAO;AAAA,IACb,OAAO;AAAA,EACT;AAAA,EACA,OAAO,CAAM,YAGwB;AAAA,IACnC,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,OAAO,OAAO;AAAA,EAChB;AACF;AAWO,IAAM,sBAAN,cAAkC,QAAQ;AAAA,EAC/C;AACF,EAAyC,EAAE;AAAC;AAOrC,IAAM,WAAW;AAAA,EACtB;AACF;AAcO,IAAM,OAAO,CAClB,SACqC;AAYhC,IAAM,QAAQ,CACnB,UAEA,MAAM;AAAA,EACJ;AAAA,GACC,MAAM;AACL,UAAM,MAAM,oBAAI,IAA6B;AAC7C,eAAW,QAAQ,OAAO;AACxB,UAAI,SAAS,KAAK,IAAI,IAAI,KAAK,EAAE,KAAK,IAAI,IAAI,KAAK,EAAE,MAAM,MAAM;AAC/D,cAAM,IAAI;AAAA,UACR,2CAA2C,KAAK,EAAE;AAAA,QACpD;AAAA,MACF;AACA,UAAI,IAAI,KAAK,IAAI,IAAI;AAAA,IACvB;AACA,WAAO,EAAE,OAAO,IAAI;AAAA,EACtB,GAAG;AACL;",
  "names": []
}
