@voltro/protocol 0.83.1 → 0.85.0

package/dist/inspect.d.ts

@@ -1,74 +1,74 @@
 import { ParseOptions } from 'effect/SchemaAST';
 import { Schema } from 'effect';
 
-export declare const decodeInspectBackfillInput: (u: unknown, overrideOptions?: ParseOptions) => {
+export declare const decodeInspectBackfillInput: (input: unknown, options?: ParseOptions) => {
+    readonly requestId: string;
     readonly name: string;
-    readonly limit: number;
     readonly from: string;
     readonly to: string;
-    readonly requestId: string;
     readonly confirm: boolean;
+    readonly limit: number;
 };
 
 export declare type InspectBackfillInput = typeof InspectBackfillInputSchema.Type;
 
 export declare const InspectBackfillInputSchema: Schema.Struct<{
-    requestId: Schema.filter<Schema.filter<typeof Schema.String>>;
-    name: Schema.filter<Schema.filter<typeof Schema.String>>;
-    from: Schema.filter<typeof Schema.String>;
-    to: Schema.filter<typeof Schema.String>;
-    confirm: typeof Schema.Boolean;
-    limit: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly requestId: Schema.String;
+    readonly name: Schema.String;
+    readonly from: Schema.String;
+    readonly to: Schema.String;
+    readonly confirm: Schema.Boolean;
+    readonly limit: Schema.Number;
 }>;
 
 export declare type InspectBackfillReceipt = typeof InspectBackfillReceiptSchema.Type;
 
 export declare const InspectBackfillReceiptSchema: Schema.Struct<{
-    id: Schema.filter<Schema.filter<typeof Schema.String>>;
-    name: Schema.filter<Schema.filter<typeof Schema.String>>;
-    from: Schema.filter<typeof Schema.String>;
-    to: Schema.filter<typeof Schema.String>;
-    occurrences: Schema.Array$<typeof Schema.Number>;
-    status: Schema.Literal<["queued", "running", "completed", "interrupted"]>;
-    owner: Schema.NullOr<typeof Schema.String>;
-    createdAt: Schema.filter<typeof Schema.String>;
-    updatedAt: Schema.filter<typeof Schema.String>;
-    cursor: typeof Schema.Number;
-    activeIndex: Schema.NullOr<typeof Schema.Number>;
-    results: Schema.Array$<Schema.Struct<{
-        runId: Schema.filter<Schema.filter<typeof Schema.String>>;
-        status: Schema.Literal<["succeeded", "failed", "skipped", "missed"]>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly from: Schema.String;
+    readonly to: Schema.String;
+    readonly occurrences: Schema.$Array<Schema.Number>;
+    readonly status: Schema.Literals<readonly ["queued", "running", "completed", "interrupted"]>;
+    readonly owner: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly cursor: Schema.Number;
+    readonly activeIndex: Schema.NullOr<Schema.Number>;
+    readonly results: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "skipped", "missed"]>;
     }>>;
-    error: Schema.NullOr<typeof Schema.String>;
+    readonly error: Schema.NullOr<Schema.String>;
 }>;
 
 export declare type InspectBackfillResult = typeof InspectBackfillResultSchema.Type;
 
-export declare const InspectBackfillResultSchema: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["accepted"]>;
-    request: Schema.Struct<{
-        id: Schema.filter<Schema.filter<typeof Schema.String>>;
-        name: Schema.filter<Schema.filter<typeof Schema.String>>;
-        from: Schema.filter<typeof Schema.String>;
-        to: Schema.filter<typeof Schema.String>;
-        occurrences: Schema.Array$<typeof Schema.Number>;
-        status: Schema.Literal<["queued", "running", "completed", "interrupted"]>;
-        owner: Schema.NullOr<typeof Schema.String>;
-        createdAt: Schema.filter<typeof Schema.String>;
-        updatedAt: Schema.filter<typeof Schema.String>;
-        cursor: typeof Schema.Number;
-        activeIndex: Schema.NullOr<typeof Schema.Number>;
-        results: Schema.Array$<Schema.Struct<{
-            runId: Schema.filter<Schema.filter<typeof Schema.String>>;
-            status: Schema.Literal<["succeeded", "failed", "skipped", "missed"]>;
+export declare const InspectBackfillResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"accepted">;
+    readonly request: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly from: Schema.String;
+        readonly to: Schema.String;
+        readonly occurrences: Schema.$Array<Schema.Number>;
+        readonly status: Schema.Literals<readonly ["queued", "running", "completed", "interrupted"]>;
+        readonly owner: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly cursor: Schema.Number;
+        readonly activeIndex: Schema.NullOr<Schema.Number>;
+        readonly results: Schema.$Array<Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly status: Schema.Literals<readonly ["succeeded", "failed", "skipped", "missed"]>;
         }>>;
-        error: Schema.NullOr<typeof Schema.String>;
+        readonly error: Schema.NullOr<Schema.String>;
     }>;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["refused"]>;
