@voltro/protocol 0.85.0 → 0.87.0

package/dist/boundedRing.js

@@ -0,0 +1,27 @@
+//#region src/boundedRing.ts
+var e = class {
+	slots = [];
+	head = 0;
+	size = 0;
+	capacity;
+	constructor(e) {
+		this.capacity = Number.isNaN(e) ? Infinity : Math.max(0, Math.floor(e));
+	}
+	get length() {
+		return this.size;
+	}
+	get(e) {
+		if (!(!Number.isInteger(e) || e < 0 || e >= this.size)) return this.slots[(this.head + e) % this.capacity];
+	}
+	push(e) {
+		this.capacity !== 0 && (this.size < this.capacity ? (this.slots[(this.head + this.size) % this.capacity] = e, this.size++) : (this.slots[this.head] = e, this.head = (this.head + 1) % this.capacity));
+	}
+	clear() {
+		this.slots.length = 0, this.head = 0, this.size = 0;
+	}
+	*[Symbol.iterator]() {
+		for (let e = 0; e < this.size; e++) yield this.get(e);
+	}
+};
+//#endregion
+export { e as BoundedRing };

package/dist/businessRule.js

@@ -0,0 +1,11 @@
+import { Schema as e } from "effect";
+//#region src/businessRule.ts
+var t = class extends e.TaggedError()("BusinessRuleViolation", {
+	rule: e.String,
+	params: e.optional(e.Record(e.String, e.Unknown)),
+	field: e.optional(e.String),
+	message: e.optional(e.String),
+	severity: e.Literals(["error", "warning"])
+}) {};
+//#endregion
+export { t as BusinessRuleViolation };

package/dist/canonicalJson.js

@@ -0,0 +1,14 @@
+//#region src/canonicalJson.ts
+var e = (e) => {
+	let t = (e) => {
+		if (Array.isArray(e)) return e.map(t);
+		if (typeof e == "object" && e) {
+			let n = e;
+			return Object.fromEntries(Object.keys(n).sort().map((e) => [e, t(n[e])]));
+		}
+		return e;
+	};
+	return JSON.stringify(t(e) ?? null);
+};
+//#endregion
+export { e as canonicalJson };

package/dist/connection.js

@@ -0,0 +1,73 @@
+import { defineAction as e, defineMutation as t, defineQuery as n } from "./procedure.js";
+import { Schema as r } from "effect";
+//#region src/connection.ts
+var i = "__voltro.connections.list", a = "__voltro.connections.start", o = "__voltro.connections.submitToken", s = "__voltro.connections.disconnect", c = r.Literals(["oauth2", "pat"]), l = r.Literals([
+	"disconnected",
+	"connected",
+	"expired",
+	"revoked",
+	"error"
+]), u = r.Struct({
+	connectionId: r.String,
+	kind: c,
+	label: r.String,
+	status: l,
+	accountId: r.NullOr(r.String),
+	accountLabel: r.NullOr(r.String),
+	scopes: r.Array(r.String),
+	expiresAt: r.NullOr(r.String),
+	lastError: r.NullOr(r.String),
+	connectedAt: r.NullOr(r.String)
+}), d = class extends r.TaggedError()("ConnectionNotDeclared", { connectionId: r.String }) {}, f = class extends r.TaggedError()("ConnectionSubjectRequired", { connectionId: r.String }) {}, p = class extends r.TaggedError()("ConnectionKindMismatch", {
+	connectionId: r.String,
+	expected: c,
+	actual: c
+}) {}, m = class extends r.TaggedError()("ConnectionHandshakeFailed", {
+	connectionId: r.String,
+	reason: r.String,
+	transient: r.Boolean
+}) {
+	get message() {
+		return this.reason;
+	}
+}, h = r.Union([
+	d,
+	f,
+	p,
+	m
+]), g = n({
+	name: i,
+	source: "_voltro_connections",
+	input: r.Struct({}),
+	output: r.Array(u),
+	openAccess: "self-scoped read: projects the declared connections for the calling subject only (its own connect/disconnect state)"
+}), _ = e({
+	name: a,
+	input: r.Struct({
+		connectionId: r.String,
+		redirectTo: r.optional(r.String)
+	}),
+	output: r.Struct({
+		authorizeUrl: r.String,
+		state: r.String
+	}),
+	error: h,
+	openAccess: "self-service: begins an oauth handshake that stores a credential for the calling subject only; anonymous callers fail typed with ConnectionSubjectRequired"
+}), v = t({
+	name: o,
+	input: r.Struct({
+		connectionId: r.String,
+		token: r.String
+	}),
+	output: r.Struct({ ok: r.Boolean }),
+	error: h,
+	openAccess: "self-service: stores a pasted token as the calling subject's own credential; anonymous callers fail typed with ConnectionSubjectRequired"
+}), y = t({
+	name: s,
+	input: r.Struct({ connectionId: r.String }),
+	output: r.Struct({ ok: r.Boolean }),
+	error: h,
+	openAccess: "self-service: deletes only the calling subject's own credential row for this connection"
+});
+//#endregion
+export { i as CONNECTIONS_LIST_TAG, s as CONNECTION_DISCONNECT_TAG, a as CONNECTION_START_TAG, o as CONNECTION_SUBMIT_TOKEN_TAG, m as ConnectionHandshakeFailed, c as ConnectionKind, p as ConnectionKindMismatch, d as ConnectionNotDeclared, u as ConnectionState, l as ConnectionStatus, f as ConnectionSubjectRequired, y as connectionDisconnectDescriptor, _ as connectionStartDescriptor, v as connectionSubmitTokenDescriptor, g as connectionsListQueryDescriptor };

