@shivaedev/effect-contract 0.5.1 → 0.7.0

package/dist/makeLiveServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"makeLiveServer.js","sourceRoot":"","sources":["../src/makeLiveServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAY,QAAQ,EAAE,MAAM,WAAW,CAAC;AAG/C,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IACjD,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;IAChD,MAAM,SAAS,GAAG,qCAAqC,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;IAC7E,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,SAAS,MAAM,CAAC,IAAoB;QACnC,OAAO,MAAM,CAAC,MAAM,CACnB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;YAChB,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;YACd,OAAO,UAAU,CAAC,MAAM,CACvB,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,EAC9B,MAAM,CAAC,IAAI,CAAC,GAAa,EAAE;gBAC1B,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;oBACzB,IAAI,GAAG,UAAU,CAAC;oBAClB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;gBAC3B,CAAC;gBACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;YAClC,CAAC,CAAC,CACF,CAAC;QACH,CAAC,CAAC,CACF,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;QAC/B,UAAU,IAAI,CAAC,CAAC;QAChB,UAAU,CAAC,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC3B,CAAC,CAAC,CAAC"}
+{"version":3,"file":"makeLiveServer.js","sourceRoot":"","sources":["../src/makeLiveServer.ts"],"names":[],"mappings":"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"}

package/dist/readPolicy.d.ts

@@ -0,0 +1,9 @@
+import { Context, Effect } from "effect";
+import type { Rpc } from "effect/rpc";
+import type { Key } from "./keys.ts";
+export declare const ReadPolicy: Context.Reference<(key: Key) => Effect.Effect<boolean>>;
+export declare const authorizeReads: <A, E, R, TPolicyServices, TDenied>(effect: Effect.Effect<A, E, R>, request: {
+    readonly rpc: Rpc.AnyWithProps;
+    readonly payload: unknown;
+}, policy: (key: Key) => Effect.Effect<boolean, never, TPolicyServices>, denied: Effect.Effect<never, TDenied, never>) => Effect.Effect<A, E | TDenied, TPolicyServices | Exclude<R, never>>;
+//# sourceMappingURL=readPolicy.d.ts.map

package/dist/readPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readPolicy.d.ts","sourceRoot":"","sources":["../src/readPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AACjD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAGrC,eAAO,MAAM,UAAU,0BAA2B,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAE9E,CAAC;AAEH,eAAO,MAAM,cAAc,GAAgC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,eAAe,EAAE,OAAO;kBAElE,GAAG,CAAC,YAAY;sBAAoB,OAAO;iBACtD,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,eAAe,CAAC,qHAgBnE,CAAC"}

package/dist/readPolicy.js

@@ -0,0 +1,21 @@
+import { Context, Effect, Option } from "effect";
+import { QueryReads } from "./serverMetadata.js";
+export const ReadPolicy = Context.Reference("@shivaedev/effect-contract/ReadPolicy", {
+    defaultValue: () => () => Effect.succeed(true),
+});
+export const authorizeReads = Effect.fnUntraced(function* (effect, request, policy, denied) {
+    const context = yield* Effect.context();
+    function canRead(key) {
+        return Effect.provideContext(policy(key), context);
+    }
+    const reads = Context.getOption(request.rpc.annotations, QueryReads);
+    if (Option.isSome(reads)) {
+        for (const key of reads.value(request.payload)) {
+            if (!(yield* canRead(key))) {
+                return yield* denied;
+            }
+        }
+    }
+    return yield* Effect.provideService(effect, ReadPolicy, canRead);
+});
+//# sourceMappingURL=readPolicy.js.map

package/dist/readPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readPolicy.js","sourceRoot":"","sources":["../src/readPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGjD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,CAAuC,uCAAuC,EAAE;IAC1H,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;CAC9C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EACxD,MAA8B,EAC9B,OAAsE,EACtE,MAAoE,EACpE,MAAqC;IAErC,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,EAAmB,CAAC;IACzD,SAAS,OAAO,CAAC,GAAQ;QACxB,OAAO,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IACrE,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAChD,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC5B,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC;YACtB,CAAC;QACF,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AAClE,CAAC,CAAC,CAAC"}

