@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,153 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isReadQuery
+} from "./chunk-RDHNRWQP.js";
+import {
+  record
+} from "./chunk-4GMUQTWH.js";
+import {
+  RunSessionTag,
+  make,
+  run
+} from "./chunk-GZ2NSE6A.js";
+import {
+  EffectOpMiddlewareTag
+} from "./chunk-S6ZZHV6G.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: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
+    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 { AnyModuleShape, ModuleRuntime, StateOf, ActionOf, ModuleShape } 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'\nimport * as ReadQuery from './ReadQuery.js'\n\nconst getMiddlewareStack = (): Effect.Effect<EffectOp.MiddlewareStack, never, any> =>\n  Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag).pipe(\n    Effect.map((maybe) => (Option.isSome(maybe) ? maybe.value.stack : [])),\n  )\n\nconst getRuntimeScope = (runtime: unknown): { 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>>(predicate: (a: ActionOf<Sh>) => a is T) => Stream.Stream<T>\n\n  readonly fromState: {\n    <V>(selector: (s: StateOf<Sh>) => V): Stream.Stream<V>\n    <V>(query: ReadQuery.ReadQuery<StateOf<Sh>, V>): Stream.Stream<V>\n  }\n\n  readonly debounce: <V>(ms: number) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly throttle: <V>(ms: number) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly filter: <V>(predicate: (value: V) => boolean) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly run: <V, A = void, E = never, R2 = unknown>(\n    eff: Logic.Of<Sh, R & R2, A, E> | ((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: Logic.Of<Sh, R & R2, A, E> | ((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: Logic.Of<Sh, R & R2, A, E> | ((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: Logic.Of<Sh, R & R2, A, E> | ((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: Logic.Of<Sh, R, A, E> | ((payload: T) => Logic.Of<Sh, R, A, E>),\n  payload: T,\n): Logic.Of<Sh, R, A, E> => (typeof eff === 'function' ? (eff as (p: T) => Logic.Of<Sh, R, A, E>)(payload) : 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<number | 'unbounded', never, any> =>\n    runtimeInternals\n      ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(Effect.map((p) => p.concurrencyLimit))\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>(eff: Logic.Of<Sh, R & R2, A, E> | ((payload: T) => Logic.Of<Sh, R & R2, A, E>)) =>\n    (payload: T) =>\n      resolveEffect<T, Sh, R & R2, A, E>(eff, payload)\n\n  const runStreamSequential =\n    <T, A, E, R2>(\n      eff: Logic.Of<Sh, R & R2, A, E> | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n      options?: Logic.OperationOptions,\n    ) =>\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>('flow.run', payload, runEffect<T, A, E, R2>(eff)(payload), options),\n      )\n\n  const runStreamParallel =\n    <T, A, E, R2>(\n      eff: Logic.Of<Sh, R & R2, A, E> | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n      options?: Logic.OperationOptions,\n    ) =>\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>('flow.runParallel', payload, runEffect<T, A, E, R2>(eff)(payload), options),\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: '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>>(predicate: (a: ActionOf<Sh>) => a is T) =>\n      runtime.actions$.pipe(Stream.filter(predicate)),\n\n    fromState: <V>(selectorOrQuery: ((s: StateOf<Sh>) => V) | ReadQuery.ReadQuery<StateOf<Sh>, V>) =>\n      runtime.changes(ReadQuery.isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),\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) => Stream.filter(stream, predicate),\n\n    run: (eff, options) => (stream) => runStreamSequential<any, any, any, any>(eff, options)(stream),\n\n    runParallel: (eff, options) => (stream) => 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(stream.pipe(Stream.mapEffect(mapper, { concurrency })))\n      }),\n  }\n}\n"],
  "mappings": "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",
  "names": ["make"]
}
