@voltro/protocol 0.84.0 → 0.86.0

package/dist/serverErrorBus.js

@@ -0,0 +1,15 @@
+//#region src/serverErrorBus.ts
+var e = (e) => {
+	let t = e.error, n = t instanceof Error ? t.name : typeof t?._tag == "string" ? String(t._tag) : "Error", r = [e.name === void 0 ? e.source : `${e.source} '${e.name}'`, ...typeof e.fields?.runId == "string" ? [`run ${e.fields.runId}`] : []].join(", "), i = /* @__PURE__ */ Error(`[message withheld: ${r} is declared encrypted — read it where the run is shown]`);
+	i.name = n;
+	let a = t instanceof Error && typeof t.stack == "string" ? t.stack : "", o = a.search(/^\s+at /m);
+	return i.stack = `${n}: ${i.message}${o === -1 ? "" : `\n${a.slice(o)}`}`, i;
+}, t = /* @__PURE__ */ new Set(), n = (e) => {
+	for (let n of t) try {
+		n(e);
+	} catch {}
+}, r = (e) => (t.add(e), () => {
+	t.delete(e);
+});
+//#endregion
+export { n as publishServerError, r as subscribeServerErrors, e as withheldServerError };

package/dist/serviceCall.js

@@ -0,0 +1,14 @@
+import { Schema as e } from "effect";
+//#region src/serviceCall.ts
+var t = class extends e.TaggedError()("ApiUnavailable", {
+	api: e.String,
+	tag: e.String,
+	reason: e.Literals([
+		"timeout",
+		"transport",
+		"closed"
+	]),
+	message: e.String
+}) {}, n = (e) => typeof e == "object" && !!e && e._tag === "ApiUnavailable";
+//#endregion
+export { t as ApiUnavailable, n as isApiUnavailable };

package/dist/session.d.ts

@@ -170,53 +170,51 @@ export declare type SessionPayload = typeof SessionPayload_2.Type;
 
 declare const SessionPayload_2: Schema.Struct<{
     /** Payload format version. Required and pinned — see the header. */
-    v: Schema.Literal<[2]>;
+    readonly v: Schema.Literal<2>;
     /** WHO, never WHAT-THEY-MAY-DO. `SubjectIdentity` has no `scopes` field. */
-    subject: Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["user"]>;
-        id: typeof Schema.String;
-        tenantId: typeof Schema.String;
-        metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly subject: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"user">;
+        readonly id: Schema.String;
+        readonly tenantId: Schema.String;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["apiKey"]>;
-        id: typeof Schema.String;
-        tenantId: typeof Schema.String;
-        metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+        readonly type: Schema.Literal<"apiKey">;
+        readonly id: Schema.String;
+        readonly tenantId: Schema.String;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["serviceAccount"]>;
-        id: typeof Schema.String;
-        tenantId: typeof Schema.String;
-        metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-        auditActorId: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
-            exact: true;
-        }>;
+        readonly type: Schema.Literal<"serviceAccount">;
+        readonly id: Schema.String;
+        readonly tenantId: Schema.String;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly auditActorId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["anonymous"]>;
-        id: typeof Schema.Null;
-        tenantId: Schema.NullOr<typeof Schema.String>;
-        credentialRejected: Schema.optional<typeof Schema.String>;
+        readonly type: Schema.Literal<"anonymous">;
+        readonly id: Schema.Null;
+        readonly tenantId: Schema.NullOr<Schema.String>;
+        readonly credentialRejected: Schema.optional<Schema.String>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["system"]>;
-        id: typeof Schema.String;
-        tenantId: typeof Schema.Null;
-        metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+        readonly type: Schema.Literal<"system">;
+        readonly id: Schema.String;
+        readonly tenantId: Schema.Null;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["service"]>;
-        id: typeof Schema.String;
-        tenantId: typeof Schema.Null;
-        metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-        service: typeof Schema.String;
+        readonly type: Schema.Literal<"service">;
+        readonly id: Schema.String;
+        readonly tenantId: Schema.Null;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        readonly service: Schema.String;
     }>]>;
     /** Unix seconds when this session expires. Verify rejects past expiry. */
-    exp: typeof Schema.Number;
+    readonly exp: Schema.Number;
     /** Unix seconds when this session was issued. Drives sliding-window
      *  auto-renewal: verify signals a renew once `now - iat` passes the
      *  renewal threshold (default 70% of the session's lifetime). */
