@logixjs/core 0.0.1

package/dist/Reflection.d.cts

@@ -0,0 +1,17 @@
+import 'effect';
+import './module-B8CBqIZ_.cjs';
+import './Module-B_0xRDMR.cjs';
+import './ir-BMP7yxJJ.cjs';
+export { E as ExtractManifestOptions, M as ModuleManifest } from './Observability-COqEvp2C.cjs';
+export { D as DiffManifestOptions, F as FullCutoverGateTrialRunOptions, c as FullCutoverGateVerificationResult, a as KernelContractAllowedDiff, K as KernelContractVerificationResult, M as ModuleManifestDiff, b as VerifyFullCutoverGateOptions, V as VerifyKernelContractOptions, d as diffManifest, f as exportStaticIr, e as extractManifest, g as verifyFullCutoverGate, v as verifyKernelContract } from './Reflection-Kabo1mlU.cjs';
+import './Kernel-8kC-jOda.cjs';
+import 'mutative';
+import './Platform-C49Pv956.cjs';
+import './action-DiMDD_0v.cjs';
+import './ReadQuery-SinbStGF.cjs';
+import './Logic-DRh4sDZj.cjs';
+import './protocol-g_1897M2.cjs';
+import './Debug-Bq8Sqjcr.cjs';
+import 'effect/FiberRef';
+import './StateTrait-OWhbj12c.cjs';
+import './Bound-BPIfH9SS.cjs';

package/dist/Reflection.d.ts

@@ -0,0 +1,17 @@
+import 'effect';
+import './module-k7m3txak.js';
+import './Module-DnzluX2J.js';
+import './ir-DUOz6H-5.js';
+export { E as ExtractManifestOptions, M as ModuleManifest } from './Observability-cY4kLn0S.js';
+export { D as DiffManifestOptions, F as FullCutoverGateTrialRunOptions, c as FullCutoverGateVerificationResult, a as KernelContractAllowedDiff, K as KernelContractVerificationResult, M as ModuleManifestDiff, b as VerifyFullCutoverGateOptions, V as VerifyKernelContractOptions, d as diffManifest, f as exportStaticIr, e as extractManifest, g as verifyFullCutoverGate, v as verifyKernelContract } from './Reflection-CQnKwPXj.js';
+import './Kernel-CnGE1Fyk.js';
+import 'mutative';
+import './Platform-C49Pv956.js';
+import './action-DiMDD_0v.js';
+import './ReadQuery-SinbStGF.js';
+import './Logic-BRjEMr-W.js';
+import './protocol-g_1897M2.js';
+import './Debug-B5q5Bkzx.js';
+import 'effect/FiberRef';
+import './StateTrait-BGsZghTz.js';
+import './Bound-BN1DQ_lM.js';

package/dist/Reflection.js

@@ -0,0 +1,40 @@
+import {
+  diffManifest,
+  exportStaticIr,
+  extractManifest,
+  verifyFullCutoverGate,
+  verifyKernelContract
+} from "./chunk-DFNM3WX2.js";
+import "./chunk-24VULZ7A.js";
+import "./chunk-KP7MUZNX.js";
+import "./chunk-M3WTHJHJ.js";
+import "./chunk-EGK3KN7B.js";
+import "./chunk-PAYXCY6A.js";
+import "./chunk-ZGDVUPTM.js";
+import "./chunk-BE3HW4FY.js";
+import "./chunk-ZFLHVFUC.js";
+import "./chunk-KL5ACTCT.js";
+import "./chunk-AUIR5O6W.js";
+import "./chunk-BZ2SHDN2.js";
+import "./chunk-YS3AZQ2G.js";
+import "./chunk-ZFY7U2FR.js";
+import "./chunk-M3BFQ7HK.js";
+import "./chunk-IHVBV5C2.js";
+import "./chunk-3RMKLXHX.js";
+import "./chunk-3QMIVH35.js";
+import "./chunk-NQZ2OSGR.js";
+import "./chunk-CW6T36TN.js";
+import "./chunk-DMBALCE2.js";
+import "./chunk-GMPEOUP2.js";
+import "./chunk-OFADUJWJ.js";
+import "./chunk-M7IYCTJV.js";
+import "./chunk-JWOYLO27.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  diffManifest,
+  exportStaticIr,
+  extractManifest,
+  verifyFullCutoverGate,
+  verifyKernelContract
+};
+//# sourceMappingURL=Reflection.js.map

package/dist/Reflection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Resource-Dy1xD_DG.d.cts

