@voltro/protocol 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -39,6 +39,27 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.5.0] — 2026-07-18
+
+### ⚠ BREAKING
+
+- **@voltro/runtime** — `.one()` now fails when a query matches MORE than one row, not only when it matches none. It previously probed with `LIMIT 1`, so a filter that quietly stopped being unique returned an arbitrary row while the thrown error still claimed "expected exactly one row". It now probes with `LIMIT 2` and fails with `NoRowFound({ found: 2 })`. Migration: a `.one()` whose filter is not unique and that meant "any match" becomes `.first()` / `.maybeOne()`; one that meant "the unique row" stays as-is and now fails loudly when that assumption breaks. `NoRowFound` and `OptimisticLockError` are now `Schema.TaggedError`s, so they can be declared directly in a descriptor's `error:` union and caught with `Effect.catchTag`. Previously they carried a `_tag` field that looked declarable but did not typecheck there, forcing every caller to catch and re-wrap them in a hand-written tagged error — that wrapper can be deleted. Constructing one directly now takes an object: `new NoRowFound({ table, found })`, `new OptimisticLockError({ table, expected })`. `instanceof` and `_tag` checks are unaffected.
+
+### Added
+
+- **@voltro/protocol, @voltro/runtime, @voltro/cli, @voltro/mcp** — Relationship (ReBAC) authorization is now declarative. A descriptor can carry `guards: [{ action, resourceType, resource: (input) => input.id }]` alongside its scope guards; the framework resolves it before the executor (for a mutation, before the transaction opens) and fails with a typed `ScopeError` naming `<resourceType>:<action>`. `defineResourcePolicy` previously enforced nothing on its own. Making it bite required hand-building a map from rpc tag to policy rule and installing an interceptor — undocumented plumbing that nobody wired, and **fail-open by omission**: an rpc missing from the map passed unchecked, with no type error and no boot warning. A guard on the descriptor cannot be forgotten for an rpc that exists, because it is part of the rpc. `setTupleSource` registers where relations are read from — a real registry, not a per-call parameter. Both entrypoints register a default reading `_voltro_rebac_tuples`; an app whose relations already live in its own tables (a `teamMembers` row) registers its own instead of copying data into a framework table. Every unanswerable case DENIES: no tuple source, no policy for the type, an input that does not identify a resource, or a tuple source that throws. An authorization question nobody can answer is a refusal. The capability manifest now carries the declared guards, so a client gates UI on the same declaration the server enforces instead of a hand-kept copy. Only the data crosses the wire — the pure `resource` extractor stays server-side and is reported as `resourceScoped: true`, so a client knows the real answer is per-row and asks rather than assuming. Because guards are re-checked on every subscription delivery, a relationship revoked mid-session now ends the stream rather than continuing to serve it.
+- **@voltro/database, @voltro/runtime, @voltro/cli** — `paginateBy(descriptor, column, cursor, limit, direction?)` generalises `paginateById` to any orderable column. `paginateById` hardcoded `id`, which is right for a sortable key and useless for what feeds actually need — "the next page by `createdAt`" — so apps fell back to hand-rolled `limit + 1` / slice / `hasMore` triples on cursors the helper could not express. `paginateById` is now literally `paginateBy(descriptor, 'id', …)`, so the two cannot drift. `direction` flips the comparison as well as the sort: a `desc` feed pages with `<`. Mismatching those is the classic keyset bug — an ascending comparison under a descending sort returns the same first page forever. The docs example previously demonstrated a related trap (ordering by `createdAt desc` and then calling `paginateById`, which silently re-orders by `id asc`); it now shows the correct form and names the trap. `ctx.load` / `ctx.loadMany` add request-scoped batching. Same-tick reads of one table coalesce into a single `WHERE id IN (...)`, so a breadth-first walk costs one query per LEVEL rather than per node — the assembly shape `relations()` + `.with()` cannot express, because each level's ids come from the level above. Misses are cached too (a repeated dangling reference is fetched once) and a failed batch rejects its waiters without poisoning the cache, so a transient store error does not become "these rows do not exist" for the rest of the request. The cache is request-scoped as a correctness requirement, not a tuning choice: anything longer-lived would serve one subject's rows to another. Workflow steps can now `yield* EffectStore`. Handlers always could; workflow executors could not, so a step reading the store had to lift `ctx.store` with `Effect.tryPromise` — the idiom the rest of the framework tells you to avoid, because it discards the typed `StoreError` channel. The asymmetry was an oversight; the layer is now provided from the workflow context's own store.
+- **@voltro/cli** — `voltro capabilities [--json]` enumerates the framework's export surface by reading the `.d.ts` files in the project's own `node_modules`, so the answer to "what does this framework export" can be verified rather than recalled. The `--json` form is locale-independent and byte-stable, so it can be diffed across upgrades. Symbols that ship but appear nowhere in the project's seeded agent guide are flagged — limited to primitives and hooks, because counting every undocumented export on a real tree gave 1,088 (mostly types and internal Layers), a number too large to act on. `voltro doctor`'s hand-roll detector gained server rules: a hand-written not-found branch on `rows[0]` (→ `.one()`), several sequential `store.query` calls assembling related data (→ `relations()` + `.with()`), `ctx.store` lifted with `Effect.promise` (→ `EffectStore`), an imperative scope check at the top of an executor (→ `guards:`), a credential-shaped column with no `.encrypted()`, a notify/webhook helper at a mutation's tail (→ `defineSubscriber` / `defineReaction`), and hand-rolled cursor pagination (→ `paginateById`). Its scan roots now include the API app directories (`queries/`, `mutations/`, `database/`, …) — without that the server rules could never have fired. The always-loaded agent core now carries a "Pick the SERVER primitive" rubric alongside the client one, and a doc-coverage gate keeps the server surface from drifting out of it.
+- **@voltro/runtime, @voltro/cli** — `ctx.outbox.enqueue(effect, payload, options?)` — a reliable external side effect from a mutation. The enqueue writes through `ctx.store`, which inside a mutation IS the transactional view, so the intent to deliver commits in the same transaction as the domain write or not at all. That closes the window a post-commit tap cannot: `@voltro/plugin-cdc-out` is at-least-once *from enqueue* (its own docs say so — a crash between commit and tap loses the event). Here the enqueue cannot be lost, because losing it means the domain write rolled back too. Delivery after commit remains at-least-once, so handlers must be idempotent; `idempotencyKey` makes that easy to honour. Delivery is declared per effect in a `*.outbox.ts` via `defineOutboxHandler`. The worker is nudged on commit for the fast path and polls every 5s — the poll is the contract, not the optimisation: it recovers rows whose nudge was lost to a crash, rows from another replica, and rows waiting out a backoff. Exponential backoff capped at 5 minutes, configurable `maxAttempts` (default 8), and a dead-letter that stays queryable in `_voltro_outbox` with its `lastError`. An effect with no registered handler is left PENDING rather than dead-lettered — the usual cause is a deploy where the enqueuing code shipped ahead of its handler, and discarding those would turn a rollout ordering detail into permanent loss of a side effect the app believes happened. Two handlers claiming one effect are refused at boot with both filenames. `_voltro_outbox` rides the declarative differ and is created only when the app declares at least one handler. Wired in both `voltro dev` and `voltro serve`.
+- **@voltro/database, @voltro/runtime** — `ctx.store.query()` now returns the row type instead of `Readonly<Record<string, unknown>>`. `QueryDescriptor<R>` carries a phantom row type, so the shape the typed builder already knew survives `.descriptor` into the store: ```ts const rows = await ctx.store.query(database.notes.where(eq('id', id)).descriptor) rows[0].title   // string — previously `rows[0]['title'] as string` ``` The type was always available; it was dropped at exactly this boundary, which is why reading a field meant casting. One downstream app accumulated 2,032 of those casts against a surface that could have typed them all along. `EffectStore.query` is typed the same way, so an Effect-form handler keeps both the row type and the `StoreError` channel. A hand-built descriptor still resolves to `Row` — this never types less than before, so it is additive: existing code keeps compiling, and the casts it contains simply become redundant. The driver-level `DataStore.query` stays untyped deliberately. It is the SPI every dialect store and transactional view implements, and those genuinely do return untyped rows off the wire; the type is re-applied one layer up, at the handler-facing `FluentStore`.
+
+### Fixed
+
+- **@voltro/runtime, @voltro/cli** — Declarative `guards:` are now re-checked before EVERY subscription delivery, not only when the subscription is opened. A subscription is a long-lived authorization grant, and the scopes that justified it can be withdrawn while it is still open — a role revoked, a resource un-shared, a membership ended. Previously the gate ran once at subscribe and every later delivery re-ran the query and pushed rows out without re-asking, so a revoked subject kept receiving live updates until their socket happened to drop. A denial now ends the subscription with the typed `ScopeError` rather than silently freezing the subscriber on its last authorized value, and the re-check runs BEFORE the read, so a revoked subject's rows are never materialised. Both the descriptor and computed-query paths are covered, in both `voltro dev` and `voltro serve`. Non-authorization failures (a bad predicate, a dropped connection) still leave the subscriber on its last good snapshot as before.
+- **@voltro/testing, @voltro/cli** — - **`@voltro/testing`'s context now provides `ctx.load` / `ctx.loadMany`.** The request-scoped batching helpers were added to the handler context but not to the test harness, so `makeTestContext` no longer satisfied `AppContext` — any suite building a context failed to typecheck, and a handler calling `ctx.load` could not be tested at all. The harness now builds a loader over the same underlying store (one per context, so `withSubject` / `withTenant` can't serve one subject's cached rows to another), mirroring the real builder. - **The `.one()` codemod is declared for 0.5.0, not 0.4.0.** It was authored while 0.4.0 was unreleased; since codemods are selected with `from < version <= to`, leaving it at 0.4.0 would have silently skipped it for everyone upgrading from 0.4.0 — exactly the users who need it.
+
+---
+
 ## [0.4.0] — 2026-07-18
 
 ### ⚠ BREAKING