package/dist/serverMetadata.d.ts

@@ -0,0 +1,33 @@
+import { Context, Schema } from "effect";
+import { Rpc } from "effect/rpc";
+import { Key } from "./keys.ts";
+declare const QueryReads_base: Context.ServiceClass<QueryReads, "@shivaedev/effect-contract/QueryReads", import("@shivaedev/types/bivariant.ts").Bivariant<(payload: unknown) => readonly Key[]>>;
+export declare class QueryReads extends QueryReads_base {
+}
+declare const CommandInvalidation_base: Context.ServiceClass<CommandInvalidation, "@shivaedev/effect-contract/CommandInvalidation", import("@shivaedev/types/bivariant.ts").Bivariant<(payload: unknown, result: unknown) => readonly Key[]>>;
+export declare class CommandInvalidation extends CommandInvalidation_base {
+}
+export declare function changesRpc<const TName extends string>(name: TName): Rpc.Rpc<`${TName}.$changes`, Schema.Struct<{
+    keys: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"List">;
+        readonly collection: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"Item">;
+        readonly collection: Schema.String;
+        readonly id: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>]>>;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Changed">;
+    readonly keys: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"List">;
+        readonly collection: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"Item">;
+        readonly collection: Schema.String;
+        readonly id: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>]>>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Resync">;
+}>]>, Schema.Never>, Schema.Never, never, never>;
+export {};
+//# sourceMappingURL=serverMetadata.d.ts.map

package/dist/serverMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverMetadata.d.ts","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;AACjC,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;;AAIhC,qBAAa,UAAW,SAAQ,eAA2F;CAAG;;AAE9H,qBAAa,mBAAoB,SAAQ,wBAExC;CAAG;AAEJ,wBAAgB,UAAU,CAAC,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,EAAE,KAAK;;;;;;;;;;;;;;;;;;;;;iDAEjE"}

package/dist/serverMetadata.js

@@ -0,0 +1,12 @@
+import { Context, Schema } from "effect";
+import { Rpc } from "effect/rpc";
+import { Key } from "./keys.js";
+import { LiveHint } from "./live.js";
+export class QueryReads extends Context.Service()("@shivaedev/effect-contract/QueryReads") {
+}
+export class CommandInvalidation extends Context.Service()("@shivaedev/effect-contract/CommandInvalidation") {
+}
+export function changesRpc(name) {
+    return Rpc.make(`${name}.$changes`, { payload: { keys: Schema.Array(Key) }, stream: true, success: LiveHint });
+}
+//# sourceMappingURL=serverMetadata.js.map

package/dist/serverMetadata.js.map