@@ -0,0 +1,75 @@
+import * as effect_Layer from 'effect/Layer';
+import * as effect from 'effect';
+import { Context } from 'effect';
+
+interface ResourceSpec$1<Key, Out, Err, Env> {
+    readonly id: string;
+    readonly keySchema: effect.Schema.Schema<Key, any>;
+    readonly load: (key: Key) => effect.Effect.Effect<Out, Err, Env>;
+    readonly meta?: {
+        readonly cacheGroup?: string;
+        readonly description?: string;
+        readonly [k: string]: unknown;
+    };
+}
+type AnyResourceSpec$1 = ResourceSpec$1<any, any, any, any>;
+type ResourceStatus$1 = 'idle' | 'loading' | 'success' | 'error';
+interface ResourceSnapshot$1<Data = unknown, Err = unknown> {
+    readonly status: ResourceStatus$1;
+    readonly keyHash?: string;
+    readonly data?: Data;
+    readonly error?: Err;
+}
+interface ResourceRegistry$1 {
+    readonly specs: ReadonlyMap<string, AnyResourceSpec$1>;
+}
+declare const ResourceRegistryTag_base: Context.TagClass<ResourceRegistryTag, "@logixjs/core/ResourceRegistry", ResourceRegistry$1>;
+declare class ResourceRegistryTag extends ResourceRegistryTag_base {
+}
+type Spec$1<Key, Out, Err, Env> = ResourceSpec$1<Key, Out, Err, Env>;
+
+type ResourceSpec<Key, Out, Err, Env> = ResourceSpec$1<Key, Out, Err, Env>;
+type AnyResourceSpec = AnyResourceSpec$1;
+type ResourceStatus = ResourceStatus$1;
+type ResourceSnapshot<Data = unknown, Err = unknown> = ResourceSnapshot$1<Data, Err>;
+type ResourceRegistry = ResourceRegistry$1;
+type Spec<Key, Out, Err, Env> = Spec$1<Key, Out, Err, Env>;
+declare const keyHash: (key: unknown) => string;
+declare const Snapshot: {
+    readonly idle: <Data = never, Err = never>() => ResourceSnapshot$1<Data, Err>;
+    readonly loading: <Data = never, Err = never>(params: {
+        readonly keyHash: string;
+    }) => ResourceSnapshot$1<Data, Err>;
+    readonly success: <Data>(params: {
+        readonly keyHash: string;
+        readonly data: Data;
+    }) => ResourceSnapshot$1<Data, never>;
+    readonly error: <Err>(params: {
+        readonly keyHash: string;
+        readonly error: Err;
+    }) => ResourceSnapshot$1<never, Err>;
+};
+declare const internal: {
+    ResourceRegistryTag: typeof ResourceRegistryTag;
+};
+declare const make: <Key, Out, Err, Env>(spec: ResourceSpec$1<Key, Out, Err, Env>) => ResourceSpec$1<Key, Out, Err, Env>;
+declare const layer: (specs: ReadonlyArray<AnyResourceSpec$1>) => effect_Layer.Layer<ResourceRegistryTag, never, never>;
+
+type Resource_AnyResourceSpec = AnyResourceSpec;
+type Resource_ResourceRegistry = ResourceRegistry;
+type Resource_ResourceRegistryTag = ResourceRegistryTag;
+declare const Resource_ResourceRegistryTag: typeof ResourceRegistryTag;
+type Resource_ResourceSnapshot<Data = unknown, Err = unknown> = ResourceSnapshot<Data, Err>;
+type Resource_ResourceSpec<Key, Out, Err, Env> = ResourceSpec<Key, Out, Err, Env>;
+type Resource_ResourceStatus = ResourceStatus;
+declare const Resource_Snapshot: typeof Snapshot;
+type Resource_Spec<Key, Out, Err, Env> = Spec<Key, Out, Err, Env>;
+declare const Resource_internal: typeof internal;
+declare const Resource_keyHash: typeof keyHash;
+declare const Resource_layer: typeof layer;
+declare const Resource_make: typeof make;
+declare namespace Resource {
+  export { type Resource_AnyResourceSpec as AnyResourceSpec, type Resource_ResourceRegistry as ResourceRegistry, Resource_ResourceRegistryTag as ResourceRegistryTag, type Resource_ResourceSnapshot as ResourceSnapshot, type Resource_ResourceSpec as ResourceSpec, type Resource_ResourceStatus as ResourceStatus, Resource_Snapshot as Snapshot, type Resource_Spec as Spec, Resource_internal as internal, Resource_keyHash as keyHash, Resource_layer as layer, Resource_make as make };
+}
+
+export { type AnyResourceSpec as A, Resource as R, type Spec as S, type ResourceSpec as a, type ResourceStatus as b, type ResourceSnapshot as c, type ResourceRegistry as d, Snapshot as e, ResourceRegistryTag as f, internal as i, keyHash as k, layer as l, make as m };

