@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,102 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-2UGKSXDZ.js";
+
+// ../logix-core/src/ScopeRegistry.ts
+import { Context, Layer } from "../effect.js";
+var ScopeRegistryTag = class extends Context.Tag("@logix/core/ScopeRegistry")() {
+};
+var ScopedRuntimeTag = class extends Context.Tag("@logix/core/ScopeRegistry/ScopedRuntime")() {
+};
+var internal = {
+  ScopeRegistryTag,
+  ScopedRuntimeTag
+};
+var makeRegistry = () => {
+  let nextLeaseId = 0;
+  const scopes = /* @__PURE__ */ new Map();
+  const getStack = (scopeId, token) => {
+    const byToken = scopes.get(scopeId);
+    if (byToken) {
+      const stack = byToken.get(token);
+      if (stack) return stack;
+      const created2 = [];
+      byToken.set(token, created2);
+      return created2;
+    }
+    const created = [];
+    const createdByToken = /* @__PURE__ */ new Map();
+    createdByToken.set(token, created);
+    scopes.set(scopeId, createdByToken);
+    return created;
+  };
+  const tryDeleteEmpty = (scopeId, token) => {
+    const byToken = scopes.get(scopeId);
+    if (!byToken) return;
+    const stack = byToken.get(token);
+    if (stack && stack.length === 0) {
+      byToken.delete(token);
+    }
+    if (byToken.size === 0) {
+      scopes.delete(scopeId);
+    }
+  };
+  const register = (scopeId, token, value) => {
+    nextLeaseId += 1;
+    const leaseId = nextLeaseId;
+    const stack = getStack(scopeId, token);
+    if (isDevEnv() && stack.length > 0) {
+      console.debug(
+        `[ScopeRegistry] Multiple registrations detected for scopeId="${scopeId}". This is allowed (LIFO), but usually indicates scopeId collisions or missing cleanup.`
+      );
+    }
+    stack.push({ leaseId, value });
+    const release = () => {
+      const stack2 = scopes.get(scopeId)?.get(token);
+      if (!stack2 || stack2.length === 0) return;
+      const last = stack2[stack2.length - 1];
+      if (last && last.leaseId === leaseId) {
+        stack2.pop();
+        tryDeleteEmpty(scopeId, token);
+        return;
+      }
+      const idx = stack2.findIndex((e) => e.leaseId === leaseId);
+      if (idx >= 0) {
+        stack2.splice(idx, 1);
+        tryDeleteEmpty(scopeId, token);
+      }
+    };
+    return { release };
+  };
+  const get = (scopeId, token) => {
+    const stack = scopes.get(scopeId)?.get(token);
+    if (!stack || stack.length === 0) return void 0;
+    return stack[stack.length - 1].value;
+  };
+  const clearToken = (scopeId, token) => {
+    const byToken = scopes.get(scopeId);
+    if (!byToken) return;
+    byToken.delete(token);
+    if (byToken.size === 0) {
+      scopes.delete(scopeId);
+    }
+  };
+  const clearScope = (scopeId) => {
+    scopes.delete(scopeId);
+  };
+  const clearAll = () => {
+    scopes.clear();
+  };
+  return { register, get, clearToken, clearScope, clearAll };
+};
+var layer = () => Layer.succeed(ScopeRegistryTag, makeRegistry());
+
+export {
+  ScopeRegistryTag,
+  ScopedRuntimeTag,
+  internal,
+  layer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/ScopeRegistry.ts"],
  "sourcesContent": ["import { Context, Layer, ManagedRuntime } from 'effect'\nimport { isDevEnv } from './Env.js'\n\nexport type ScopeId = string\n\ntype AnyTag = Context.Tag<any, any>\n\ntype LeaseId = number\n\ntype Entry = {\n  readonly leaseId: LeaseId\n  readonly value: unknown\n}\n\nexport interface ScopeRegistry {\n  /**\n   * \u6CE8\u518C\u4E00\u4E2A scope-bound \u7684\u503C\uFF08\u652F\u6301\u591A\u65B9\u6CE8\u518C\uFF1A\u540E\u6CE8\u518C\u8005\u8986\u76D6 get \u7684\u8FD4\u56DE\u503C\uFF09\u3002\n   * \u8FD4\u56DE release \u51FD\u6570\uFF1A\u8C03\u7528\u540E\u5C06\u64A4\u9500\u672C\u6B21\u6CE8\u518C\u3002\n   */\n  readonly register: <A>(scopeId: ScopeId, token: Context.Tag<any, A>, value: A) => { readonly release: () => void }\n\n  /**\n   * \u8BFB\u53D6\u67D0\u4E2A scope \u4E0B\u67D0\u4E2A token \u7684\u201C\u5F53\u524D\u503C\u201D\uFF08\u6700\u540E\u4E00\u6B21 register \u7684\u503C\uFF09\u3002\n   */\n  readonly get: <A>(scopeId: ScopeId, token: Context.Tag<any, A>) => A | undefined\n\n  /**\n   * \u5220\u9664\u67D0\u4E2A scope \u4E0B\u67D0\u4E2A token \u7684\u6240\u6709\u6CE8\u518C\uFF08\u65E0\u8BBA\u8C01\u6CE8\u518C\u7684\uFF09\u3002\n   */\n  readonly clearToken: (scopeId: ScopeId, token: AnyTag) => void\n\n  /**\n   * \u6E05\u7406\u67D0\u4E2A scope \u4E0B\u7684\u6240\u6709 token\u3002\n   */\n  readonly clearScope: (scopeId: ScopeId) => void\n\n  /**\n   * \u6E05\u7406\u6574\u4E2A registry\u3002\n   */\n  readonly clearAll: () => void\n}\n\nexport class ScopeRegistryTag extends Context.Tag('@logix/core/ScopeRegistry')<ScopeRegistryTag, ScopeRegistry>() {}\n\n/**\n * \u7528\u4E8E\u5728 ScopeRegistry \u4E2D\u5B58\u653E\u201C\u67D0\u4E2A scope \u5BF9\u5E94\u7684 ManagedRuntime \u53E5\u67C4\u201D\u3002\n *\n * \u5178\u578B\u573A\u666F\uFF1A\u8DE8 React \u5B50\u6811 / \u72EC\u7ACB root \u9700\u8981\u590D\u7528\u540C\u4E00\u4E2A runtime scope\uFF08Env/Scope/FiberRef\uFF09\u65F6\uFF0C\n * \u5C06\u8BE5 runtime \u4EE5 scopeId \u6CE8\u518C\u5E76\u5728\u53E6\u4E00\u68F5\u6811\u4E2D\u53D6\u56DE\u3002\n */\nexport class ScopedRuntimeTag extends Context.Tag('@logix/core/ScopeRegistry/ScopedRuntime')<\n  ScopedRuntimeTag,\n  ManagedRuntime.ManagedRuntime<any, any>\n>() {}\n\nexport const internal = {\n  ScopeRegistryTag,\n  ScopedRuntimeTag,\n}\n\nconst makeRegistry = (): ScopeRegistry => {\n  let nextLeaseId: LeaseId = 0\n\n  // scopeId -> (token -> stack(entries))\n  const scopes = new Map<ScopeId, Map<AnyTag, Array<Entry>>>()\n\n  const getStack = (scopeId: ScopeId, token: AnyTag): Array<Entry> => {\n    const byToken = scopes.get(scopeId)\n    if (byToken) {\n      const stack = byToken.get(token)\n      if (stack) return stack\n      const created: Array<Entry> = []\n      byToken.set(token, created)\n      return created\n    }\n    const created: Array<Entry> = []\n    const createdByToken = new Map<AnyTag, Array<Entry>>()\n    createdByToken.set(token, created)\n    scopes.set(scopeId, createdByToken)\n    return created\n  }\n\n  const tryDeleteEmpty = (scopeId: ScopeId, token: AnyTag): void => {\n    const byToken = scopes.get(scopeId)\n    if (!byToken) return\n    const stack = byToken.get(token)\n    if (stack && stack.length === 0) {\n      byToken.delete(token)\n    }\n    if (byToken.size === 0) {\n      scopes.delete(scopeId)\n    }\n  }\n\n  const register: ScopeRegistry['register'] = (scopeId, token, value) => {\n    nextLeaseId += 1\n    const leaseId = nextLeaseId\n    const stack = getStack(scopeId, token as AnyTag)\n\n    // dev: \u540C\u4E00 scopeId+token \u591A\u65B9\u6CE8\u518C\u5F80\u5F80\u610F\u5473\u7740 scopeId \u9009\u62E9\u51B2\u7A81\u6216\u751F\u547D\u5468\u671F\u6CC4\u6F0F\uFF1B\n    // \u4F46 React/\u5E76\u53D1\u6E32\u67D3/\u91CD\u5EFA Provider \u53EF\u80FD\u5BFC\u81F4\u77ED\u6682\u91CD\u5165\uFF0C\u56E0\u6B64\u8FD9\u91CC\u53EA\u505A\u8F7B\u91CF\u63D0\u793A\uFF0C\u4E0D\u5F3A\u5236\u629B\u9519\u3002\n    if (isDevEnv() && stack.length > 0) {\n      // eslint-disable-next-line no-console\n      console.debug(\n        `[ScopeRegistry] Multiple registrations detected for scopeId=\"${scopeId}\". ` +\n          `This is allowed (LIFO), but usually indicates scopeId collisions or missing cleanup.`,\n      )\n    }\n\n    stack.push({ leaseId, value })\n\n    const release = () => {\n      const stack2 = scopes.get(scopeId)?.get(token as AnyTag)\n      if (!stack2 || stack2.length === 0) return\n\n      // \u5E38\u89C1\u60C5\u51B5\uFF1ALIFO \u91CA\u653E\n      const last = stack2[stack2.length - 1]\n      if (last && last.leaseId === leaseId) {\n        stack2.pop()\n        tryDeleteEmpty(scopeId, token as AnyTag)\n        return\n      }\n\n      // \u515C\u5E95\uFF1A\u4E2D\u95F4\u91CA\u653E\uFF08\u7EBF\u6027\u626B\u63CF\uFF09\n      const idx = stack2.findIndex((e) => e.leaseId === leaseId)\n      if (idx >= 0) {\n        stack2.splice(idx, 1)\n        tryDeleteEmpty(scopeId, token as AnyTag)\n      }\n    }\n\n    return { release }\n  }\n\n  const get: ScopeRegistry['get'] = (scopeId, token) => {\n    const stack = scopes.get(scopeId)?.get(token as AnyTag)\n    if (!stack || stack.length === 0) return undefined\n    return stack[stack.length - 1]!.value as any\n  }\n\n  const clearToken: ScopeRegistry['clearToken'] = (scopeId, token) => {\n    const byToken = scopes.get(scopeId)\n    if (!byToken) return\n    byToken.delete(token)\n    if (byToken.size === 0) {\n      scopes.delete(scopeId)\n    }\n  }\n\n  const clearScope: ScopeRegistry['clearScope'] = (scopeId) => {\n    scopes.delete(scopeId)\n  }\n\n  const clearAll: ScopeRegistry['clearAll'] = () => {\n    scopes.clear()\n  }\n\n  return { register, get, clearToken, clearScope, clearAll }\n}\n\nexport const layer = (): Layer.Layer<ScopeRegistryTag, never, never> => Layer.succeed(ScopeRegistryTag, makeRegistry())\n"],
  "mappings": ";;;;;;;AAAA,SAAS,SAAS,aAA6B;AA0CxC,IAAM,mBAAN,cAA+B,QAAQ,IAAI,2BAA2B,EAAmC,EAAE;AAAC;AAQ5G,IAAM,mBAAN,cAA+B,QAAQ,IAAI,yCAAyC,EAGzF,EAAE;AAAC;AAEE,IAAM,WAAW;AAAA,EACtB;AAAA,EACA;AACF;AAEA,IAAM,eAAe,MAAqB;AACxC,MAAI,cAAuB;AAG3B,QAAM,SAAS,oBAAI,IAAwC;AAE3D,QAAM,WAAW,CAAC,SAAkB,UAAgC;AAClE,UAAM,UAAU,OAAO,IAAI,OAAO;AAClC,QAAI,SAAS;AACX,YAAM,QAAQ,QAAQ,IAAI,KAAK;AAC/B,UAAI,MAAO,QAAO;AAClB,YAAMA,WAAwB,CAAC;AAC/B,cAAQ,IAAI,OAAOA,QAAO;AAC1B,aAAOA;AAAA,IACT;AACA,UAAM,UAAwB,CAAC;AAC/B,UAAM,iBAAiB,oBAAI,IAA0B;AACrD,mBAAe,IAAI,OAAO,OAAO;AACjC,WAAO,IAAI,SAAS,cAAc;AAClC,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,CAAC,SAAkB,UAAwB;AAChE,UAAM,UAAU,OAAO,IAAI,OAAO;AAClC,QAAI,CAAC,QAAS;AACd,UAAM,QAAQ,QAAQ,IAAI,KAAK;AAC/B,QAAI,SAAS,MAAM,WAAW,GAAG;AAC/B,cAAQ,OAAO,KAAK;AAAA,IACtB;AACA,QAAI,QAAQ,SAAS,GAAG;AACtB,aAAO,OAAO,OAAO;AAAA,IACvB;AAAA,EACF;AAEA,QAAM,WAAsC,CAAC,SAAS,OAAO,UAAU;AACrE,mBAAe;AACf,UAAM,UAAU;AAChB,UAAM,QAAQ,SAAS,SAAS,KAAe;AAI/C,QAAI,SAAS,KAAK,MAAM,SAAS,GAAG;AAElC,cAAQ;AAAA,QACN,gEAAgE,OAAO;AAAA,MAEzE;AAAA,IACF;AAEA,UAAM,KAAK,EAAE,SAAS,MAAM,CAAC;AAE7B,UAAM,UAAU,MAAM;AACpB,YAAM,SAAS,OAAO,IAAI,OAAO,GAAG,IAAI,KAAe;AACvD,UAAI,CAAC,UAAU,OAAO,WAAW,EAAG;AAGpC,YAAM,OAAO,OAAO,OAAO,SAAS,CAAC;AACrC,UAAI,QAAQ,KAAK,YAAY,SAAS;AACpC,eAAO,IAAI;AACX,uBAAe,SAAS,KAAe;AACvC;AAAA,MACF;AAGA,YAAM,MAAM,OAAO,UAAU,CAAC,MAAM,EAAE,YAAY,OAAO;AACzD,UAAI,OAAO,GAAG;AACZ,eAAO,OAAO,KAAK,CAAC;AACpB,uBAAe,SAAS,KAAe;AAAA,MACzC;AAAA,IACF;AAEA,WAAO,EAAE,QAAQ;AAAA,EACnB;AAEA,QAAM,MAA4B,CAAC,SAAS,UAAU;AACpD,UAAM,QAAQ,OAAO,IAAI,OAAO,GAAG,IAAI,KAAe;AACtD,QAAI,CAAC,SAAS,MAAM,WAAW,EAAG,QAAO;AACzC,WAAO,MAAM,MAAM,SAAS,CAAC,EAAG;AAAA,EAClC;AAEA,QAAM,aAA0C,CAAC,SAAS,UAAU;AAClE,UAAM,UAAU,OAAO,IAAI,OAAO;AAClC,QAAI,CAAC,QAAS;AACd,YAAQ,OAAO,KAAK;AACpB,QAAI,QAAQ,SAAS,GAAG;AACtB,aAAO,OAAO,OAAO;AAAA,IACvB;AAAA,EACF;AAEA,QAAM,aAA0C,CAAC,YAAY;AAC3D,WAAO,OAAO,OAAO;AAAA,EACvB;AAEA,QAAM,WAAsC,MAAM;AAChD,WAAO,MAAM;AAAA,EACf;AAEA,SAAO,EAAE,UAAU,KAAK,YAAY,YAAY,SAAS;AAC3D;AAEO,IAAM,QAAQ,MAAmD,MAAM,QAAQ,kBAAkB,aAAa,CAAC;",
  "names": ["created"]
}


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

