effectweb 0.2.3 → 0.3.1

package/dist/pages.js

@@ -1,14 +1,18 @@
-import { shareValue } from './share.js';
+import { commandSlot } from './program.js';
+import { shareData } from './sharing.js';
 import { Cause, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
-import { effectCommand, program } from './program.js';
+import { effectCommand, program, } from './program.js';
+import { defaultUiRuntime } from './runtime.js';
 import { available } from './resource.js';
 /**
  * Pagination owns the `page` command slot. Key changes clear results and replace the request;
  * same-key refreshes keep the last success, and retries repeat the failed cursor.
  * Feed request inputs through receive; pass { refresh: true } for explicit same-key submissions.
  */
-export function pages(definition) {
+export function pages(definition, ...provided) {
+    const runtime = provided[0] ?? defaultUiRuntime;
+    const commandPage = commandSlot('page');
     const request = (model, append) => {
         const previous = available(model.result);
         if (append && (model.result.waiting || !previous || previous.next === undefined))
@@ -19,24 +23,27 @@ export function pages(definition) {
         return {
             model: { ...model, append, result: AsyncResult.waiting(model.result) },
             commands: [
-                effectCommand('page', () => definition.load(model.props, cursor), {
+                runtime.command(effectCommand(commandPage, () => definition.load(model.props, cursor), {
+                    policy: 'replace',
                     onSuccess: (page) => ({ type: 'Loaded', page, append }),
                     onFailure: (cause) => ({ type: 'Failed', cause }),
-                }),
+                })),
             ],
         };
     };
     const pagination = {
         init: (props) => ({
-            props,
+            props: props,
             key: undefined,
             result: AsyncResult.initial(),
             append: false,
         }),
-        receive(model, props, options = {}) {
+        receive(snapshot, input, options = {}) {
+            const model = snapshot;
+            const props = input;
             const key = definition.key(props);
             if (key === model.key) {
-                const shared = shareValue(model.props, props);
+                const shared = shareData(model.props, props);
                 const next = shared === model.props ? model : { ...model, props: shared };
                 return options.refresh ? request(next, false) : { model: next };
             }
@@ -47,9 +54,10 @@ export function pages(definition) {
                 append: false,
                 result: AsyncResult.initial(),
             };
-            return key === undefined ? { model: next, cancel: ['page'] } : request(next, false);
+            return key === undefined ? { model: next, cancel: [commandPage] } : request(next, false);
         },
-        update(model, message) {
+        update(snapshot, message) {
+            const model = snapshot;
             switch (message.type) {
                 case 'More':
                     return request(model, true);
@@ -68,7 +76,7 @@ export function pages(definition) {
                     };
                 case 'Loaded': {
                     const previous = message.append ? available(model.result) : undefined;
-                    const known = new Set(previous?.items.map(definition.itemKey));
+                    const known = new Set(previous?.items.map((item) => definition.itemKey(item)));
                     const incoming = message.page.items.filter((item) => {
                         const key = definition.itemKey(item);
                         if (known.has(key))

package/dist/program.d.ts

@@ -1,9 +1,20 @@
 import { type Snapshot } from './snapshot.js';
 import { Cause, Effect, Stream } from 'effect';
 export type Send<Message> = (message: Message) => void;
+/** queue retains FIFO requests; latest-queued retains only the newest pending request. */
+export type TaskPolicy = 'replace' | 'drop' | 'parallel' | 'queue' | 'latest-queued';
+declare const slotType: unique symbol;
+/** Stable operation identity. Equal diagnostic names never share cancellation. */
+export type CommandSlot = symbol & {
+    readonly [slotType]: true;
+};
+export declare const commandSlot: (name: string) => CommandSlot;
 /** A slot owns either one completion or a stream of progress/events, canceled together. */
 export type Command<Message, R = never> = {
-    readonly slot: string;
+    readonly slot: CommandSlot;
+    readonly policy: TaskPolicy;
+    /** Notification for work that never started. */
+    readonly onDiscard?: (reason: 'Cancelled' | 'Superseded' | 'Dropped') => void;
 } & ({
     readonly effect: Effect.Effect<Message, never, R>;
     readonly stream?: never;
@@ -18,32 +29,41 @@ export type Command<Message, R = never> = {
     readonly stream?: never;
 });
 /** A lazy request settles successes, typed failures and defects through one message contract. */
-export declare function effectCommand<A, E, Success, Failure, R = never>(slot: string, load: () => Effect.Effect<A, E, R>, handlers: {
+export declare function effectCommand<A, E, Success, Failure, R = never>(slot: CommandSlot, load: () => Effect.Effect<A, E, R>, handlers: {
+    readonly policy: TaskPolicy;
     readonly onSuccess: (value: A) => Success;
     readonly onFailure: (cause: Cause.Cause<E>) => Failure;
 }): Command<Success | Failure, R>;
 /** Owned work with no model result. Failures use the program's error reporter. */
-export declare function actionCommand<R = never>(slot: string, action: () => Effect.Effect<unknown, unknown, R>): Command<never, R>;
+export declare function actionCommand<R = never>(slot: CommandSlot, action: () => Effect.Effect<unknown, unknown, R>, policy: TaskPolicy): Command<never, R>;
 export declare function mapCommand<A, B, R = never>(command: Command<A, R>, map: (message: A) => B): Command<B, R>;
 export interface Transition<Model, Message, R = never> {
-    readonly model: Model;
+    readonly model: Model | Snapshot<Model>;
     readonly commands?: readonly Command<Message, R>[];
-    readonly cancel?: readonly string[];
+    readonly cancel?: readonly CommandSlot[];
 }
+export declare function mapTransition<Model, Message, Parent, ParentMessage, R = never>(transition: Transition<Model, Message, R>, maps: {
+    readonly model: (model: Snapshot<Model>) => Parent | Snapshot<Parent>;
+    readonly message: (message: Message) => ParentMessage;
+}): Transition<Parent, ParentMessage, R>;
 export interface Program<Model, Message> {
     readonly model: () => Snapshot<Model>;
     readonly send: Send<Message>;
     readonly subscribe: (listener: (model: Snapshot<Model>) => void) => () => void;
     readonly dispose: () => void;
+    readonly close?: () => Promise<void>;
 }
 export interface RunningProgram<Model, Message> extends Program<Model, Message> {
-    readonly activeSlots: () => readonly string[];
-    readonly awaitIdle: (slot?: string) => Promise<void>;
+    /** Wait for interrupted work and its finalizers as well as admitted work. */
+    readonly awaitStopped: () => Promise<void>;
+    readonly close: () => Promise<void>;
+    readonly activeSlots: () => readonly CommandSlot[];
+    readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
 }
 export declare function program<Model, Message>(options: {
-    initial: Model;
+    initial: Model | Snapshot<Model>;
     name?: string;
-    checkSnapshots?: boolean;
     update: (model: Snapshot<Model>, message: Message) => Transition<Model, Message>;
     onDefect?: (cause: unknown) => void;
 }): RunningProgram<Model, Message>;
+export {};

package/dist/program.js

@@ -1,31 +1,45 @@
-import { protectSnapshot, checkSnapshotsByDefault } from './snapshot.js';
+import { protectSnapshot } from './snapshot.js';
 import { reportError, reportSafely } from './errors.js';
 import { traceProgram, nextProgramId, hasProgramObservers } from './diagnostics.js';
 import { Cause, Effect, Fiber, Option, Stream } from 'effect';
+export const commandSlot = (name) => Symbol(name);
+const taskPolicies = ['replace', 'drop', 'parallel', 'queue', 'latest-queued'];
 /** A lazy request settles successes, typed failures and defects through one message contract. */
 export function effectCommand(slot, load, handlers) {
-    return { slot, effect: Effect.suspend(load).pipe(Effect.matchCause(handlers)) };
+    return {
+        slot,
+        policy: handlers.policy,
+        effect: Effect.suspend(load).pipe(Effect.matchCause(handlers)),
+    };
 }
 /** Owned work with no model result. Failures use the program's error reporter. */
-export function actionCommand(slot, action) {
-    return { slot, action: Effect.suspend(action).pipe(Effect.asVoid) };
+export function actionCommand(slot, action, policy) {
+    return { slot, policy, action: Effect.suspend(action).pipe(Effect.asVoid) };
 }
 export function mapCommand(command, map) {
     if (command.action)
-        return { slot: command.slot, action: command.action };
+        return { ...command, action: command.action };
     return command.stream
-        ? { slot: command.slot, stream: command.stream.pipe(Stream.map(map)) }
-        : { slot: command.slot, effect: command.effect.pipe(Effect.map(map)) };
+        ? { ...command, stream: command.stream.pipe(Stream.map(map)) }
+        : { ...command, effect: command.effect.pipe(Effect.map(map)) };
+}
+export function mapTransition(transition, maps) {
+    return {
+        model: maps.model(transition.model),
+        ...(transition.cancel ? { cancel: transition.cancel } : {}),
+        ...(transition.commands
+            ? { commands: transition.commands.map((command) => mapCommand(command, maps.message)) }
+            : {}),
+    };
 }
 export function program(options) {
-    const checkSnapshots = options.checkSnapshots ?? checkSnapshotsByDefault;
     const id = nextProgramId();
     const trace = (kind, slot, message) => hasProgramObservers() &&
         traceProgram({
             program: id,
             ...(options.name ? { name: options.name } : {}),
             kind,
-            ...(slot ? { slot } : {}),
+            ...(slot ? { slot: slot.description ?? 'command' } : {}),
             ...(message &&
                 typeof message === 'object' &&
                 'type' in message &&
@@ -35,6 +49,7 @@ export function program(options) {
         });
     const waiters = new Set();
     const notify = () => {
+        notifyStopped();
         for (const waiter of waiters) {
             if (disposed ||
                 (!draining && (waiter.slot ? !running.has(waiter.slot) : running.size === 0))) {
@@ -45,79 +60,199 @@ export function program(options) {
     };
     // A program publishes one immutable value. It needs no reactive dependency graph;
     // Effect still owns all command fibers, streams, and cancellation below.
-    let current = protectSnapshot(options.initial, checkSnapshots);
+    let current = protectSnapshot(options.initial);
     const listeners = new Set();
     const running = new Map();
+    const live = new Set();
+    const stopped = new Set();
+    const notifyStopped = () => {
+        if (live.size || running.size || draining)
+            return;
+        for (const done of stopped)
+            done();
+        stopped.clear();
+    };
+    const awaitStopped = () => live.size === 0 && running.size === 0 && !draining
+        ? Promise.resolve()
+        : new Promise((done) => stopped.add(done));
     let disposed = false;
     let draining = false;
     const queue = [];
-    const cancel = (slot) => {
+    const deferred = [];
+    const discard = (command, reason) => {
+        if (command.onDiscard) {
+            try {
+                command.onDiscard(reason);
+            }
+            catch (error) {
+                reportSafely(options.onDefect ?? reportError, error);
+            }
+        }
+    };
+    const cancel = (slot, reason = 'Cancelled') => {
+        // A synchronous Effect can enqueue completion behind a reset/replacement message.
+        // Its fiber is already done, but cancellation still owns that unpublished completion.
+        for (let index = queue.length - 1; index >= 0; index--)
+            if (queue[index].slot === slot)
+                queue.splice(index, 1);
         const previous = running.get(slot);
         running.delete(slot);
-        if (previous)
+        if (previous) {
             trace('cancel', slot);
-        if (previous?.fiber)
-            Effect.runFork(Fiber.interrupt(previous.fiber));
+            const pending = previous.pending.splice(0);
+            for (const command of pending)
+                discard(command, reason);
+            for (const task of previous.active) {
+                if (task.fiber)
+                    Effect.runFork(Fiber.interrupt(task.fiber));
+                else if (task.command && !live.has(task))
+                    discard(task.command, reason);
+            }
+            previous.active.clear();
+        }
+    };
+    const ready = [];
+    let launching = false;
+    const launch = (command, group, task) => {
+        ready.push({ command, group, task });
+        if (launching)
+            return;
+        launching = true;
+        try {
+            while (ready.length) {
+                const next = ready.shift();
+                start(next.command, next.group, next.task);
+            }
+        }
+        finally {
+            launching = false;
+        }
     };
-    const send = (message) => {
+    const start = (command, group, task) => {
+        const valid = () => !disposed && running.get(command.slot) === group && group.active.has(task);
+        if (!valid())
+            return;
+        trace('start', command.slot);
+        const effect = command.stream
+            ? command.stream.pipe(Stream.runForEach((message) => Effect.sync(() => {
+                if (valid())
+                    enqueue(message, command.slot);
+            })), Effect.as(Option.none()))
+            : command.action
+                ? command.action.pipe(Effect.as(Option.none()))
+                : command.effect.pipe(Effect.map(Option.some));
+        live.add(task);
+        const fiber = Effect.runFork(effect);
+        task.fiber = fiber;
+        fiber.addObserver((exit) => {
+            live.delete(task);
+            notifyStopped();
+            if (!valid())
+                return;
+            group.active.delete(task);
+            if (!group.active.size && !group.pending.length)
+                running.delete(command.slot);
+            trace(exit._tag === 'Success' ? 'complete' : 'defect', command.slot);
+            if (exit._tag === 'Success') {
+                if (Option.isSome(exit.value))
+                    enqueue(exit.value.value, command.slot);
+            }
+            else
+                reportSafely(options.onDefect ?? reportError, exit.cause);
+            if (!disposed && running.get(command.slot) === group && !group.active.size) {
+                // Process earlier reducer messages and completion subscribers before choosing the
+                // next write, so cancellation and latest-queued still apply to all pending work.
+                if (draining)
+                    deferred.push({ slot: command.slot, group });
+                else
+                    advance(command.slot, group);
+            }
+            notify();
+        });
+        if (!valid())
+            Effect.runFork(Fiber.interrupt(fiber));
+    };
+    const advance = (slot, group) => {
+        if (disposed || running.get(slot) !== group || group.active.size)
+            return;
+        const next = group.pending.shift();
+        if (!next)
+            return;
+        const task = { command: next };
+        group.active.add(task);
+        launch(next, group, task);
+    };
+    const enqueue = (message, slot) => {
         if (disposed)
             return;
-        queue.push(message);
+        queue.push(slot === undefined ? { message } : { message, slot });
         if (draining)
             return;
         draining = true;
         try {
-            while (queue.length && !disposed) {
-                const message = queue.shift();
+            while ((queue.length || deferred.length) && !disposed) {
+                if (!queue.length) {
+                    const next = deferred.shift();
+                    advance(next.slot, next.group);
+                    continue;
+                }
+                const { message } = queue.shift();
                 const transition = options.update(current, message);
+                for (const command of transition.commands ?? []) {
+                    if (typeof command.slot !== 'symbol' || !taskPolicies.includes(command.policy))
+                        throw new TypeError('Commands require a commandSlot() token and an explicit concurrency policy.');
+                }
                 trace('update', undefined, message);
                 for (const slot of transition.cancel ?? [])
                     cancel(slot);
-                const next = protectSnapshot(transition.model, checkSnapshots);
+                const next = protectSnapshot(transition.model);
                 if (!Object.is(current, next)) {
                     current = next;
                     for (const listener of listeners)
                         listener(current);
                 }
+                const starts = [];
+                // Admit the entire transition before launching Effects, so a later replacement can
+                // supersede earlier work in the same transaction without executing it.
                 for (const command of transition.commands ?? []) {
                     if (disposed)
                         break;
-                    cancel(command.slot);
-                    const token = {};
-                    const runningCommand = { token };
-                    running.set(command.slot, runningCommand);
-                    trace('start', command.slot);
-                    const effect = command.stream
-                        ? command.stream.pipe(Stream.runForEach((message) => Effect.sync(() => {
-                            if (!disposed && running.get(command.slot)?.token === token)
-                                send(message);
-                        })), Effect.as(Option.none()))
-                        : command.action
-                            ? command.action.pipe(Effect.as(Option.none()))
-                            : command.effect.pipe(Effect.map(Option.some));
-                    const fiber = Effect.runFork(effect);
-                    runningCommand.fiber = fiber;
-                    if (disposed) {
-                        Effect.runFork(Fiber.interrupt(fiber));
-                        break;
+                    const policy = command.policy;
+                    let group = running.get(command.slot);
+                    if (policy === 'drop' && group) {
+                        discard(command, 'Dropped');
+                        continue;
+                    }
+                    if (policy === 'replace') {
+                        cancel(command.slot, 'Superseded');
+                        group = undefined;
+                    }
+                    if (group && (policy === 'queue' || policy === 'latest-queued')) {
+                        if (policy === 'latest-queued')
+                            for (const pending of group.pending.splice(0))
+                                discard(pending, 'Superseded');
+                        group.pending.push(command);
+                        continue;
                     }
-                    fiber.addObserver((exit) => {
-                        if (disposed || running.get(command.slot)?.token !== token)
-                            return;
-                        running.delete(command.slot);
-                        trace(exit._tag === 'Success' ? 'complete' : 'defect', command.slot);
-                        if (exit._tag === 'Success') {
-                            if (Option.isSome(exit.value))
-                                send(exit.value.value);
-                        }
-                        else
-                            reportSafely(options.onDefect ?? reportError, exit.cause);
-                        notify();
-                    });
+                    if (!group) {
+                        group = { active: new Set(), pending: [] };
+                        running.set(command.slot, group);
+                    }
+                    const task = { command };
+                    group.active.add(task);
+                    const admitted = group;
+                    starts.push(() => launch(command, admitted, task));
                 }
+                for (const launch of starts)
+                    launch();
             }
         }
         catch (error) {
+            // A failed reducer must not leave deferred work keeping awaitIdle pending.
+            for (const { slot, group } of deferred)
+                if (running.get(slot) === group)
+                    cancel(slot);
+            deferred.length = 0;
             queue.length = 0;
             throw error;
         }
@@ -126,7 +261,25 @@ export function program(options) {
             notify();
         }
     };
+    const send = (message) => enqueue(message);
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        queue.length = 0;
+        deferred.length = 0;
+        for (const slot of running.keys())
+            cancel(slot);
+        listeners.clear();
+        trace('dispose');
+        notify();
+    };
     return {
+        awaitStopped,
+        close: () => {
+            dispose();
+            return awaitStopped();
+        },
         model: () => current,
         activeSlots: () => [...running.keys()],
         awaitIdle: (slot) => disposed || (!draining && (slot ? !running.has(slot) : running.size === 0))
@@ -151,16 +304,6 @@ export function program(options) {
                 listeners.delete(receive);
             };
         },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            queue.length = 0;
-            for (const slot of running.keys())
-                cancel(slot);
-            listeners.clear();
-            trace('dispose');
-            notify();
-        },
+        dispose,
     };
 }

package/dist/query-internals.d.ts

@@ -0,0 +1,13 @@
+import type { Effect } from 'effect';
+import type { Snapshot } from './snapshot.js';
+import type { Query, QueryGroup } from './query.js';
+export interface QueryDefinition<Args, A, E, R> {
+    readonly name: string;
+    readonly load: (args: Snapshot<Args>, previous?: Snapshot<A>) => Effect.Effect<A, E, R>;
+    readonly groups?: readonly QueryGroup[];
+    readonly unused?: 'retain' | 'cancel';
+    readonly staleTime: number;
+    readonly share?: (previous: Snapshot<A>, next: A | Snapshot<A>) => A | Snapshot<A>;
+}
+export declare function registerQuery<Args, A, E, R>(query: Query<Args, A, E, R>, definition: QueryDefinition<Args, A, E, R>): void;
+export declare function queryDefinition<Args, A, E, R>(query: Query<Args, A, E, R>): QueryDefinition<Args, A, E, R>;

package/dist/query-internals.js

@@ -0,0 +1,10 @@
+const definitions = new WeakMap();
+export function registerQuery(query, definition) {
+    definitions.set(query, definition);
+}
+export function queryDefinition(query) {
+    const definition = definitions.get(query);
+    if (!definition)
+        throw new TypeError('Use query() to create a query definition.');
+    return definition;
+}

package/dist/query.d.ts

@@ -1,25 +1,36 @@
 import type { Effect } from 'effect';
+import { type QueryDefinition } from './query-internals.js';
+/** Canonical data identity: plain objects, dense arrays, and finite scalar values. */
+export type QueryKey = string | number | boolean | null | undefined | readonly QueryKey[] | {
+    readonly [key: string]: QueryKey;
+};
+/** Shared by cache lookup and resource reconciliation. Object property order is irrelevant. */
+export declare function encodeQueryKey(key: QueryKey): string;
+/** Data-only request arguments. Services belong in the Effect environment. */
+export type QueryArgs<A> = A extends string | number | boolean | null | undefined ? A : A extends (...args: never[]) => unknown ? never : A extends object ? {
+    readonly [K in keyof A]: K extends symbol ? never : QueryArgs<A[K]>;
+} : never;
+declare const queryType: unique symbol;
+/** An opaque typed definition. Every request argument participates in cache identity. */
 export interface Query<Args, A, E = never, R = never> {
-    readonly id: number;
     readonly name: string;
-    readonly key: (args: Args) => string;
-    readonly load: (args: Args) => Effect.Effect<A, E, R>;
-    /** Revalidate on activation/prefetch after this many milliseconds. No polling timer. */
-    readonly staleTime: number;
-    /** Reuse unchanged domain entities before publishing a refreshed result. */
-    readonly share?: (previous: A, next: A) => A;
+    readonly [queryType]: (args: Args) => Effect.Effect<A, E, R>;
 }
-/** Identity belongs to arguments, never callback identity. Separate caches isolate independent data scopes. */
-export declare function query<A, E = never, R = never>(definition: {
-    readonly name: string;
-    readonly load: () => Effect.Effect<A, E, R>;
+type Definition<Args, A, E, R> = Omit<QueryDefinition<Args, A, E, R>, 'staleTime'> & {
     readonly staleTime?: number;
-    readonly share?: (previous: A, next: A) => A;
+    /** Custom projections can silently reuse a different request's result. */
+    readonly key?: never;
+};
+export declare function query<Args, A, E = never, R = never>(definition: Definition<Args, A, E, R> & (Args extends QueryArgs<Args> ? unknown : {
+    readonly nonSerializableQueryArguments: never;
+})): Query<Args, A, E, R>;
+export declare function query<A, E = never, R = never>(definition: Definition<true, A, E, R> & {
+    readonly load: () => Effect.Effect<A, E, R>;
 }): Query<true, A, E, R>;
-export declare function query<Args, A, E = never, R = never>(definition: {
-    readonly name: string;
-    readonly key: (args: Args) => string;
-    readonly load: (args: Args) => Effect.Effect<A, E, R>;
-    readonly staleTime?: number;
-    readonly share?: (previous: A, next: A) => A;
-}): Query<Args, A, E, R>;
+declare const groupType: unique symbol;
+export type QueryGroup = symbol & {
+    readonly [groupType]: true;
+};
+/** Invalidation identity; equal diagnostic names do not share membership. */
+export declare const queryGroup: (name: string) => QueryGroup;
+export {};

package/dist/query.js

@@ -1,12 +1,71 @@
-let nextQueryId = 0;
+import { registerQuery } from './query-internals.js';
+/** Shared by cache lookup and resource reconciliation. Object property order is irrelevant. */
+export function encodeQueryKey(key) {
+    const ancestors = new Set();
+    const encode = (value) => {
+        if (value === undefined)
+            return 'u';
+        if (value === null)
+            return 'n';
+        if (typeof value === 'string')
+            return `s${JSON.stringify(value)}`;
+        if (typeof value === 'boolean')
+            return value ? 'b1' : 'b0';
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new TypeError('Query keys require finite numbers.');
+            return Object.is(value, -0) ? 'd-0' : `d${value}`;
+        }
+        if (typeof value !== 'object')
+            throw new TypeError('Unsupported query key value.');
+        if (ancestors.has(value))
+            throw new TypeError('Query keys cannot contain cycles.');
+        const prototype = Object.getPrototypeOf(value);
+        if (Array.isArray(value)
+            ? prototype !== Array.prototype
+            : prototype !== Object.prototype && prototype !== null)
+            throw new TypeError('Query keys require plain objects and arrays.');
+        ancestors.add(value);
+        try {
+            const descriptors = Object.getOwnPropertyDescriptors(value);
+            if (Reflect.ownKeys(value).some((key) => typeof key === 'symbol'))
+                throw new TypeError('Query keys cannot contain symbol properties.');
+            for (const [name, descriptor] of Object.entries(descriptors)) {
+                if (Array.isArray(value) && name === 'length')
+                    continue;
+                if (!descriptor.enumerable || !('value' in descriptor))
+                    throw new TypeError('Query keys require enumerable data properties.');
+            }
+            if (Array.isArray(value)) {
+                if (Object.keys(value).length !== value.length ||
+                    Object.keys(value).some((key, index) => key !== String(index)))
+                    throw new TypeError('Query keys require dense arrays without extra properties.');
+                return `a[${value.map(encode).join(',')}]`;
+            }
+            return `o{${Object.keys(value)
+                .sort()
+                .map((key) => `${JSON.stringify(key)}:${encode(descriptors[key].value)}`)
+                .join(',')}}`;
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    };
+    return encode(key);
+}
 export function query(definition) {
+    if ('key' in definition)
+        throw new TypeError('Query identity includes all arguments. Remove key and provide services through the Effect environment.');
     const staleTime = definition.staleTime ?? Infinity;
     if (Number.isNaN(staleTime) || staleTime < 0)
         throw new RangeError('Query staleTime must be nonnegative.');
-    return Object.freeze({
+    const result = Object.freeze({ name: definition.name });
+    registerQuery(result, Object.freeze({
         ...definition,
-        key: definition.key ?? (() => ''),
-        id: ++nextQueryId,
+        ...(definition.groups ? { groups: Object.freeze([...definition.groups]) } : {}),
         staleTime,
-    });
+    }));
+    return result;
 }
+/** Invalidation identity; equal diagnostic names do not share membership. */
+export const queryGroup = (name) => Symbol(name);