package/dist/Resource-Dy1xD_DG.d.ts

@@ -0,0 +1,75 @@
+import * as effect_Layer from 'effect/Layer';
+import * as effect from 'effect';
+import { Context } from 'effect';
+
+interface ResourceSpec$1<Key, Out, Err, Env> {
+    readonly id: string;
+    readonly keySchema: effect.Schema.Schema<Key, any>;
+    readonly load: (key: Key) => effect.Effect.Effect<Out, Err, Env>;
+    readonly meta?: {
+        readonly cacheGroup?: string;
+        readonly description?: string;
+        readonly [k: string]: unknown;
+    };
+}
+type AnyResourceSpec$1 = ResourceSpec$1<any, any, any, any>;
+type ResourceStatus$1 = 'idle' | 'loading' | 'success' | 'error';
+interface ResourceSnapshot$1<Data = unknown, Err = unknown> {
+    readonly status: ResourceStatus$1;
+    readonly keyHash?: string;
+    readonly data?: Data;
+    readonly error?: Err;
+}
+interface ResourceRegistry$1 {
+    readonly specs: ReadonlyMap<string, AnyResourceSpec$1>;
+}
+declare const ResourceRegistryTag_base: Context.TagClass<ResourceRegistryTag, "@logixjs/core/ResourceRegistry", ResourceRegistry$1>;
+declare class ResourceRegistryTag extends ResourceRegistryTag_base {
+}
+type Spec$1<Key, Out, Err, Env> = ResourceSpec$1<Key, Out, Err, Env>;
+
+type ResourceSpec<Key, Out, Err, Env> = ResourceSpec$1<Key, Out, Err, Env>;
+type AnyResourceSpec = AnyResourceSpec$1;
+type ResourceStatus = ResourceStatus$1;
+type ResourceSnapshot<Data = unknown, Err = unknown> = ResourceSnapshot$1<Data, Err>;
+type ResourceRegistry = ResourceRegistry$1;
+type Spec<Key, Out, Err, Env> = Spec$1<Key, Out, Err, Env>;
+declare const keyHash: (key: unknown) => string;
+declare const Snapshot: {
+    readonly idle: <Data = never, Err = never>() => ResourceSnapshot$1<Data, Err>;
+    readonly loading: <Data = never, Err = never>(params: {
+        readonly keyHash: string;
+    }) => ResourceSnapshot$1<Data, Err>;
+    readonly success: <Data>(params: {
+        readonly keyHash: string;
+        readonly data: Data;
+    }) => ResourceSnapshot$1<Data, never>;
+    readonly error: <Err>(params: {
+        readonly keyHash: string;
+        readonly error: Err;
+    }) => ResourceSnapshot$1<never, Err>;
+};
+declare const internal: {
+    ResourceRegistryTag: typeof ResourceRegistryTag;
+};
+declare const make: <Key, Out, Err, Env>(spec: ResourceSpec$1<Key, Out, Err, Env>) => ResourceSpec$1<Key, Out, Err, Env>;
+declare const layer: (specs: ReadonlyArray<AnyResourceSpec$1>) => effect_Layer.Layer<ResourceRegistryTag, never, never>;
+
+type Resource_AnyResourceSpec = AnyResourceSpec;
+type Resource_ResourceRegistry = ResourceRegistry;
+type Resource_ResourceRegistryTag = ResourceRegistryTag;
+declare const Resource_ResourceRegistryTag: typeof ResourceRegistryTag;
+type Resource_ResourceSnapshot<Data = unknown, Err = unknown> = ResourceSnapshot<Data, Err>;
+type Resource_ResourceSpec<Key, Out, Err, Env> = ResourceSpec<Key, Out, Err, Env>;
+type Resource_ResourceStatus = ResourceStatus;
+declare const Resource_Snapshot: typeof Snapshot;
+type Resource_Spec<Key, Out, Err, Env> = Spec<Key, Out, Err, Env>;
+declare const Resource_internal: typeof internal;
+declare const Resource_keyHash: typeof keyHash;
+declare const Resource_layer: typeof layer;
+declare const Resource_make: typeof make;
+declare namespace Resource {
+  export { type Resource_AnyResourceSpec as AnyResourceSpec, type Resource_ResourceRegistry as ResourceRegistry, Resource_ResourceRegistryTag as ResourceRegistryTag, type Resource_ResourceSnapshot as ResourceSnapshot, type Resource_ResourceSpec as ResourceSpec, type Resource_ResourceStatus as ResourceStatus, Resource_Snapshot as Snapshot, type Resource_Spec as Spec, Resource_internal as internal, Resource_keyHash as keyHash, Resource_layer as layer, Resource_make as make };
+}
+
+export { type AnyResourceSpec as A, Resource as R, type Spec as S, type ResourceSpec as a, type ResourceStatus as b, type ResourceSnapshot as c, type ResourceRegistry as d, Snapshot as e, ResourceRegistryTag as f, internal as i, keyHash as k, layer as l, make as m };