package/dist/devActivity.js

@@ -0,0 +1,4 @@
+//#region src/devActivity.ts
+var e = "voltro:dev-activity";
+//#endregion
+export { e as DEV_ACTIVITY_EVENT };

package/dist/errorSchema.js

@@ -0,0 +1,24 @@
+import { Schema as e } from "effect";
+import * as t from "effect/SchemaAST";
+//#region src/errorSchema.ts
+var n = (e) => {
+	let n = /* @__PURE__ */ new Set();
+	if (e === void 0) return n;
+	let r = (e) => {
+		if (t.isUnion(e)) for (let t of e.types) r(t);
+		else if (e.encoding !== void 0 && r(t.toEncoded(e)), t.isObjects(e)) {
+			let r = e.propertySignatures.find((e) => e.name === "_tag");
+			r !== void 0 && t.isLiteral(r.type) && typeof r.type.literal == "string" && n.add(r.type.literal);
+		}
+	};
+	return r(e.ast), n;
+}, r = (r, i) => {
+	if (r === void 0) return;
+	let a = t.isUnion(r.ast) ? r.ast.types : [r.ast];
+	for (let t of a) {
+		let r = e.make(t);
+		if (n(r).has(i)) return r;
+	}
+};
+//#endregion
+export { n as declaredErrorTags, r as errorMemberSchema };

package/dist/errorValue.js

@@ -0,0 +1,21 @@
+//#region src/errorValue.ts
+var e = (e) => {
+	if (typeof e != "object" || !e) return;
+	let t = e._tag;
+	return typeof t == "string" ? t : void 0;
+}, t = (t) => {
+	if (typeof t == "string") return t;
+	if (typeof t == "object" && t) {
+		let n = t.message;
+		if (typeof n == "string" && n !== "") return n;
+		let r = e(t);
+		if (r !== void 0) return r;
+	}
+	return String(t);
+}, n = (n) => {
+	if (n instanceof Error) return n;
+	let r = Error(t(n), { cause: n });
+	return r.name = e(n) ?? "NonErrorThrown", r;
+};
+//#endregion
+export { t as errorMessage, e as errorTag, n as reportableError };

package/dist/event.js

