@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,85 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-LTFCYZQ6.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-FEGFZ5OX.js

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