package/dist/Resource.cjs

@@ -0,0 +1,166 @@
+"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/Resource.ts
+var Resource_exports = {};
+__export(Resource_exports, {
+  ResourceRegistryTag: () => ResourceRegistryTag,
+  Snapshot: () => Snapshot2,
+  internal: () => internal2,
+  keyHash: () => keyHash2,
+  layer: () => layer2,
+  make: () => make2
+});
+module.exports = __toCommonJS(Resource_exports);
+
+// src/internal/resource.ts
+var import_effect2 = require("effect");
+
+// src/internal/runtime/core/env.ts
+var import_effect = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/resource.ts
+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 import_effect2.Context.Tag("@logixjs/core/ResourceRegistry")() {
+};
+var internal = {
+  ResourceRegistryTag
+};
+var make = (spec) => spec;
+var layer = (specs) => import_effect2.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 };
+  })()
+);
+
+// src/Resource.ts
+var keyHash2 = keyHash;
+var Snapshot2 = Snapshot;
+var internal2 = internal;
+var make2 = make;
+var layer2 = layer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceRegistryTag,
+  Snapshot,
+  internal,
+  keyHash,
+  layer,
+  make
+});
+//# sourceMappingURL=Resource.cjs.map

package/dist/Resource.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Resource.ts","../src/internal/resource.ts","../src/internal/runtime/core/env.ts"],"sourcesContent":["// Resource module: public facade (@logixjs/core/Resource).\n// Note: implementation lives in `src/internal/resource.ts` to avoid internal importing root submodules.\n\nimport type * as Internal from './internal/resource.js'\nimport * as Impl from './internal/resource.js'\n\nexport type ResourceSpec<Key, Out, Err, Env> = Internal.ResourceSpec<Key, Out, Err, Env>\nexport type AnyResourceSpec = Internal.AnyResourceSpec\nexport type ResourceStatus = Internal.ResourceStatus\nexport type ResourceSnapshot<Data = unknown, Err = unknown> = Internal.ResourceSnapshot<Data, Err>\nexport type ResourceRegistry = Internal.ResourceRegistry\nexport type Spec<Key, Out, Err, Env> = Internal.Spec<Key, Out, Err, Env>\n\nexport const keyHash = Impl.keyHash\nexport const Snapshot = Impl.Snapshot\nexport const internal = Impl.internal\nexport const make = Impl.make\nexport const layer = Impl.layer\n\nexport { ResourceRegistryTag } from './internal/resource.js'\n","import { Context, Layer } from 'effect'\nimport { isDevEnv } from './runtime/core/env.js'\n\nexport interface ResourceSpec<Key, Out, Err, Env> {\n  readonly id: string\n  readonly keySchema: import('effect').Schema.Schema<Key, any>\n  readonly load: (key: Key) => import('effect').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 (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {\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: { readonly keyHash: string }): ResourceSnapshot<Data, Err> => ({\n    status: 'loading',\n    keyHash: params.keyHash,\n    data: undefined,\n    error: undefined,\n  }),\n  success: <Data>(params: { readonly keyHash: string; readonly data: Data }): ResourceSnapshot<Data, never> => ({\n    status: 'success',\n    keyHash: params.keyHash,\n    data: params.data,\n    error: undefined,\n  }),\n  error: <Err>(params: { readonly keyHash: string; readonly error: Err }): ResourceSnapshot<never, Err> => ({\n    status: 'error',\n    keyHash: params.keyHash,\n    data: undefined,\n    error: params.error,\n  }),\n} as const\n\nexport interface ResourceRegistry {\n  readonly specs: ReadonlyMap<string, AnyResourceSpec>\n}\n\nexport class ResourceRegistryTag extends Context.Tag('@logixjs/core/ResourceRegistry')<\n  ResourceRegistryTag,\n  ResourceRegistry\n>() {}\n\nexport const internal = {\n  ResourceRegistryTag,\n}\n\nexport type Spec<Key, Out, Err, Env> = ResourceSpec<Key, Out, Err, Env>\n\nexport const make = <Key, Out, Err, Env>(spec: ResourceSpec<Key, Out, Err, Env>): ResourceSpec<Key, Out, Err, Env> =>\n  spec\n\nexport const layer = (specs: ReadonlyArray<AnyResourceSpec>): 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(`[Resource.layer] Duplicate resource id \"${spec.id}\" detected in the same runtime scope`)\n        }\n        map.set(spec.id, spec)\n      }\n      return { specs: map }\n    })(),\n  )\n","import { Context, Layer } from 'effect'\nimport type { TraitConvergeRequestedMode } from '../../state-trait/model.js'\nimport type { ReadQueryStrictGateConfig } from './ReadQuery.js'\n\n// Unified runtime env detection, avoiding bundlers inlining NODE_ENV at build time.\nexport const getNodeEnv = (): string | undefined => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const env = (globalThis as any)?.process?.env\n    return typeof env?.NODE_ENV === 'string' ? env.NODE_ENV : undefined\n  } catch {\n    return undefined\n  }\n}\n\nexport const isDevEnv = (): boolean => getNodeEnv() !== 'production'\n\nexport type StateTransactionInstrumentation = 'full' | 'light'\n\n/**\n * getDefaultStateTxnInstrumentation：\n * - Currently chooses default instrumentation by NODE_ENV:\n *   - dev / test: full (keep patches and snapshots for debugging).\n *   - production: light (keep minimal semantics to reduce overhead).\n * - May evolve with finer-grained overrides in Runtime.make / Module.make.\n */\nexport const getDefaultStateTxnInstrumentation = (): StateTransactionInstrumentation => (isDevEnv() ? 'full' : 'light')\n\n/**\n * Runtime-level StateTransaction config Service:\n * - Provided at the app layer by Logix.Runtime.make / AppRuntime.makeApp.\n * - ModuleRuntime.make can read runtime-level defaults from Env.\n *\n * Notes:\n * - instrumentation is only a runtime-level default.\n * - Explicit instrumentation in ModuleImpl / ModuleRuntimeOptions has higher priority.\n */\nexport interface StateTransactionRuntimeConfig {\n  readonly instrumentation?: StateTransactionInstrumentation\n  /**\n   * StateTrait derived converge budget (ms):\n   * - Exceeding the budget triggers a soft degrade (freeze derived fields, preserve base writes and 0/1 commit semantics).\n   * - Default is 200ms (aligned with the 007 spec threshold).\n   */\n  readonly traitConvergeBudgetMs?: number\n  /**\n   * Auto-mode decision budget (ms):\n   * - Only used during the decision phase when requestedMode=\"auto\".\n   * - Exceeding the budget must immediately fall back to full (and record evidence).\n   */\n  readonly traitConvergeDecisionBudgetMs?: number\n  /**\n   * StateTrait converge scheduling strategy:\n   * - full: full topo execution (current default; safest).\n   * - dirty: minimal triggering based on dirtyPaths + deps in the txn window (requires accurate deps).\n   */\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  /**\n   * 043: Trait converge time-slicing (explicit opt-in). Disabled by default.\n   */\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  /**\n   * 060: Txn Lanes (priority scheduling for transaction follow-up work). Enabled by default since 062.\n   */\n  readonly txnLanes?: TxnLanesPatch\n  /**\n   * Runtime-level per-module overrides (hotfix path):\n   * - Only affects converge behavior for the specified moduleId.\n   * - Lower priority than Provider overrides.\n   */\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /**\n   * 060: Txn Lanes runtime_module overrides (hotfix / gradual tuning).\n   * - Only affects the specified moduleId.\n   * - Lower priority than Provider overrides.\n   */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionConfigTagImpl extends Context.Tag('@logixjs/core/StateTransactionRuntimeConfig')<\n  StateTransactionConfigTagImpl,\n  StateTransactionRuntimeConfig\n>() {}\n\nexport const StateTransactionConfigTag = StateTransactionConfigTagImpl\n\nexport type ReadQueryStrictGateRuntimeConfig = ReadQueryStrictGateConfig\n\nclass ReadQueryStrictGateConfigTagImpl extends Context.Tag('@logixjs/core/ReadQueryStrictGateRuntimeConfig')<\n  ReadQueryStrictGateConfigTagImpl,\n  ReadQueryStrictGateRuntimeConfig\n>() {}\n\nexport const ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl\n\nexport type ReplayMode = 'live' | 'replay'\n\nexport interface ReplayModeConfig {\n  readonly mode: ReplayMode\n}\n\nclass ReplayModeConfigTagImpl extends Context.Tag('@logixjs/core/ReplayModeConfig')<\n  ReplayModeConfigTagImpl,\n  ReplayModeConfig\n>() {}\n\nexport const ReplayModeConfigTag = ReplayModeConfigTagImpl\n\nexport const replayModeLayer = (mode: ReplayMode): Layer.Layer<ReplayModeConfigTagImpl, never, never> =>\n  Layer.succeed(ReplayModeConfigTag, { mode })\n\nexport interface StateTransactionTraitConvergeOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n}\n\nexport interface TxnLanesPatch {\n  /**\n   * enabled: whether Txn Lanes is enabled (default on since 062).\n   * - undefined: default enabled (when not explicitly configured)\n   * - false: disabled (returns to baseline behavior)\n   * - true: enabled (only affects scheduling of follow-up work outside the transaction; transactions remain synchronous)\n   */\n  readonly enabled?: boolean\n  /**\n   * overrideMode: runtime temporary override (for debugging/rollback/comparison).\n   * - forced_off: forcibly disables Txn Lanes (returns to baseline behavior).\n   * - forced_sync: forces fully synchronous execution (ignores non-urgent deferral and time-slicing; used for comparisons).\n   *\n   * Notes:\n   * - Override precedence follows StateTransactionOverrides: provider > runtime_module > runtime_default > builtin.\n   * - Overrides must be explainable by evidence (see 060 LaneEvidence reasons).\n   */\n  readonly overrideMode?: 'forced_off' | 'forced_sync'\n  /** non-urgent work loop slice budget (ms). */\n  readonly budgetMs?: number\n  /** Non-urgent backlog coalescing window (ms). */\n  readonly debounceMs?: number\n  /** Max lag upper bound (ms): exceeding it triggers an explainable starvation protection (forced catch-up). */\n  readonly maxLagMs?: number\n  /** Whether to allow coalescing/canceling intermediate non-urgent work (must preserve eventual consistency). */\n  readonly allowCoalesce?: boolean\n  /**\n   * Yield strategy for the non-urgent work loop (progressive enhancement).\n   * - baseline: uses only time budget + hard upper bound\n   * - inputPending: when supported by browsers, also consults `navigator.scheduling.isInputPending`\n   */\n  readonly yieldStrategy?: 'baseline' | 'inputPending'\n}\n\nexport interface TraitConvergeTimeSlicingPatch {\n  /**\n   * enabled：\n   * - false/undefined: disabled (default)\n   * - true: enables time-slicing (only affects computed/link explicitly marked as deferred)\n   */\n  readonly enabled?: boolean\n  /**\n   * debounceMs: coalescing interval (ms) for the deferral window; merges high-frequency inputs into one deferred flush.\n   */\n  readonly debounceMs?: number\n  /**\n   * maxLagMs: max lag upper bound (ms); exceeding it triggers an explainable forced flush (starvation protection).\n   */\n  readonly maxLagMs?: number\n}\n\n/**\n * Provider-scoped StateTransactionOverrides (delta overrides):\n * - Used to inject more local overrides into a Provider subtree on top of inherited global runtime config.\n * - Override precedence: provider > runtime_module > runtime_default > builtin.\n */\nexport interface StateTransactionOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /** 060: Txn Lanes provider-level overrides (delta overrides). */\n  readonly txnLanes?: TxnLanesPatch\n  /** 060: Txn Lanes provider_module overrides (by moduleId). */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionOverridesTagImpl extends Context.Tag('@logixjs/core/StateTransactionOverrides')<\n  StateTransactionOverridesTagImpl,\n  StateTransactionOverrides\n>() {}\n\nexport const StateTransactionOverridesTag = StateTransactionOverridesTagImpl\n\nexport type ConcurrencyLimit = number | 'unbounded'\n\nexport interface ConcurrencyPolicyPatch {\n  readonly concurrencyLimit?: ConcurrencyLimit\n  readonly losslessBackpressureCapacity?: number\n  readonly allowUnbounded?: boolean\n  readonly pressureWarningThreshold?: {\n    readonly backlogCount?: number\n    readonly backlogDurationMs?: number\n  }\n  readonly warningCooldownMs?: number\n}\n\n/**\n * Runtime-level ConcurrencyPolicy:\n * - Provided at the app layer by Logix.Runtime.make / AppRuntime.makeApp.\n * - ModuleRuntime merges sources via a resolver (builtin/runtime_module/provider, etc.).\n *\n * Notes:\n * - overridesByModuleId is used for runtime_module hot-switching (hotfix / gradual tuning) and is lower priority than provider overrides.\n */\nexport interface ConcurrencyPolicy extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyTagImpl extends Context.Tag('@logixjs/core/ConcurrencyPolicy')<\n  ConcurrencyPolicyTagImpl,\n  ConcurrencyPolicy\n>() {}\n\nexport const ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl\n\n/**\n * Provider-scoped ConcurrencyPolicyOverrides (delta overrides):\n * - Used to inject more local overrides into a Provider subtree on top of inherited global runtime config.\n * - Override precedence: provider > runtime_module > runtime_default > builtin.\n */\nexport interface ConcurrencyPolicyOverrides extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyOverridesTagImpl extends Context.Tag('@logixjs/core/ConcurrencyPolicyOverrides')<\n  ConcurrencyPolicyOverridesTagImpl,\n  ConcurrencyPolicyOverrides\n>() {}\n\nexport const ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl\n"],"mappings":"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","names":["Snapshot","internal","keyHash","layer","make","import_effect","keyHash","Snapshot","internal","make","layer"]}