@@ -0,0 +1,164 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-4KIYG5E4.js";
+import {
+  EffectOpMiddlewareTag,
+  RunSessionTag,
+  make,
+  run
+} from "./chunk-O57OZBDR.js";
+
+// ../logix-core/src/internal/runtime/core/FlowRuntime.ts
+import { Effect, Stream, Ref, Option } from "../effect.js";
+var getMiddlewareStack = () => Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  Effect.map((maybe) => Option.isSome(maybe) ? maybe.value.stack : [])
+);
+var getRuntimeScope = (runtime) => {
+  if (!runtime) return {};
+  if (typeof runtime !== "object" && typeof runtime !== "function") return {};
+  const scope = runtime;
+  return {
+    moduleId: typeof scope.moduleId === "string" ? scope.moduleId : void 0,
+    instanceId: typeof scope.instanceId === "string" ? scope.instanceId : void 0
+  };
+};
+var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var make2 = (runtime, runtimeInternals) => {
+  const scope = getRuntimeScope(runtime);
+  const resolveConcurrencyLimit = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(
+    Effect.map((p) => p.concurrencyLimit)
+  ) : Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => Effect.gen(function* () {
+    const stack = yield* getMiddlewareStack();
+    const meta = {
+      ...options?.meta ?? {},
+      policy: options?.policy,
+      tags: options?.tags,
+      trace: options?.trace,
+      moduleId: scope.moduleId,
+      instanceId: scope.instanceId
+    };
+    if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
+      const sessionOpt = yield* Effect.serviceOption(RunSessionTag);
+      if (Option.isSome(sessionOpt)) {
+        const key = meta.instanceId ?? "global";
+        meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+      }
+    }
+    const op = make({
+      kind: "flow",
+      name,
+      payload,
+      effect: eff,
+      meta
+    });
+    return yield* run(op, stack);
+  });
+  const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
+  const runStreamSequential = (eff, options) => (stream) => Stream.runForEach(
+    stream,
+    (payload) => runAsFlowOp(
+      "flow.run",
+      payload,
+      runEffect(eff)(payload),
+      options
+    )
+  );
+  const runStreamParallel = (eff, options) => (stream) => Effect.gen(function* () {
+    const concurrency = yield* resolveConcurrencyLimit();
+    return yield* Stream.runDrain(
+      stream.pipe(
+        Stream.mapEffect(
+          (payload) => runAsFlowOp(
+            "flow.runParallel",
+            payload,
+            runEffect(eff)(payload),
+            options
+          ),
+          { concurrency }
+        )
+      )
+    ).pipe(
+      Effect.catchAllCause(
+        (cause) => record({
+          type: "diagnostic",
+          moduleId: scope.moduleId,
+          instanceId: scope.instanceId,
+          code: "flow::unhandled_failure",
+          severity: "error",
+          message: "Flow watcher (runParallel) failed with an unhandled error.",
+          hint: "Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.",
+          kind: "flow_unhandled_failure",
+          trigger: {
+            kind: "flow",
+            name: "runParallel"
+          }
+        }).pipe(Effect.zipRight(Effect.failCause(cause)))
+      )
+    );
+  });
+  return {
+    fromAction: (predicate) => runtime.actions$.pipe(Stream.filter(predicate)),
+    fromState: (selector) => runtime.changes(selector),
+    debounce: (ms) => (stream) => Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => Stream.throttle(stream, {
+      cost: () => 1,
+      units: 1,
+      duration: ms,
+      strategy: "enforce"
+    }),
+    filter: (predicate) => (stream) => Stream.filter(stream, predicate),
+    run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
+    runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
+    runLatest: (eff, options) => (stream) => Stream.runDrain(
+      Stream.map(
+        stream,
+        (payload) => runAsFlowOp(
+          "flow.runLatest",
+          payload,
+          runEffect(eff)(payload),
+          options
+        )
+      ).pipe(
+        Stream.flatMap((effect) => Stream.fromEffect(effect), {
+          switch: true
+        })
+      )
+    ),
+    runExhaust: (eff, options) => (stream) => Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit();
+      const busyRef = yield* Ref.make(false);
+      const mapper = (payload) => Effect.gen(function* () {
+        const acquired = yield* Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runAsFlowOp(
+            "flow.runExhaust",
+            payload,
+            runEffect(eff)(payload),
+            options
+          );
+        } finally {
+          yield* Ref.set(busyRef, false);
+        }
+      });
+      return yield* Stream.runDrain(
+        stream.pipe(
+          Stream.mapEffect(mapper, { concurrency })
+        )
+      );
+    })
+  };
+};
+
+export {
+  make2 as make
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/FlowRuntime.ts"],
  "sourcesContent": ["import { Effect, Stream, Ref, Option } from \"effect\"\nimport type {\n  AnyModuleShape,\n  ModuleRuntime,\n  StateOf,\n  ActionOf,\n  ModuleShape,\n} from \"./module.js\"\nimport type * as Logic from \"./LogicMiddleware.js\"\nimport * as EffectOp from \"../../effect-op.js\"\nimport * as EffectOpCore from \"./EffectOpCore.js\"\nimport { RunSessionTag } from \"../../observability/runSession.js\"\nimport type { RuntimeInternals } from \"./RuntimeInternals.js\"\nimport * as Debug from \"./DebugSink.js\"\n\nconst getMiddlewareStack = (): Effect.Effect<\n  EffectOp.MiddlewareStack,\n  never,\n  any\n> =>\n  Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag).pipe(\n    Effect.map((maybe) => (Option.isSome(maybe) ? maybe.value.stack : [])),\n  )\n\nconst getRuntimeScope = (\n  runtime: unknown,\n): { readonly moduleId?: string; readonly instanceId?: string } => {\n  if (!runtime) return {}\n  if (typeof runtime !== \"object\" && typeof runtime !== \"function\") return {}\n  const scope = runtime as { readonly moduleId?: unknown; readonly instanceId?: unknown }\n  return {\n    moduleId: typeof scope.moduleId === \"string\" ? scope.moduleId : undefined,\n    instanceId: typeof scope.instanceId === \"string\" ? scope.instanceId : undefined,\n  }\n}\n\nexport interface Api<Sh extends ModuleShape<any, any>, R = never> {\n  readonly fromAction: <T extends ActionOf<Sh>>(\n    predicate: (a: ActionOf<Sh>) => a is T\n  ) => Stream.Stream<T>\n\n  readonly fromState: <V>(\n    selector: (s: StateOf<Sh>) => V\n  ) => Stream.Stream<V>\n\n  readonly debounce: <V>(\n    ms: number\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly throttle: <V>(\n    ms: number\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly filter: <V>(\n    predicate: (value: V) => boolean\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly run: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runParallel: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runLatest: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runExhaust: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n}\n\nconst resolveEffect = <T, Sh extends AnyModuleShape, R, A, E>(\n  eff:\n    | Logic.Of<Sh, R, A, E>\n    | ((payload: T) => Logic.Of<Sh, R, A, E>),\n  payload: T\n): Logic.Of<Sh, R, A, E> =>\n  typeof eff === \"function\"\n    ? (eff as (p: T) => Logic.Of<Sh, R, A, E>)(payload)\n    : eff\n\nexport const make = <Sh extends AnyModuleShape, R = never>(\n  runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  runtimeInternals?: RuntimeInternals,\n): Api<Sh, R> => {\n  const scope = getRuntimeScope(runtime)\n  const resolveConcurrencyLimit = (): Effect.Effect<\n    number | \"unbounded\",\n    never,\n    any\n  > =>\n    runtimeInternals\n      ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(\n          Effect.map((p) => p.concurrencyLimit),\n        )\n      : Effect.succeed(16)\n\n  const runAsFlowOp = <A, E, R2, V>(\n    name: string,\n    payload: V,\n    eff: Effect.Effect<A, E, Logic.Env<Sh, R & R2>>,\n    options?: Logic.OperationOptions,\n  ): Effect.Effect<A, E, Logic.Env<Sh, R & R2>> =>\n    Effect.gen(function* () {\n      const stack = yield* getMiddlewareStack()\n      const meta: any = {\n        ...(options?.meta ?? {}),\n        policy: options?.policy,\n        tags: options?.tags,\n        trace: options?.trace,\n        moduleId: scope.moduleId,\n        instanceId: scope.instanceId,\n      }\n\n      if (!(typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq))) {\n        const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n        if (Option.isSome(sessionOpt)) {\n          const key = meta.instanceId ?? \"global\"\n          meta.opSeq = sessionOpt.value.local.nextSeq(\"opSeq\", key)\n        }\n      }\n\n      const op = EffectOp.make<A, E, any>({\n        kind: \"flow\",\n        name,\n        payload,\n        effect: eff as any,\n        meta,\n      })\n      return yield* EffectOp.run(op, stack)\n    }) as any\n\n  const runEffect =\n    <T, A, E, R2>(\n      eff:\n        | Logic.Of<Sh, R & R2, A, E>\n        | ((payload: T) => Logic.Of<Sh, R & R2, A, E>)\n    ) =>\n      (payload: T) =>\n        resolveEffect<T, Sh, R & R2, A, E>(eff, payload)\n\n  const runStreamSequential = <T, A, E, R2>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<T>): Effect.Effect<void, E, Logic.Env<Sh, R & R2>> =>\n    Stream.runForEach(stream, (payload) =>\n      runAsFlowOp<A, E, R2, T>(\n        \"flow.run\",\n        payload,\n        runEffect<T, A, E, R2>(eff)(payload),\n        options,\n      ),\n    )\n\n  const runStreamParallel = <T, A, E, R2>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<T>): Effect.Effect<void, E, Logic.Env<Sh, R & R2>> =>\n    Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit()\n\n      return yield* Stream.runDrain(\n        stream.pipe(\n          Stream.mapEffect(\n            (payload) =>\n              runAsFlowOp<A, E, R2, T>(\n                \"flow.runParallel\",\n                payload,\n                runEffect<T, A, E, R2>(eff)(payload),\n                options,\n              ),\n            { concurrency },\n          ),\n        ),\n      ).pipe(\n        Effect.catchAllCause((cause) =>\n          Debug.record({\n            type: \"diagnostic\",\n            moduleId: scope.moduleId,\n            instanceId: scope.instanceId,\n            code: \"flow::unhandled_failure\",\n            severity: \"error\",\n            message: \"Flow watcher (runParallel) failed with an unhandled error.\",\n            hint:\n              \"Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.\",\n            kind: \"flow_unhandled_failure\",\n            trigger: {\n              kind: \"flow\",\n              name: \"runParallel\",\n            },\n          }).pipe(Effect.zipRight(Effect.failCause(cause))),\n        ),\n      )\n    }) as any\n\n  return {\n    fromAction: <T extends ActionOf<Sh>>(\n      predicate: (a: ActionOf<Sh>) => a is T\n    ) => runtime.actions$.pipe(Stream.filter(predicate)),\n\n    fromState: <V>(selector: (s: StateOf<Sh>) => V) =>\n      runtime.changes(selector),\n\n    debounce: (ms: number) => (stream) => Stream.debounce(stream, ms),\n\n    throttle: (ms: number) => (stream) =>\n      Stream.throttle(stream, {\n        cost: () => 1,\n        units: 1,\n        duration: ms,\n        strategy: \"enforce\",\n      }),\n\n    filter: (predicate: (value: any) => boolean) => (stream) =>\n      Stream.filter(stream, predicate),\n\n    run: (eff, options) => (stream) =>\n      runStreamSequential<any, any, any, any>(eff, options)(stream),\n\n    runParallel: (eff, options) => (stream) =>\n      runStreamParallel<any, any, any, any>(eff, options)(stream),\n\n    runLatest: (eff, options) => (stream) =>\n      Stream.runDrain(\n        Stream.map(stream, (payload) =>\n          runAsFlowOp<any, any, any, any>(\n            \"flow.runLatest\",\n            payload,\n            runEffect<any, any, any, any>(eff)(payload),\n            options,\n          )\n        ).pipe(\n          Stream.flatMap((effect) => Stream.fromEffect(effect), {\n            switch: true,\n          })\n        )\n      ),\n\n    runExhaust: (eff, options) => (stream) =>\n      Effect.gen(function* () {\n        const concurrency = yield* resolveConcurrencyLimit()\n        const busyRef = yield* Ref.make(false)\n        const mapper = (payload: any) =>\n          Effect.gen(function* () {\n            const acquired = yield* Ref.modify(busyRef, (busy) =>\n              busy ? ([false, busy] as const) : ([true, true] as const)\n            )\n            if (!acquired) {\n              return\n            }\n            try {\n              yield* runAsFlowOp<any, any, any, any>(\n                \"flow.runExhaust\",\n                payload,\n                runEffect<any, any, any, any>(eff)(payload),\n                options,\n              )\n            } finally {\n              yield* Ref.set(busyRef, false)\n            }\n          })\n\n        return yield* Stream.runDrain(\n          stream.pipe(\n            Stream.mapEffect(mapper, { concurrency })\n          )\n        )\n      }),\n  }\n}\n"],
  "mappings": "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",
  "names": ["make"]
}


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

