@logixjs/query 0.0.1

package/dist/Traits.d.cts

@@ -0,0 +1,76 @@
+import * as Logix from '@logixjs/core';
+
+type QueryTrigger = 'onMount' | 'onKeyChange' | 'manual';
+type QueryConcurrency = 'switch' | 'exhaust';
+type QueryResourceRef = {
+    readonly id: string;
+};
+type QueryResource = QueryResourceRef | Logix.Resource.ResourceSpec<any, any, any, any>;
+type QueryResourceKey<R> = R extends Logix.Resource.ResourceSpec<infer Key, any, any, any> ? Key : unknown;
+type QueryResourceData<R> = R extends Logix.Resource.ResourceSpec<any, infer Data, any, any> ? Data : unknown;
+type QueryResourceError<R> = R extends Logix.Resource.ResourceSpec<any, any, infer Err, any> ? Err : unknown;
+type QueryKeyState<TParams, TUI> = Readonly<{
+    readonly params: TParams;
+    readonly ui: TUI;
+}>;
+type QueryDepsPath<TParams, TUI> = Logix.StateTrait.StateFieldPath<QueryKeyState<TParams, TUI>>;
+type DepsArgs<S extends object, Deps extends ReadonlyArray<string>> = {
+    readonly [K in keyof Deps]: Deps[K] extends Logix.StateTrait.StateFieldPath<S> ? Logix.StateTrait.StateAtPath<S, Deps[K]> : any;
+};
+type BivariantCallback<Args extends ReadonlyArray<any>, R> = {
+    bivarianceHack(...args: Args): R;
+}['bivarianceHack'];
+interface QuerySourceConfig<TParams, TUI = unknown, R extends QueryResource = QueryResource, Deps extends ReadonlyArray<string> = ReadonlyArray<QueryDepsPath<TParams, TUI>>> {
+    readonly resource: R;
+    readonly deps: Deps & ReadonlyArray<QueryDepsPath<TParams, TUI>>;
+    readonly triggers?: ReadonlyArray<QueryTrigger>;
+    /**
+     * Optional static tags for invalidate(byTag), used to narrow byTag from "refresh all" to a matched subset.
+     * - Must be serializable (recommend: string constants only)
+     * - If omitted, byTag conservatively falls back to refreshing everything
+     */
+    readonly tags?: ReadonlyArray<string>;
+    readonly debounceMs?: number;
+    readonly concurrency?: QueryConcurrency;
+    readonly key: BivariantCallback<DepsArgs<QueryKeyState<TParams, TUI>, Deps>, QueryResourceKey<R> | undefined>;
+}
+type QueryBuilder<TParams, TUI> = {
+    readonly source: <R extends QueryResource, const Deps extends ReadonlyArray<string> = ReadonlyArray<QueryDepsPath<TParams, TUI>>>(config: {
+        readonly resource: R;
+        readonly deps: Deps & ReadonlyArray<QueryDepsPath<TParams, TUI>>;
+        readonly triggers?: ReadonlyArray<QueryTrigger>;
+        readonly tags?: ReadonlyArray<string>;
+        readonly debounceMs?: number;
+        readonly concurrency?: QueryConcurrency;
+        readonly key: (...depsValues: DepsArgs<QueryKeyState<TParams, TUI>, Deps>) => QueryResourceKey<R> | undefined;
+    }) => QuerySourceConfig<TParams, TUI, R, Deps>;
+};
+/**
+ * Query.source:
+ * - Strongly typed helper to preserve `deps` as a tuple and infer `key(...depsValues)` argument types from it.
+ * - Recommended usage inside `Query.make(..., { queries: { name: Query.source({ ... }) } })`.
+ */
+declare const source: <TParams, TUI = unknown, R extends QueryResource = QueryResource, const Deps extends ReadonlyArray<string> = ReadonlyArray<QueryDepsPath<TParams, TUI>>>(config: {
+    readonly resource: R;
+    readonly deps: Deps & ReadonlyArray<QueryDepsPath<TParams, TUI>>;
+    readonly triggers?: ReadonlyArray<QueryTrigger>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly debounceMs?: number;
+    readonly concurrency?: QueryConcurrency;
+    readonly key: (...depsValues: DepsArgs<QueryKeyState<TParams, TUI>, Deps>) => QueryResourceKey<R> | undefined;
+}) => QuerySourceConfig<TParams, TUI, R, Deps>;
+interface QueryTraitsInput<TParams, TUI> {
+    readonly queries: Readonly<Record<string, QuerySourceConfig<TParams, TUI, any>>>;
+}
+/**
+ * Lowering rules (Query -> StateTrait):
+ * - Each Query rule maps to a `StateTrait.source`, writing back to `queries.<name>` (isomorphic to module state).
+ * - keySelector computes key from `{ params; ui }`; keyHash/race gating is guaranteed by the kernel source runtime.
+ *
+ * Notes:
+ * - deps uses module-root paths (e.g. "params.q" / "ui.query.autoEnabled"), aligned with the constraints in 007/004.
+ * - concurrency "exhaust" is represented as "exhaust-trailing" in the kernel.
+ */
+declare const toStateTraitSpec: <TParams, TUI>(input: QueryTraitsInput<TParams, TUI>) => Logix.StateTrait.StateTraitSpec<any>;
+
+export { type QueryBuilder, type QueryConcurrency, type QueryDepsPath, type QueryKeyState, type QueryResource, type QueryResourceData, type QueryResourceError, type QueryResourceKey, type QueryResourceRef, type QuerySourceConfig, type QueryTraitsInput, type QueryTrigger, source, toStateTraitSpec };