package/dist/index.d.ts

@@ -29,6 +29,12 @@ export declare const ADMIN_SCOPE = "admin:full";
 
 export declare const anonymousSubject: (tenantId: string | null) => Subject;
 
+/** A guard entry is either a scope check or a relationship check. */
+export declare type AnyCheckSpec = GuardCheckSpec | PolicyCheckSpec;
+
+/** A guard is either a scope check or a relationship check. */
+export declare type AnyGuardSpec<Input = unknown> = GuardSpec<Input> | PolicyGuardSpec<Input>;
+
 /**
  * Apply a `RowPatch` to `prev`, producing `next`. Exact inverse of
  * `diffRows`: `applyRowPatch(prev, diffRows(prev, next))` deep-equals
@@ -171,7 +177,7 @@ export declare const checkFrameworkCompat: (pluginName: string, range: string |
  * mutations, before the transaction opens). The `admin:full` bypass passes
  * everything.
  */
-export declare const checkGuards: (subject: Subject, guards: ReadonlyArray<GuardCheckSpec> | undefined) => ScopeError | null;
+export declare const checkGuards: (subject: Subject, guards: ReadonlyArray<AnyCheckSpec> | undefined) => ScopeError | null;
 
 /**
  * The resource-aware counterpart of `checkGuards`. Identical semantics when no
@@ -188,7 +194,7 @@ export declare const checkGuards: (subject: Subject, guards: ReadonlyArray<Guard
  * every guard passes. The runtime calls this in the dispatch spine BEFORE the
  * executor (mutations: before the transaction opens).
  */