@@ -0,0 +1,57 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  CutoverCoverageMatrix,
+  evaluateFullCutoverGate
+} from "./chunk-SIXNQNIR.js";
+import {
+  FullCutoverGateModeTag,
+  KernelImplementationRefTag,
+  RuntimeServicesRegistryTag,
+  RuntimeServicesRuntimeConfigTag,
+  defaultKernelImplementationRef,
+  getKernelImplementationRef,
+  getRuntimeServicesEvidence,
+  isKernelImplementationRef
+} from "./chunk-CRE4NJJ6.js";
+
+// ../logix-core/src/Kernel.ts
+import { Layer } from "../effect.js";
+var defaultKernelImplementationRef2 = defaultKernelImplementationRef;
+var isKernelImplementationRef2 = isKernelImplementationRef;
+var CutoverCoverageMatrix2 = CutoverCoverageMatrix;
+var evaluateFullCutoverGate2 = (args) => {
+  return evaluateFullCutoverGate({
+    mode: args.mode,
+    requestedKernelId: args.requestedKernelId,
+    runtimeServicesEvidence: args.runtimeServicesEvidence,
+    coverageMatrix: args.coverageMatrix,
+    diagnosticsLevel: args.diagnosticsLevel
+  });
+};
+var KernelContractMetaAllowlist = [];
+var kernelLayer = (ref) => Layer.succeed(KernelImplementationRefTag, ref);
+var runtimeDefaultServicesOverridesLayer = (services) => Layer.succeed(RuntimeServicesRuntimeConfigTag, {
+  services
+});
+var getRuntimeServicesEvidence2 = getRuntimeServicesEvidence;
+var getKernelImplementationRef2 = getKernelImplementationRef;
+var runtimeServicesRegistryLayer = (registry) => Layer.succeed(RuntimeServicesRegistryTag, registry);
+var fullCutoverGateModeLayer = (mode) => Layer.succeed(FullCutoverGateModeTag, mode);
+var isKernelFullyActivated = (evidence) => !evidence.overridesApplied.some((s) => s.includes("fallback="));
+
+export {
+  defaultKernelImplementationRef2 as defaultKernelImplementationRef,
+  isKernelImplementationRef2 as isKernelImplementationRef,
+  CutoverCoverageMatrix2 as CutoverCoverageMatrix,
+  evaluateFullCutoverGate2 as evaluateFullCutoverGate,
+  KernelContractMetaAllowlist,
+  kernelLayer,
+  runtimeDefaultServicesOverridesLayer,
+  getRuntimeServicesEvidence2 as getRuntimeServicesEvidence,
+  getKernelImplementationRef2 as getKernelImplementationRef,
+  runtimeServicesRegistryLayer,
+  fullCutoverGateModeLayer,
+  isKernelFullyActivated
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Kernel.ts"],
  "sourcesContent": ["import { Layer } from 'effect'\nimport type { Layer as LayerType } from 'effect'\nimport type * as Debug from './Debug.js'\nimport * as FullCutoverGate from './internal/runtime/core/FullCutoverGate.js'\nimport * as RuntimeKernel from './internal/runtime/core/RuntimeKernel.js'\nimport * as KernelRef from './internal/runtime/core/KernelRef.js'\nexport type { RuntimeServiceBuiltins } from './internal/runtime/core/RuntimeServiceBuiltins.js'\nexport { RuntimeServiceBuiltinsTag } from './internal/runtime/core/RuntimeServiceBuiltins.js'\n\nexport type KernelId = KernelRef.KernelId\n\nexport interface KernelImplementationRef extends KernelRef.KernelImplementationRef {}\n\nexport const defaultKernelImplementationRef = KernelRef.defaultKernelImplementationRef\n\nexport const isKernelImplementationRef = KernelRef.isKernelImplementationRef\n\nexport type RuntimeServiceOverride = RuntimeKernel.RuntimeServiceOverride\nexport type RuntimeServicesOverrides = RuntimeKernel.RuntimeServicesOverrides\nexport type RuntimeServiceBinding = RuntimeKernel.RuntimeServiceBinding\nexport type RuntimeServicesEvidence = RuntimeKernel.RuntimeServicesEvidence\n\nexport type RuntimeServiceImpl<Service> = RuntimeKernel.RuntimeServiceImpl<Service>\nexport type RuntimeServicesRegistry = RuntimeKernel.RuntimeServicesRegistry\n\nexport type CutoverCoverageMatrix = FullCutoverGate.CutoverCoverageMatrix\n\nexport const CutoverCoverageMatrix = FullCutoverGate.CutoverCoverageMatrix\n\nexport type FullCutoverGateMode = FullCutoverGate.FullCutoverGateMode\n\nexport type FullCutoverGateAnchor = FullCutoverGate.FullCutoverGateAnchor\n\nexport type FullCutoverGateVerdict = FullCutoverGate.FullCutoverGateVerdict\n\nexport type FullCutoverGateResult = FullCutoverGate.FullCutoverGateResult\n\nexport const evaluateFullCutoverGate = (args: {\n  readonly mode: FullCutoverGateMode\n  readonly requestedKernelId: KernelId\n  readonly runtimeServicesEvidence: RuntimeServicesEvidence\n  readonly coverageMatrix?: CutoverCoverageMatrix\n  readonly diagnosticsLevel?: Debug.DiagnosticsLevel\n}): FullCutoverGateResult => {\n  return FullCutoverGate.evaluateFullCutoverGate({\n    mode: args.mode,\n    requestedKernelId: args.requestedKernelId,\n    runtimeServicesEvidence: args.runtimeServicesEvidence,\n    coverageMatrix: args.coverageMatrix,\n    diagnosticsLevel: args.diagnosticsLevel,\n  })\n}\n\nexport interface KernelContractMetaAllowlistItem {\n  readonly metaKey: string\n  readonly reason?: string\n}\n\nexport const KernelContractMetaAllowlist = [] as const satisfies ReadonlyArray<KernelContractMetaAllowlistItem>\n\n/**\n * kernelLayer\uFF1A\n * - \u5728\u5F53\u524D runtime tree \u4E0B\u58F0\u660E\u201C\u8BF7\u6C42\u7684\u5185\u6838\u65CF\u201D\uFF08requested kernel family\uFF09\uFF1B\n * - \u4E0D\u76F4\u63A5\u4F5C\u4E3A\u201C\u5168\u5957\u751F\u6548\u201D\u7684\u8BC1\u660E\uFF08fallback/mix \u7531 RuntimeServicesEvidence \u5224\u5B9A\uFF09\u3002\n */\nexport const kernelLayer = (ref: KernelImplementationRef): LayerType.Layer<any, never, never> =>\n  Layer.succeed(KernelRef.KernelImplementationRefTag, ref) as LayerType.Layer<any, never, never>\n\n/**\n * runtimeDefaultServicesOverridesLayer\uFF1A\n * - \u5728 ManagedRuntime \u88C5\u914D\u9636\u6BB5\u63D0\u4F9B runtime_default scope \u7684 serviceId \u2192 implId \u8986\u5199\uFF1B\n * - \u9ED8\u8BA4\u4E0D\u63D0\u4F9B servicesByModuleId\uFF08\u7981\u6B62\u7528 moduleId \u4F5C\u4E3A\u9ED8\u8BA4\u5185\u6838\u9009\u62E9\u7C92\u5EA6\uFF09\u3002\n */\nexport const runtimeDefaultServicesOverridesLayer = (\n  services: RuntimeServicesOverrides,\n): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.RuntimeServicesRuntimeConfigTag, {\n    services,\n  }) as LayerType.Layer<any, never, never>\n\n/**\n * getRuntimeServicesEvidence\uFF1A\n * - \u8BFB\u53D6\u5DF2\u5B89\u88C5\u5728 ModuleRuntime \u4E0A\u7684 RuntimeServicesEvidence\uFF08serviceId \u2192 implId \u8BC1\u636E\uFF09\u3002\n * - \u4F5C\u4E3A\u5BF9\u5916\u5165\u53E3\uFF0C\u907F\u514D\u8C03\u7528\u65B9\u76F4\u63A5\u4F9D\u8D56 src/internal \u8DEF\u5F84\u3002\n */\nexport const getRuntimeServicesEvidence = RuntimeKernel.getRuntimeServicesEvidence\n\n/**\n * getKernelImplementationRef\uFF1A\n * - \u8BFB\u53D6\u5DF2\u5B89\u88C5\u5728 ModuleRuntime \u4E0A\u7684 KernelImplementationRef\uFF08requested kernel family\uFF09\u3002\n */\nexport const getKernelImplementationRef = KernelRef.getKernelImplementationRef\n\n/**\n * runtimeServicesRegistryLayer\uFF1A\n * - \u5728 runtime \u88C5\u914D\u9636\u6BB5\u6CE8\u5165\u989D\u5916\u7684 serviceId \u2192 impls\uFF08\u4F8B\u5982 core-ng \u63D0\u4F9B\u7684\u5B9E\u73B0\uFF09\u3002\n */\nexport const runtimeServicesRegistryLayer = (registry: RuntimeServicesRegistry): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.RuntimeServicesRegistryTag, registry) as LayerType.Layer<any, never, never>\n\n/**\n * fullCutoverGateModeLayer\uFF1A\n * - \u63A7\u5236\u8FD0\u884C\u65F6\u88C5\u914D\u9636\u6BB5\u7684 cutover gate \u6267\u884C\u6A21\u5F0F\uFF08trial/fullCutover\uFF09\u3002\n * - \u9ED8\u8BA4\u8DEF\u5F84\uFF08048\uFF09\u5E94\u663E\u5F0F\u8BBE\u7F6E\u4E3A fullCutover\uFF1Btrial-run/\u5BF9\u7167\u53EF\u8986\u76D6\u4E3A trial\u3002\n */\nexport const fullCutoverGateModeLayer = (mode: FullCutoverGateMode): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.FullCutoverGateModeTag, mode) as LayerType.Layer<any, never, never>\n\n/**\n * isKernelFullyActivated\uFF1A\n * - \u201C\u5168\u5957\u5207\u6362\u201D\u7684\u6700\u5C0F\u5224\u5B9A\uFF1A\u4E0D\u5141\u8BB8\u53D1\u751F fallback\uFF08\u5426\u5219\u89C6\u4E3A\u672A\u8FBE\u6807\uFF09\u3002\n */\nexport const isKernelFullyActivated = (evidence: RuntimeServicesEvidence): boolean =>\n  !evidence.overridesApplied.some((s) => s.includes('fallback='))\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA,SAAS,aAAa;AAaf,IAAMA,kCAA2C;AAEjD,IAAMC,6BAAsC;AAY5C,IAAMC,yBAAwC;AAU9C,IAAMC,2BAA0B,CAAC,SAMX;AAC3B,SAAuB,wBAAwB;AAAA,IAC7C,MAAM,KAAK;AAAA,IACX,mBAAmB,KAAK;AAAA,IACxB,yBAAyB,KAAK;AAAA,IAC9B,gBAAgB,KAAK;AAAA,IACrB,kBAAkB,KAAK;AAAA,EACzB,CAAC;AACH;AAOO,IAAM,8BAA8B,CAAC;AAOrC,IAAM,cAAc,CAAC,QAC1B,MAAM,QAAkB,4BAA4B,GAAG;AAOlD,IAAM,uCAAuC,CAClD,aAEA,MAAM,QAAsB,iCAAiC;AAAA,EAC3D;AACF,CAAC;AAOI,IAAMC,8BAA2C;AAMjD,IAAMC,8BAAuC;AAM7C,IAAM,+BAA+B,CAAC,aAC3C,MAAM,QAAsB,4BAA4B,QAAQ;AAO3D,IAAM,2BAA2B,CAAC,SACvC,MAAM,QAAsB,wBAAwB,IAAI;AAMnD,IAAM,yBAAyB,CAAC,aACrC,CAAC,SAAS,iBAAiB,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,CAAC;",
  "names": ["defaultKernelImplementationRef", "isKernelImplementationRef", "CutoverCoverageMatrix", "evaluateFullCutoverGate", "getRuntimeServicesEvidence", "getKernelImplementationRef"]
}