package/dist/Traits.d.ts

@@ -0,0 +1,76 @@
+import * as Logix from '@logixjs/core';
+
+type QueryTrigger = 'onMount' | 'onKeyChange' | 'manual';
+type QueryConcurrency = 'switch' | 'exhaust';
+type QueryResourceRef = {
+    readonly id: string;
+};
+type QueryResource = QueryResourceRef | Logix.Resource.ResourceSpec<any, any, any, any>;
+type QueryResourceKey<R> = R extends Logix.Resource.ResourceSpec<infer Key, any, any, any> ? Key : unknown;
+type QueryResourceData<R> = R extends Logix.Resource.ResourceSpec<any, infer Data, any, any> ? Data : unknown;
+type QueryResourceError<R> = R extends Logix.Resource.ResourceSpec<any, any, infer Err, any> ? Err : unknown;
+type QueryKeyState<TParams, TUI> = Readonly<{
+    readonly params: TParams;
+    readonly ui: TUI;
+}>;
+type QueryDepsPath<TParams, TUI> = Logix.StateTrait.StateFieldPath<QueryKeyState<TParams, TUI>>;
+type DepsArgs<S extends object, Deps extends ReadonlyArray<string>> = {
+    readonly [K in keyof Deps]: Deps[K] extends Logix.StateTrait.StateFieldPath<S> ? Logix.StateTrait.StateAtPath<S, Deps[K]> : any;
+};
+type BivariantCallback<Args extends ReadonlyArray<any>, R> = {
+    bivarianceHack(...args: Args): R;
+}['bivarianceHack'];
+interface QuerySourceConfig<TParams, TUI = unknown, R extends QueryResource = QueryResource, Deps extends ReadonlyArray<string> = ReadonlyArray<QueryDepsPath<TParams, TUI>>> {
+    readonly resource: R;
+    readonly deps: Deps & ReadonlyArray<QueryDepsPath<TParams, TUI>>;
+    readonly triggers?: ReadonlyArray<QueryTrigger>;
+    /**
+     * Optional static tags for invalidate(byTag), used to narrow byTag from "refresh all" to a matched subset.
+     * - Must be serializable (recommend: string constants only)
+     * - If omitted, byTag conservatively falls back to refreshing everything
+     */
+    readonly tags?: ReadonlyArray<string>;
+    readonly debounceMs?: number;
+    readonly concurrency?: QueryConcurrency;
+    readonly key: BivariantCallback<DepsArgs<QueryKeyState<TParams, TUI>, Deps>, QueryResourceKey<R> | undefined>;
+}
+type QueryBuilder<TParams, TUI> = {
+    readonly source: <R extends QueryResource, const Deps extends ReadonlyArray<string> = ReadonlyArray<QueryDepsPath<TParams, TUI>>>(config: {
+        readonly resource: R;
+        readonly deps: Deps & ReadonlyArray<QueryDepsPath<TParams, TUI>>;
+        readonly triggers?: ReadonlyArray<QueryTrigger>;
+        readonly tags?: ReadonlyArray<string>;
+        readonly debounceMs?: number;
+        readonly concurrency?: QueryConcurrency;
+        readonly key: (...depsValues: DepsArgs<QueryKeyState<TParams, TUI>, Deps>) => QueryResourceKey<R> | undefined;
+    }) => QuerySourceConfig<TParams, TUI, R, Deps>;
+};
+/**
+ * Query.source:
+ * - Strongly typed helper to preserve `deps` as a tuple and infer `key(...depsValues)` argument types from it.
+ * - Recommended usage inside `Query.make(..., { queries: { name: Query.source({ ... }) } })`.
+ */
+declare const source: <TParams, TUI = unknown, R extends QueryResource = QueryResource, const Deps extends ReadonlyArray<string> = ReadonlyArray<QueryDepsPath<TParams, TUI>>>(config: {
+    readonly resource: R;
+    readonly deps: Deps & ReadonlyArray<QueryDepsPath<TParams, TUI>>;
+    readonly triggers?: ReadonlyArray<QueryTrigger>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly debounceMs?: number;
+    readonly concurrency?: QueryConcurrency;
+    readonly key: (...depsValues: DepsArgs<QueryKeyState<TParams, TUI>, Deps>) => QueryResourceKey<R> | undefined;
+}) => QuerySourceConfig<TParams, TUI, R, Deps>;
+interface QueryTraitsInput<TParams, TUI> {
+    readonly queries: Readonly<Record<string, QuerySourceConfig<TParams, TUI, any>>>;
+}
+/**
+ * Lowering rules (Query -> StateTrait):
+ * - Each Query rule maps to a `StateTrait.source`, writing back to `queries.<name>` (isomorphic to module state).
+ * - keySelector computes key from `{ params; ui }`; keyHash/race gating is guaranteed by the kernel source runtime.
+ *
+ * Notes:
+ * - deps uses module-root paths (e.g. "params.q" / "ui.query.autoEnabled"), aligned with the constraints in 007/004.
+ * - concurrency "exhaust" is represented as "exhaust-trailing" in the kernel.
+ */
+declare const toStateTraitSpec: <TParams, TUI>(input: QueryTraitsInput<TParams, TUI>) => Logix.StateTrait.StateTraitSpec<any>;
+
+export { type QueryBuilder, type QueryConcurrency, type QueryDepsPath, type QueryKeyState, type QueryResource, type QueryResourceData, type QueryResourceError, type QueryResourceKey, type QueryResourceRef, type QuerySourceConfig, type QueryTraitsInput, type QueryTrigger, source, toStateTraitSpec };