@@ -0,0 +1,110 @@
+import { RequestedTenantRefused as e } from "./tenantSelection.js";
+import { Unauthenticated as t } from "./auth.js";
+import { NoSuchResource as n, ScopeError as r, declaresResourceGuard as i, isOpenAccess as a, openAccessSpec as o } from "./scopes.js";
+import { strictInput as s } from "./strictInput.js";
+import { hasEnforcedGuard as c } from "./procedure.js";
+import { Context as l, Schema as u } from "effect";
+import { Rpc as d } from "effect/rpc";
+//#region src/event.ts
+var f = 7500, p = (e) => typeof e == "object" && !!e && e.kind === "event", m = (e) => {
+	if (e.clientPolicy !== void 0) {
+		if (!/^[A-Za-z][A-Za-z0-9_.:-]{0,255}$/.test(e.clientPolicy)) throw Error("defineEvent: invalid client policy ID");
+		if (e.openAccess !== void 0 || !c(e.guards)) throw Error("defineEvent: a client policy requires explicit enforced guards");
+		if (e.webhook !== void 0) throw Error("defineEvent: private client policies do not authorize webhook recipients");
+	}
+	if (e.name.length === 0) throw Error("defineEvent: `name` must not be empty");
+	if (/\s/.test(e.name)) throw Error(`defineEvent("${e.name}"): \`name\` must not contain whitespace.\n  The name is used as a broker subject segment. NATS refuses a subject with
+  whitespace and delivers nothing — silently, and only on that broker, so an
+  app that works on Redis stops working when the transport changes.
+  Use a dot for namespacing: "orders.paid".`);
+	if (e.guards !== void 0 && e.guards.length === 0) throw Error(`defineEvent("${e.name}"): \`guards: []\` is empty, so it enforces nothing —\n  but it reads at the call site as if the event were protected. Omit the field
+  for an unguarded event, or list the scopes that may subscribe.`);
+	if (e.openAccess !== void 0) {
+		if (e.openAccess.trim() === "") throw Error(`defineEvent("${e.name}"): \`openAccess\` needs a REASON, not an empty string. It is\n  the sentence a reviewer reads to decide whether anyone should really be able to
+  subscribe without an authorization check — e.g. \`openAccess: 'public scoreboard,
+  no caller data'\`.`);
+		if (e.guards !== void 0 && e.guards.length > 0) throw Error(`defineEvent("${e.name}"): \`openAccess\` and \`guards\` are two different access\n  decisions, so declaring both says the event is protected AND open. Keep the guards
+  if a subscriber must hold a scope; drop them if anyone may listen.`);
+	}
+	if (e.webhook?.rateLimit !== void 0 && e.webhook.rateLimit.perMinute < 1) throw Error(`defineEvent("${e.name}"): \`webhook.rateLimit.perMinute\` is ${e.webhook.rateLimit.perMinute}, which defers every delivery forever.\n  There is no "unlimited" spelling here — omit \`rateLimit\` for no ceiling.`);
+	if (e.webhook?.version !== void 0 && e.webhook.version < 1) throw Error(`defineEvent("${e.name}"): \`webhook.version\` must be >= 1 (default 1).\n  A subscriber pinned to 1 would read this event as BEHIND its own version,
+  which is the opposite of what a version bump is for.`);
+	if (e.delivery === "latest" && e.webhook !== void 0) throw Error(`defineEvent(${e.name}): \`delivery: 'latest'\` cannot be combined with \`webhook\`.\n  \`latest\` means a superseded delivery did not matter — but a webhook delivery is a
+  durable side effect at a third party, and one already sent cannot be superseded.
+  A high-rate event with an HTTP audience is also 60 deliveries per second per target;
+  the rate limit DEFERS the excess as pending rows, so it grows a table instead of failing.
+  Split them: publish the high-rate event for clients, and publish a separate, coarser
+  event (a summary, a state change) for the outside world.`);
+	return {
+		kind: "event",
+		name: e.name,
+		key: e.key,
+		payload: e.payload,
+		guards: e.openAccess === void 0 ? e.guards : [o(e.openAccess.trim())],
+		openAccess: e.openAccess,
+		rewind: e.rewind,
+		webhook: e.webhook,
+		delivery: e.delivery,
+		...e.clientPolicy === void 0 ? {} : { clientPolicy: e.clientPolicy }
+	};
+}, h = (e) => u.Struct({
+	_tag: u.Literal("event"),
+	origin: u.String,
+	n: u.Number,
+	emittedAt: u.Number,
+	payload: e
+}), g = u.Struct({
+	_tag: u.Literal("gap"),
+	missed: u.Number,
+	reason: u.Literals(["buffer", "resume"])
+}), _ = u.Struct({ _tag: u.Literal("attached") }), v = (e) => u.Union([
+	_,
+	h(e),
+	g
+]), y = u.Struct({
+	origin: u.String,
+	n: u.Number
+}), b = (e) => u.Struct({
+	key: e,
+	resume: u.optional(u.Array(y))
+}), x = l.Service("@voltro/protocol/EventRpcWorkload"), S = (o, l) => {
+	let f = o.guards !== void 0 && o.guards.some((e) => !a(e)) ? u.Union([
+		r,
+		t,
+		e
+	]) : u.Union([t, e]), p = i(o.guards) ? u.Union([f, n]) : f, m = l && l.length > 0 ? u.Union([p, ...l]) : p;
+	return d.make(o.name, {
+		payload: s(b(o.key), o.name, c(o.guards)),
+		success: v(o.payload),
+		error: m,
+		stream: !0
+	}).annotate(x, !0);
+}, C = class extends u.TaggedError()("EventPayloadInvalid", {
+	event: u.String,
+	message: u.String
+}) {}, w = class extends u.TaggedError()("EventKeyInvalid", {
+	event: u.String,
+	message: u.String
+}) {}, T = class extends u.TaggedError()("EventPayloadTooLarge", {
+	event: u.String,
+	bytes: u.Number,
+	limit: u.Number
+}) {}, E = (e) => {
+	if (typeof e != "object" || !e) return JSON.stringify(e) ?? "null";
+	let t = Object.entries(e), n = 0;
+	for (let e of t) e[1] !== void 0 && (t[n++] = e);
+	return t.length = n, t.sort(([e], [t]) => e < t ? -1 : +(e > t)), JSON.stringify(t);
+}, D = "\0", O = (e, t, n) => [
+	e ?? "~",
+	t,
+	E(n)
+].join("\0"), k = (e) => {
+	let [t = "~", n = "", r = ""] = e.split("\0");
+	return {
+		tenantId: t === "~" ? null : t,
+		event: n,
+		key: r
+	};
+}, A = (e) => e.split("\0").join(" · ");
+//#endregion
+export { D as EVENT_ROUTE_SEP, w as EventKeyInvalid, C as EventPayloadInvalid, T as EventPayloadTooLarge, x as EventRpcWorkload, f as MAX_EVENT_ENVELOPE_BYTES, m as defineEvent, E as encodeEventKey, _ as eventAttached, h as eventEnvelope, g as eventGap, y as eventResumePoint, O as eventRoute, v as eventStreamEvent, b as eventSubscribeInput, S as eventToRpc, A as formatEventRoute, p as isEventDescriptor, k as parseEventRoute };