package/dist/Resource.d.cts

@@ -0,0 +1,3 @@
+import 'effect/Layer';
+export { A as AnyResourceSpec, d as ResourceRegistry, f as ResourceRegistryTag, c as ResourceSnapshot, a as ResourceSpec, b as ResourceStatus, e as Snapshot, S as Spec, i as internal, k as keyHash, l as layer, m as make } from './Resource-Dy1xD_DG.cjs';
+import 'effect';

package/dist/Resource.d.ts

@@ -0,0 +1,3 @@
+import 'effect/Layer';
+export { A as AnyResourceSpec, d as ResourceRegistry, f as ResourceRegistryTag, c as ResourceSnapshot, a as ResourceSpec, b as ResourceStatus, e as Snapshot, S as Spec, i as internal, k as keyHash, l as layer, m as make } from './Resource-Dy1xD_DG.js';
+import 'effect';

package/dist/Resource.js

@@ -0,0 +1,21 @@
+import {
+  Snapshot,
+  internal,
+  keyHash,
+  layer,
+  make
+} from "./chunk-4CQAV7YB.js";
+import {
+  ResourceRegistryTag
+} from "./chunk-NZJKFF45.js";
+import "./chunk-3QMIVH35.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ResourceRegistryTag,
+  Snapshot,
+  internal,
+  keyHash,
+  layer,
+  make
+};
+//# sourceMappingURL=Resource.js.map