package/dist/Traits.js

@@ -0,0 +1,10 @@
+import {
+  source,
+  toStateTraitSpec
+} from "./chunk-V3F5KWNH.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  source,
+  toStateTraitSpec
+};
+//# sourceMappingURL=Traits.js.map

package/dist/Traits.js.map

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

package/dist/chunk-L745BR5P.js

@@ -0,0 +1,124 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/TanStack.ts
+var TanStack_exports = {};
+__export(TanStack_exports, {
+  engine: () => engine,
+  observe: () => observe
+});
+
+// src/internal/engine/tanstack.ts
+import { Effect, Option } from "effect";
+var makeQueryKey = (resourceId, keyHash) => [resourceId, keyHash];
+var engine = (queryClient, config) => {
+  const byResourceId = /* @__PURE__ */ new Map();
+  const maxEntriesPerResource = config?.maxEntriesPerResource ?? 2e3;
+  try {
+    const queryCache = queryClient.getQueryCache?.();
+    if (queryCache && typeof queryCache.clear === "function") {
+      const original = queryCache.clear.bind(queryCache);
+      queryCache.clear = () => {
+        byResourceId.clear();
+        return original();
+      };
+    }
+  } catch {
+  }
+  const ensureBucket = (resourceId) => {
+    let bucket = byResourceId.get(resourceId);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      byResourceId.set(resourceId, bucket);
+    }
+    return bucket;
+  };
+  const evictIfNeeded = (bucket) => {
+    if (maxEntriesPerResource === Infinity) return;
+    if (!Number.isFinite(maxEntriesPerResource) || maxEntriesPerResource <= 0) return;
+    while (bucket.size > maxEntriesPerResource) {
+      const firstKey = bucket.keys().next().value;
+      if (firstKey === void 0) return;
+      bucket.delete(firstKey);
+    }
+  };
+  const fetchFast = (resourceId, keyHash, effect) => Effect.suspend(() => {
+    const hit = byResourceId.get(resourceId)?.get(keyHash);
+    if (hit !== void 0) {
+      return Effect.succeed(hit);
+    }
+    return Effect.map(effect, (out) => {
+      if (out !== void 0) {
+        const bucket = ensureBucket(resourceId);
+        bucket.set(keyHash, out);
+        evictIfNeeded(bucket);
+      }
+      return out;
+    });
+  });
+  return {
+    fetch: ({ resourceId, keyHash, effect }) => fetchFast(resourceId, keyHash, effect),
+    fetchFast,
+    invalidate: (request) => Effect.gen(function* () {
+      yield* Effect.sync(() => {
+        if (request.kind === "byParams") {
+          const bucket = byResourceId.get(request.resourceId);
+          if (!bucket) return;
+          bucket.delete(request.keyHash);
+          if (bucket.size === 0) {
+            byResourceId.delete(request.resourceId);
+          }
+          return;
+        }
+        if (request.kind === "byResource") {
+          byResourceId.delete(request.resourceId);
+          return;
+        }
+        byResourceId.clear();
+      });
+      yield* Effect.tryPromise({
+        try: () => {
+          if (request.kind === "byResource") {
+            return queryClient.invalidateQueries({
+              queryKey: [request.resourceId]
+            });
+          }
+          if (request.kind === "byParams") {
+            return queryClient.invalidateQueries({
+              queryKey: makeQueryKey(request.resourceId, request.keyHash)
+            });
+          }
+          return queryClient.invalidateQueries({
+            predicate: (q) => {
+              const tags = q.meta?.tags;
+              return Array.isArray(tags) && tags.includes(request.tag);
+            }
+          });
+        },
+        catch: (e) => e
+      }).pipe(Effect.asVoid);
+    }),
+    peekFresh: ({ resourceId, keyHash }) => Effect.sync(() => {
+      const hit = byResourceId.get(resourceId)?.get(keyHash);
+      return hit === void 0 ? Option.none() : Option.some(hit);
+    })
+  };
+};
+
+// src/internal/tanstack/observer.ts
+import { Effect as Effect2 } from "effect";
+import { QueryObserver } from "@tanstack/query-core";
+var observe = (params) => Effect2.gen(function* () {
+  const observer = new QueryObserver(params.queryClient, params.options);
+  const unsubscribe = observer.subscribe(params.onResult);
+  yield* Effect2.addFinalizer(() => Effect2.sync(() => unsubscribe()));
+  return observer;
+});
+
+export {
+  engine,
+  observe,
+  TanStack_exports
+};
+//# sourceMappingURL=chunk-L745BR5P.js.map