@@ -0,0 +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;AACjC,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAGrC,MAAM,OAAO,UAAW,SAAQ,OAAO,CAAC,OAAO,EAAmC,CAAC,uCAAuC,CAAC;CAAG;AAE9H,MAAM,OAAO,mBAAoB,SAAQ,OAAO,CAAC,OAAO,EAAoD,CAC3G,gDAAgD,CAChD;CAAG;AAEJ,MAAM,UAAU,UAAU,CAA6B,IAAW;IACjE,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,WAAW,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;AAChH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-contract",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Typed query and command contracts over native Effect RPC and reactivity",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-contract#readme",
   "bugs": {
@@ -23,55 +23,12 @@
     }
   },
   "exports": {
-    "./package.json": "./package.json",
-    "./bind.ts": {
-      "types": "./dist/bind.d.ts",
-      "source": "./src/bind.ts",
-      "import": "./dist/bind.js",
-      "default": "./dist/bind.js"
-    },
-    "./contract.ts": {
-      "types": "./dist/contract.d.ts",
-      "source": "./src/contract.ts",
-      "import": "./dist/contract.js",
-      "default": "./dist/contract.js"
-    },
-    "./keys.ts": {
-      "types": "./dist/keys.d.ts",
-      "source": "./src/keys.ts",
-      "import": "./dist/keys.js",
-      "default": "./dist/keys.js"
-    },
-    "./live.ts": {
-      "types": "./dist/live.d.ts",
-      "source": "./src/live.ts",
-      "import": "./dist/live.js",
-      "default": "./dist/live.js"
-    },
-    "./makeLiveServer.ts": {
-      "types": "./dist/makeLiveServer.d.ts",
-      "source": "./src/makeLiveServer.ts",
-      "import": "./dist/makeLiveServer.js",
-      "default": "./dist/makeLiveServer.js"
-    },
-    "./operation.ts": {
-      "types": "./dist/operation.d.ts",
-      "source": "./src/operation.ts",
-      "import": "./dist/operation.js",
-      "default": "./dist/operation.js"
-    },
-    "./rejection.ts": {
-      "types": "./dist/rejection.d.ts",
-      "source": "./src/rejection.ts",
-      "import": "./dist/rejection.js",
-      "default": "./dist/rejection.js"
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
     },
-    "./resume.ts": {
-      "types": "./dist/resume.d.ts",
-      "source": "./src/resume.ts",
-      "import": "./dist/resume.js",
-      "default": "./dist/resume.js"
-    }
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -79,7 +36,6 @@
     "!src/**/*.test.ts",
     "!src/**/*.spec.ts",
     "!src/**/test-support",
-    "docs",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -89,14 +45,14 @@
   "devDependencies": {
     "@effect/platform-node": "4.0.4",
     "@effect/vitest": "4.0.4",
-    "@shivaedev/effect-test": "0.5.0",
-    "@shivaedev/quality": "0.22.0",
-    "@types/node": "24.19.1",
-    "@typescript/native": "npm:typescript@7.0.2",
+    "@shivaedev/effect-test": "0.7.1",
+    "@shivaedev/quality": "0.29.1",
+    "@shivaedev/test-story": "0.15.0",
+    "@types/node": "24.19.2",
     "effect": "4.0.4",
     "esbuild": "0.28.2",
     "happy-dom": "20.14.6",
-    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "typescript": "7.0.2",
     "vitest": "5.0.3"
   },
   "peerDependencies": {

package/src/automaticLive.ts

@@ -0,0 +1,44 @@
+import { Effect, Stream, SubscriptionRef } from "effect";
+import type * as Atom from "effect/reactivity/Atom";
+import type * as AtomRpc from "effect/reactivity/AtomRpc";
+import { type Key, readKeys } from "./keys.ts";
+import { type LiveStatus, live } from "./live.ts";
+import { type ResumeWindow, resumeSignal } from "./resume.ts";
+import type { changesRpc } from "./serverMetadata.ts";
+
+declare const window: ResumeWindow | undefined;
+
+export const LiveConnection = Symbol.for("@shivaedev/effect-contract/LiveConnection");
+export interface LiveBound {
+	readonly [LiveConnection]: { readonly connection: Atom.Atom<unknown>; readonly status: Atom.Atom<LiveStatus<unknown>> };
+}
+
+export type ChangesClient = AtomRpc.AtomRpcClient<unknown, string, ReturnType<typeof changesRpc>>;
+
+export function automaticLive(service: ChangesClient, name: string) {
+	const keys = Effect.runSync(SubscriptionRef.make<readonly Key[]>([]));
+	const known = new Set<string>();
+	function track(reads: readonly Key[]) {
+		const fresh = reads.filter((key) => {
+			const id = readKeys([key])[0] ?? "";
+			if (known.has(id)) {
+				return false;
+			}
+			known.add(id);
+			return true;
+		});
+		if (fresh.length > 0) {
+			Effect.runSync(SubscriptionRef.update(keys, (current) => [...current, ...fresh]));
+		}
+	}
+	const subscription = live(service.runtime, {
+		resume: resumeSignal(typeof window === "undefined" ? {} : { window }),
+		resyncKeys: () => Effect.runSync(SubscriptionRef.get(keys)),
+		stream: SubscriptionRef.changes(keys).pipe(
+			Stream.switchMap((current) =>
+				current.length === 0 ? Stream.never : Stream.unwrap(service.use((client) => Effect.succeed(client(`${name}.$changes`, { keys: current })))),
+			),
+		),
+	});
+	return { subscription, track };
+}

package/src/bind.ts

@@ -7,6 +7,7 @@ import type * as AtomRpc from "effect/reactivity/AtomRpc";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import type { Rpc, RpcSchema } from "effect/rpc";
 import type { RpcClientError } from "effect/rpc/RpcClientError";
+import { automaticLive, type LiveBound, LiveConnection } from "./automaticLive.ts";
 import type { Contract, Declared, Tag } from "./contract.ts";
 import { invalidationKeys, type Key, readKeys } from "./keys.ts";
 import type { CommandShape, QueryShape, StreamShape } from "./operation.ts";
@@ -73,12 +74,15 @@ const invalidateAfter = Effect.fn("EffectContract.invalidateAfter")(function* (k
 	yield* Reactivity.invalidate(invalidationKeys(keys));
 });
 
-function boundQuery(service: ErasedClient, tag: string, query: QueryShape) {
+function boundQuery(service: ErasedClient, tag: string, query: QueryShape, track: (keys: readonly Key[]) => void) {
 	function reads(payload: unknown) {
 		return readKeys(query.reads(payload));
 	}
 	return {
-		query: (payload: unknown, options: QueryOptions = {}) => service.query(tag, payload, { ...options, reactivityKeys: reads(payload) }),
+		query: (payload: unknown, options: QueryOptions = {}) => {
+			track(query.reads(payload));
+			return service.query(tag, payload, { ...options, reactivityKeys: reads(payload) });
+		},
 		run: (payload: unknown) => service.use((client) => client(tag, payload)),
 	};
 }
@@ -108,15 +112,19 @@ export function bind<
 >(
 	contract: Contract<TName, TQueries, TCommands, TRpcs, TStreams>,
 	service: AtomRpc.AtomRpcClient<TSelf, TId, TClientRpcs> & MatchingClient<NoInfer<TRpcs>, TClientRpcs>,
-): Bound<TName, TQueries, TCommands, TRpcs, TSelf, TStreams>;
+): Bound<TName, TQueries, TCommands, TRpcs, TSelf, TStreams> & LiveBound;
 export function bind(
 	contract: { readonly declaration: Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[]> },
 	service: AtomRpc.AtomRpcClient<unknown, string, Rpc.Any>,
 ): unknown {
 	const { name, queries, commands, streams } = contract.declaration;
-	return Object.fromEntries([
-		...queries.map((query) => [query.name, boundQuery(service, `${name}.${query.name}`, query)] as const),
-		...commands.map((command) => [command.name, boundCommand(service, `${name}.${command.name}`, command)] as const),
-		...streams.map((stream) => [stream.name, boundStream(service, `${name}.${stream.name}`)] as const),
-	]);
+	const automatic = automaticLive(service, name);
+	return Object.assign(
+		Object.fromEntries([
+			...queries.map((query) => [query.name, boundQuery(service, `${name}.${query.name}`, query, automatic.track)] as const),
+			...commands.map((command) => [command.name, boundCommand(service, `${name}.${command.name}`, command)] as const),
+			...streams.map((stream) => [stream.name, boundStream(service, `${name}.${stream.name}`)] as const),
+		]),
+		{ [LiveConnection]: automatic.subscription },
+	);
 }

package/src/contract.ts

@@ -1,6 +1,7 @@
-import type { Schema } from "effect";
+import { Context, type 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, QueryReads } from "./serverMetadata.ts";
 
 export type Tag<TContract extends string, TName extends string> = `${TContract}.${TName}`;
 
@@ -51,6 +52,13 @@ function assertUnique(operations: readonly OperationShape[]) {
 	}
 }
 
+function annotations(operation: QueryShape | CommandShape | StreamShape) {
+	if (operation.kind === "command") {
+		return Context.make(CommandInvalidation, operation.invalidates);
+	}
+	return operation.kind === "query" ? Context.make(QueryReads, operation.reads) : Context.empty();
+}
+
 type AnyDeclared = Declared<string, readonly QueryShape[], readonly CommandShape[], readonly StreamShape[]>;
 
 interface Group {
@@ -94,7 +102,7 @@ export function contract(
 			payload: operation.payload,
 			stream: operation.kind === "stream",
 			success: operation.success,
-		}),
+		}).annotateMerge(annotations(operation)),
 	);