package/dist/Resource.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Root-7ADUMk4t.d.cts

@@ -0,0 +1,29 @@
+import * as effect_Layer from 'effect/Layer';
+import * as effect_Effect from 'effect/Effect';
+import * as effect_Context from 'effect/Context';
+
+type RootResolveEntrypoint$1 = 'logic.root.resolve' | 'logic.$.root.resolve';
+interface RootResolveOptions$1 {
+    readonly entrypoint?: RootResolveEntrypoint$1;
+    /**
+     * Whether to wait when RootContext is not ready yet:
+     * - Default false: avoid misuse during layer/setup which can deadlock.
+     * - `$.root.resolve` passes true in the run phase (run-only), allowing Env assembly to complete.
+     */
+    readonly waitForReady?: boolean;
+}
+
+type RootResolveEntrypoint = RootResolveEntrypoint$1;
+type RootResolveOptions = RootResolveOptions$1;
+declare const resolve: <Id, Svc>(tag: effect_Context.Tag<Id, Svc>, options?: RootResolveOptions$1) => effect_Effect.Effect<Svc, never, any>;
+declare const layerFromContext: (context: effect_Context.Context<any>) => effect_Layer.Layer<any, never, any>;
+
+type Root_RootResolveEntrypoint = RootResolveEntrypoint;
+type Root_RootResolveOptions = RootResolveOptions;
+declare const Root_layerFromContext: typeof layerFromContext;
+declare const Root_resolve: typeof resolve;
+declare namespace Root {
+  export { type Root_RootResolveEntrypoint as RootResolveEntrypoint, type Root_RootResolveOptions as RootResolveOptions, Root_layerFromContext as layerFromContext, Root_resolve as resolve };
+}
+
+export { Root as R, type RootResolveEntrypoint as a, type RootResolveOptions as b, layerFromContext as l, resolve as r };

