@shivaedev/contract 0.18.0 → 0.19.1

package/dist/serverMetadata.js

@@ -1,27 +1,34 @@
-import { Context, Schema } from "effect";
+import { Context, Effect, Option, Schema } from "effect";
 import { Rpc } from "effect/rpc";
 import { LiveHint } from "#live.ts";
-export class QueryReads extends Context.Service()("@shivaedev/contract/QueryReads") {
+import { MissingReadPolicy, QueryReadDenied } from "#readPolicyErrors.ts";
+export class QueryDefinition extends Context.Service()("@shivaedev/contract/QueryDefinition") {
+}
+export class ChangesQueries extends Context.Service()("@shivaedev/contract/ChangesQueries") {
 }
 export class CommandInvalidation extends Context.Service()("@shivaedev/contract/CommandInvalidation") {
 }
 export class KeyScope extends Context.Service()("@shivaedev/contract/KeyScope") {
 }
-export class ChangesReads extends Context.Service()("@shivaedev/contract/ChangesReads") {
-}
-export function queryKeys(queries, requested) {
-    return requested.flatMap((reference) => {
-        const declared = queries.find((candidate) => candidate.name === reference.query);
-        if (declared === undefined) {
-            throw new Error(`Unknown query: ${reference.query}`);
-        }
-        return declared.reads(reference.payload);
+function resolveQueries(queries, requested) {
+    return Effect.forEach(requested, (reference) => {
+        const query = queries.find((candidate) => candidate.name === reference.query);
+        return query === undefined ? Effect.die(new Error(`Unknown query: ${reference.query}`)) : Effect.succeed({ payload: reference.payload, query });
     });
 }
+export const queryKeys = Effect.fnUntraced(function* (queries, requested, viewer = Option.none()) {
+    const resolved = yield* resolveQueries(queries, requested);
+    return resolved.flatMap(({ query, payload }) => query.reads(payload, viewer));
+});
 function referenceSchemas(queries) {
     return Schema.Array(Schema.Union(queries.map((query) => Schema.Struct({ payload: query.payload, query: Schema.Literal(query.name) }))));
 }
 export function changesRpc(name, queries) {
-    return Rpc.make(`${name}.$changes`, { payload: { queries: referenceSchemas(queries) }, stream: true, success: LiveHint }).annotate(ChangesReads, (requested) => queryKeys(queries, requested));
+    return Rpc.make(`${name}.$changes`, {
+        error: Schema.Union([MissingReadPolicy, QueryReadDenied]),
+        payload: { queries: referenceSchemas(queries) },
+        stream: true,
+        success: LiveHint,
+    }).annotate(ChangesQueries, { resolve: (references) => resolveQueries(queries, references) });
 }
 //# sourceMappingURL=serverMetadata.js.map

package/dist/serverMetadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"serverMetadata.js","sourceRoot":"","sources":["../src/serverMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,MAAM,OAAO,UAAW,SAAQ,OAAO,CAAC,OAAO,EAAmC,CAAC,gCAAgC,CAAC;CAAG;AAEvH,MAAM,OAAO,mBAAoB,SAAQ,OAAO,CAAC,OAAO,EAAoD,CAC3G,yCAAyC,CACzC;CAAG;AAEJ,MAAM,OAAO,QAAS,SAAQ,OAAO,CAAC,OAAO,EAAuB,CAAC,8BAA8B,CAAC;CAAG;AAWvG,MAAM,OAAO,YAAa,SAAQ,OAAO,CAAC,OAAO,EAA2E,CAC3H,kCAAkC,CAClC;CAAG;AAEJ,MAAM,UAAU,SAAS,CAAC,OAA8B,EAAE,SAAoC;IAC7F,OAAO,SAAS,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;QACtC,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,KAAK,CAAC,CAAC;QACjF,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,kBAAkB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;AACJ,CAAC;AAKD,SAAS,gBAAgB,CAAC,OAA8B;IACvD,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AACzI,CAAC;AAED,MAAM,UAAU,UAAU,CAA2E,IAAW,EAAE,OAAiB;IAClI,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,WAAW,EAAE,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,CACjI,YAAY,EACZ,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,CAC5C,CAAC;AACH,CAAC"}
+{"version":3,"file":"serverMetadata.js","sourceRoot":"","sources":["../src/serverMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACzD,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE1E,MAAM,OAAO,eAAgB,SAAQ,OAAO,CAAC,OAAO,EAAwD,CAAC,qCAAqC,CAAC;CAAG;AAKtJ,MAAM,OAAO,cAAe,SAAQ,OAAO,CAAC,OAAO,EAKhD,CAAC,oCAAoC,CAAC;CAAG;AAE5C,MAAM,OAAO,mBAAoB,SAAQ,OAAO,CAAC,OAAO,EAA8E,CACrI,yCAAyC,CACzC;CAAG;AAEJ,MAAM,OAAO,QAAS,SAAQ,OAAO,CAAC,OAAO,EAAuB,CAAC,8BAA8B,CAAC;CAAG;AAWvG,SAAS,cAAc,CAAC,OAA8B,EAAE,SAAoC;IAC3F,OAAO,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,EAAE;QAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,KAAK,CAAC,CAAC;QAC9E,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,kBAAkB,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IACjJ,CAAC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EACnD,OAA8B,EAC9B,SAAoC,EACpC,MAAM,GAA0B,MAAM,CAAC,IAAI,EAAE;IAE7C,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC3D,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;AAC/E,CAAC,CAAC,CAAC;AAKH,SAAS,gBAAgB,CAAC,OAA8B;IACvD,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AACzI,CAAC;AAED,MAAM,UAAU,UAAU,CAA2E,IAAW,EAAE,OAAiB;IAClI,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,WAAW,EAAE;QACnC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC;QACzD,OAAO,EAAE,EAAE,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE;QAC/C,MAAM,EAAE,IAAI;QACZ,OAAO,EAAE,QAAQ;KACjB,CAAC,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,CAAC,UAAU,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC;AAC/F,CAAC"}

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
 import { type Duration, Effect, Stream, SubscriptionRef } from "effect";
-import type { Key } from "./keys.ts";
+import type { Key } from "@shivaedev/changes/keys.ts";
 import type { LiveHint } from "./live.ts";
 export interface HintViewer<E> {
     readonly finished: Effect.Effect<void, E>;
@@ -8,6 +8,11 @@ export interface HintViewer<E> {
 export declare const watchHints: <E, R>(stream: Stream.Stream<{
     readonly _tag: "Changed";
     readonly keys: readonly ({
+        readonly _tag: "Bucket";
+        readonly collection: string;
+        readonly field: string;
+        readonly value: string | number;
+    } | {
         readonly _tag: "List";
         readonly collection: string;
     } | {
@@ -15,6 +20,7 @@ export declare const watchHints: <E, R>(stream: Stream.Stream<{
         readonly collection: string;
         readonly id: string | number;
     })[];
+    readonly queryIndexes?: readonly number[] | undefined;
 } | {
     readonly _tag: "Resync";
 }, E, R>) => Effect.Effect<{
@@ -22,6 +28,11 @@ export declare const watchHints: <E, R>(stream: Stream.Stream<{
     hints: SubscriptionRef.SubscriptionRef<readonly ({
         readonly _tag: "Changed";
         readonly keys: readonly ({
+            readonly _tag: "Bucket";
+            readonly collection: string;
+            readonly field: string;
+            readonly value: string | number;
+        } | {
             readonly _tag: "List";
             readonly collection: string;
         } | {
@@ -29,6 +40,7 @@ export declare const watchHints: <E, R>(stream: Stream.Stream<{
             readonly collection: string;
             readonly id: string | number;
         })[];
+        readonly queryIndexes?: readonly number[] | undefined;
     } | {
         readonly _tag: "Resync";
     })[]>;

package/dist/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,EAAS,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AACzF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,WAAW,UAAU,CAAC,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,eAAe,CAAC,SAAS,QAAQ,EAAE,CAAC,CAAC;CACrE;AAED,eAAO,MAAM,UAAU,GAA2C,CAAC,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAYpE,CAAC;AAEH,eAAO,MAAM,KAAK,GAAsC,CAAC;sBAG3B,QAAQ,CAAC,KAAK;kDAU1C,CAAC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,EAAS,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AACzF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,WAAW,UAAU,CAAC,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,eAAe,CAAC,SAAS,QAAQ,EAAE,CAAC,CAAC;CACrE;AAED,eAAO,MAAM,UAAU,GAA2C,CAAC,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAYpE,CAAC;AAEH,eAAO,MAAM,KAAK,GAAsC,CAAC;sBAG3B,QAAQ,CAAC,KAAK;kDAU1C,CAAC"}

package/dist/testing.js

@@ -12,9 +12,6 @@ export const heard = Effect.fn("Live.heard")(function* (viewer, keys, options =
     return yield* Effect.raceFirst(matching, Effect.as(viewer.finished, false)).pipe(Effect.timeoutOrElse({ duration: options.within ?? "1 second", orElse: () => Effect.succeed(false) }));
 });
 function namesKeys(hint, keys) {
-    return (hint._tag === "Changed"
-        && keys.every((key) => hint.keys.some((actual) => actual._tag === key._tag
-            && actual.collection === key.collection
-            && (key._tag === "List" || (actual._tag === "Item" && actual.id === key.id)))));
+    return hint._tag === "Changed" && keys.every((key) => hint.keys.some((actual) => JSON.stringify(actual) === JSON.stringify(key)));
 }
 //# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAiB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AASzF,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,EAAQ,MAAqC;IAC5G,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,IAAI,CAAsB,EAAE,CAAC,CAAC;IACnE,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAQ,CAAC;IAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAC/B,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,EAAE,CAC1B,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CACzH,EACD,MAAM,CAAC,UAAU,CACjB,CAAC;IACF,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;IACzD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAA0B,CAAC;AACpD,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,EACrD,MAAqB,EACrB,IAAoB,EACpB,OAAO,GAAyC,EAAE;IAElD,MAAM,QAAQ,GAAG,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAC1D,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACrE,MAAM,CAAC,OAAO,EACd,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CACf,CAAC;IACF,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAC/E,MAAM,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,IAAI,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CACrG,CAAC;AACH,CAAC,CAAC,CAAC;AAEH,SAAS,SAAS,CAAC,IAAc,EAAE,IAAoB;IACtD,OAAO,CACN,IAAI,CAAC,IAAI,KAAK,SAAS;WACpB,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CACrB,IAAI,CAAC,IAAI,CAAC,IAAI,CACb,CAAC,MAAM,EAAE,EAAE,CACV,MAAM,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI;eACrB,MAAM,CAAC,UAAU,KAAK,GAAG,CAAC,UAAU;eACpC,CAAC,GAAG,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,MAAM,IAAI,MAAM,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAC7E,CACD,CACD,CAAC;AACH,CAAC"}
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAiB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AASzF,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,EAAQ,MAAqC;IAC5G,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,IAAI,CAAsB,EAAE,CAAC,CAAC;IACnE,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAQ,CAAC;IAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAC/B,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,EAAE,CAC1B,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CACzH,EACD,MAAM,CAAC,UAAU,CACjB,CAAC;IACF,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;IACzD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAA0B,CAAC;AACpD,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,EACrD,MAAqB,EACrB,IAAoB,EACpB,OAAO,GAAyC,EAAE;IAElD,MAAM,QAAQ,GAAG,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAC1D,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACrE,MAAM,CAAC,OAAO,EACd,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CACf,CAAC;IACF,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAC/E,MAAM,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,IAAI,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CACrG,CAAC;AACH,CAAC,CAAC,CAAC;AAEH,SAAS,SAAS,CAAC,IAAc,EAAE,IAAoB;IACtD,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACnI,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/contract",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "Typed query and command contracts over native Effect RPC and reactivity",
   "keywords": [
     "effect"
@@ -44,19 +44,20 @@
     "README.md"
   ],
   "dependencies": {
+    "@shivaedev/changes": "0.5.0",
     "@shivaedev/types": "0.3.0"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.5",
     "@effect/vitest": "4.0.5",
-    "@shivaedev/quality": "0.42.0",
+    "@shivaedev/quality": "0.44.0",
     "@shivaedev/test": "0.10.0",
-    "@shivaedev/test-sql": "0.10.1",
-    "@shivaedev/test-story": "0.21.1",
+    "@shivaedev/test-sql": "0.10.2",
+    "@shivaedev/test-story": "0.22.0",
     "@types/node": "24.19.2",
     "effect": "4.0.5",
     "esbuild": "0.28.2",
-    "happy-dom": "21.0.3",
+    "happy-dom": "21.0.4",
     "typescript": "7.0.2",
     "vitest": "5.0.5"
   },

package/src/automaticLive.ts

@@ -2,8 +2,9 @@ import { type Duration, Effect, Stream, SubscriptionRef } from "effect";
 import * as Atom from "effect/reactivity/Atom";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import type * as AtomRpc from "effect/reactivity/AtomRpc";
+import { type Key, readKeys } from "@shivaedev/changes/keys.ts";
 import type { BindingOwner } from "#internal/bindingOwner.ts";
-import { type Key, readKeys } from "#keys.ts";
+import { localQueryKeys, queryHint } from "#internal/queryHints.ts";
 import { type LiveStatus, live } from "#live.ts";
 import { type ResumeSource, type ResumeWindow, resumeSignal } from "#resume.ts";
 import type { changesRpc, QueryReference } from "#serverMetadata.ts";
@@ -68,13 +69,17 @@ export function automaticLive(service: ChangesClient, name: string, owner?: Bind
 			return Stream.never;
 		}
 		const queries = [...current.values()].map(({ reference }) => reference);
-		return Stream.unwrap(service.use((client) => Effect.succeed(client(`${name}.$changes`, { queries }))));
+		return Stream.unwrap(
+			service.use((client) =>
+				Effect.succeed(client(`${name}.$changes`, { queries }).pipe(Stream.map((hint) => queryHint(hint, [...current.values()])))),
+			),
+		);
 	}
 	const signal = resumeSignal({ ...(typeof window === "undefined" ? {} : { window }), ...(resume === undefined ? {} : { native: resume }) });
 	const subscription = live(service.runtime, {
 		keyContext: owner?.context,
 		resume: signal,
-		resyncKeys: (registry) => [...Effect.runSync(SubscriptionRef.get(registry.get(tracked))).values()].flatMap(({ keys }) => keys),
+		resyncKeys: (registry) => [...Effect.runSync(SubscriptionRef.get(registry.get(tracked))).values()].flatMap(({ keys }) => localQueryKeys(keys)),
 		stream: Stream.unwrap(
 			Effect.map(AtomRegistry.AtomRegistry, (registry) =>
 				Stream.zipLatest(SubscriptionRef.changes(registry.get(tracked)), AtomRegistry.toStream(registry, signal)).pipe(

package/src/bind.ts

@@ -1,17 +1,20 @@
-import type { Duration, Effect, Stream } from "effect";
+import type { Duration, Effect, Layer, Stream } from "effect";
 import type { Headers } from "effect/http";
 import type * as AsyncResult from "effect/reactivity/AsyncResult";
 import type * as Atom from "effect/reactivity/Atom";
 import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import type * as AtomRpc from "effect/reactivity/AtomRpc";
 import type * as Reactivity from "effect/reactivity/Reactivity";
-import type { Rpc } from "effect/rpc";
+import type { Rpc, RpcGroup } from "effect/rpc";
 import type { RpcClientError } from "effect/rpc/RpcClientError";
 import { automaticLive, type LiveBound, LiveConnection } from "#automaticLive.ts";
+import type { ClientOptions, MadeClient } from "#clientOptions.ts";
 import type { Contract, Declared, Tag } from "#contract.ts";
 import { bindingOwner } from "#internal/bindingOwner.ts";
 import { boundCommand, boundQuery, boundStream } from "#internal/clientOperations.ts";
+import { type HttpGroup, httpClient } from "#internal/httpClient.ts";
 import type { CommandShape, QueryShape, StreamShape } from "#operation.ts";
+import type { MissingReadPolicy } from "#readPolicyErrors.ts";
 import type { ResumeSource } from "#resume.ts";
 
 export type Failure<R extends Rpc.Any> =
@@ -31,7 +34,10 @@ export interface QueryOptions {
 }
 
 export interface BoundQuery<R extends Rpc.Any, TSelf> {
-	readonly query: (payload: Rpc.Payload<R>, options?: QueryOptions) => Atom.Atom<AsyncResult.AsyncResult<Rpc.Success<R>, Failure<R>>>;
+	readonly query: (
+		payload: Rpc.Payload<R>,
+		options?: QueryOptions,
+	) => Atom.Atom<AsyncResult.AsyncResult<Rpc.Success<R>, Failure<R> | MissingReadPolicy>>;
 	readonly run: (payload: Rpc.Payload<R>) => Effect.Effect<Rpc.Success<R>, RunFailure<R>, TSelf>;
 }
 
@@ -89,6 +95,14 @@ export function bind(
 	service: AtomRpc.AtomRpcClient<unknown, string, Rpc.Any>,
 	options?: BindOptions,
 ): unknown {
+	return bindApi(contract, service, options);
+}
+
+function bindApi(
+	contract: { readonly declaration: Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[], "session" | undefined> },
+	service: AtomRpc.AtomRpcClient<unknown, string, Rpc.Any>,
+	options?: BindOptions,
+) {
 	const { name, queries, commands, streams, keyScope } = contract.declaration;
 	const owner = bindingOwner(keyScope, options?.registry);
 	const automatic = automaticLive(service, name, owner, options?.resume);
@@ -101,3 +115,31 @@ export function bind(
 		{ [LiveConnection]: automatic.subscription },
 	);
 }
+
+export function makeClient<
+	TName extends string,
+	TQueries extends readonly QueryShape[],
+	TCommands extends readonly CommandShape[],
+	TRpcs extends Rpc.Any,
+	TStreams extends readonly StreamShape[],
+	TScope extends "session" | undefined,
+	TExtra extends Rpc.Any = never,
+>(
+	contract: Contract<TName, TQueries, TCommands, TRpcs, TStreams, TScope>,
+	options: ClientOptions & { readonly group?: RpcGroup.RpcGroup<TRpcs | TExtra> } & ("session" extends TScope
+			? { readonly registry: AtomRegistry.AtomRegistry }
+			: { readonly registry?: AtomRegistry.AtomRegistry }),
+): MadeClient<TName, TQueries, TCommands, TRpcs, TStreams, TExtra>;
+export function makeClient(
+	contract: HttpGroup & {
+		readonly declaration: Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[], "session" | undefined>;
+	},
+	options: ClientOptions & {
+		readonly group?: HttpGroup;
+		readonly registry?: AtomRegistry.AtomRegistry;
+	},
+): Layer.Layer<never> {
+	const connection = httpClient(contract.declaration.name, options.group ?? contract, options);
+	const api = bindApi(contract, connection.Client, options);
+	return Object.assign(connection, { api });
+}

package/src/clientOptions.ts

@@ -0,0 +1,35 @@
+import type { Context, Effect, Layer, Scope } from "effect";
+import type { HttpClient } from "effect/http/HttpClient";
+import type * as Atom from "effect/reactivity/Atom";
+import type * as AtomRpc from "effect/reactivity/AtomRpc";
+import type { Rpc, RpcClient, RpcSerialization } from "effect/rpc";
+import type { RpcClientError } from "effect/rpc/RpcClientError";
+import type { LiveBound } from "#automaticLive.ts";
+import type { Bound } from "#bind.ts";
+import type { CommandShape, QueryShape, StreamShape } from "#operation.ts";
+
+export interface ClientOptions {
+	readonly httpClient?: Layer.Layer<HttpClient>;
+	readonly serialization?: Layer.Layer<RpcSerialization.RpcSerialization>;
+	readonly transformClient?: NonNullable<Parameters<typeof RpcClient.layerProtocolHttp>[0]["transformClient"]>;
+	readonly url: string;
+}
+
+export type ClientService<TName extends string, TRpcs extends Rpc.Any> = Context.ServiceClass.Shape<
+	`${TName}/Client`,
+	RpcClient.RpcClient.Flat<TRpcs, RpcClientError>
+>;
+
+export type MadeClient<
+	TName extends string,
+	TQueries extends readonly QueryShape[],
+	TCommands extends readonly CommandShape[],
+	TRpcs extends Rpc.Any,
+	TStreams extends readonly StreamShape[],
+	TExtra extends Rpc.Any,
+> = Layer.Layer<ClientService<TName, TRpcs | TExtra>> & {
+	readonly api: Bound<TName, TQueries, TCommands, TRpcs, ClientService<TName, TRpcs | TExtra>, TStreams> & LiveBound;
+	readonly Client: AtomRpc.AtomRpcClient<ClientService<TName, TRpcs | TExtra>, `${TName}/Client`, TRpcs | TExtra>;
+	readonly client: Effect.Effect<RpcClient.RpcClient<TRpcs | TExtra, RpcClientError>, never, Scope.Scope | Rpc.MiddlewareClient<TRpcs | TExtra>>;
+	readonly runtime: Atom.AtomRuntime<ClientService<TName, TRpcs | TExtra>>;
+};

package/src/contract.ts

@@ -1,14 +1,19 @@
-import { Context, type Schema } from "effect";
+import { Context, Schema } from "effect";
 import { Rpc, RpcGroup, type RpcMiddleware, type RpcSchema } from "effect/rpc";
 import type { CommandShape, OperationShape, QueryShape, StreamShape } from "#operation.ts";
-import { CommandInvalidation, changesRpc, KeyScope, QueryReads } from "#serverMetadata.ts";
+import { QueryReadDenied } from "#readPolicyErrors.ts";
+import { CommandInvalidation, changesRpc, KeyScope, QueryDefinition } from "#serverMetadata.ts";
 
 export type Tag<TContract extends string, TName extends string> = `${TContract}.${TName}`;
 
+type OperationError<TOperation extends OperationShape> = TOperation extends QueryShape
+	? Schema.Union<readonly [TOperation["error"], typeof QueryReadDenied]>
+	: TOperation["error"];
+
 export type OperationRpc<TContract extends string, TOperation> = TOperation extends OperationShape
 	? TOperation extends StreamShape
 		? Rpc.Rpc<Tag<TContract, TOperation["name"]>, TOperation["payload"], RpcSchema.Stream<TOperation["success"], TOperation["error"]>, Schema.Never>
-		: Rpc.Rpc<Tag<TContract, TOperation["name"]>, TOperation["payload"], TOperation["success"], TOperation["error"]>
+		: Rpc.Rpc<Tag<TContract, TOperation["name"]>, TOperation["payload"], TOperation["success"], OperationError<TOperation>>
 	: never;
 
 export interface Declared<
@@ -61,9 +66,9 @@ function assertUnique(operations: readonly OperationShape[]) {
 function annotations(operation: QueryShape | CommandShape | StreamShape, keyScope: "session" | undefined) {
 	const scope = keyScope === undefined ? Context.empty() : Context.make(KeyScope, keyScope);
 	if (operation.kind === "command") {
-		return Context.add(scope, CommandInvalidation, operation.invalidates);
+		return Context.add(scope, CommandInvalidation, { invalidates: operation.invalidates });
 	}
-	return operation.kind === "query" ? Context.add(scope, QueryReads, operation.reads) : scope;
+	return operation.kind === "query" ? Context.add(scope, QueryDefinition, { definition: operation }) : scope;
 }
 
 type AnyDeclared = Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[], "session" | undefined>;
@@ -122,7 +127,7 @@ export function contract(
 	assertUnique([...queries, ...commands, ...streams]);
 	const rpcs = [...queries, ...commands, ...streams].map((operation) =>
 		Rpc.make(`${name}.${operation.name}`, {
-			error: operation.error,
+			error: operation.kind === "query" ? Schema.Union([operation.error, QueryReadDenied]) : operation.error,
 			payload: operation.payload,
 			stream: operation.kind === "stream",
 			success: operation.success,

package/src/internal/bindingOwner.ts

@@ -1,5 +1,5 @@
 import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
-import type { KeyContext } from "#keys.ts";
+import type { KeyContext } from "@shivaedev/changes/keys.ts";
 
 export interface BindingOwner {
 	readonly context: KeyContext;

package/src/internal/clientOperations.ts

@@ -1,17 +1,22 @@
-import { Effect, type Schema, Stream } from "effect";
+import { Effect, MutableHashMap, Option, type Schema, Stream } from "effect";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import type * as AtomRpc from "effect/reactivity/AtomRpc";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import type { Rpc, RpcSchema } from "effect/rpc";
+import { invalidationKeys, type Key, readKeys } from "@shivaedev/changes/keys.ts";
 import type { automaticLive } from "#automaticLive.ts";
 import type { QueryOptions } from "#bind.ts";
-import { invalidationKeys, readKeys } from "#keys.ts";
 import type { CommandShape, QueryShape } from "#operation.ts";
+import { MissingReadPolicy } from "#readPolicyErrors.ts";
 import type { BindingOwner } from "./bindingOwner.ts";
 import { queryReactivity } from "./queryReactivity.ts";
 
 type ErasedClient = AtomRpc.AtomRpcClient<unknown, string, Rpc.Rpc<string, Schema.Top, Schema.Top, Schema.Top>>;
 
+// AtomRpc holds query atoms weakly, so an id per atom object would change after a collection and make live tracking resubscribe.
+const queryIds = MutableHashMap.empty<{ readonly payload: unknown; readonly tag: string }, number>();
+let nextQueryId = 0;
+
 type ErasedStreamingClient = AtomRpc.AtomRpcClient<
 	unknown,
 	string,
@@ -32,15 +37,30 @@ export function boundQuery(
 	const reactive = queryReactivity(service.runtime);
 	return {
 		query: (payload: unknown, options: QueryOptions = {}) => {
+			if (query.readPolicy === undefined) {
+				return service.runtime.atom(
+					Effect.fail(new MissingReadPolicy({ message: `Declare a readPolicy on query ${query.name} before running it live or subscribing` })),
+				);
+			}
 			const atom = service.query(tag, payload, options);
-			const keys = query.reads(payload);
+			const identity = { payload, tag };
+			let id = Option.getOrUndefined(MutableHashMap.get(queryIds, identity));
+			if (id === undefined) {
+				id = nextQueryId;
+				nextQueryId += 1;
+				MutableHashMap.set(queryIds, identity, id);
+			}
+			const local = query.reads(payload, Option.none());
+			const keys = [...local, { _tag: "List" as const, collection: `@query/${tag}/${id}` }];
+			const dependencies =
+				local.length === 0 ? [...keys, { _tag: "List" as const, collection: `@query/${tag.slice(0, tag.lastIndexOf("."))}` }] : keys;
 			const reference = { payload, query: query.name };
 			if (owner === undefined) {
 				track(undefined, reference, keys);
 			}
 			return reactive(
 				atom,
-				readKeys(keys, owner?.context),
+				readKeys(dependencies, owner?.context),
 				(registry) => (owner === undefined ? () => undefined : track(registry, reference, keys)),
 				owner?.registry,
 			);
@@ -55,15 +75,16 @@ export function boundQuery(
 }
 
 export function boundCommand(service: ErasedClient, tag: string, command: CommandShape, owner?: BindingOwner) {
+	function invalidate(payload: unknown, result: unknown) {
+		const keys: readonly Key[] = [
+			...command.invalidates(payload, result),
+			{ _tag: "List", collection: `@query/${tag.slice(0, tag.lastIndexOf("."))}` },
+		];
+		return Reactivity.invalidate(invalidationKeys(keys, owner?.context));
+	}
 	return {
 		run: (payload: unknown) =>
-			run(
-				service,
-				service
-					.use((client) => client(tag, payload))
-					.pipe(Effect.tap((result) => Reactivity.invalidate(invalidationKeys(command.invalidates(payload, result), owner?.context)))),
-				owner,
-			),
+			run(service, service.use((client) => client(tag, payload)).pipe(Effect.tap((result) => invalidate(payload, result))), owner),
 	};
 }
 

package/src/internal/httpClient.ts

@@ -0,0 +1,21 @@
+import { type Context, Effect, Layer } from "effect";
+import { FetchHttpClient } from "effect/http";
+import * as AtomRpc from "effect/reactivity/AtomRpc";
+import { type Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/rpc";
+import type { ClientOptions } from "#clientOptions.ts";
+
+export interface HttpGroup {
+	readonly annotations: Context.Context<never>;
+	readonly requests: ReadonlyMap<string, Rpc.Any>;
+}
+
+export function httpClient(name: string, source: HttpGroup, options: ClientOptions) {
+	const group = RpcGroup.make(...source.requests.values()).annotateMerge(source.annotations);
+	const protocol = RpcClient.layerProtocolHttp(options).pipe(
+		Layer.provide([options.httpClient ?? FetchHttpClient.layer, options.serialization ?? RpcSerialization.layerNdjson]),
+	);
+	const Client = AtomRpc.Service<unknown>()(`${name}/Client`, { group, protocol });
+	const client = RpcClient.make(group).pipe(Effect.provide(protocol));
+	const layer = Layer.effect(Client, RpcClient.make(group, { flatten: true })).pipe(Layer.provide(protocol));
+	return Object.assign(layer, { Client, client, runtime: Client.runtime });
+}

package/src/internal/operationDeclaration.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import type { OperationShape } from "#operation.ts";
+import { type RejectionSpecs, rejectionSet } from "#rejection.ts";
+
+export interface Loose {
+	readonly payload?: Schema.Top | Schema.Struct.Fields;
+	readonly rejections?: RejectionSpecs;
+	readonly success?: Schema.Top;
+}
+
+function payloadSchema(payload: Loose["payload"]): Schema.Top {
+	if (payload === undefined) {
+		return Schema.Void;
+	}
+	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
+}
+
+export function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
+	const { payload, success, rejections = {} } = declaration;
+	return {
+		kind,
+		name,
+		payload: payloadSchema(payload),
+		rejections,
+		success: success ?? Schema.Void,
+		...rejectionSet(rejections),
+	};
+}

package/src/internal/queryHints.ts

@@ -0,0 +1,38 @@
+import { invalidationKeys, type Key, readKeys } from "@shivaedev/changes/keys.ts";
+import type { LiveHint } from "#live.ts";
+
+export function localQueryKeys(keys: readonly Key[]) {
+	return keys.filter((key) => key.collection.startsWith("@query/"));
+}
+
+export function queryHint(hint: LiveHint, tracked: readonly { readonly keys: readonly Key[] }[]): LiveHint {
+	if (hint._tag === "Resync") {
+		return hint;
+	}
+	const invalidated = invalidationKeys(hint.keys);
+	return {
+		_tag: "Changed",
+		keys: [
+			...hint.keys,
+			...tracked.flatMap(({ keys }, index) => {
+				const local = keys.filter((key) => !key.collection.startsWith("@query/"));
+				const affected =
+					hint.queryIndexes === undefined
+						? local.length === 0 || hint.keys.some((key) => key._tag === "Bucket") || readKeys(local).some((key) => invalidated.includes(key))
+						: hint.queryIndexes.includes(index);
+				return affected ? localQueryKeys(keys) : [];
+			}),
+		],
+	};
+}
+
+export function changedHint(keys: readonly Key[], scopes?: readonly (readonly Key[])[]): LiveHint {
+	const changed = new Set(keys.map((key) => JSON.stringify(key)));
+	return {
+		_tag: "Changed",
+		keys,
+		...(scopes === undefined
+			? {}
+			: { queryIndexes: scopes.flatMap((scope, index) => (scope.some((key) => changed.has(JSON.stringify(key))) ? [index] : [])) }),
+	};
+}

package/src/live.ts

@@ -2,11 +2,11 @@ import { type Cause, Duration, Effect, Option, Schema, Stream } from "effect";
 import * as Atom from "effect/reactivity/Atom";
 import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import * as Reactivity from "effect/reactivity/Reactivity";
+import { invalidationKeys, Key, type KeyContext, readKeys } from "@shivaedev/changes/keys.ts";
 import { invalidateLive } from "#internal/liveInvalidation.ts";
-import { invalidationKeys, Key, type KeyContext, readKeys } from "#keys.ts";
 
 export const LiveHint = Schema.Union([
-	Schema.Struct({ _tag: Schema.Literal("Changed"), keys: Schema.Array(Key) }),
+	Schema.Struct({ _tag: Schema.Literal("Changed"), keys: Schema.Array(Key), queryIndexes: Schema.optional(Schema.Array(Schema.Number)) }),
 	Schema.Struct({ _tag: Schema.Literal("Resync") }),
 ]);
 export type LiveHint = typeof LiveHint.Type;

package/src/makeLiveServer.ts

@@ -1,20 +1,18 @@
 import { Effect, Queue, Stream } from "effect";
 import * as Reactivity from "effect/reactivity/Reactivity";
-import { makeHintPolicy } from "#internal/makeHintPolicy.ts";
-import { type Key, type KeyContext, readKeys } from "#keys.ts";
+import { type Key, type KeyContext, readKeys } from "@shivaedev/changes/keys.ts";
+import { changedHint } from "#internal/queryHints.ts";
 import type { LiveHint } from "#live.ts";
+import type { QuerySubscription } from "#querySubscription.ts";
 
 export const makeLiveServer = Effect.gen(function* () {
 	const reactivity = yield* Reactivity.Reactivity;
 	let openStreams = 0;
 	const resyncKey = `@shivaedev/contract/resync/${crypto.randomUUID()}`;
-	function stream(keys: readonly Key[], context?: KeyContext) {
+	function open(keys: readonly Key[], context?: KeyContext, subscription?: QuerySubscription) {
 		return Stream.unwrap(
 			Effect.gen(function* () {
 				const queue = yield* Queue.unbounded<LiveHint>();
-				const allowedKeys = yield* makeHintPolicy(keys.length, (retryKeys) =>
-					Queue.offer(queue, { _tag: "Changed", keys: retryKeys }).pipe(Effect.asVoid),
-				);
 				const pending = new Map<string, Key>();
 				let scheduled = false;
 				let resync = false;
@@ -57,12 +55,16 @@ export const makeLiveServer = Effect.gen(function* () {
 					}),
 				);
 				yield* Queue.offer(queue, { _tag: "Resync" });
+				function authorizeHint(hint: LiveHint) {
+					if (hint._tag === "Resync") {
+						return Effect.succeed(hint);
+					}
+					return Effect.map(subscription?.authorized ?? Effect.succeed(true), (allowed) =>
+						changedHint(allowed ? hint.keys : [], subscription?.scopes),
+					);
+				}
 				return Stream.fromQueue(queue).pipe(
-					Stream.mapEffect((hint) =>
-						hint._tag === "Resync"
-							? Effect.succeed(hint)
-							: Effect.map(allowedKeys(hint.keys), (allowed): LiveHint => ({ _tag: "Changed", keys: allowed })),
-					),
+					Stream.mapEffect(authorizeHint),
 					Stream.filter((hint) => hint._tag === "Resync" || hint.keys.length > 0),
 				);
 			}),
@@ -72,5 +74,9 @@ export const makeLiveServer = Effect.gen(function* () {
 		reactivity.invalidateUnsafe([resyncKey]);
 		return openStreams;
 	});
-	return { resync, stream };
+	return {
+		resync,
+		stream: (keys: readonly Key[], context?: KeyContext) => open(keys, context),
+		subscribe: (subscription: QuerySubscription, context?: KeyContext) => open(subscription.keys, context, subscription),
+	};
 });