@voltro/protocol 0.69.1 → 0.71.0

package/dist/inspect.d.ts

@@ -0,0 +1,100 @@
+import { ParseOptions } from 'effect/SchemaAST';
+import { Schema } from 'effect';
+
+export declare const decodeInspectBackfillInput: (u: unknown, overrideOptions?: ParseOptions) => {
+    readonly from: string;
+    readonly name: string;
+    readonly limit: number;
+    readonly to: string;
+    readonly requestId: string;
+    readonly confirm: boolean;
+};
+
+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>>;
+}>;
+
+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"]>;
+    }>>;
+    error: Schema.NullOr<typeof 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"]>;
+        }>>;
+        error: Schema.NullOr<typeof Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["refused"]>;
+    name: Schema.filter<Schema.filter<typeof Schema.String>>;
+    occurrences: typeof Schema.Number;
+    reason: typeof Schema.String;
+}>]>;
+
+export declare type InspectReplicaSelection = {
+    readonly mode: 'all';
+} | {
+    readonly mode: 'selected';
+    readonly replicaIds: ReadonlyArray<string>;
+};
+
+export declare class InvalidReplicaSelection extends Error {
+    readonly name = "InvalidReplicaSelection";
+}
+
+/** Repeated parameters preserve IDs containing commas, spaces or punctuation. */
+export declare const parseReplicaSelection: (params: URLSearchParams) => InspectReplicaSelection | undefined;
+
+/** Preserve evidence about failed peers while projecting the composable inspect
+ * domains into their ordinary payload shape. Other domains require an explicit
+ * per-replica comparison; returning one responder as the aggregate is forbidden. */
+export declare const projectReplicaObservation: (value: unknown) => unknown;
+
+export declare class ScheduleBackfillRequestConflict extends Error {
+    readonly name = "ScheduleBackfillRequestConflict";
+}
+
+/** Canonical selection parameters; unrelated filters and pagination survive. */
+export declare const withReplicaSelection: (href: string, selection: InspectReplicaSelection) => string;
+
+export { }

package/dist/inspect.js