package/dist/Root-7ADUMk4t.d.ts

@@ -0,0 +1,29 @@
+import * as effect_Layer from 'effect/Layer';
+import * as effect_Effect from 'effect/Effect';
+import * as effect_Context from 'effect/Context';
+
+type RootResolveEntrypoint$1 = 'logic.root.resolve' | 'logic.$.root.resolve';
+interface RootResolveOptions$1 {
+    readonly entrypoint?: RootResolveEntrypoint$1;
+    /**
+     * Whether to wait when RootContext is not ready yet:
+     * - Default false: avoid misuse during layer/setup which can deadlock.
+     * - `$.root.resolve` passes true in the run phase (run-only), allowing Env assembly to complete.
+     */
+    readonly waitForReady?: boolean;
+}
+
+type RootResolveEntrypoint = RootResolveEntrypoint$1;
+type RootResolveOptions = RootResolveOptions$1;
+declare const resolve: <Id, Svc>(tag: effect_Context.Tag<Id, Svc>, options?: RootResolveOptions$1) => effect_Effect.Effect<Svc, never, any>;
+declare const layerFromContext: (context: effect_Context.Context<any>) => effect_Layer.Layer<any, never, any>;
+
+type Root_RootResolveEntrypoint = RootResolveEntrypoint;
+type Root_RootResolveOptions = RootResolveOptions;
+declare const Root_layerFromContext: typeof layerFromContext;
+declare const Root_resolve: typeof resolve;
+declare namespace Root {
+  export { type Root_RootResolveEntrypoint as RootResolveEntrypoint, type Root_RootResolveOptions as RootResolveOptions, Root_layerFromContext as layerFromContext, Root_resolve as resolve };
+}
+
+export { Root as R, type RootResolveEntrypoint as a, type RootResolveOptions as b, layerFromContext as l, resolve as r };