package/dist/formCapture.js

@@ -0,0 +1,12 @@
+//#region src/formCapture.ts
+var e = "__voltro_capture", t = "voltro:form-source", n = (e) => typeof e == "string" && e.length === 261 && /^1(?:\.[a-f0-9]{64}){4}$/.test(e) ? e : void 0, r = (e, t) => {
+	let r = n(e + "." + t);
+	if (r === void 0) throw Error("Native form source unavailable");
+	return r;
+}, i = (e = globalThis.document) => {
+	if (e === void 0) return;
+	let r = e.querySelectorAll(`meta[name="${t}"]`);
+	return r.length === 1 ? n(r[0].getAttribute("content")) : void 0;
+};
+//#endregion
+export { e as FORM_CAPTURE_FIELD, t as FORM_CAPTURE_META_NAME, r as encodeNativeFormCapture, n as formCaptureSource, i as readFormCaptureSource };

package/dist/httpStreamMaxDuration.js

@@ -0,0 +1,9 @@
+//#region src/httpStreamMaxDuration.ts
+var e = (e) => {
+	if (e !== void 0) {
+		if (typeof e != "number" || !Number.isSafeInteger(e) || e < 1 || e > 2147483647) throw RangeError("SSE maxDurationMs must be an integer between 1 and 2147483647.");
+		return e;
+	}
+};
+//#endregion
+export { e as validateHttpStreamMaxDuration };