@@ -0,0 +1,160 @@
+import { Schema as e } from "effect";
+//#region src/inspectBackfill.ts
+var t = e.String.pipe(e.filter((e) => Number.isFinite(Date.parse(e)))), n = e.String.pipe(e.minLength(1), e.maxLength(256)), r = e.Struct({
+	id: n,
+	name: n,
+	from: t,
+	to: t,
+	occurrences: e.Array(e.Number),
+	status: e.Literal("queued", "running", "completed", "interrupted"),
+	owner: e.NullOr(e.String),
+	createdAt: t,
+	updatedAt: t,
+	cursor: e.Number,
+	activeIndex: e.NullOr(e.Number),
+	results: e.Array(e.Struct({
+		runId: n,
+		status: e.Literal("succeeded", "failed", "skipped", "missed")
+	})),
+	error: e.NullOr(e.String)
+}), i = e.Struct({
+	requestId: n,
+	name: n,
+	from: t,
+	to: t,
+	confirm: e.Boolean,
+	limit: e.Number.pipe(e.int(), e.between(1, 1e4))
+}), a = e.decodeUnknownSync(i), o = e.Union(e.Struct({
+	kind: e.Literal("accepted"),
+	request: r
+}), e.Struct({
+	kind: e.Literal("refused"),
+	name: n,
+	occurrences: e.Number,
+	reason: e.String
+})), s = class extends Error {
+	name = "ScheduleBackfillRequestConflict";
+}, c = (e) => typeof e == "object" && e && !Array.isArray(e) ? e : void 0, l = (e) => Array.isArray(e) && e.every((e) => c(e) !== void 0) ? e : void 0, u = (e) => typeof e == "number" && Number.isFinite(e) ? e : 0, d = /* @__PURE__ */ new Set([
+	"counter",
+	"gauge",
+	"histogram",
+	"summary",
+	"frequency"
+]), f = (e) => {
+	let t = l(e);
+	return t?.every((e) => typeof e.name == "string" && d.has(String(e.type))) ? t : void 0;
+}, p = (e) => {
+	let t = c(e), n = c(t?.data), r = l(n?.results);
+	if (!t || !n?.selection || !r) return e;
+	let i = r.filter((e) => e.status === "answered").map((e) => ({
+		replicaId: String(e.replicaId),
+		observation: c(e.observation),
+		data: c(e.observation)?.data
+	}));
+	if (i.length === 0) throw Error("None of the selected replicas answered. Check replica availability and retry.");
+	let a = i.map((e) => ({
+		...e,
+		object: c(e.data)
+	})), o = (e) => a.reduce((t, n) => t + u(n.object?.[e]), 0), s = Math.max(...i.map((e) => u(e.observation?.capturedAt))), d = {
+		capturedAt: s,
+		bufferSize: o("bufferSize"),
+		bufferCapacity: o("bufferCapacity")
+	}, p;
+	if (a.every((e) => l(e.object?.records))) {
+		let e = a.flatMap((e) => l(e.object?.records).map((t) => ({
+			...t,
+			fields: {
+				...c(t.fields),
+				"voltro.replica": e.replicaId
+			}
+		}))).sort((e, t) => u(e.ts) - u(t.ts));
+		p = {
+			...d,
+			returned: e.length,
+			records: e
+		};
+	} else if (a.every((e) => l(e.object?.traces))) {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of a) for (let n of l(t.object?.traces)) {
+			let r = String(n.traceId), i = (l(n.spans) ?? []).map((e) => ({
+				...e,
+				attributes: {
+					...c(e.attributes),
+					"voltro.replica": t.replicaId
+				}
+			})), a = e.get(r) ?? [];
+			a.push({
+				...n,
+				spans: i
+			}), e.set(r, a);
+		}
+		let t = [...e.values()].map((e) => {
+			let t = e.flatMap((e) => l(e.spans) ?? []).sort((e, t) => u(e.startMs) - u(t.startMs)), n = [...e].sort((e, t) => u(e.startMs) - u(t.startMs))[0], r = Math.min(...e.map((e) => u(e.startMs))), i = Math.max(...e.map((e) => u(e.startMs) + u(e.durationMs)));
+			return {
+				...n,
+				startMs: r,
+				durationMs: Math.max(0, i - r),
+				spanCount: t.length,
+				hasError: e.some((e) => e.hasError === !0),
+				spans: t,
+				...e.some((e) => e.deliveryCount !== void 0) ? { deliveryCount: e.reduce((e, t) => e + u(t.deliveryCount), 0) } : {},
+				...e.some((e) => e.lastDeliveryMs !== void 0) ? { lastDeliveryMs: Math.max(...e.map((e) => u(e.lastDeliveryMs))) } : {}
+			};
+		}).sort((e, t) => t.startMs - e.startMs);
+		p = {
+			...d,
+			returned: t.length,
+			traces: t
+		};
+	} else if (a.every((e) => l(e.object?.buckets) && typeof e.object?.windowMs == "number")) p = {
+		capturedAt: s,
+		windowMs: Math.max(...a.map((e) => u(e.object?.windowMs))),
+		totalSamples: o("totalSamples"),
+		buckets: a.flatMap((e) => l(e.object?.buckets).map((t) => ({
+			...t,
+			tag: `${String(t.tag)} [${e.replicaId}]`
+		})))
+	};
+	else if (i.every((e) => f(e.data))) p = i.flatMap((e) => f(e.data).map((t) => ({
+		...t,
+		labels: {
+			...c(t.labels),
+			voltro_replica: e.replicaId
+		}
+	})));
+	else if (a.every((e) => f(e.object?.samples))) p = { samples: a.flatMap((e) => f(e.object?.samples).map((t) => ({
+		...t,
+		labels: {
+			...c(t.labels),
+			voltro_replica: e.replicaId
+		}
+	}))) };
+	else throw Error("This view must compare observations per replica; its values cannot be safely combined.");
+	return {
+		...t,
+		data: p
+	};
+}, m = class extends Error {
+	name = "InvalidReplicaSelection";
+}, h = (e) => {
+	let t = e.getAll("replicas"), n = e.getAll("replica");
+	if (t.length !== 0 || n.length !== 0) {
+		if (t.length > 1 || t.length === 1 && t[0] !== "all" || t.length > 0 && n.length > 0) throw new m("Choose all replicas or explicit replica IDs, not both.");
+		if (t[0] === "all") return { mode: "all" };
+		if (n.some((e) => e.trim().length === 0 || e.length > 512 || /[\u0000-\u001f\u007f]/.test(e))) throw new m("Replica IDs must be nonempty and contain no control characters.");
+		return {
+			mode: "selected",
+			replicaIds: [...new Set(n)].sort()
+		};
+	}
+}, g = (e, t) => {
+	let n = e.indexOf("#"), r = n < 0 ? "" : e.slice(n), i = n < 0 ? e : e.slice(0, n), a = i.indexOf("?"), o = a < 0 ? i : i.slice(0, a), s = new URLSearchParams(a < 0 ? "" : i.slice(a + 1));
+	if (s.delete("replica"), s.delete("replicas"), t.mode === "all") s.set("replicas", "all");
+	else {
+		if (t.replicaIds.length === 0) throw new m("Select at least one replica.");
+		for (let e of [...new Set(t.replicaIds)].sort()) s.append("replica", e);
+	}
+	return h(s), `${o}?${s}${r}`;
+};
+//#endregion
+export { i as InspectBackfillInputSchema, r as InspectBackfillReceiptSchema, o as InspectBackfillResultSchema, m as InvalidReplicaSelection, s as ScheduleBackfillRequestConflict, a as decodeInspectBackfillInput, h as parseReplicaSelection, p as projectReplicaObservation, g as withReplicaSelection };

package/dist/jwt.d.ts

@@ -305,6 +305,11 @@ declare const Subject: Schema.Union<[Schema.Struct<{
     type: Schema.Literal<["serviceAccount"]>;
     id: typeof Schema.String;
     tenantId: typeof 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>>;
 }>, Schema.Struct<{