package/dist/Root.cjs

@@ -0,0 +1,125 @@
+"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/Root.ts
+var Root_exports = {};
+__export(Root_exports, {
+  layerFromContext: () => layerFromContext2,
+  resolve: () => resolve2
+});
+module.exports = __toCommonJS(Root_exports);
+
+// src/internal/root.ts
+var import_effect3 = require("effect");
+
+// src/internal/runtime/core/env.ts
+var import_effect = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/runtime/core/RootContext.ts
+var import_effect2 = require("effect");
+var RootContextTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RootContext")() {
+};
+var RootContextTag = RootContextTagImpl;
+
+// src/internal/root.ts
+var tagIdOf = (tag) => typeof tag?.id === "string" ? String(tag.id) : typeof tag?.key === "string" ? String(tag.key) : "<unknown tag>";
+var makeMissingRootProviderError = (tag, entrypoint, extra) => {
+  const dev = isDevEnv();
+  const tokenId = tagIdOf(tag);
+  const fix = dev ? [
+    "- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).",
+    "- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).",
+    "- Do not rely on nested RuntimeProvider.layer to mock Root.resolve."
+  ] : [];
+  const message = dev ? [
+    "[MissingRootProviderError] Cannot resolve Tag from root provider.",
+    extra ? `
+${extra}` : "",
+    `tokenId: ${tokenId}`,
+    `entrypoint: ${entrypoint}`,
+    "mode: global",
+    "startScope: root",
+    "",
+    "fix:",
+    ...fix
+  ].filter((s) => s.length > 0).join("\n") : "[MissingRootProviderError] tag not found in root provider";
+  const err = new Error(message);
+  err.name = "MissingRootProviderError";
+  err.tokenId = tokenId;
+  err.entrypoint = entrypoint;
+  err.mode = "global";
+  err.startScope = { kind: "root" };
+  err.fix = fix;
+  return err;
+};
+var resolve = (tag, options) => import_effect3.Effect.gen(function* () {
+  const entrypoint = options?.entrypoint ?? "logic.root.resolve";
+  const root = yield* RootContextTag;
+  const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
+  if (!rootContext) {
+    return yield* import_effect3.Effect.die(
+      makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
+    );
+  }
+  try {
+    return import_effect3.Context.get(rootContext, tag);
+  } catch {
+    return yield* import_effect3.Effect.die(makeMissingRootProviderError(tag, entrypoint));
+  }
+});
+var layerFromContext = (context) => import_effect3.Layer.scoped(
+  RootContextTag,
+  import_effect3.Effect.gen(function* () {
+    const ready = yield* import_effect3.Deferred.make();
+    yield* import_effect3.Deferred.succeed(ready, context);
+    const root = { context, ready };
+    return root;
+  })
+);
+
+// src/Root.ts
+var resolve2 = resolve;
+var layerFromContext2 = layerFromContext;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  layerFromContext,
+  resolve
+});
+//# sourceMappingURL=Root.cjs.map