package/dist/chunk-L745BR5P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/TanStack.ts","../src/internal/engine/tanstack.ts","../src/internal/tanstack/observer.ts"],"sourcesContent":["export * from './internal/engine/tanstack.js'\nexport * from './internal/tanstack/observer.js'\n","import { Effect, Option } from 'effect'\nimport type { QueryClient } from '@tanstack/query-core'\nimport type { Engine, InvalidateRequest } from '../../Engine.js'\n\nconst makeQueryKey = (resourceId: string, keyHash: string) => [resourceId, keyHash] as const\n\nexport interface TanStackEngineConfig {\n  /**\n   * The max number of entries per resourceId in the local fast cache.\n   * - Goal: prevent unbounded memory growth when the key space is unbounded.\n   * - Semantics: evicts oldest entries in insertion order (FIFO); cache misses fall back to re-loading.\n   * - Set to Infinity to disable the cap (not recommended for long-running processes).\n   */\n  readonly maxEntriesPerResource?: number\n}\n\n/**\n * TanStack engine：\n * - Uses QueryClient for invalidation (easy integration with TanStack ecosystem).\n * - fetch/peekFresh uses a slim in-memory cache to avoid frequently creating Query objects on the Logix runtime hot path.\n * - Still preserves Logix Runtime's keyHash gating and ResourceSnapshot source-of-truth semantics.\n */\nexport const engine = (queryClient: QueryClient, config?: TanStackEngineConfig): Engine => {\n  const byResourceId = new Map<string, Map<string, unknown>>()\n  const maxEntriesPerResource = config?.maxEntriesPerResource ?? 2000\n\n  // Align with external QueryClient.clear(): when QueryCache is cleared, clear the local fast cache as well.\n  try {\n    const queryCache: any = (queryClient as any).getQueryCache?.()\n    if (queryCache && typeof queryCache.clear === 'function') {\n      const original = queryCache.clear.bind(queryCache)\n      queryCache.clear = () => {\n        byResourceId.clear()\n        return original()\n      }\n    }\n  } catch {\n    // ignore\n  }\n\n  const ensureBucket = (resourceId: string): Map<string, unknown> => {\n    let bucket = byResourceId.get(resourceId)\n    if (!bucket) {\n      bucket = new Map<string, unknown>()\n      byResourceId.set(resourceId, bucket)\n    }\n    return bucket\n  }\n\n  const evictIfNeeded = (bucket: Map<string, unknown>): void => {\n    if (maxEntriesPerResource === Infinity) return\n    if (!Number.isFinite(maxEntriesPerResource) || maxEntriesPerResource <= 0) return\n    while (bucket.size > maxEntriesPerResource) {\n      const firstKey = bucket.keys().next().value as string | undefined\n      if (firstKey === undefined) return\n      bucket.delete(firstKey)\n    }\n  }\n\n  const fetchFast: Engine['fetchFast'] = (resourceId, keyHash, effect) =>\n    Effect.suspend(() => {\n      const hit = byResourceId.get(resourceId)?.get(keyHash)\n      if (hit !== undefined) {\n        return Effect.succeed(hit as any)\n      }\n\n      return Effect.map(effect, (out) => {\n        if (out !== undefined) {\n          const bucket = ensureBucket(resourceId)\n          bucket.set(keyHash, out)\n          evictIfNeeded(bucket)\n        }\n        return out as any\n      })\n    })\n\n  return {\n    fetch: ({ resourceId, keyHash, effect }) => fetchFast!(resourceId, keyHash, effect),\n\n    fetchFast,\n\n    invalidate: (request: InvalidateRequest) =>\n      Effect.gen(function* () {\n        yield* Effect.sync(() => {\n          if (request.kind === 'byParams') {\n            const bucket = byResourceId.get(request.resourceId)\n            if (!bucket) return\n            bucket.delete(request.keyHash)\n            if (bucket.size === 0) {\n              byResourceId.delete(request.resourceId)\n            }\n            return\n          }\n\n          if (request.kind === 'byResource') {\n            byResourceId.delete(request.resourceId)\n            return\n          }\n\n          // byTag: we currently lack a serializable tags mapping; conservatively clear all (explainable but coarse).\n          byResourceId.clear()\n        })\n\n        // Sync to QueryClient (if there are external observers/ecosystem consumers).\n        yield* Effect.tryPromise({\n          try: () => {\n            if (request.kind === 'byResource') {\n              return queryClient.invalidateQueries({\n                queryKey: [request.resourceId],\n              })\n            }\n\n            if (request.kind === 'byParams') {\n              return queryClient.invalidateQueries({\n                queryKey: makeQueryKey(request.resourceId, request.keyHash),\n              })\n            }\n\n            return queryClient.invalidateQueries({\n              predicate: (q) => {\n                const tags = (q.meta as any)?.tags\n                return Array.isArray(tags) && tags.includes(request.tag)\n              },\n            })\n          },\n          catch: (e) => e,\n        }).pipe(Effect.asVoid)\n      }),\n\n    peekFresh: <A>({ resourceId, keyHash }: { readonly resourceId: string; readonly keyHash: string }) =>\n      Effect.sync(() => {\n        const hit = byResourceId.get(resourceId)?.get(keyHash) as A | undefined\n        return hit === undefined ? Option.none<A>() : Option.some(hit)\n      }),\n  }\n}\n","import { Effect } from 'effect'\nimport type { QueryClient } from '@tanstack/query-core'\nimport { QueryObserver } from '@tanstack/query-core'\n\n/**\n * observe (subscribe within scope + cleanup):\n * - For scenarios where you want \"TanStack-like automatic tracking\" of enabled/queryKey changes.\n * - Provided as infrastructure; domain logic can choose to use it (no hard dependency).\n */\nexport const observe = <TData = unknown>(params: {\n  readonly queryClient: QueryClient\n  readonly options: ConstructorParameters<typeof QueryObserver<TData>>[1]\n  readonly onResult: (result: unknown) => void\n}): Effect.Effect<QueryObserver<TData>, never, any> =>\n  Effect.gen(function* () {\n    const observer = new QueryObserver<TData>(params.queryClient, params.options as any)\n    const unsubscribe = observer.subscribe(params.onResult as any)\n    yield* Effect.addFinalizer(() => Effect.sync(() => unsubscribe()))\n    return observer\n  })\n"],"mappings":"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","names":["Effect"]}

package/dist/chunk-NXFX6RIH.js

@@ -0,0 +1,355 @@
+import {
+  Engine
+} from "./chunk-THVAADR2.js";
+import {
+  toStateTraitSpec
+} from "./chunk-V3F5KWNH.js";
+
+// src/Query.ts
+import * as Logix3 from "@logixjs/core";
+import { Schema } from "effect";
+
+// src/internal/logics/auto-trigger.ts
+import * as Logix from "@logixjs/core";
+import { Duration, Effect, Fiber } from "effect";
+var defaultTriggers = ["onMount", "onKeyChange"];
+var getTriggers = (triggers) => triggers ?? defaultTriggers;
+var isManualOnly = (triggers) => triggers.length === 1 && triggers[0] === "manual";
+var getSnapshotKeyHash = (snapshot) => {
+  if (!snapshot || typeof snapshot !== "object") return void 0;
+  const keyHash = snapshot.keyHash;
+  return typeof keyHash === "string" ? keyHash : void 0;
+};
+var getSnapshotStatus = (snapshot) => {
+  if (!snapshot || typeof snapshot !== "object") return void 0;
+  const status = snapshot.status;
+  return typeof status === "string" ? status : void 0;
+};
+var autoTrigger = (module, config) => module.logic(($) => {
+  const pending = /* @__PURE__ */ new Map();
+  const lastKeyHash = /* @__PURE__ */ new Map();
+  const hydrateFromFreshCache = (name, q, keyHash) => Effect.gen(function* () {
+    const engineOpt = yield* Effect.serviceOption(Engine);
+    if (engineOpt._tag === "None") return false;
+    const engine = engineOpt.value;
+    if (!engine.peekFresh) return false;
+    const dataOpt = yield* engine.peekFresh({
+      resourceId: q.resource.id,
+      keyHash
+    });
+    if (dataOpt._tag === "None") return false;
+    const snapshot = Logix.Resource.Snapshot.success({
+      keyHash,
+      data: dataOpt.value
+    });
+    yield* $.state.mutate((draft) => {
+      ;
+      draft.queries[name] = snapshot;
+    });
+    return true;
+  });
+  const cancelPending = (name) => Effect.gen(function* () {
+    const prev = pending.get(name);
+    if (!prev) return;
+    pending.delete(name);
+    yield* Fiber.interruptFork(prev);
+  });
+  const sourcePathOf = (name) => `queries.${name}`;
+  const refresh = (name, options) => $.traits.source.refresh(sourcePathOf(name), options);
+  const scheduleDebounced = (name, ms) => Effect.gen(function* () {
+    yield* cancelPending(name);
+    const fiber = yield* Effect.forkScoped(
+      Effect.sleep(Duration.millis(ms)).pipe(
+        Effect.zipRight(refresh(name)),
+        Effect.ensuring(Effect.sync(() => pending.delete(name))),
+        Effect.catchAllCause(() => Effect.void)
+      )
+    );
+    pending.set(name, fiber);
+  });
+  const computeKeyHash = (state, q) => {
+    const getAtPath = (root, path) => {
+      const parts = path.split(".");
+      let cur = root;
+      for (const p of parts) {
+        if (cur == null) return void 0;
+        cur = cur[p];
+      }
+      return cur;
+    };
+    try {
+      const keyState = { params: state.params, ui: state.ui };
+      const args = q.deps.map((dep) => getAtPath(keyState, dep));
+      const key = q.key(...args);
+      if (key === void 0) return void 0;
+      return Logix.Resource.keyHash(key);
+    } catch {
+      return void 0;
+    }
+  };
+  const maybeAutoRefresh = (phase, stateOverride) => Effect.gen(function* () {
+    const state = stateOverride ?? (yield* $.state.read);
+    for (const [name, q] of Object.entries(config.queries)) {
+      const queryName = name;
+      const triggers = getTriggers(q.triggers);
+      if (isManualOnly(triggers)) {
+        continue;
+      }
+      if (phase === "mount" && !triggers.includes("onMount")) {
+        continue;
+      }
+      if (phase === "keyChange" && !triggers.includes("onKeyChange")) {
+        continue;
+      }
+      const keyHash = computeKeyHash(state, q);
+      const snapshot = state?.queries?.[queryName];
+      const snapshotKeyHash = getSnapshotKeyHash(snapshot);
+      const snapshotStatus = getSnapshotStatus(snapshot);
+      if (keyHash === void 0) {
+        lastKeyHash.set(queryName, void 0);
+        continue;
+      }
+      const last = lastKeyHash.get(queryName);
+      if (snapshotStatus && snapshotStatus !== "idle" && snapshotKeyHash === keyHash && last === keyHash) {
+        continue;
+      }
+      if (snapshotStatus && snapshotStatus !== "idle" && snapshotKeyHash === keyHash) {
+        lastKeyHash.set(queryName, keyHash);
+        continue;
+      }
+      lastKeyHash.set(queryName, keyHash);
+      const hydrated = yield* hydrateFromFreshCache(queryName, q, keyHash);
+      if (hydrated) {
+        yield* cancelPending(queryName);
+        continue;
+      }
+      const debounceMs = q.debounceMs ?? 0;
+      if (phase === "keyChange" && debounceMs > 0) {
+        yield* scheduleDebounced(queryName, debounceMs);
+      } else {
+        yield* cancelPending(queryName);
+        yield* refresh(queryName);
+      }
+    }
+  });
+  const refreshAll = (options) => Effect.forEach(
+    Object.keys(config.queries),
+    (name) => cancelPending(name).pipe(Effect.zipRight(refresh(name, options)))
+  ).pipe(Effect.asVoid);
+  const setup = $.lifecycle.onStart(maybeAutoRefresh("mount"));
+  const run = Effect.suspend(
+    () => Effect.all(
+      [
+        // params/ui changes: handled by Query's default logic, avoiding scattered UI-side useEffect triggers.
+        $.onAction("setParams").runFork(
+          (action) => Effect.gen(function* () {
+            const state = yield* $.state.read;
+            const next = { ...state, params: action.payload };
+            yield* maybeAutoRefresh("keyChange", next);
+          })
+        ),
+        $.onAction("setUi").runFork(
+          (action) => Effect.gen(function* () {
+            const state = yield* $.state.read;
+            const next = { ...state, ui: action.payload };
+            yield* maybeAutoRefresh("keyChange", next);
+          })
+        ),
+        // Manual refresh: not restricted by triggers (manual-only still allows explicit refresh).
+        $.onAction("refresh").runFork(
+          (action) => Effect.gen(function* () {
+            const target = action.payload;
+            if (typeof target === "string" && target.length > 0) {
+              yield* cancelPending(target);
+              yield* refresh(target, { force: true });
+            } else {
+              yield* refreshAll({ force: true });
+            }
+          })
+        )
+      ],
+      { concurrency: "unbounded" }
+    ).pipe(Effect.asVoid)
+  );
+  return { setup, run };
+});
+
+// src/internal/logics/invalidate.ts
+import * as Logix2 from "@logixjs/core";
+import { Effect as Effect2 } from "effect";
+var toInvalidateTargets = (request, queries) => {
+  if (request.kind === "byResource") {
+    return Object.entries(queries).filter(([, q]) => q.resource.id === request.resourceId).map(([name, q]) => ({ name, resourceId: q.resource.id }));
+  }
+  if (request.kind === "byParams") {
+    return Object.entries(queries).filter(([, q]) => q.resource.id === request.resourceId).map(([name, q]) => ({ name, resourceId: q.resource.id }));
+  }
+  const entries = Object.entries(queries);
+  const tagged = entries.filter(([, q]) => Array.isArray(q.tags) && q.tags.includes(request.tag));
+  const selected = tagged.length > 0 ? tagged : entries;
+  return selected.map(([name, q]) => ({ name, resourceId: q.resource.id }));
+};
+var invalidate = (module, config) => module.logic(
+  ($) => Effect2.gen(function* () {
+    yield* $.onAction("invalidate").runFork(
+      (action) => Effect2.gen(function* () {
+        const request = action.payload;
+        yield* Logix2.TraitLifecycle.scopedExecute($, {
+          kind: "query:invalidate",
+          request
+        });
+        const engineOpt = yield* Effect2.serviceOption(Engine);
+        if (engineOpt._tag !== "None") {
+          yield* engineOpt.value.invalidate(request);
+        }
+        const targets = toInvalidateTargets(request, config.queries);
+        const sourcePathOf = (name) => `queries.${name}`;
+        yield* Effect2.forEach(
+          targets,
+          (t) => $.traits.source.refresh(sourcePathOf(t.name), { force: true })
+        ).pipe(Effect2.asVoid);
+      })
+    );
+  })
+);
+
+// src/Query.ts
+var InvalidateRequestSchema = Schema.Union(
+  Schema.Struct({
+    kind: Schema.Literal("byResource"),
+    resourceId: Schema.String
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("byParams"),
+    resourceId: Schema.String,
+    keyHash: Schema.String
+  }),
+  Schema.Struct({
+    kind: Schema.Literal("byTag"),
+    tag: Schema.String
+  })
+);
+var assertQueryName = (name) => {
+  if (!name) {
+    throw new Error(`[Query.make] query name must be non-empty`);
+  }
+  if (name.includes(".")) {
+    throw new Error(`[Query.make] query name must not include "."; got "${name}"`);
+  }
+  if (name === "params" || name === "ui" || name === "queries") {
+    throw new Error(`[Query.make] query name "${name}" is reserved`);
+  }
+};
+var make = (id, config) => {
+  const queryBuilder = {
+    source: (q) => q
+  };
+  const queries = (() => {
+    const raw = config.queries;
+    if (!raw) return {};
+    return raw(queryBuilder);
+  })();
+  const queriesForTraits = queries;
+  for (const name of Object.keys(queries)) {
+    assertQueryName(name);
+  }
+  const RefreshTargetSchema = (() => {
+    const names = Object.keys(queries);
+    if (names.length === 0) return Schema.Never;
+    if (names.length === 1) {
+      return Schema.Literal(names[0]);
+    }
+    const asUnionMembers = (items) => {
+      if (items.length < 2) {
+        throw new Error(`[Query.make] internal error: expected at least 2 query names for union`);
+      }
+      return items;
+    };
+    const members = names.map((n) => Schema.Literal(n));
+    return Schema.Union(...asUnionMembers(members));
+  })();
+  const UiSchema = Schema.Unknown;
+  const QueriesSchema = Schema.Struct(
+    Object.fromEntries(Object.keys(queries).map((k) => [k, Schema.Unknown]))
+  );
+  const StateSchema = Schema.Struct({
+    params: config.params,
+    ui: UiSchema,
+    queries: QueriesSchema
+  });
+  const Actions = {
+    setParams: config.params,
+    setUi: UiSchema,
+    refresh: Schema.UndefinedOr(RefreshTargetSchema),
+    invalidate: InvalidateRequestSchema
+  };
+  const reducers = {
+    setParams: (state, action, sink) => {
+      sink?.("params");
+      return { ...state, params: action.payload ?? state.params };
+    },
+    setUi: (state, action, sink) => {
+      sink?.("ui");
+      return { ...state, ui: action.payload ?? state.ui };
+    },
+    refresh: (state) => state,
+    invalidate: (state) => state
+  };
+  const queryTraits = Object.keys(queriesForTraits).length > 0 ? toStateTraitSpec({ queries: queriesForTraits }) : void 0;
+  const traits = queryTraits || config.traits ? {
+    ...queryTraits,
+    ...config.traits
+  } : void 0;
+  const module = Logix3.Module.make(id, {
+    state: StateSchema,
+    actions: Actions,
+    reducers,
+    traits
+  });
+  const logics = [
+    autoTrigger(module.tag, { queries: queriesForTraits }),
+    invalidate(module.tag, { queries: queriesForTraits })
+  ];
+  const initial = (params) => ({
+    params: params ?? config.initialParams,
+    ui: config.ui ?? {},
+    queries: Object.fromEntries(
+      Object.keys(queries).map((k) => [k, Logix3.Resource.Snapshot.idle()])
+    )
+  });
+  const controller = {
+    make: (runtime) => {
+      const dispatch = runtime.dispatch;
+      const actions = module.actions;
+      return {
+        runtime,
+        getState: runtime.getState,
+        dispatch,
+        controller: {
+          setParams: (params) => dispatch(actions.setParams(params)),
+          setUi: (ui) => dispatch(actions.setUi(ui)),
+          refresh: (target) => dispatch(actions.refresh(target)),
+          invalidate: (request) => dispatch(actions.invalidate(request))
+        }
+      };
+    }
+  };
+  module.controller = controller;
+  const EXTEND_HANDLE = /* @__PURE__ */ Symbol.for("logix.module.handle.extend");
+  module.tag[EXTEND_HANDLE] = (runtime, base) => {
+    const c = controller.make(runtime);
+    return {
+      ...base,
+      controller: c.controller
+    };
+  };
+  return module.implement({
+    initial: initial(),
+    logics: [...logics]
+  });
+};
+
+export {
+  make
+};
+//# sourceMappingURL=chunk-NXFX6RIH.js.map