-    iat: typeof Schema.Number;
+    readonly iat: Schema.Number;
     /** Key id of the signing secret. Stamped from the current key on sign;
      *  read on verify to pick which secret to check first. Absent on
      *  values minted with a bare-string secret (single-key path). */
-    kid: Schema.optional<typeof Schema.String>;
+    readonly kid: Schema.optional<Schema.String>;
 }>;
 
 declare type SessionPayload = typeof SessionPayload_2.Type;
@@ -278,33 +276,31 @@ export declare interface SignOptions {
  */
 export declare const signSession: (subject: Subject | SubjectIdentity, secret: string | KeyedSecret, options?: SignOptions) => string;
 
-declare const Subject: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["user"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.String;
-    scopes: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+declare const Subject: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"user">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly scopes: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["apiKey"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.String;
-    scopes: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly type: Schema.Literal<"apiKey">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly scopes: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["serviceAccount"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.String;
+    readonly type: Schema.Literal<"serviceAccount">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.String;
     /** Application actor used for audit columns; null means machine work with
      * no application actor. Identity only, never a permission grant. */
-    auditActorId: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
-        exact: true;
-    }>;
-    scopes: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly auditActorId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopes: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["anonymous"]>;
-    id: typeof Schema.Null;
-    tenantId: Schema.NullOr<typeof Schema.String>;
+    readonly type: Schema.Literal<"anonymous">;
+    readonly id: Schema.Null;
+    readonly tenantId: Schema.NullOr<Schema.String>;
     /**
      * Set when this caller PRESENTED a credential and it was rejected — an
      * expired token above all. Absent when they presented none.
@@ -321,47 +317,45 @@ declare const Subject: Schema.Union<[Schema.Struct<{
      * must not break an `openAccess` procedure that needs no session at all. The
      * fact travels, and only a guard that actually refuses spends it.
      */
-    credentialRejected: Schema.optional<typeof Schema.String>;
+    readonly credentialRejected: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["system"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.Null;
-    scopes: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly type: Schema.Literal<"system">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.Null;
+    readonly scopes: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["service"]>;
-    id: typeof Schema.String;
+    readonly type: Schema.Literal<"service">;
+    readonly id: Schema.String;
     /** The calling app's name, as the callee lists it in `serviceCallers`. */
-    service: typeof Schema.String;
-    tenantId: typeof Schema.Null;
-    scopes: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly service: Schema.String;
+    readonly tenantId: Schema.Null;
+    readonly scopes: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>]>;
 
 declare type Subject = typeof Subject.Type;
 
-declare const SubjectIdentity: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["user"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.String;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+declare const SubjectIdentity: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"user">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["apiKey"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.String;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly type: Schema.Literal<"apiKey">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["serviceAccount"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.String;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-    auditActorId: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
-        exact: true;
-    }>;
+    readonly type: Schema.Literal<"serviceAccount">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly auditActorId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["anonymous"]>;
-    id: typeof Schema.Null;
-    tenantId: Schema.NullOr<typeof Schema.String>;
+    readonly type: Schema.Literal<"anonymous">;
+    readonly id: Schema.Null;
+    readonly tenantId: Schema.NullOr<Schema.String>;
     /**
      * Set when this caller PRESENTED a credential and it was rejected — an
      * expired token above all. Absent when they presented none.
@@ -378,18 +372,18 @@ declare const SubjectIdentity: Schema.Union<[Schema.Struct<{
      * must not break an `openAccess` procedure that needs no session at all. The
      * fact travels, and only a guard that actually refuses spends it.
      */
-    credentialRejected: Schema.optional<typeof Schema.String>;
+    readonly credentialRejected: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["system"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.Null;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly type: Schema.Literal<"system">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.Null;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["service"]>;
-    id: typeof Schema.String;
-    tenantId: typeof Schema.Null;
-    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-    service: typeof Schema.String;
+    readonly type: Schema.Literal<"service">;
+    readonly id: Schema.String;
+    readonly tenantId: Schema.Null;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly service: Schema.String;
 }>]>;
 
 declare type SubjectIdentity = typeof SubjectIdentity.Type;

package/dist/session.js

@@ -1,12 +1,13 @@
-import { j as e, nt as t, z as n } from "./scopes-Di756ENh.js";
-import { n as r, t as i } from "./sessionHeader-DriTZhmv.js";
+import { SubjectIdentity as e, subjectIdentity as t } from "./auth.js";
+import { subjectScopes as n } from "./scopes.js";
+import { SESSION_HEADER_NAME as r, sessionValueFromHeaders as i } from "./sessionHeader.js";
 import { Schema as a } from "effect";
 import { createHmac as o, timingSafeEqual as s } from "node:crypto";
 import { createLogger as c } from "@voltro/logger";
 //#region src/session.ts
 var l = c({ scope: "@voltro/protocol:session" }), u = 2, d = a.Struct({
 	v: a.Literal(2),
-	subject: n,
+	subject: e,
 	exp: a.Number,
 	iat: a.Number,
 	kid: a.optional(a.String)
@@ -39,14 +40,14 @@ var l = c({ scope: "@voltro/protocol:session" }), u = 2, d = a.Struct({
 }, T = 604800, E = .7, D = (e, t) => C(o("sha256", t).update(e).digest()), O = (e) => typeof e == "string" ? {
 	kid: "k0",
 	secret: e
-} : e, k = (n, r, i = {}) => {
+} : e, k = (e, r, i = {}) => {
 	let a = O(r);
 	if (!a.secret) throw Error("signSession: secret must be a non-empty string");
-	let o = e(n);
-	if (o.length > 0) throw Error(`signSession: refusing to mint a session cookie for a ${n.type} subject carrying ${o.length} scope(s) (${o.slice(0, 5).join(", ")}). A session cookie carries IDENTITY only — authority is resolved per request, so that removing a role takes effect on the session that already exists instead of in up to 7 days. Mint the session from the identity and move the scopes into the auth.resolveScopes resolver, which runs on every request and can be invalidated the moment a role changes.`);
+	let o = n(e);
+	if (o.length > 0) throw Error(`signSession: refusing to mint a session cookie for a ${e.type} subject carrying ${o.length} scope(s) (${o.slice(0, 5).join(", ")}). A session cookie carries IDENTITY only — authority is resolved per request, so that removing a role takes effect on the session that already exists instead of in up to 7 days. Mint the session from the identity and move the scopes into the auth.resolveScopes resolver, which runs on every request and can be invalidated the moment a role changes.`);
 	let s = i.ttlSeconds ?? T, c = Math.floor((i.now ?? Date.now)() / 1e3), l = {
 		v: 2,
-		subject: t(n),
+		subject: t(e),
 		exp: c + s,
 		iat: c,
 		...typeof r == "string" ? {} : { kid: a.kid }
@@ -112,19 +113,16 @@ var l = c({ scope: "@voltro/protocol:session" }), u = 2, d = a.Struct({
 		e >= 0 && r.splice(e, 1);
 	}
 	return r.push(`SameSite=${n.sameSite ?? "Lax"}`), (n.secure ?? !0) && r.push("Secure"), n.domain && r.push(`Domain=${n.domain}`), r.join("; ");
-}, L = process.env.VOLTRO_SESSION_COOKIE ?? "voltro:session", R = (e, t = L) => r(e, t, F), z = (e) => {
-	let t = r(e, L, F);
+}, L = process.env.VOLTRO_SESSION_COOKIE ?? "voltro:session", R = (e, t = L) => i(e, t, F), z = (e) => {
+	let t = i(e, L, F);
 	if (!t) return;
 	let n = v();
-	if (!n) {
-		V();
-		return;
-	}
-	return M(t, n)?.exp;
+	if (!n) V();
+	else return M(t, n)?.exp;
 }, B = !1, V = () => {
 	B || (B = !0, l.error("a `voltro:session` cookie was presented but VOLTRO_SESSION_SECRET is not set — the session cannot be verified, so no credential-expiry bound is imposed and realtime subscriptions on this connection will not be cut off when the session expires. Set VOLTRO_SESSION_SECRET (`voltro secret generate session`); `voltro dev` mints one, `voltro serve` refuses to boot without one.", { cookieName: L }));
 }, H = () => {
 	B = !1;
 };
 //#endregion
-export { p as DEFAULT_PREVIOUS_SESSION_KID, f as DEFAULT_SESSION_KID, y as MIN_SESSION_SECRET_LENGTH, L as SESSION_COOKIE_NAME, i as SESSION_HEADER_NAME, u as SESSION_PAYLOAD_VERSION, b as assertProductionSessionSecret, I as buildSetCookie, P as checkBearer, F as readCookie, R as readSessionValue, H as resetSessionSecretWarningLatch, v as resolveOptionalSessionSecrets, h as resolveSessionSecret, g as resolveSessionSecrets, z as sessionExpiryFromHeaders, k as signSession, N as timingSafeStringEqual, j as verifySession, M as verifySessionKeyed };
+export { p as DEFAULT_PREVIOUS_SESSION_KID, f as DEFAULT_SESSION_KID, y as MIN_SESSION_SECRET_LENGTH, L as SESSION_COOKIE_NAME, r as SESSION_HEADER_NAME, u as SESSION_PAYLOAD_VERSION, b as assertProductionSessionSecret, I as buildSetCookie, P as checkBearer, F as readCookie, R as readSessionValue, H as resetSessionSecretWarningLatch, v as resolveOptionalSessionSecrets, h as resolveSessionSecret, g as resolveSessionSecrets, z as sessionExpiryFromHeaders, k as signSession, N as timingSafeStringEqual, j as verifySession, M as verifySessionKeyed };

package/dist/{sessionHeader-DriTZhmv.js → sessionHeader.js}

@@ -4,4 +4,4 @@ var e = "x-voltro-session", t = (e, t, n) => {
 	return r !== void 0 && r.length > 0 ? r : n(e.cookie ?? e.Cookie, t);
 };
 //#endregion
-export { t as n, e as t };
+export { e as SESSION_HEADER_NAME, t as sessionValueFromHeaders };

package/dist/storageAccess.js

@@ -0,0 +1,14 @@
+import { Schema as e } from "effect";
+//#region src/storageAccess.ts
+var t = e.Array(e.String).pipe(e.check(e.isMaxLength(64))), n = e.Struct({
+	owner: e.optional(e.Boolean),
+	roles: e.optional(t),
+	groups: e.optional(t),
+	scopes: e.optional(t),
+	tenant: e.optional(e.Boolean),
+	apiKey: e.optional(e.Boolean),
+	password: e.optional(e.Boolean),
+	guard: e.optional(e.String)
+}), r = e.Array(n).pipe(e.check(e.isMaxLength(32)));
+//#endregion
+export { r as StorageAccessPolicySchema, n as StorageAccessRuleSchema };

package/dist/storeErrors.js

@@ -0,0 +1,66 @@
+import { Schema as e } from "effect";
+//#region src/storeErrors.ts
+var t = class extends e.TaggedError()("TenantScopeViolation", {
+	table: e.String,
+	reason: e.String
+}) {}, n = class extends e.TaggedError()("StoreOperationFailed", {
+	operation: e.String,
+	table: e.String,
+	cause: e.String
+}) {
+	get message() {
+		return `${this.operation} on '${this.table}' failed: ${this.cause}`;
+	}
+}, r = class extends e.TaggedError()("NoRowFound", {
+	table: e.String,
+	found: e.Number
+}) {
+	get message() {
+		return this.found === 0 ? `expected exactly one row in '${this.table}', found none` : `expected exactly one row in '${this.table}', found more than one`;
+	}
+}, i = class extends e.TaggedError()("TableValidationFailed", {
+	table: e.String,
+	summary: e.String,
+	issues: e.Array(e.Struct({
+		path: e.String,
+		message: e.String
+	}))
+}) {
+	get message() {
+		return this.summary;
+	}
+}, a = class extends e.TaggedError()("TenantRowNotFound", {
+	table: e.String,
+	id: e.String,
+	reason: e.String
+}) {}, o = class extends e.TaggedError()("ServerOnlyColumnWrite", {
+	table: e.String,
+	columns: e.Array(e.String)
+}) {}, s = class extends e.TaggedError()("ConstraintViolation", {
+	kind: e.Literals([
+		"foreignKey",
+		"foreignKeyInUse",
+		"unique",
+		"notNull",
+		"check"
+	]),
+	table: e.String,
+	operation: e.String,
+	constraint: e.optional(e.String),
+	column: e.optional(e.String),
+	detail: e.optional(e.String)
+}) {
+	get message() {
+		if (this.detail !== void 0) return this.detail;
+		let e = this.constraint ?? this.column, t = e === void 0 ? `on ${this.table}` : `${e} on ${this.table}`;
+		switch (this.kind) {
+			case "foreignKey": return `foreign key ${t}: the referenced row does not exist`;
+			case "foreignKeyInUse": return `foreign key ${t}: the row is still referenced by other rows`;
+			case "unique": return `unique constraint ${t}: a row with this value already exists`;
+			case "notNull": return `not-null constraint ${t}: the column requires a value`;
+			case "check": return `check constraint ${t}: the row does not satisfy it`;
+		}
+	}
+};
+//#endregion
+export { s as ConstraintViolation, r as NoRowFound, o as ServerOnlyColumnWrite, n as StoreOperationFailed, i as TableValidationFailed, a as TenantRowNotFound, t as TenantScopeViolation };

package/dist/storeScreenshots.js

@@ -0,0 +1,90 @@
+//#region src/storeScreenshots.ts
+var e = [
+	"app-store",
+	"play",
+	"mac-app-store",
+	"microsoft-store"
+], t = [
+	{
+		name: "iphone-6.7",
+		label: "iPhone 6.7″ — 1290×2796",
+		kind: "phone",
+		viewport: {
+			width: 430,
+			height: 932
+		},
+		deviceScaleFactor: 3,
+		stores: ["app-store"]
+	},
+	{
+		name: "iphone-6.5",
+		label: "iPhone 6.5″ — 1242×2688",
+		kind: "phone",
+		viewport: {
+			width: 414,
+			height: 896
+		},
+		deviceScaleFactor: 3,
+		stores: ["app-store"]
+	},
+	{
+		name: "ipad-12.9",
+		label: "iPad 12.9″ — 2048×2732",
+		kind: "tablet",
+		viewport: {
+			width: 1024,
+			height: 1366
+		},
+		deviceScaleFactor: 2,
+		stores: ["app-store"]
+	},
+	{
+		name: "android-phone",
+		label: "Android phone — 1080×2160",
+		kind: "phone",
+		viewport: {
+			width: 360,
+			height: 720
+		},
+		deviceScaleFactor: 3,
+		stores: ["play"]
+	},
+	{
+		name: "android-tablet-10",
+		label: "Android 10″ tablet — 1600×2560",
+		kind: "tablet",
+		viewport: {
+			width: 800,
+			height: 1280
+		},
+		deviceScaleFactor: 2,
+		stores: ["play"]
+	},
+	{
+		name: "mac",
+		label: "Mac — 2880×1800",
+		kind: "desktop",
+		viewport: {
+			width: 1440,
+			height: 900
+		},
+		deviceScaleFactor: 2,
+		stores: ["mac-app-store"]
+	},
+	{
+		name: "windows",
+		label: "Windows — 1366×768",
+		kind: "desktop",
+		viewport: {
+			width: 1366,
+			height: 768
+		},
+		deviceScaleFactor: 1,
+		stores: ["microsoft-store"]
+	}
+], n = t.map((e) => e.name), r = (e) => t.find((t) => t.name === e), i = (e) => ({
+	width: e.viewport.width * e.deviceScaleFactor,
+	height: e.viewport.height * e.deviceScaleFactor
+}), a = (e) => t.filter((t) => t.stores.includes(e));
+//#endregion
+export { t as STORE_SCREENSHOT_PRESETS, n as STORE_SCREENSHOT_PRESET_NAMES, e as STORE_SCREENSHOT_STORES, i as storeScreenshotPixels, r as storeScreenshotPreset, a as storeScreenshotPresetsFor };

package/dist/strictInput.js

@@ -0,0 +1,27 @@
+import { Effect as e, Schema as t, SchemaIssue as n } from "effect";
+import * as r from "effect/SchemaAST";
+//#region src/strictInput.ts
+var i = (e, t) => {
+	let n = `${e ?? "this procedure"} input`;
+	return t === !0 ? `${n} (guarded — the guard did NOT run: the payload failed to decode first, so this says nothing about access)` : n;
+}, a = n.makeFormatterDefault(), o = (e) => t.Never.annotate({ message: e.size === 0 ? "is unexpected: the input declares no keys" : `is unexpected: the input declares ${[...e].map(String).join(", ")}` }).ast, s = (e) => t.String.check(t.makeFilter((t) => e.has(t) ? "a declared key" : void 0)).ast, c = (e, t = /* @__PURE__ */ new Map()) => {
+	let n = t.get(e);
+	if (n !== void 0) return n;
+	let r = l(e, t);
+	return t.set(e, r), r;
+}, l = (e, n) => {
+	if (e.encoding !== void 0) {
+		let i = r.toEncoded(e), a = c(i, n);
+		return a === i ? e : t.make(a).pipe(t.decodeTo(t.make(e))).ast;
+	}
+	if (r.isObjects(e)) {
+		let t = e.propertySignatures.map((e) => new r.PropertySignature(e.name, c(e.type, n))), i = new Set(t.map((e) => e.name)), a = e.indexSignatures.length > 0 ? e.indexSignatures.map((e) => new r.IndexSignature(e.parameter, c(e.type, n))) : [new r.IndexSignature(s(i), o(i))];
+		return new r.Objects(t, a, e.annotations, e.checks, void 0, e.context);
+	}
+	return r.isArrays(e) ? new r.Arrays(e.isMutable, e.elements.map((e) => c(e, n)), e.rest.map((e) => c(e, n)), e.annotations, e.checks, void 0, e.context) : r.isUnion(e) ? new r.Union(e.types.map((e) => c(e, n)), e.options, e.annotations, e.checks, void 0, e.context) : r.isSuspend(e) ? new r.Suspend(() => c(e.thunk(), n), e.annotations, e.checks, void 0, e.context) : e;
+}, u = (r, o, s) => {
+	let l = i(o, s);
+	return t.make(c(r.ast)).pipe(t.middlewareDecoding((t) => e.catch(t, (t) => e.fail(new n.InvalidValue({ message: `${l}\n${a(t)}` })))));
+};
+//#endregion
+export { i as inputLabel, u as strictInput };

package/dist/subscriptionEvent.js

@@ -0,0 +1,37 @@
+import { rowPatchSchema as e } from "./rowPatch.js";
+import { Schema as t, SchemaGetter as n } from "effect";
+//#region src/subscriptionEvent.ts
+var r = t.Json.pipe(t.decodeTo(t.Unknown, {
+	decode: n.passthrough({ strict: !1 }),
+	encode: n.transform((e) => JSON.parse(JSON.stringify(e)))
+})), i = (n) => t.Union([
+	t.Struct({
+		_tag: t.Literal("snapshot"),
+		revision: t.Number,
+		data: n,
+		computed: t.optional(t.Boolean),
+		reconciles: t.optional(t.String)
+	}),
+	t.Struct({
+		_tag: t.Literal("delta"),
+		revision: t.Number,
+		emittedAt: t.Number,
+		patch: e
+	}),
+	t.Struct({
+		_tag: t.Literal("error"),
+		error: r,
+		revision: t.optional(t.Number)
+	})
+]), a = (e, t, n) => {
+	if (!t || typeof t != "object" || !("_tag" in t)) return t;
+	let r = t;
+	switch (r._tag) {
+		case "snapshot": return r.data;
+		case "error": throw r.error === void 0 ? Error(`${n} ${e}: the rpc refused without an error value`) : r.error;
+		case "delta": throw Error(`${n} ${e}: received a 'delta' as the first event, which should be impossible — a subscription always opens with a snapshot. This is a framework bug.`);
+		default: return t;
+	}
+};
+//#endregion
+export { a as firstEventValue, i as subscriptionEvent };

package/dist/tenantSelection.js

@@ -0,0 +1,40 @@
+import { Schema as e } from "effect";
+//#region src/tenantSelection.ts
+var t = class extends e.TaggedError()("RequestedTenantRefused", { reason: e.Literals([
+	"target-unavailable",
+	"invalid-target",
+	"memberships-unavailable",
+	"not-a-member",
+	"subject-has-no-tenant"
+]) }) {}, n = (e) => e.type === "user" || e.type === "apiKey" || e.type === "serviceAccount", r = class extends e.TaggedError()("TenantSelectionRefused", {
+	subjectType: e.String,
+	subjectId: e.NullOr(e.String),
+	tenantId: e.String,
+	reason: e.Literals(["not-a-member", "subject-has-no-tenant"])
+}) {}, i = (e, t, i) => {
+	if (!n(e)) throw new r({
+		subjectType: e.type,
+		subjectId: e.id,
+		tenantId: t,
+		reason: "subject-has-no-tenant"
+	});
+	if (!i.some((e) => e.tenantId === t)) throw new r({
+		subjectType: e.type,
+		subjectId: e.id,
+		tenantId: t,
+		reason: "not-a-member"
+	});
+	return {
+		...e,
+		tenantId: t,
+		metadata: {
+			...e.metadata,
+			memberships: i.map((e) => e.role === void 0 ? { tenantId: e.tenantId } : {
+				tenantId: e.tenantId,
+				role: e.role
+			})
+		}
+	};
+};
+//#endregion
+export { t as RequestedTenantRefused, r as TenantSelectionRefused, n as isTenantSelectable, i as selectSubjectTenant };

package/dist/time.js

@@ -0,0 +1,7 @@
+//#region src/time.ts
+var e = (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;
+};
+//#endregion
+export { e as tsMs };