-	return withDeclaration(RpcGroup.make(...rpcs), { commands, name, queries, streams });
+	return withDeclaration(RpcGroup.make(...rpcs, changesRpc(name)), { commands, name, queries, streams });
 }

package/src/keys.ts

@@ -26,21 +26,25 @@ export interface Collection<TName extends string, TId extends Identity> {
 	readonly name: TName;
 }
 
-export const collection = <const TName extends string, TId extends Schema.Top & { readonly Type: Identity }>(
+export function collection<const TName extends string, TId extends Schema.Top & { readonly Type: Identity }>(
 	name: TName,
 	_id: TId,
-): Collection<TName, TId["Type"]> => ({
-	item: (id) => ({ _tag: "Item", collection: name, id }),
-	list: { _tag: "List", collection: name },
-	name,
-});
+): Collection<TName, TId["Type"]> {
+	return {
+		item: (id) => ({ _tag: "Item", collection: name, id }),
+		list: { _tag: "List", collection: name },
+		name,
+	};
+}
 
 function own(key: Key): string {
 	return key._tag === "List" ? key.collection : `${key.collection}:${key.id}`;
 }
 
-export const readKeys = (keys: readonly Key[]): readonly string[] => [...new Set(keys.map(own))];
+export function readKeys(keys: readonly Key[]): readonly string[] {
+	return [...new Set(keys.map(own))];
+}
 
