@logixjs/core 0.0.1

package/dist/Flow.cjs

@@ -0,0 +1,504 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Flow.ts
+var Flow_exports = {};
+__export(Flow_exports, {
+  make: () => make3
+});
+module.exports = __toCommonJS(Flow_exports);
+
+// src/internal/runtime/core/FlowRuntime.ts
+var import_effect6 = require("effect");
+
+// src/internal/effect-op.ts
+var import_effect3 = require("effect");
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect = require("effect");
+var currentLinkId = import_effect.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+var composeMiddleware = (stack) => {
+  return (op) => stack.reduceRight(
+    (eff, mw) => mw({ ...op, effect: eff }),
+    op.effect
+  );
+};
+var runWithMiddleware = (op, stack) => {
+  return import_effect.Effect.gen(function* () {
+    const existing = yield* import_effect.FiberRef.get(currentLinkId);
+    const metaLinkId = op.meta?.linkId;
+    const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
+    const nextOp = {
+      ...op,
+      meta: {
+        ...op.meta ?? {},
+        linkId
+      }
+    };
+    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
+    return yield* import_effect.Effect.locally(currentLinkId, linkId)(program);
+  });
+};
+
+// src/internal/observability/runSession.ts
+var import_effect2 = require("effect");
+
+// src/internal/observability/jsonValue.ts
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+
+// src/internal/observability/runSession.ts
+var RunSessionTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+
+// src/internal/effect-op.ts
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var make = (params) => ({
+  ...params.id ? { id: params.id, meta: params.meta } : (() => {
+    const meta = params.meta ?? {};
+    const instanceId = meta.instanceId;
+    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
+    return {
+      id: makeId(instanceId, opSeq),
+      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
+    };
+  })(),
+  kind: params.kind,
+  name: params.name,
+  payload: params.payload,
+  effect: params.effect
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+// src/internal/runtime/core/DebugSink.ts
+var import_effect5 = require("effect");
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect4 = require("effect");
+
+// src/internal/runtime/core/DebugSink.ts
+var currentDebugSinks = import_effect5.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect5.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect5.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect5.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect5.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect5.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect5.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect5.Effect.logError(message).pipe(
+    import_effect5.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect5.Effect.logWarning(msg) : event.severity === "info" ? import_effect5.Effect.logInfo(msg) : import_effect5.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect5.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect5.Effect.void
+};
+var errorOnlyLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
+var consoleSink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect5.Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect5.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect5.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect5.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect5.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect5.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect5.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect5.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect5.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect5.Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect5.Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect5.Logger.replace(
+  import_effect5.Logger.defaultLogger,
+  import_effect5.Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => import_effect5.Effect.gen(function* () {
+  const sinks = yield* import_effect5.FiberRef.get(currentDebugSinks);
+  if (isErrorOnlyOnlySinks(sinks)) {
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      if (event.severity !== "info") {
+        yield* diagnosticLog(event);
+      } else {
+        yield* import_effect5.Effect.void;
+      }
+      return;
+    }
+    yield* import_effect5.Effect.void;
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+        return;
+      }
+      yield* import_effect5.Effect.void;
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect5.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel = yield* import_effect5.FiberRef.get(currentDiagnosticsLevel);
+  let now;
+  const getNow = () => {
+    if (now === void 0) now = Date.now();
+    return now;
+  };
+  if (enriched.timestamp === void 0 && (diagnosticsLevel !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel = yield* import_effect5.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect5.FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* import_effect5.FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect5.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+
+// src/internal/runtime/core/ReadQuery.ts
+function isReadQuery(input) {
+  if (!input || typeof input !== "object" && typeof input !== "function") return false;
+  const maybe = input;
+  return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
+}
+
+// src/internal/runtime/core/FlowRuntime.ts
+var getMiddlewareStack = () => import_effect6.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect6.Effect.map((maybe) => import_effect6.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(import_effect6.Effect.map((p) => p.concurrencyLimit)) : import_effect6.Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => import_effect6.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* import_effect6.Effect.serviceOption(RunSessionTag);
+      if (import_effect6.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) => import_effect6.Stream.runForEach(
+    stream,
+    (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
+  );
+  const runStreamParallel = (eff, options) => (stream) => import_effect6.Effect.gen(function* () {
+    const concurrency = yield* resolveConcurrencyLimit();
+    return yield* import_effect6.Stream.runDrain(
+      stream.pipe(
+        import_effect6.Stream.mapEffect(
+          (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
+          { concurrency }
+        )
+      )
+    ).pipe(
+      import_effect6.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(import_effect6.Effect.zipRight(import_effect6.Effect.failCause(cause)))
+      )
+    );
+  });
+  return {
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect6.Stream.filter(predicate)),
+    fromState: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
+    debounce: (ms) => (stream) => import_effect6.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect6.Stream.throttle(stream, {
+      cost: () => 1,
+      units: 1,
+      duration: ms,
+      strategy: "enforce"
+    }),
+    filter: (predicate) => (stream) => import_effect6.Stream.filter(stream, predicate),
+    run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
+    runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
+    runLatest: (eff, options) => (stream) => import_effect6.Stream.runDrain(
+      import_effect6.Stream.map(
+        stream,
+        (payload) => runAsFlowOp(
+          "flow.runLatest",
+          payload,
+          runEffect(eff)(payload),
+          options
+        )
+      ).pipe(
+        import_effect6.Stream.flatMap((effect) => import_effect6.Stream.fromEffect(effect), {
+          switch: true
+        })
+      )
+    ),
+    runExhaust: (eff, options) => (stream) => import_effect6.Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit();
+      const busyRef = yield* import_effect6.Ref.make(false);
+      const mapper = (payload) => import_effect6.Effect.gen(function* () {
+        const acquired = yield* import_effect6.Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runAsFlowOp(
+            "flow.runExhaust",
+            payload,
+            runEffect(eff)(payload),
+            options
+          );
+        } finally {
+          yield* import_effect6.Ref.set(busyRef, false);
+        }
+      });
+      return yield* import_effect6.Stream.runDrain(stream.pipe(import_effect6.Stream.mapEffect(mapper, { concurrency })));
+    })
+  };
+};
+
+// src/Flow.ts
+var make3 = make2;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  make
+});
+//# sourceMappingURL=Flow.cjs.map