-export declare const checkGuardsEffect: (subject: Subject, guards: ReadonlyArray<GuardCheckSpec> | undefined, input: unknown) => Effect.Effect<ScopeError | null>;
+export declare const checkGuardsEffect: (subject: Subject, guards: ReadonlyArray<AnyCheckSpec> | undefined, input: unknown) => Effect.Effect<ScopeError | null>;
 
 export declare interface ClientDescriptor {
     readonly kind: 'query' | 'mutation' | 'action' | 'stream' | 'workflow';
@@ -499,6 +505,9 @@ export declare const failIdempotent: (store: IdempotencyStore, scope: string, ke
 /** Record a completed response for replay. */
 export declare const finishIdempotent: (store: IdempotencyStore, scope: string, key: string, response: IdempotencyResponse, now: number) => Promise<void>;
 
+/** The currently-registered policy-guard resolver, or `undefined`. */
+export declare const getPolicyGuardResolver: () => PolicyGuardResolver | undefined;
+
 /** The currently-registered resource-scope resolver, or `undefined`. */
 export declare const getResourceScopeResolver: () => ResourceScopeResolver | undefined;
 
@@ -517,7 +526,7 @@ export declare interface GuardCheckSpec {
 
 /** One or more declarative guards on a descriptor. All must pass (AND across
  *  entries; `mode` controls AND/OR WITHIN one entry's scope array). */
-export declare type Guards<Input = unknown> = ReadonlyArray<GuardSpec<Input>>;
+export declare type Guards<Input = unknown> = ReadonlyArray<AnyGuardSpec<Input>>;
 
 export declare interface GuardSpec<Input = unknown> {
     /** Required permission scope(s). A single string, or an array combined by
@@ -683,6 +692,12 @@ export declare interface InsertTarget<Input = unknown, Row = unknown, Item = Rec
  *  diffed by id and falls back to shipping the full data. */
 export declare const isIdKeyed: (rows: ReadonlyArray<Readonly<Record<string, unknown>>>) => rows is ReadonlyArray<PatchRow>;
 
+/** Runtime narrowing for the relationship variant. */
+export declare const isPolicyCheck: (g: AnyCheckSpec) => g is PolicyCheckSpec;
+
+/** Narrow a guard entry to the relationship variant. */
+export declare const isPolicyGuard: <I>(g: AnyGuardSpec<I>) => g is PolicyGuardSpec<I>;
+
 export declare const isSystemSubject: (subject: Subject) => boolean;
 
 /** In-memory store — the default for single-process dev + the test double. */
@@ -1341,6 +1356,61 @@ export declare interface PluginTemplate {
  */
 export declare type PluginUninstallHook = (ctx: PluginLifecycleContext) => Effect.Effect<void, unknown> | Promise<void> | void;
 
+/** The runtime-erased form of `PolicyGuardSpec` — a relationship check. */
+export declare interface PolicyCheckSpec {
+    readonly action: string;
+    readonly resourceType: string;
+    readonly resource: (input: unknown) => string | undefined;
+}
+
+/** The question the runtime asks a registered policy-guard resolver. */
+export declare interface PolicyGuardRequest {
+    readonly subject: Subject;
+    /** The action named in the resource policy's `actions` map. */
+    readonly action: string;
+    readonly resourceType: string;
+    /** The id the guard's pure `resource` extractor produced. */
+    readonly resourceId: string;
+}
+
+/**
+ * Answers "does `subject` have `action` on `<resourceType>:<resourceId>`".
+ * Registered once at boot via `setPolicyGuardResolver`. A failed Effect is
+ * treated as a DENIAL — a resolver wanting another posture catches its own
+ * errors.
+ */
+export declare type PolicyGuardResolver = (req: PolicyGuardRequest) => Effect.Effect<boolean, unknown>;
+
+/**
+ * A relationship (ReBAC) guard — "may this subject perform ACTION on THIS row?"
+ *
+ * The scope guard above answers "what may this subject do at all"; this answers
+ * "on which row". Both live in the same `guards:` array on purpose, because the
+ * alternative is what apps actually built: a hand-maintained map from rpc tag →
+ * policy rule, installed as an interceptor. That map is FAIL-OPEN BY OMISSION —
+ * add an rpc, forget the entry, and it is silently unguarded. A declaration on
+ * the descriptor cannot be forgotten for an rpc that exists, because it IS the
+ * rpc.
+ *
+ * Browser-safe by the same construction as `GuardSpec`: strings plus a PURE
+ * `resource` extractor. Resolution — reading relationship tuples, applying the
+ * policy's `implies` closure — happens server-side through the registered
+ * policy resolver. With no resolver registered the check FAILS CLOSED: an
+ * unanswerable authorization question is a denial, never a pass.
+ *
+ * Because it is data, the same declaration compiles into the capability
+ * manifest the client reads, so a UI gate and the server check cannot drift.
+ */
+export declare interface PolicyGuardSpec<Input = unknown> {
+    /** The action to authorize, as named in the resource policy's `actions`. */
+    readonly action: string;
+    /** Which registered resource policy governs the check. */
+    readonly resourceType: string;
+    /** PURE `input → resource id`. Returning undefined DENIES — an unidentifiable
+     *  resource is not a reason to skip the check. */
+    readonly resource: (input: Input) => string | undefined;
+}
+
 export declare type ProcedureDescriptor = QueryProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All> | MutationProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All> | ActionProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All> | StreamProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All>;
 
 export declare const PROTOCOL_VERSION: 1;
@@ -1736,6 +1806,11 @@ export declare type ServerErrorSource = 'rest' | 'aggregate' | 'subscriber' | 'r
  */
 export declare const setEffectiveScopes: (subject: Subject, scopes: ReadonlyArray<string>) => void;
 
+/** Register (or clear) the process-global policy-guard resolver. Last write
+ *  wins. The runtime installs one backed by the resource-policy registry and
+ *  the registered tuple source. */
+export declare const setPolicyGuardResolver: (resolver: PolicyGuardResolver | undefined) => void;
+
 /**
  * Register (or clear, with `undefined`) the process-global resource-scope
  * resolver. Call once at boot — from `@voltro/plugin-rbac`'s wiring, or directly

package/dist/index.js

@@ -1,30 +1,30 @@
-import { _ as e, a as t, c as n, d as r, f as i, g as a, h as o, i as ee, l as s, m as te, n as ne, o as re, p as ie, r as ae, s as oe, t as c, u as se, v as ce, y as le } from "./serverErrorBus-0wjvKwGO.js";
-import { a as ue, c as de, d as fe, f as pe, i as me, l as he, n as ge, o as _e, r as ve, s as ye, t as be, u as l } from "./auth-DCE6m7Bo.js";
-import { Context as u, Layer as xe, Schema as d } from "effect";
-import { Rpc as f } from "@effect/rpc";
+import { S as e, _ as t, a as n, b as r, c as i, d as a, f as o, g as ee, h as te, i as ne, l as s, m as c, n as re, o as ie, p as ae, r as oe, s as se, t as ce, u as le, v as ue, x as de, y as fe } from "./serverErrorBus-XDdIJk0c.js";
+import { a as pe, c as me, d as he, f as ge, i as _e, l as ve, n as ye, o as be, r as xe, s as Se, t as Ce, u as we } from "./auth-DCE6m7Bo.js";
+import { Context as Te, Layer as Ee, Schema as l } from "effect";
+import { Rpc as u } from "@effect/rpc";
 //#region src/rowPatch.ts
-var Se = d.Union(d.String, d.Number), p = d.Record({
-	key: d.String,
-	value: d.Unknown
-}).pipe(d.filter((e) => "id" in e, { message: () => "patch row must carry an id" })), m = d.Union(d.Struct({
-	op: d.Literal("add"),
-	path: d.String,
-	value: p
-}), d.Struct({
-	op: d.Literal("replace"),
-	path: d.String,
-	value: p
-}), d.Struct({
-	op: d.Literal("remove"),
-	path: d.String
-})), h = d.Struct({
-	ops: d.Array(m),
-	order: d.Array(Se)
-}), g = (e) => `/${String(e).replace(/~/g, "~0").replace(/\//g, "~1")}`, Ce = (e) => (e.startsWith("/") ? e.slice(1) : e).replace(/~1/g, "/").replace(/~0/g, "~"), _ = (e) => {
+var De = l.Union(l.String, l.Number), d = l.Record({
+	key: l.String,
+	value: l.Unknown
+}).pipe(l.filter((e) => "id" in e, { message: () => "patch row must carry an id" })), f = l.Union(l.Struct({
+	op: l.Literal("add"),
+	path: l.String,
+	value: d
+}), l.Struct({
+	op: l.Literal("replace"),
+	path: l.String,
+	value: d
+}), l.Struct({
+	op: l.Literal("remove"),
+	path: l.String
+})), p = l.Struct({
+	ops: l.Array(f),
+	order: l.Array(De)
+}), m = (e) => `/${String(e).replace(/~/g, "~0").replace(/\//g, "~1")}`, Oe = (e) => (e.startsWith("/") ? e.slice(1) : e).replace(/~1/g, "/").replace(/~0/g, "~"), h = (e) => {
 	let t = Object.keys(e).sort(), n = {};
 	for (let r of t) n[r] = e[r];
 	return JSON.stringify(n);
-}, we = (e, t) => _(e) === _(t), Te = (e, t) => {
+}, ke = (e, t) => h(e) === h(t), Ae = (e, t) => {
 	let n = /* @__PURE__ */ new Map();
 	for (let t of e) n.set(t.id, t);
 	let r = [], i = [], a = /* @__PURE__ */ new Set();
@@ -33,26 +33,26 @@ var Se = d.Union(d.String, d.Number), p = d.Record({
 		let t = n.get(e.id);
 		t === void 0 ? r.push({
 			op: "add",
-			path: g(e.id),
+			path: m(e.id),
 			value: e
-		}) : we(t, e) || r.push({
+		}) : ke(t, e) || r.push({
 			op: "replace",
-			path: g(e.id),
+			path: m(e.id),
 			value: e
 		});
 	}
 	for (let t of e) a.has(t.id) || r.push({
 		op: "remove",
-		path: g(t.id)
+		path: m(t.id)
 	});
 	return {
 		ops: r,
 		order: i
 	};
-}, Ee = (e) => e.every((e) => {
+}, je = (e) => e.every((e) => {
 	let t = e.id;
 	return typeof t == "string" || typeof t == "number";
-}), De = (e, t) => {
+}), Me = (e, t) => {
 	let n = /* @__PURE__ */ new Map();
 	for (let t of e) n.set(t.id, t);
 	for (let e of t.ops) (e.op === "add" || e.op === "replace") && n.set(e.value.id, e.value);
@@ -62,82 +62,82 @@ var Se = d.Union(d.String, d.Number), p = d.Record({
 		t !== void 0 && r.push(t);
 	}
 	return r;
-}, v = (e) => d.Union(d.Struct({
-	_tag: d.Literal("snapshot"),
-	revision: d.Number,
+}, g = (e) => l.Union(l.Struct({
+	_tag: l.Literal("snapshot"),
+	revision: l.Number,
 	data: e,
-	computed: d.optional(d.Boolean)
-}), d.Struct({
-	_tag: d.Literal("delta"),
-	revision: d.Number,
-	emittedAt: d.Number,
-	patch: h
-}), d.Struct({
-	_tag: d.Literal("error"),
-	error: d.Unknown,
-	revision: d.optional(d.Number)
-})), y = (e) => ({
+	computed: l.optional(l.Boolean)
+}), l.Struct({
+	_tag: l.Literal("delta"),
+	revision: l.Number,
+	emittedAt: l.Number,
+	patch: p
+}), l.Struct({
+	_tag: l.Literal("error"),
+	error: l.Unknown,
+	revision: l.optional(l.Number)
+})), Ne = (e) => e.action !== void 0 && e.resourceType !== void 0, _ = (e) => ({
 	kind: "query",
 	name: e.name,
 	input: e.input,
 	output: e.output,
-	error: e.error ?? d.Never,
+	error: e.error ?? l.Never,
 	source: e.source,
 	cache: e.cache,
 	guards: e.guards,
 	publicApi: e.publicApi,
 	exposeAsTool: e.exposeAsTool
-}), b = (e) => ({
+}), v = (e) => ({
 	kind: "mutation",
 	name: e.name,
 	input: e.input,
 	output: e.output,
-	error: e.error ?? d.Never,
+	error: e.error ?? l.Never,
 	target: e.target,
 	guards: e.guards,
 	publicApi: e.publicApi,
 	exposeAsTool: e.exposeAsTool
-}), x = (e) => ({
+}), y = (e) => ({
 	kind: "action",
 	name: e.name,
 	input: e.input,
 	output: e.output,
-	error: e.error ?? d.Never,
+	error: e.error ?? l.Never,
 	guards: e.guards,
 	publicApi: e.publicApi,
 	exposeAsTool: e.exposeAsTool
-}), Oe = (e) => ({
+}), b = (e) => ({
 	kind: "stream",
 	name: e.name,
 	input: e.input,
 	element: e.element,
-	error: e.error ?? d.Never
-}), S = (e, t) => t && t.length > 0 ? d.Union(e, ...t) : e, C = (e, t) => t && t.length > 0 ? d.Union(e, s) : e, w = (e, t) => f.make(e.name, {
+	error: e.error ?? l.Never
+}), x = (e, t) => t && t.length > 0 ? l.Union(e, ...t) : e, S = (e, t) => t && t.length > 0 ? l.Union(e, s) : e, C = (e, t) => u.make(e.name, {
 	payload: e.input,
-	success: v(e.output),
-	error: S(C(e.error, e.guards), t),
+	success: g(e.output),
+	error: x(S(e.error, e.guards), t),
 	stream: !0
-}), T = (e, t) => f.make(e.name, {
+}), w = (e, t) => u.make(e.name, {
 	payload: e.input,
 	success: e.output,
-	error: S(C(e.error, e.guards), t)
-}), E = (e, t) => f.make(e.name, {
+	error: x(S(e.error, e.guards), t)
+}), T = (e, t) => u.make(e.name, {
 	payload: e.input,
 	success: e.output,
-	error: S(C(e.error, e.guards), t)
-}), D = (e, t) => f.make(e.name, {
+	error: x(S(e.error, e.guards), t)
+}), E = (e, t) => u.make(e.name, {
 	payload: e.input,
 	success: e.element,
-	error: S(e.error, t),
+	error: x(e.error, t),
 	stream: !0
-}), ke = (e) => {
+}), Pe = (e) => {
 	switch (e.kind) {
-		case "query": return w(e);
-		case "mutation": return T(e);
-		case "action": return E(e);
-		case "stream": return D(e);
+		case "query": return C(e);
+		case "mutation": return w(e);
+		case "action": return T(e);
+		case "stream": return E(e);
 	}
-}, Ae = (e) => {
+}, Fe = (e) => {
 	let t = e.input, n = t === void 0 ? {} : { input: t }, r = e.output, i = r === void 0 ? {} : { output: r };
 	if (e.kind === "query") return {
 		kind: "query",
@@ -178,15 +178,15 @@ var Se = d.Union(d.String, d.Number), p = d.Record({
 			..."shapeItem" in e && e.shapeItem !== void 0 ? { shapeItem: e.shapeItem } : {}
 		}))
 	};
-}, je = (e) => e, Me = (e) => e, Ne = (e) => {
+}, Ie = (e) => e, Le = (e) => e, Re = (e) => {
 	if (e.length !== 0) return (t, n) => e.reduceRight((e, t) => t(e, n), t);
-}, Pe = (e, t) => {
-	let n = u.GenericTag(e);
+}, ze = (e, t) => {
+	let n = Te.GenericTag(e);
 	return {
 		Tag: n,
-		Live: xe.succeed(n, t)
+		Live: Ee.succeed(n, t)
 	};
-}, Fe = (e, t, n) => {
+}, D = (e, t, n) => {
 	if (!t) return { ok: !0 };
 	let r = O(n);
 	if (!r) return {
@@ -196,7 +196,7 @@ var Se = d.Union(d.String, d.Number), p = d.Record({
 	let i = t.trim();
 	if (i === "*" || i === "") return { ok: !0 };
 	let a = i.split(/\s+/).filter((e) => e.length > 0);
-	for (let i of a) if (!Ie(i, r)) return {
+	for (let i of a) if (!Be(i, r)) return {
 		ok: !1,
 		reason: `plugin "${e}" requires framework ${t}, running ${n}`
 	};
@@ -209,7 +209,7 @@ var Se = d.Union(d.String, d.Number), p = d.Record({
 		patch: Number(t[3]),
 		pre: t[4] ?? ""
 	} : null;
-}, k = (e, t) => e.major === t.major ? e.minor === t.minor ? e.patch === t.patch ? e.pre && !t.pre ? -1 : !e.pre && t.pre ? 1 : e.pre && t.pre ? e.pre < t.pre ? -1 : +(e.pre > t.pre) : 0 : e.patch - t.patch : e.minor - t.minor : e.major - t.major, Ie = (e, t) => {
+}, k = (e, t) => e.major === t.major ? e.minor === t.minor ? e.patch === t.patch ? e.pre && !t.pre ? -1 : !e.pre && t.pre ? 1 : e.pre && t.pre ? e.pre < t.pre ? -1 : +(e.pre > t.pre) : 0 : e.patch - t.patch : e.minor - t.minor : e.major - t.major, Be = (e, t) => {
 	if (e === "*") return !0;
 	if (e.startsWith("^")) {
 		let n = O(e.slice(1));
@@ -231,173 +231,173 @@ var Se = d.Union(d.String, d.Number), p = d.Record({
 	}
 	let r = O(e);
 	return r ? k(t, r) === 0 : !1;
-}, A = d.Literal("running", "succeeded", "failed", "cancelled", "suspended"), j = d.Literal("cancel", "terminate", "abandon"), Le = d.Struct({
-	id: d.String,
-	workflowName: d.String,
-	executionId: d.String,
-	status: d.Literal("running")
-}), M = d.Struct({
-	id: d.String,
-	tag: d.String,
-	executionId: d.String,
+}, A = l.Literal("running", "succeeded", "failed", "cancelled", "suspended"), j = l.Literal("cancel", "terminate", "abandon"), Ve = l.Struct({
+	id: l.String,
+	workflowName: l.String,
+	executionId: l.String,
+	status: l.Literal("running")
+}), M = l.Struct({
+	id: l.String,
+	tag: l.String,
+	executionId: l.String,
 	status: A,
-	payload: d.Unknown,
-	workflowVersion: d.NullOr(d.String),
-	workflowPatches: d.NullOr(d.Unknown),
-	output: d.NullOr(d.Unknown),
-	subject: d.NullOr(d.Unknown),
-	source: d.NullOr(d.String),
-	errorTag: d.NullOr(d.String),
-	errorMessage: d.NullOr(d.String),
-	cancelled: d.Boolean,
-	startedAt: d.Date,
-	completedAt: d.NullOr(d.Date),
-	durationMs: d.NullOr(d.Number),
-	traceId: d.NullOr(d.String),
-	parentExecutionId: d.NullOr(d.String),
-	parentClosePolicy: d.NullOr(j)
-}), N = d.Struct({
-	tag: d.optional(d.String),
-	status: d.optional(A),
-	limit: d.optional(d.Number)
-}), P = d.Struct({
-	id: d.String,
-	runId: d.String,
-	stepName: d.String,
-	attempt: d.Number,
-	status: d.Literal("running", "succeeded", "failed"),
-	input: d.NullOr(d.Unknown),
-	retryPolicy: d.NullOr(d.Unknown),
-	output: d.NullOr(d.Unknown),
-	errorTag: d.NullOr(d.String),
-	errorMessage: d.NullOr(d.String),
-	errorCause: d.NullOr(d.Unknown),
-	startedAt: d.Date,
-	completedAt: d.NullOr(d.Date),
-	durationMs: d.NullOr(d.Number)
-}), F = d.Struct({
-	id: d.String,
-	runId: d.String,
-	eventType: d.String,
-	payload: d.NullOr(d.Unknown),
-	occurredAt: d.Date,
-	stepName: d.NullOr(d.String),
-	attempt: d.NullOr(d.Number)
-}), I = d.Struct({
-	id: d.String,
-	name: d.String,
-	payload: d.Unknown,
-	source: d.String,
-	subject: d.NullOr(d.Unknown),
-	traceId: d.NullOr(d.String),
-	occurredAt: d.Date
-}), L = d.Struct({
-	id: d.String,
-	eventId: d.String,
-	eventName: d.String,
-	triggerId: d.String,
-	workflowName: d.String,
-	executionId: d.NullOr(d.String),
-	status: d.Literal("starting", "started", "skipped", "failed"),
-	idempotencyKey: d.String,
-	skipped: d.Boolean,
-	errorMessage: d.NullOr(d.String),
-	createdAt: d.Date,
-	completedAt: d.NullOr(d.Date)
-}), R = d.Struct({ id: d.String }), z = d.Struct({ runId: d.String }), B = d.Struct({
-	name: d.optional(d.String),
-	limit: d.optional(d.Number)
-}), V = d.Struct({ eventId: d.String }), H = d.Struct({
-	workflowName: d.String,
-	executionId: d.String
-}), U = d.Struct({
-	id: d.String,
-	signalName: d.String,
-	payload: d.optional(d.Unknown)
-}), W = d.Struct({
-	id: d.String,
-	updateName: d.String,
-	payload: d.optional(d.Unknown),
-	timeoutMs: d.optional(d.Number)
-}), G = d.Struct({
-	eventId: d.String,
-	updateId: d.String,
-	completedEventId: d.String,
-	result: d.Unknown
-}), Re = y({
+	payload: l.Unknown,
+	workflowVersion: l.NullOr(l.String),
+	workflowPatches: l.NullOr(l.Unknown),
+	output: l.NullOr(l.Unknown),
+	subject: l.NullOr(l.Unknown),
+	source: l.NullOr(l.String),
+	errorTag: l.NullOr(l.String),
+	errorMessage: l.NullOr(l.String),
+	cancelled: l.Boolean,
+	startedAt: l.Date,
+	completedAt: l.NullOr(l.Date),
+	durationMs: l.NullOr(l.Number),
+	traceId: l.NullOr(l.String),
+	parentExecutionId: l.NullOr(l.String),
+	parentClosePolicy: l.NullOr(j)
+}), N = l.Struct({
+	tag: l.optional(l.String),
+	status: l.optional(A),
+	limit: l.optional(l.Number)
+}), P = l.Struct({
+	id: l.String,
+	runId: l.String,
+	stepName: l.String,
+	attempt: l.Number,
+	status: l.Literal("running", "succeeded", "failed"),
+	input: l.NullOr(l.Unknown),
+	retryPolicy: l.NullOr(l.Unknown),
+	output: l.NullOr(l.Unknown),
+	errorTag: l.NullOr(l.String),
+	errorMessage: l.NullOr(l.String),
+	errorCause: l.NullOr(l.Unknown),
+	startedAt: l.Date,
+	completedAt: l.NullOr(l.Date),
+	durationMs: l.NullOr(l.Number)
+}), F = l.Struct({
+	id: l.String,
+	runId: l.String,
+	eventType: l.String,
+	payload: l.NullOr(l.Unknown),
+	occurredAt: l.Date,
+	stepName: l.NullOr(l.String),
+	attempt: l.NullOr(l.Number)
+}), I = l.Struct({
+	id: l.String,
+	name: l.String,
+	payload: l.Unknown,
+	source: l.String,
+	subject: l.NullOr(l.Unknown),
+	traceId: l.NullOr(l.String),
+	occurredAt: l.Date
+}), L = l.Struct({
+	id: l.String,
+	eventId: l.String,
+	eventName: l.String,
+	triggerId: l.String,
+	workflowName: l.String,
+	executionId: l.NullOr(l.String),
+	status: l.Literal("starting", "started", "skipped", "failed"),
+	idempotencyKey: l.String,
+	skipped: l.Boolean,
+	errorMessage: l.NullOr(l.String),
+	createdAt: l.Date,
+	completedAt: l.NullOr(l.Date)
+}), R = l.Struct({ id: l.String }), z = l.Struct({ runId: l.String }), B = l.Struct({
+	name: l.optional(l.String),
+	limit: l.optional(l.Number)
+}), V = l.Struct({ eventId: l.String }), H = l.Struct({
+	workflowName: l.String,
+	executionId: l.String
+}), U = l.Struct({
+	id: l.String,
+	signalName: l.String,
+	payload: l.optional(l.Unknown)
+}), W = l.Struct({
+	id: l.String,
+	updateName: l.String,
+	payload: l.optional(l.Unknown),
+	timeoutMs: l.optional(l.Number)
+}), G = l.Struct({
+	eventId: l.String,
+	updateId: l.String,
+	completedEventId: l.String,
+	result: l.Unknown
+}), He = _({
 	name: "__voltro.workflow.run",
 	source: "_voltro_workflow_runs",
 	input: R,
-	output: d.Array(M)
-}), ze = y({
+	output: l.Array(M)
+}), Ue = _({
 	name: "__voltro.workflow.runs",
 	source: "_voltro_workflow_runs",
 	input: N,
-	output: d.Array(M)
-}), Be = y({
+	output: l.Array(M)
+}), We = _({
 	name: "__voltro.workflow.run.steps",
 	source: "_voltro_workflow_run_steps",
 	input: z,
-	output: d.Array(P)
-}), Ve = y({
+	output: l.Array(P)
+}), Ge = _({
 	name: "__voltro.workflow.run.events",
 	source: "_voltro_workflow_run_events",
 	input: z,
-	output: d.Array(F)
-}), He = y({
+	output: l.Array(F)
+}), Ke = _({
 	name: "__voltro.workflow.domainEvents",
 	source: "_voltro_workflow_events",
 	input: B,
-	output: d.Array(I)
-}), Ue = y({
+	output: l.Array(I)
+}), qe = _({
 	name: "__voltro.workflow.event.deliveries",
 	source: "_voltro_workflow_event_deliveries",
 	input: V,
-	output: d.Array(L)
-}), We = x({
+	output: l.Array(L)
+}), Je = y({
 	name: "__voltro.workflow.cancel",
 	input: H,
-	output: d.Struct({ ok: d.Boolean })
-}), Ge = x({
+	output: l.Struct({ ok: l.Boolean })
+}), Ye = y({
 	name: "__voltro.workflow.resume",
 	input: H,
-	output: d.Struct({ ok: d.Boolean })
-}), Ke = x({
+	output: l.Struct({ ok: l.Boolean })
+}), Xe = y({
 	name: "__voltro.workflow.signal",
 	input: U,
-	output: d.Struct({ eventId: d.String })
-}), qe = x({
+	output: l.Struct({ eventId: l.String })
+}), Ze = y({
 	name: "__voltro.workflow.update",
 	input: W,
 	output: G
-}), K = "__voltro.undo.log", q = "__voltro.undo.apply", J = "__voltro.undo.redo", Y = d.Struct({
-	id: d.String,
-	tag: d.String,
-	label: d.NullOr(d.String),
-	undone: d.Boolean,
-	crossesAction: d.Boolean,
-	createdAt: d.String
-}), X = class extends d.TaggedError()("UndoNotFound", { invocationId: d.String }) {}, Z = class extends d.TaggedError()("UndoForbidden", { invocationId: d.String }) {}, Q = class extends d.TaggedError()("UndoConflict", {
-	invocationId: d.String,
-	reason: d.Literal("conflict", "action")
-}) {}, $ = d.Union(X, Z, Q), Je = y({
+}), K = "__voltro.undo.log", q = "__voltro.undo.apply", J = "__voltro.undo.redo", Y = l.Struct({
+	id: l.String,
+	tag: l.String,
+	label: l.NullOr(l.String),
+	undone: l.Boolean,
+	crossesAction: l.Boolean,
+	createdAt: l.String
+}), X = class extends l.TaggedError()("UndoNotFound", { invocationId: l.String }) {}, Z = class extends l.TaggedError()("UndoForbidden", { invocationId: l.String }) {}, Q = class extends l.TaggedError()("UndoConflict", {
+	invocationId: l.String,
+	reason: l.Literal("conflict", "action")
+}) {}, $ = l.Union(X, Z, Q), Qe = _({
 	name: K,
 	source: "_voltro_undo_log",
-	input: d.Struct({ limit: d.optional(d.Number) }),
-	output: d.Array(Y)
-}), Ye = b({
+	input: l.Struct({ limit: l.optional(l.Number) }),
+	output: l.Array(Y)
+}), $e = v({
 	name: q,
-	input: d.Struct({ invocationId: d.String }),
-	output: d.Struct({ ok: d.Boolean }),
+	input: l.Struct({ invocationId: l.String }),
+	output: l.Struct({ ok: l.Boolean }),
 	error: $
-}), Xe = b({
+}), et = v({
 	name: J,
-	input: d.Struct({ invocationId: d.String }),
-	output: d.Struct({ ok: d.Boolean }),
+	input: l.Struct({ invocationId: l.String }),
+	output: l.Struct({ ok: l.Boolean }),
 	error: $
-}), Ze = (e) => {
+}), tt = (e) => {
 	let t = e instanceof Date ? e.getTime() : typeof e == "number" ? e : typeof e == "string" ? new Date(e).getTime() : 0;
 	return Number.isNaN(t) ? 0 : t;
-}, Qe = 1;
+}, nt = 1;
 //#endregion
-export { n as ADMIN_SCOPE, be as AuthMiddleware, ge as ConnectionInfo, ve as ConnectionInfoMiddleware, Qe as PROTOCOL_VERSION, s as ScopeError, me as Subject, ue as SubjectService, q as UNDO_APPLY_TAG, K as UNDO_LOG_TAG, J as UNDO_REDO_TAG, _e as Unauthenticated, Q as UndoConflict, Z as UndoForbidden, Y as UndoLogEntry, X as UndoNotFound, H as WorkflowControlInputSchema, I as WorkflowDomainEventRowSchema, B as WorkflowDomainEventsInputSchema, V as WorkflowEventDeliveriesInputSchema, L as WorkflowEventDeliveryRowSchema, j as WorkflowParentClosePolicySchema, F as WorkflowRunEventRowSchema, Le as WorkflowRunHandleSchema, R as WorkflowRunRefSchema, M as WorkflowRunRowSchema, A as WorkflowRunStatusSchema, P as WorkflowRunStepRowSchema, z as WorkflowRunTableRefSchema, N as WorkflowRunsInputSchema, U as WorkflowSignalInputSchema, W as WorkflowUpdateInputSchema, G as WorkflowUpdateResultSchema, E as actionToRpc, ye as anonymousSubject, De as applyRowPatch, de as assertAuthenticated, ae as beginIdempotent, Fe as checkFrameworkCompat, se as checkGuards, r as checkGuardsEffect, he as composeAuthStrategies, Ne as composeRpcInterceptors, x as defineAction, b as defineMutation, je as definePlugin, Me as definePluginRoute, Pe as definePluginService, y as defineQuery, Oe as defineStream, Te as diffRows, i as effectiveScopes, ee as failIdempotent, t as finishIdempotent, ie as getResourceScopeResolver, l as hasCallbackRoutes, te as hasEffectiveScope, o as hasScope, g as idToPath, re as idempotencyScope, Ee as isIdKeyed, fe as isSystemSubject, oe as memoryIdempotencyStore, T as mutationToRpc, Ae as normalizeDescriptor, Ce as pathToId, c as publishServerError, w as queryToRpc, a as requireScope, m as rowPatchOpSchema, h as rowPatchSchema, e as setEffectiveScopes, ce as setResourceScopeResolver, D as streamToRpc, le as subjectScopes, ne as subscribeServerErrors, v as subscriptionEvent, pe as systemSubject, ke as toRpc, Ze as tsMs, Ye as undoApplyDescriptor, Je as undoLogQueryDescriptor, Xe as undoRedoDescriptor, We as workflowCancelDescriptor, He as workflowDomainEventsQueryDescriptor, Ue as workflowEventDeliveriesQueryDescriptor, Ge as workflowResumeDescriptor, Ve as workflowRunEventsQueryDescriptor, Re as workflowRunQueryDescriptor, Be as workflowRunStepsQueryDescriptor, ze as workflowRunsQueryDescriptor, Ke as workflowSignalDescriptor, qe as workflowUpdateDescriptor };
+export { i as ADMIN_SCOPE, Ce as AuthMiddleware, ye as ConnectionInfo, xe as ConnectionInfoMiddleware, nt as PROTOCOL_VERSION, s as ScopeError, _e as Subject, pe as SubjectService, q as UNDO_APPLY_TAG, K as UNDO_LOG_TAG, J as UNDO_REDO_TAG, be as Unauthenticated, Q as UndoConflict, Z as UndoForbidden, Y as UndoLogEntry, X as UndoNotFound, H as WorkflowControlInputSchema, I as WorkflowDomainEventRowSchema, B as WorkflowDomainEventsInputSchema, V as WorkflowEventDeliveriesInputSchema, L as WorkflowEventDeliveryRowSchema, j as WorkflowParentClosePolicySchema, F as WorkflowRunEventRowSchema, Ve as WorkflowRunHandleSchema, R as WorkflowRunRefSchema, M as WorkflowRunRowSchema, A as WorkflowRunStatusSchema, P as WorkflowRunStepRowSchema, z as WorkflowRunTableRefSchema, N as WorkflowRunsInputSchema, U as WorkflowSignalInputSchema, W as WorkflowUpdateInputSchema, G as WorkflowUpdateResultSchema, T as actionToRpc, Se as anonymousSubject, Me as applyRowPatch, me as assertAuthenticated, oe as beginIdempotent, D as checkFrameworkCompat, le as checkGuards, a as checkGuardsEffect, ve as composeAuthStrategies, Re as composeRpcInterceptors, y as defineAction, v as defineMutation, Ie as definePlugin, Le as definePluginRoute, ze as definePluginService, _ as defineQuery, b as defineStream, Ae as diffRows, o as effectiveScopes, ne as failIdempotent, n as finishIdempotent, ae as getPolicyGuardResolver, c as getResourceScopeResolver, we as hasCallbackRoutes, te as hasEffectiveScope, ee as hasScope, m as idToPath, ie as idempotencyScope, je as isIdKeyed, t as isPolicyCheck, Ne as isPolicyGuard, he as isSystemSubject, se as memoryIdempotencyStore, w as mutationToRpc, Fe as normalizeDescriptor, Oe as pathToId, ce as publishServerError, C as queryToRpc, ue as requireScope, f as rowPatchOpSchema, p as rowPatchSchema, fe as setEffectiveScopes, r as setPolicyGuardResolver, de as setResourceScopeResolver, E as streamToRpc, e as subjectScopes, re as subscribeServerErrors, g as subscriptionEvent, ge as systemSubject, Pe as toRpc, tt as tsMs, $e as undoApplyDescriptor, Qe as undoLogQueryDescriptor, et as undoRedoDescriptor, Je as workflowCancelDescriptor, Ke as workflowDomainEventsQueryDescriptor, qe as workflowEventDeliveriesQueryDescriptor, Ye as workflowResumeDescriptor, Ge as workflowRunEventsQueryDescriptor, He as workflowRunQueryDescriptor, We as workflowRunStepsQueryDescriptor, Ue as workflowRunsQueryDescriptor, Xe as workflowSignalDescriptor, Ze as workflowUpdateDescriptor };

package/dist/rest.d.ts

@@ -15,6 +15,9 @@ declare interface ActionProcedureDescriptor<Name extends string, Input extends S
     readonly exposeAsTool: ExposeAsTool | undefined;
 }
 
+/** A guard is either a scope check or a relationship check. */
+declare type AnyGuardSpec<Input = unknown> = GuardSpec<Input> | PolicyGuardSpec<Input>;
+
 /**
  * Project every descriptor carrying a `publicApi` annotation into a REST
  * route, in stable (path) order. The boot layer feeds these straight into
@@ -77,7 +80,7 @@ declare interface ExposeAsToolSpec {
 
 /** One or more declarative guards on a descriptor. All must pass (AND across
  *  entries; `mode` controls AND/OR WITHIN one entry's scope array). */
-declare type Guards<Input = unknown> = ReadonlyArray<GuardSpec<Input>>;
+declare type Guards<Input = unknown> = ReadonlyArray<AnyGuardSpec<Input>>;
 
 declare interface GuardSpec<Input = unknown> {
     /** Required permission scope(s). A single string, or an array combined by
@@ -253,6 +256,36 @@ declare interface PluginHttpRouteResult {
     readonly headers?: Record<string, string>;
 }
 
+/**
+ * A relationship (ReBAC) guard — "may this subject perform ACTION on THIS row?"
+ *
+ * The scope guard above answers "what may this subject do at all"; this answers
+ * "on which row". Both live in the same `guards:` array on purpose, because the
+ * alternative is what apps actually built: a hand-maintained map from rpc tag →
+ * policy rule, installed as an interceptor. That map is FAIL-OPEN BY OMISSION —
+ * add an rpc, forget the entry, and it is silently unguarded. A declaration on
+ * the descriptor cannot be forgotten for an rpc that exists, because it IS the
+ * rpc.
+ *
+ * Browser-safe by the same construction as `GuardSpec`: strings plus a PURE
+ * `resource` extractor. Resolution — reading relationship tuples, applying the
+ * policy's `implies` closure — happens server-side through the registered
+ * policy resolver. With no resolver registered the check FAILS CLOSED: an
+ * unanswerable authorization question is a denial, never a pass.
+ *
+ * Because it is data, the same declaration compiles into the capability
+ * manifest the client reads, so a UI gate and the server check cannot drift.
+ */
+declare interface PolicyGuardSpec<Input = unknown> {
+    /** The action to authorize, as named in the resource policy's `actions`. */
+    readonly action: string;
+    /** Which registered resource policy governs the check. */
+    readonly resourceType: string;
+    /** PURE `input → resource id`. Returning undefined DENIES — an unidentifiable
+     *  resource is not a reason to skip the check. */
+    readonly resource: (input: Input) => string | undefined;
+}
+
 /** A descriptor kind that can be projected to REST (streams are not, in v1). */
 export declare type PublicApiDescriptor = QueryProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All> | MutationProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All> | ActionProcedureDescriptor<string, Schema.Schema.Any, Schema.Schema.Any, Schema.Schema.All>;
 

package/dist/rest.js

@@ -1,4 +1,4 @@
-import { a as e, i as t, o as n, r, t as i } from "./serverErrorBus-0wjvKwGO.js";
+import { a as e, i as t, o as n, r, t as i } from "./serverErrorBus-XDdIJk0c.js";
 import { s as a } from "./auth-DCE6m7Bo.js";
 import { Effect as o, Schema as s } from "effect";
 //#region src/publicApi.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/protocol",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "The Voltro wire + plugin contract — defineQuery/Mutation/Action/Stream, definePlugin, sessions / JWT / API-keys, and the RPC protocol.",
   "keywords": [
     "voltro",
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "@effect/sql": "^0.51.1",
-    "@voltro/database": "0.4.0",
+    "@voltro/database": "0.5.0",
     "jose": "^6.2.3"
   },
   "peerDependencies": {