-export const invalidationKeys = (keys: readonly Key[]): readonly string[] => [
-	...new Set(keys.flatMap((key) => (key._tag === "List" ? [key.collection] : [own(key), key.collection]))),
-];
+export function invalidationKeys(keys: readonly Key[]): readonly string[] {
+	return [...new Set(keys.flatMap((key) => (key._tag === "List" ? [key.collection] : [own(key), key.collection])))];
+}

package/src/live.ts

@@ -16,7 +16,7 @@ export interface LiveStatus<E> {
 }
 export interface LiveOptions<E, R> {
 	readonly resume?: Atom.Atom<unknown>;
-	readonly resyncKeys: readonly Key[];
+	readonly resyncKeys: readonly Key[] | (() => readonly Key[]);
 	readonly retryDelay?: Duration.Input;
 	readonly stream: Stream.Stream<LiveHint, E, R>;
 }
@@ -39,9 +39,11 @@ export function live<R, E, TRuntimeError>(runtime: Atom.AtomRuntime<R, TRuntimeE
 						update({ needsResync: true });
 						return;
 					}
-					reactivity.invalidateUnsafe(readKeys(options.resyncKeys));
+					reactivity.invalidateUnsafe(readKeys(typeof options.resyncKeys === "function" ? options.resyncKeys() : options.resyncKeys));
 					update({ needsResync: false, pending: 0 });
 				}