package/dist/idempotency.js

@@ -0,0 +1,121 @@
+import { Schema as e } from "effect";
+//#region src/idempotency.ts
+var t = (e, t, n) => `${e ?? "(global)"}|${t.toUpperCase()}|${n}`, n = (e, t, n, r) => r === void 0 ? `${e ?? "(global)"}|${t ?? "(anon)"}|WS|${n}` : `WS-connection:${JSON.stringify([
+	e ?? null,
+	t ?? null,
+	n,
+	r
+])}`, r = class extends e.TaggedError()("MutationConnectionRequired", { traceId: e.String }) {
+	get message() {
+		return "this mutation requires a live native WebSocket connection";
+	}
+}, i = async (e, t, n, r, i, o, s = a) => {
+	if (!/^[0-9a-f]{64}$/.test(r)) throw Error("Invalid idempotency input fingerprint");
+	let c = await e.claim(t, n, r, o, i, s);
+	if (c.kind === "claimed") {
+		let e = c.claim;
+		if (typeof e.id != "string" || e.id.length === 0 || e.scope !== t || e.key !== n || e.inputHash !== r) throw Error("Idempotency store returned an invalid claim identity");
+		return {
+			kind: "fresh",
+			claim: Object.freeze({
+				scope: t,
+				key: n,
+				id: e.id,
+				inputHash: r
+			})
+		};
+	}
+	if (c.kind === "existing") {
+		if (c.record.scope !== t || c.record.key !== n) throw Error("Idempotency store returned an invalid receipt identity");
+		return typeof c.record.inputHash == "string" ? c.record.inputHash === r ? c.record.status === "completed" && c.record.response ? {
+			kind: "replay",
+			response: c.record.response
+		} : { kind: "conflict" } : { kind: "input-conflict" } : { kind: "input-unbound" };
+	}
+	if (c.kind === "conflict") return { kind: "conflict" };
+	throw Error("Idempotency store returned an invalid acquisition result");
+}, a = 3e4, o = (e, t, n = a, r = Date.now) => {
+	let i = Object.freeze({
+		scope: t.scope,
+		key: t.key,
+		id: t.id,
+		inputHash: t.inputHash
+	}), o = !1, s = setInterval(() => {
+		o || (o = !0, e.renew(i, r()).then((e) => {
+			e || clearInterval(s);
+		}, () => {}).finally(() => {
+			o = !1;
+		}));
+	}, Math.max(1, Math.floor(n / 3)));
+	return s.unref?.(), () => clearInterval(s);
+}, s = (e, t, n, r) => e.complete(t, n, r), c = (e, t) => e.release(t), l = 0n, u = () => {
+	let e = /* @__PURE__ */ new Map(), t = (e, t) => JSON.stringify([e, t]), n = (n) => {
+		let r = e.get(t(n.scope, n.key));
+		return r?.status === "in_flight" && r.id === n.id && r.inputHash === n.inputHash ? r : void 0;
+	};
+	return {
+		get: async (n, r) => e.get(t(n, r)) ?? null,
+		claim: async (n, r, i, a, o, s) => {
+			let c = e.get(t(n, r));
+			if (c && c.inputHash !== i || c && a - c.createdAt < d(c.status, o, s)) return {
+				kind: "existing",
+				record: c
+			};
+			let u = `memory:${(++l).toString(36)}`;
+			return e.set(t(n, r), {
+				id: u,
+				scope: n,
+				key: r,
+				inputHash: i,
+				status: "in_flight",
+				response: null,
+				createdAt: a
+			}), {
+				kind: "claimed",
+				claim: Object.freeze({
+					id: u,
+					scope: n,
+					key: r,
+					inputHash: i
+				})
+			};
+		},
+		complete: async (r, i, a) => {
+			let o = n(r);
+			return o ? (e.set(t(r.scope, r.key), {
+				...o,
+				status: "completed",
+				response: i,
+				createdAt: a
+			}), !0) : !1;
+		},
+		release: async (r) => n(r) ? e.delete(t(r.scope, r.key)) : !1,
+		renew: async (r, i) => {
+			let a = n(r);
+			return a ? (e.set(t(r.scope, r.key), {
+				...a,
+				createdAt: i
+			}), !0) : !1;
+		}
+	};
+}, d = (e, t, n) => e === "completed" ? t : Math.min(t, n), f = class extends e.TaggedError()("MutationInFlight", {
+	traceId: e.String,
+	retryAfterMs: e.Number
+}) {
+	get message() {
+		return `a request with this idempotency key is still in flight — replay the same key after ${this.retryAfterMs}ms`;
+	}
+}, p = 1e3, m = class extends e.TaggedError()("MutationIdempotencyRefused", {
+	traceId: e.String,
+	reason: e.Literals([
+		"input-conflict",
+		"input-unbound",
+		"input-unavailable"
+	])
+}) {
+	get message() {
+		return this.reason === "input-unavailable" ? "This request input could not be captured safely. This attempt was stopped before execution." : "This request cannot be safely matched to the original operation. Check its current state before starting another action.";
+	}
+};
+//#endregion
+export { a as DEFAULT_IN_FLIGHT_LEASE_MS, p as MUTATION_IN_FLIGHT_RETRY_AFTER_MS, r as MutationConnectionRequired, m as MutationIdempotencyRefused, f as MutationInFlight, i as beginIdempotent, c as failIdempotent, s as finishIdempotent, d as freshFor, o as holdIdempotentClaim, t as idempotencyScope, u as memoryIdempotencyStore, n as wsMutationIdempotencyScope };