-    name: Schema.filter<Schema.filter<typeof Schema.String>>;
-    occurrences: typeof Schema.Number;
-    reason: typeof Schema.String;
+    readonly kind: Schema.Literal<"refused">;
+    readonly name: Schema.String;
+    readonly occurrences: Schema.Number;
+    readonly reason: Schema.String;
 }>]>;
 
 export declare type InspectCommandRejection = typeof InspectCommandRejectionSchema.Type;
@@ -78,9 +78,9 @@ export declare const inspectCommandRejection: (status: number, message: string)
 /** Explicit non-acceptance from an Inspect command endpoint. Transport errors,
  * conflicts with an earlier request and server failures are not this outcome. */
 export declare const InspectCommandRejectionSchema: Schema.Struct<{
-    kind: Schema.Literal<["rejected"]>;
-    status: Schema.Literal<[400, 401, 403, 404]>;
-    message: typeof Schema.String;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly status: Schema.Literals<readonly [400, 401, 403, 404]>;
+    readonly message: Schema.String;
 }>;
 
 export declare type InspectReplicaSelection = {
@@ -94,75 +94,75 @@ export declare type InspectWorkflowExecutionObservation = typeof InspectWorkflow
 
 /** A projection of engine evidence, not a run-row or recorder-entry claim.
  * Deliberately excludes payloads, outputs, raw causes and journal identifiers. */
-export declare const InspectWorkflowExecutionObservationSchema: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["not-observed"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+export declare const InspectWorkflowExecutionObservationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"not-observed">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["pending"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"pending">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["delivery-failed"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"delivery-failed">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["suspended"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"suspended">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["completed"]>;
-    outcome: Schema.Literal<["succeeded", "failed", "cancelled"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"completed">;
+    readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>]>;
 
 export declare type InspectWorkflowExecutionTarget = typeof InspectWorkflowExecutionTargetSchema.Type;
 
 /** Read an existing execution identity; this is never a start command. */
 export declare const InspectWorkflowExecutionTargetSchema: Schema.Struct<{
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>;
 
 export declare type InspectWorkflowQueuedStartObservation = typeof InspectWorkflowQueuedStartObservationSchema.Type;
 
 /** Read-only admission evidence. Accepted means an execution exists, not that it succeeded. */
-export declare const InspectWorkflowQueuedStartObservationSchema: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["pending"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+export declare const InspectWorkflowQueuedStartObservationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"pending">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["accepted"]>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+    readonly kind: Schema.Literal<"accepted">;
+    readonly executionId: Schema.NonEmptyString;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["not-executed"]>;
-    reason: Schema.Literal<["dropped", "skipped", "superseded", "cancelled", "abandoned", "rejected"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+    readonly kind: Schema.Literal<"not-executed">;
+    readonly reason: Schema.Literals<readonly ["dropped", "skipped", "superseded", "cancelled", "abandoned", "rejected"]>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>]>;
 
 export declare type InspectWorkflowQueuedStartTarget = typeof InspectWorkflowQueuedStartTargetSchema.Type;
 
 /** A caller receipt, never an execution or a reusable admission slot. */
 export declare const InspectWorkflowQueuedStartTargetSchema: Schema.Struct<{
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>;
 
 export declare class InvalidReplicaSelection extends Error {
     readonly name = "InvalidReplicaSelection";
 }
 
-export declare const isInspectCommandRejection: (u: unknown, overrideOptions?: ParseOptions | number) => u is {
-    readonly status: 400 | 401 | 403 | 404;
+export declare const isInspectCommandRejection: <I>(input: I) => input is I & {
     readonly kind: "rejected";
+    readonly status: 400 | 401 | 403 | 404;
     readonly message: string;
 };
 

package/dist/inspect.js

@@ -1,23 +1,39 @@
 import { Schema as e } from "effect";
 //#region src/inspectWorkflowQueuedStart.ts
-var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(e))), n = e.Struct({
+var t = e.NonEmptyString.pipe(e.check(e.isMaxLength(1024)), e.check(e.makeFilter((e) => e.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(e)))), n = e.Struct({
 	workflowName: t,
 	receiptId: t,
 	tenantId: e.NullOr(t)
-}), r = n.fields, i = e.Union(e.Struct({
-	...r,
-	kind: e.Literal("pending")
-}), e.Struct({
-	...r,
-	kind: e.Literal("accepted"),
-	executionId: t
-}), e.Struct({
-	...r,
-	kind: e.Literal("not-executed"),
-	reason: e.Literal("dropped", "skipped", "superseded", "cancelled", "abandoned", "rejected")
-})), a = e.Struct({
+}), r = n.fields, i = e.Union([
+	e.Struct({
+		...r,
+		kind: e.Literal("pending")
+	}),
+	e.Struct({
+		...r,
+		kind: e.Literal("accepted"),
+		executionId: t
+	}),
+	e.Struct({
+		...r,
+		kind: e.Literal("not-executed"),
+		reason: e.Literals([
+			"dropped",
+			"skipped",
+			"superseded",
+			"cancelled",
+			"abandoned",
+			"rejected"
+		])
+	})
+]), a = e.Struct({
 	kind: e.Literal("rejected"),
-	status: e.Literal(400, 401, 403, 404),
+	status: e.Literals([
+		400,
+		401,
+		403,
+		404
+	]),
 	message: e.String
 }), o = e.is(a), s = (e, t) => {
 	let n = {
@@ -26,13 +42,18 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 		message: t
 	};
 	return o(n) ? n : void 0;
-}, c = e.String.pipe(e.filter((e) => Number.isFinite(Date.parse(e)))), l = e.String.pipe(e.minLength(1), e.maxLength(256)), u = e.Struct({
+}, c = e.String.pipe(e.check(e.makeFilter((e) => Number.isFinite(Date.parse(e))))), l = e.String.pipe(e.check(e.isMinLength(1)), e.check(e.isMaxLength(256))), u = e.Struct({
 	id: l,
 	name: l,
 	from: c,
 	to: c,
 	occurrences: e.Array(e.Number),
-	status: e.Literal("queued", "running", "completed", "interrupted"),
+	status: e.Literals([
+		"queued",
+		"running",
+		"completed",
+		"interrupted"
+	]),
 	owner: e.NullOr(e.String),
 	createdAt: c,
 	updatedAt: c,
@@ -40,7 +61,12 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 	activeIndex: e.NullOr(e.Number),
 	results: e.Array(e.Struct({
 		runId: l,
-		status: e.Literal("succeeded", "failed", "skipped", "missed")
+		status: e.Literals([
+			"succeeded",
+			"failed",
+			"skipped",
+			"missed"
+		])
 	})),
 	error: e.NullOr(e.String)
 }), d = e.Struct({
@@ -49,8 +75,11 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 	from: c,
 	to: c,
 	confirm: e.Boolean,
-	limit: e.Number.pipe(e.int(), e.between(1, 1e4))
-}), f = e.decodeUnknownSync(d), p = e.Union(e.Struct({
+	limit: e.Number.pipe(e.check(e.isInt()), e.check(e.isBetween({
+		minimum: 1,
+		maximum: 1e4
+	})))
+}), f = e.decodeUnknownSync(d), p = e.Union([e.Struct({
 	kind: e.Literal("accepted"),
 	request: u
 }), e.Struct({
@@ -58,28 +87,38 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 	name: l,
 	occurrences: e.Number,
 	reason: e.String
-})), m = class extends Error {
+})]), m = class extends Error {
 	name = "ScheduleBackfillRequestConflict";
-}, h = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(e))), g = e.Struct({
+}, h = e.NonEmptyString.pipe(e.check(e.isMaxLength(1024)), e.check(e.makeFilter((e) => e.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(e)))), g = e.Struct({
 	workflowName: h,
 	executionId: h
-}), _ = g.fields, v = e.Union(e.Struct({
-	..._,
-	kind: e.Literal("not-observed")
-}), e.Struct({
-	..._,
-	kind: e.Literal("pending")
-}), e.Struct({
-	..._,
-	kind: e.Literal("delivery-failed")
-}), e.Struct({
-	..._,
-	kind: e.Literal("suspended")
-}), e.Struct({
-	..._,
-	kind: e.Literal("completed"),
-	outcome: e.Literal("succeeded", "failed", "cancelled")
-})), y = (e) => typeof e == "object" && e && !Array.isArray(e) ? e : void 0, b = (e) => Array.isArray(e) && e.every((e) => y(e) !== void 0) ? e : void 0, x = (e) => typeof e == "number" && Number.isFinite(e) ? e : 0, S = /* @__PURE__ */ new Set([
+}), _ = g.fields, v = e.Union([
+	e.Struct({
+		..._,
+		kind: e.Literal("not-observed")
+	}),
+	e.Struct({
+		..._,
+		kind: e.Literal("pending")
+	}),
+	e.Struct({
+		..._,
+		kind: e.Literal("delivery-failed")
+	}),
+	e.Struct({
+		..._,
+		kind: e.Literal("suspended")
+	}),
+	e.Struct({
+		..._,
+		kind: e.Literal("completed"),
+		outcome: e.Literals([
+			"succeeded",
+			"failed",
+			"cancelled"
+		])
+	})
+]), y = (e) => typeof e == "object" && e && !Array.isArray(e) ? e : void 0, b = (e) => Array.isArray(e) && e.every((e) => y(e) !== void 0) ? e : void 0, x = (e) => typeof e == "number" && Number.isFinite(e) ? e : 0, S = /* @__PURE__ */ new Set([
 	"counter",
 	"gauge",
 	"histogram",
@@ -100,7 +139,9 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 	let a = i.map((e) => ({
 		...e,
 		object: y(e.data)
-	})), o = (e) => a.reduce((t, n) => t + x(n.object?.[e]), 0), s = Math.max(...i.map((e) => x(e.observation?.capturedAt))), c = {
+	})), o = (e) => a.reduce((t, n) => t + x(n.object?.[e]), 0), s = -Infinity;
+	for (let e of i) s = Math.max(s, x(e.observation?.capturedAt));
+	let c = {
 		capturedAt: s,
 		bufferSize: o("bufferSize"),
 		bufferCapacity: o("bufferCapacity")
@@ -134,16 +175,22 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 			}), e.set(r, a);
 		}
 		let t = [...e.values()].map((e) => {
-			let t = e.flatMap((e) => b(e.spans) ?? []).sort((e, t) => x(e.startMs) - x(t.startMs)), n = [...e].sort((e, t) => x(e.startMs) - x(t.startMs))[0], r = Math.min(...e.map((e) => x(e.startMs))), i = Math.max(...e.map((e) => x(e.startMs) + x(e.durationMs)));
+			let t = e.flatMap((e) => b(e.spans) ?? []).sort((e, t) => x(e.startMs) - x(t.startMs)), n = e[0], r = x(n.startMs);
+			for (let t = 1; t < e.length; t += 1) {
+				let i = e[t], a = x(i.startMs);
+				a < r && (n = i, r = a);
+			}
+			let i = -Infinity, a = -Infinity, o = 0, s = !1, c = !1, l = !1;
+			for (let t of e) i = Math.max(i, x(t.startMs) + x(t.durationMs)), s ||= t.hasError === !0, c ||= t.deliveryCount !== void 0, l ||= t.lastDeliveryMs !== void 0, o += x(t.deliveryCount), a = Math.max(a, x(t.lastDeliveryMs));
 			return {
 				...n,
 				startMs: r,
 				durationMs: Math.max(0, i - r),
 				spanCount: t.length,
-				hasError: e.some((e) => e.hasError === !0),
+				hasError: s,
 				spans: t,
-				...e.some((e) => e.deliveryCount !== void 0) ? { deliveryCount: e.reduce((e, t) => e + x(t.deliveryCount), 0) } : {},
-				...e.some((e) => e.lastDeliveryMs !== void 0) ? { lastDeliveryMs: Math.max(...e.map((e) => x(e.lastDeliveryMs))) } : {}
+				...c ? { deliveryCount: o } : {},
+				...l ? { lastDeliveryMs: a } : {}
 			};
 		}).sort((e, t) => t.startMs - e.startMs);
 		l = {
@@ -151,16 +198,19 @@ var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length
 			returned: t.length,
 			traces: t
 		};
-	} else if (a.every((e) => b(e.object?.buckets) && typeof e.object?.windowMs == "number")) l = {
-		capturedAt: s,
-		windowMs: Math.max(...a.map((e) => x(e.object?.windowMs))),
-		totalSamples: o("totalSamples"),
-		buckets: a.flatMap((e) => b(e.object?.buckets).map((t) => ({
-			...t,
-			tag: `${String(t.tag)} [${e.replicaId}]`
-		})))
-	};
-	else if (i.every((e) => C(e.data))) l = i.flatMap((e) => C(e.data).map((t) => ({
+	} else if (a.every((e) => b(e.object?.buckets) && typeof e.object?.windowMs == "number")) {
+		let e = -Infinity;
+		for (let t of a) e = Math.max(e, x(t.object?.windowMs));
+		l = {
+			capturedAt: s,
+			windowMs: e,
+			totalSamples: o("totalSamples"),
+			buckets: a.flatMap((e) => b(e.object?.buckets).map((t) => ({
+				...t,
+				tag: `${String(t.tag)} [${e.replicaId}]`
+			})))
+		};
+	} else if (i.every((e) => C(e.data))) l = i.flatMap((e) => C(e.data).map((t) => ({
 		...t,
 		labels: {
 			...y(t.labels),

package/dist/jwt.d.ts

@@ -289,33 +289,31 @@ declare type StrategyResolution = {
     readonly reason: 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.
@@ -332,21 +330,21 @@ 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;