+				// A subscription alone does not build the flag, so its first read would otherwise announce a change.
+				get.once(paused);
 				get.subscribe(paused, (value) => {
 					if (!value) {
 						resync();

package/src/makeLiveServer.ts

@@ -1,31 +1,69 @@
-import { Effect, Stream } from "effect";
+import { Effect, Queue, Stream } from "effect";
 import * as Reactivity from "effect/reactivity/Reactivity";
 import { type Key, readKeys } from "./keys.ts";
 import type { LiveHint } from "./live.ts";
+import { ReadPolicy } from "./readPolicy.ts";
 
 export const makeLiveServer = Effect.gen(function* () {
 	const reactivity = yield* Reactivity.Reactivity;
 	const resyncKey = `@shivaedev/effect-contract/resync/${crypto.randomUUID()}`;
-	let generation = 0;
 	function stream(keys: readonly Key[]) {
 		return Stream.unwrap(
-			Effect.sync(() => {
-				let seen = -1;
-				return reactivity.stream(
-					[...readKeys(keys), resyncKey],
-					Effect.sync((): LiveHint => {
-						if (seen !== generation) {
-							seen = generation;
-							return { _tag: "Resync" };
+			Effect.gen(function* () {
+				const canRead = yield* ReadPolicy;
+				const queue = yield* Queue.unbounded<LiveHint>();
+				const pending = new Map<string, Key>();
+				let scheduled = false;
+				let resync = false;
+				let active = true;
+				function flush() {
+					if (scheduled) {
+						return;
+					}
+					scheduled = true;
+					queueMicrotask(() => {
+						scheduled = false;
+						if (active) {
+							Queue.offerUnsafe(queue, resync ? { _tag: "Resync" } : { _tag: "Changed", keys: [...pending.values()] });
 						}
-						return { _tag: "Changed", keys };
+						pending.clear();
+						resync = false;
+					});
+				}
+				const cancel = keys.map((key) => {
+					const own = readKeys([key]);
+					return reactivity.registerUnsafe(own, () => {
+						pending.set(own[0] ?? "", key);
+						flush();
+					});
+				});
+				cancel.push(
+					reactivity.registerUnsafe([resyncKey], () => {
+						resync = true;
+						flush();
 					}),
 				);
+				yield* Effect.addFinalizer(() =>
+					Effect.sync(() => {
+						active = false;
+						for (const stop of cancel) {
+							stop();
+						}
+					}),
+				);
+				yield* Queue.offer(queue, { _tag: "Resync" });
+				return Stream.fromQueue(queue).pipe(
+					Stream.mapEffect((hint) =>
+						hint._tag === "Resync"
+							? Effect.succeed(hint)
+							: Effect.map(Effect.filter(hint.keys, canRead), (allowed): LiveHint => ({ _tag: "Changed", keys: allowed })),
+					),
+					Stream.filter((hint) => hint._tag === "Resync" || hint.keys.length > 0),
+				);
 			}),
 		);
 	}
 	const resync = Effect.sync(() => {
-		generation += 1;
 		reactivity.invalidateUnsafe([resyncKey]);
 	});
 	return { resync, stream };

package/src/readPolicy.ts

@@ -0,0 +1,29 @@
+import { Context, Effect, Option } from "effect";
+import type { Rpc } from "effect/rpc";
+import type { Key } from "./keys.ts";
+import { QueryReads } from "./serverMetadata.ts";
+
+export const ReadPolicy = Context.Reference<(key: Key) => Effect.Effect<boolean>>("@shivaedev/effect-contract/ReadPolicy", {
+	defaultValue: () => () => Effect.succeed(true),
+});
+
+export const authorizeReads = Effect.fnUntraced(function* <A, E, R, TPolicyServices, TDenied>(
+	effect: Effect.Effect<A, E, R>,
+	request: { readonly rpc: Rpc.AnyWithProps; readonly payload: unknown },
+	policy: (key: Key) => Effect.Effect<boolean, never, TPolicyServices>,
+	denied: Effect.Effect<never, TDenied>,
+) {
+	const context = yield* Effect.context<TPolicyServices>();
+	function canRead(key: Key) {
+		return Effect.provideContext(policy(key), context);
+	}
+	const reads = Context.getOption(request.rpc.annotations, QueryReads);
+	if (Option.isSome(reads)) {
+		for (const key of reads.value(request.payload)) {
+			if (!(yield* canRead(key))) {
+				return yield* denied;
+			}
+		}
+	}
+	return yield* Effect.provideService(effect, ReadPolicy, canRead);
+});

package/src/serverMetadata.ts

@@ -0,0 +1,15 @@
+import { Context, Schema } from "effect";
+import { Rpc } from "effect/rpc";
+import { Key } from "./keys.ts";
+import { LiveHint } from "./live.ts";
+import type { CommandShape, QueryShape } from "./operation.ts";
+
+export class QueryReads extends Context.Service<QueryReads, QueryShape["reads"]>()("@shivaedev/effect-contract/QueryReads") {}
+
+export class CommandInvalidation extends Context.Service<CommandInvalidation, CommandShape["invalidates"]>()(
+	"@shivaedev/effect-contract/CommandInvalidation",
+) {}
+
+export function changesRpc<const TName extends string>(name: TName) {
+	return Rpc.make(`${name}.$changes`, { payload: { keys: Schema.Array(Key) }, stream: true, success: LiveHint });
+}

package/docs/north-star.md

@@ -1,45 +0,0 @@
-# North star
-
-## The problem
-
-A feature crosses several boundaries. A service knows its input, result and expected failures. An RPC operation repeats them. A client needs the same types, then separately needs to know which queries a successful write should refresh. When those descriptions live apart, they drift: a failure becomes an untyped message, a newly created item does not refresh, or a broad invalidation replaces unrelated views.
-
-Effect already provides the underlying pieces: Schema, typed Effects, Rpc, RpcGroup, middleware, AtomRpc, Reactivity and Streams. The missing piece is a small declaration that ties the feature's boundary and read/write dependencies together. Replacing those native pieces would introduce another model to learn and another owner for errors, interruption and resource lifetime.
-
-## The ideal
-
-A feature declares its boundary once. Its payload and success come from Schema. Its expected failures are tagged rejection classes that handlers and clients share. Queries name the dependencies they read. Commands name the dependencies their successful results change, including IDs returned by a create operation.
-
-That declaration is an ordinary native RPC group. Implementing, securing, hosting and calling it uses the APIs an Effect engineer already knows. The client binding adds only the mechanical work: register declared read keys on native query atoms and invalidate declared change keys after a successful call.
-
-Freshness has one vocabulary. An item change invalidates that item and its collection list. A reconciliation request uses an explicit read scope, rather than guessing that a list key covers all item queries. Optional live hints and resume signals request those same reads again. They do not hold replacement data; the successful query remains authoritative.
-
-## What good looks like
-
-- A reader finds the input, result, rejection and dependency rule together, and an agent can infer the types without repeating them at call sites.
-- A domain service can raise a rejection class that several operations reuse. Generated field rejections name the form fields they describe.
-- An ordinary query/command feature needs no subscription. A feature needing live freshness composes a native Stream with the same registry and keys.
-- A successful command refreshes affected views. A rejected command leaves those reads alone. A reconnect reconciles the caller's explicit scope, including changes missed while disconnected.
-- Native atoms retain query state and own stale-request interruption. The helper never becomes another cache or a parallel resource owner.
-- Browser code can import declarations, bindings and resume signals without bringing in React or server implementation packages.
-- Type tests, native client tests and real HTTP tests make different claims. Each claim stops at the boundary its evidence actually exercises.
-
-## Trade-offs
-
-- **Native composition over a shorter host setup.** Applications choose their native middleware, server host, serialization and AtomRpc service. The package removes repeated declarations without concealing those decisions.
-- **Precise dependency keys over convenient broad refresh.** A feature must name its reads and changes. Reconciliation must name a common scope when it needs one. Incorrect dependency discovery is an application error the library cannot infer away.
-- **Ordinary calls over mandatory streaming.** Live invalidation is optional. No query waits for a journal sequence, subscription cursor or change acknowledgment to return its domain value.
-- **Bounded observations over replay.** Paused live coordination records a bounded observation count and asks for current values on resume. It does not retain an unbounded list of events or promise recovery of each source change.
-- **Typed expected failures over transport-owned business wording.** Rejection schemas describe domain failures. Authentication policy, user-facing text and error presentation remain with the application and neighbouring packages.
-- **Consumer evidence over speculative helpers.** Add an abstraction after a consuming feature demonstrates repeated work. Preserve the native route for cases the helper does not cover.
-
-## What it deliberately leaves out
-
-- Service implementations, repositories, SQL transactions and commit-bound publication. These belong to `effect-service`, `effect-sql` and `effect-changes`.
-- Authentication policy, session resolution and request identity implementation. The shared server boundary belongs to `platform`; the application's host supplies its policy.
-- React hooks, rendering, editable drafts and form submission state. These belong to `effect-react` and `effect-form`.
-- A second client cache, a custom RPC transport or a required mutation atom.
-- An event journal, replay cursor, authoritative data stream, offline writes or cross-process delivery policy.
-- Claims of SSR, authenticated live delivery, physical browser lifecycle or native-device behavior based only on a local library fixture.
-
-Package status belongs in [roadmap.md](roadmap.md). Framework composition and deployment decisions belong in the [framework roadmap](https://github.com/ShivaeDev/platform/blob/main/docs/framework/roadmap.md).

package/docs/roadmap.md

@@ -1,26 +0,0 @@
-# Roadmap
-
-This file owns effect-contract's implementation status and package questions. The [framework roadmap](https://github.com/ShivaeDev/platform/blob/main/docs/framework/roadmap.md) owns application composition, adoption and deployment validation; it links here instead of repeating these package milestones.
-
-## Built
-
-- [x] `query`, `command` and `contract`: Schema payloads/results, namespaced native RPC groups, inline declarations, typed defaults, native handler layers and middleware. Compiler fixtures and native client round-trips cover the declared types and failures.
-- [x] `stream(name, { payload?, success, rejections?, reads })` declarations in `contract(..., { streams })` map to native RPC with `stream: true`. Bound `run` returns a native Stream. Compiler checks cover payloads, elements, errors, duplicate names and unary-client mismatch; real HTTP tests cover delivery, declared rejection, completion and client interruption releasing the server subscription. Work Board uses this path for its live subscription.
-- [x] Shared tagged rejection classes, generated operation-specific rejection classes and typed `reject` helpers. Field rejections derive and optionally narrow a struct's field names.
-- [x] Unique operation names checked in literal declarations and at construction when arrays conceal them.
-- [x] Collection item/list keys with native read hashing, deduplication and item-to-list mutation invalidation. Native Reactivity tests distinguish affected and unrelated items.
-- [x] Native AtomRpc binding with query atoms and per-call Effects. Successful commands invalidate their declared keys, including keys derived from results; rejected commands do not invalidate. Client type checks cover matching, larger, incomplete and incompatible RPC groups.
-- [x] Optional `LiveHint`/`Key` schemas and native live coordination: precise refresh, explicit first/reconnected scope reconciliation, a paused count capped at 256, typed stream failures and registry teardown. The framework guide owns the composed HTTP fixture evidence.
-- [x] `makeLiveServer` turns committed Reactivity keys into scoped hint streams and resyncs every active read scope. [Server evidence](https://github.com/ShivaeDev/platform/blob/main/packages/effect-contract/src/makeLiveServer.test.ts).
-- [x] Shared browser/native `resumeSignal`. Synthetic event tests cover visible versus hidden browser events, injected native callbacks, native SWR composition and listener disposal. The installed consumer checks an otherwise unobserved source's initialization and cleanup through `live`.
-- [x] Installed-package runtime and type fixtures for contracts, keys, rejection fields and live pause/resume composition.
-
-## Next
-
-No additional declaration or live helper is selected beyond the server helper used by the reference order handlers. A concrete consuming feature should establish the next repeated task before this package adds an abstraction. Host/proxy behavior, authenticated subscriptions, SSR and physical browser/mobile lifecycle remain framework or application validation work.
-
-## Open questions
-
-- Should query freshness, including live coordination and resume, remain this package's long-term scope? The APIs live here and public package consumers use them; the original declaration boundary does not by itself decide every future lifecycle helper.
-- Is the exported lower-level `rejectionSet` intended for application authors as well as operation construction? It is public and the operation tests exercise its implementation; direct standalone use has no dedicated regression fixture.
-- Which concrete consumer requirement should select the next package helper? There is no package-specific committed API backlog beyond the existing declarations, binding and freshness composition.