package/dist/idempotencyInput.js

@@ -0,0 +1,123 @@
+import { canonicalJson as e } from "./canonicalJson.js";
+import { Schema as t } from "effect";
+//#region src/idempotencyInput.ts
+var n = (t) => {
+	let n = /* @__PURE__ */ new WeakMap(), r = 0, i = (e, t = () => !1) => {
+		if (Object.getOwnPropertySymbols(e).length) throw Error("Unsupported wire fields");
+		return Object.getOwnPropertyNames(e).sort().filter((e) => !t(e)).map((t) => {
+			let n = Object.getOwnPropertyDescriptor(e, t);
+			if (!("value" in n)) throw Error("Unsupported wire accessor");
+			return [t, o(n.value)];
+		});
+	}, a = (e, t = 0, n = e.byteLength) => {
+		let r = "";
+		for (let i of new Uint8Array(e, t, n)) r += i.toString(16).padStart(2, "0");
+		return r;
+	}, o = (e) => {
+		if (e === null) return ["null"];
+		if (e === void 0) return ["undefined"];
+		if (typeof e == "string" || typeof e == "boolean") return [typeof e, e];
+		if (typeof e == "number") return ["number", Object.is(e, -0) ? "-0" : String(e)];
+		if (typeof e == "bigint") return ["bigint", String(e)];
+		if (typeof e != "object") throw Error("Unsupported wire value");
+		let t = n.get(e);
+		if (t !== void 0) return ["reference", t];
+		let s = r++;
+		if (n.set(e, s), Array.isArray(e)) {
+			if (Object.getPrototypeOf(e) !== Array.prototype) throw Error("Unsupported wire array prototype");
+			return [
+				"array",
+				s,
+				e.length,
+				i(e, (e) => e === "length")
+			];
+		}
+		if (Object.getPrototypeOf(e) === Date.prototype) return [
+			"date",
+			s,
+			String(Date.prototype.getTime.call(e)),
+			i(e)
+		];
+		if (Object.getPrototypeOf(e) === Map.prototype) return [
+			"map",
+			s,
+			Array.from(Map.prototype.entries.call(e), ([e, t]) => [o(e), o(t)]),
+			i(e)
+		];
+		if (Object.getPrototypeOf(e) === Set.prototype) return [
+			"set",
+			s,
+			Array.from(Set.prototype.values.call(e), o),
+			i(e)
+		];
+		if (Object.getPrototypeOf(e) === ArrayBuffer.prototype) return [
+			"buffer",
+			s,
+			a(e),
+			i(e)
+		];
+		if (ArrayBuffer.isView(e)) {
+			if (!(e.buffer instanceof ArrayBuffer)) throw Error("Shared wire memory is not a snapshot");
+			let t = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(e), "constructor")?.value;
+			if (typeof t != "function" || ![
+				"DataView",
+				"Int8Array",
+				"Uint8Array",
+				"Uint8ClampedArray",
+				"Int16Array",
+				"Uint16Array",
+				"Int32Array",
+				"Uint32Array",
+				"Float16Array",
+				"Float32Array",
+				"Float64Array",
+				"BigInt64Array",
+				"BigUint64Array"
+			].includes(t.name) || globalThis[t.name] !== t) throw Error("Unsupported wire view prototype");
+			return [
+				"view",
+				s,
+				t.name,
+				o(e.buffer),
+				e.byteOffset,
+				e.byteLength,
+				i(e, (t) => !(e instanceof DataView) && /^(0|[1-9]\d*)$/.test(t))
+			];
+		}
+		let c = Object.getPrototypeOf(e);
+		if (c !== null && c !== Object.prototype) throw Error("Unsupported wire object");
+		return [
+			"object",
+			s,
+			i(e)
+		];
+	};
+	return e(o(t));
+}, r = async (r, i, a, o = void 0) => {
+	try {
+		let s = t.encodeUnknownSync(r), c = t.decodeUnknownSync(r), l = s(i), u = n(l), d = c(structuredClone(l));
+		if (n(s(d)) !== u) throw Error("Input does not round trip");
+		let f = e({
+			protocol: "voltro-idempotency-input-v1",
+			principal: {
+				type: a.type,
+				id: a.id,
+				tenantId: a.tenantId,
+				kind: a.type === "user" ? a.kind ?? null : null,
+				service: a.type === "service" ? a.service : null,
+				auditActor: a.type === "serviceAccount" ? a.auditActorId === void 0 ? ["implicit"] : ["explicit", a.auditActorId] : null
+			},
+			wire: u,
+			transport: n(o)
+		}), p = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(f)), m = "";
+		for (let e of new Uint8Array(p)) m += e.toString(16).padStart(2, "0");
+		return Object.freeze({
+			input: d,
+			fingerprint: m
+		});
+	} catch {
+		throw Error("Mutation input cannot be captured for idempotent execution");
+	}
+};
+//#endregion
+export { r as prepareIdempotentInput };

package/dist/identity.js

@@ -33,15 +33,11 @@ var a = e({ scope: "voltro:identity" }), o = Symbol.for("@voltro/runtime/process
 	} catch {}
 	return l.version;
 }, m = (e) => {
-	if (l.frozen !== void 0 && l.frozen.bootPath !== e) {
-		a.warn(`process identity was already resolved as ${l.frozen.replicaId} (bootPath=${l.frozen.bootPath}); keeping it rather than becoming ${e}. Call setProcessBootPath before anything reads the identity.`, {
-			resolved: l.frozen.replicaId,
-			was: l.frozen.bootPath,
-			requested: e
-		});
-		return;
-	}
-	l.bootPath = e;
+	l.frozen !== void 0 && l.frozen.bootPath !== e ? a.warn(`process identity was already resolved as ${l.frozen.replicaId} (bootPath=${l.frozen.bootPath}); keeping it rather than becoming ${e}. Call setProcessBootPath before anything reads the identity.`, {
+		resolved: l.frozen.replicaId,
+		was: l.frozen.bootPath,
+		requested: e
+	}) : l.bootPath = e;
 }, h = (e) => {
 	l.appVersion = e, l.frozen !== void 0 && (l.frozen = {
 		...l.frozen,