experimental-a2 0.2.0 → 0.4.0

package/dist/devtools-J_jZ2vQf.d.ts

@@ -0,0 +1,151 @@
+//#region src/devtools.d.ts
+/**
+ * Shared wire protocol for A2's read-only devtools surfaces.
+ *
+ * The HTTP dashboard and non-interactive consumers use the same response
+ * shapes. Captures are newline-delimited JSON so they can be streamed,
+ * inspected with ordinary command-line tools, and verified without access to
+ * an A2 server.
+ */
+declare const DEVTOOLS_PROTOCOL_VERSION: 1;
+declare const DEVTOOLS_CAPTURE_VERSION: 1;
+declare const DEVTOOLS_CAPTURE_MEDIA_TYPE: "application/x-ndjson";
+declare const DEVTOOLS_SESSION_PAGE_LIMIT: 250;
+declare const DEVTOOLS_SESSION_PAGE_MAX_LIMIT: 1_000;
+type DevtoolsWireSessionSummary = {
+  sessionId: string;
+  eventCount: number;
+  pendingCount: number;
+  failedCount: number;
+  attemptCount: number;
+  failureCount: number;
+  firstEventAt: string;
+  updatedAt: string;
+};
+type DevtoolsWireEvent = {
+  id: string;
+  type: string;
+  payload: unknown;
+  index: number;
+  sessionId: string;
+  createdAt: string;
+  cause: {
+    index: number;
+    attempt: number;
+    batchSize?: number;
+  } | null;
+  lane: string | null;
+  processedAt: string | null;
+  processedByAttempt: number | null;
+  returnedEventIds: string[] | null;
+  firstClaimedAt: string | null;
+  lastClaimedAt: string | null;
+  attemptCount: number;
+  claimHolder: string | null;
+  claimExpiresAt: string | null;
+  failureCount: number;
+  lastFailedAt: string | null;
+  lastFailedAttempt: number | null;
+  lastError: string | null;
+  failedAt: string | null;
+};
+type DevtoolsWireSnapshot = {
+  reducerName: string;
+  index: number;
+  updatedAt: string | null;
+};
+type DevtoolsContractsResponse = {
+  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION;
+  contracts: Array<{
+    name: string;
+  }>;
+};
+type DevtoolsSessionsResponse = {
+  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION;
+  cursor: string | null;
+  sessions: DevtoolsWireSessionSummary[];
+};
+type DevtoolsSessionDetail = {
+  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION;
+  contract: string;
+  sessionId: string;
+  /** An invalidation token, not a content-integrity digest. */
+  revision: string;
+  events: DevtoolsWireEvent[];
+  snapshots: DevtoolsWireSnapshot[];
+};
+type DevtoolsSessionPage = {
+  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION;
+  contract: string;
+  sessionId: string;
+  /** Inclusive log frontier frozen by the first page. */
+  throughIndex: number;
+  /** Opaque continuation token; null means this frozen read is complete. */
+  cursor: string | null;
+  events: DevtoolsWireEvent[];
+  /** Snapshot metadata is present only on the first page. */
+  snapshots: DevtoolsWireSnapshot[];
+};
+type DevtoolsCapabilities = {
+  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION;
+  resources: Array<"contracts" | "sessions" | "session" | "watch" | "export">;
+  sessionPagination: {
+    defaultLimit: typeof DEVTOOLS_SESSION_PAGE_LIMIT;
+    maxLimit: typeof DEVTOOLS_SESSION_PAGE_MAX_LIMIT;
+  };
+  capture: {
+    version: typeof DEVTOOLS_CAPTURE_VERSION;
+    mediaType: typeof DEVTOOLS_CAPTURE_MEDIA_TYPE;
+  };
+};
+declare const DEVTOOLS_CAPABILITIES: DevtoolsCapabilities;
+type DevtoolsCaptureManifest = {
+  kind: "a2.capture";
+  captureVersion: typeof DEVTOOLS_CAPTURE_VERSION;
+  protocolVersion: typeof DEVTOOLS_PROTOCOL_VERSION;
+  contract: string;
+  sessionId: string;
+  revision: string;
+  capturedAt: string;
+  fidelity: "exact";
+};
+/** One exact durable event, with the record discriminator added. */
+type DevtoolsCaptureEvent = DevtoolsWireEvent & {
+  kind: "event";
+};
+/** Snapshot metadata only. Cached reducer state is never exported. */
+type DevtoolsCaptureSnapshot = DevtoolsWireSnapshot & {
+  kind: "snapshot";
+};
+type DevtoolsCaptureFooter = {
+  kind: "end";
+  captureVersion: typeof DEVTOOLS_CAPTURE_VERSION;
+  eventCount: number;
+  snapshotCount: number;
+  maxIndex: number | null;
+  sha256: string;
+};
+type DevtoolsCaptureRecord = DevtoolsCaptureManifest | DevtoolsCaptureEvent | DevtoolsCaptureSnapshot | DevtoolsCaptureFooter;
+type DevtoolsCapture = {
+  contract: string;
+  sessionId: string;
+  revision: string;
+  capturedAt: string;
+  manifest: DevtoolsCaptureManifest;
+  events: DevtoolsCaptureEvent[];
+  snapshots: DevtoolsCaptureSnapshot[];
+  footer: DevtoolsCaptureFooter;
+  records: DevtoolsCaptureRecord[];
+};
+/** Compute the server-compatible lifecycle invalidation token. */
+declare const devtoolsSessionRevision: (detail: {
+  events: readonly DevtoolsWireEvent[];
+  snapshots: readonly DevtoolsWireSnapshot[];
+}) => Promise<string>;
+declare function encodeDevtoolsCapture(detail: DevtoolsSessionDetail, options?: {
+  capturedAt?: string | Date;
+}): Promise<string>;
+declare function parseDevtoolsCapture(value: unknown): DevtoolsCapture;
+declare function verifyDevtoolsCapture(capture: DevtoolsCapture): Promise<void>;
+//#endregion
+export { parseDevtoolsCapture as C, encodeDevtoolsCapture as S, DevtoolsSessionsResponse as _, DEVTOOLS_SESSION_PAGE_LIMIT as a, DevtoolsWireSnapshot as b, DevtoolsCapture as c, DevtoolsCaptureManifest as d, DevtoolsCaptureRecord as f, DevtoolsSessionPage as g, DevtoolsSessionDetail as h, DEVTOOLS_PROTOCOL_VERSION as i, DevtoolsCaptureEvent as l, DevtoolsContractsResponse as m, DEVTOOLS_CAPTURE_MEDIA_TYPE as n, DEVTOOLS_SESSION_PAGE_MAX_LIMIT as o, DevtoolsCaptureSnapshot as p, DEVTOOLS_CAPTURE_VERSION as r, DevtoolsCapabilities as s, DEVTOOLS_CAPABILITIES as t, DevtoolsCaptureFooter as u, DevtoolsWireEvent as v, verifyDevtoolsCapture as w, devtoolsSessionRevision as x, DevtoolsWireSessionSummary as y };

package/dist/devtools-kJJaORn-.js

@@ -0,0 +1,338 @@
+//#region src/devtools.ts
+/**
+* Shared wire protocol for A2's read-only devtools surfaces.
+*
+* The HTTP dashboard and non-interactive consumers use the same response
+* shapes. Captures are newline-delimited JSON so they can be streamed,
+* inspected with ordinary command-line tools, and verified without access to
+* an A2 server.
+*/
+const DEVTOOLS_PROTOCOL_VERSION = 1;
+const DEVTOOLS_CAPTURE_VERSION = 1;
+const DEVTOOLS_CAPTURE_MEDIA_TYPE = "application/x-ndjson";
+const DEVTOOLS_SESSION_PAGE_LIMIT = 250;
+const DEVTOOLS_SESSION_PAGE_MAX_LIMIT = 1e3;
+const DEVTOOLS_CAPABILITIES = {
+	protocolVersion: 1,
+	resources: [
+		"contracts",
+		"sessions",
+		"session",
+		"watch",
+		"export"
+	],
+	sessionPagination: {
+		defaultLimit: 250,
+		maxLimit: DEVTOOLS_SESSION_PAGE_MAX_LIMIT
+	},
+	capture: {
+		version: 1,
+		mediaType: DEVTOOLS_CAPTURE_MEDIA_TYPE
+	}
+};
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const objectValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var DevtoolsCaptureError = class extends TypeError {};
+const captureError = (message) => new DevtoolsCaptureError(`invalid A2 devtools capture: ${message}`);
+const sha256 = async (value) => {
+	const digest = await crypto.subtle.digest("SHA-256", encoder.encode(value));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const timestampMs = (value) => value === null ? null : new Date(value).getTime();
+/** Compute the server-compatible lifecycle invalidation token. */
+const devtoolsSessionRevision = (detail) => sha256(JSON.stringify({
+	events: detail.events.map((event) => [
+		event.id,
+		event.index,
+		event.cause?.index ?? null,
+		event.cause?.attempt ?? null,
+		timestampMs(event.processedAt),
+		event.processedByAttempt,
+		timestampMs(event.firstClaimedAt),
+		timestampMs(event.lastClaimedAt),
+		event.attemptCount,
+		event.failureCount,
+		timestampMs(event.lastFailedAt),
+		event.lastFailedAttempt,
+		event.lastError,
+		timestampMs(event.failedAt)
+	]),
+	snapshots: detail.snapshots.map((snapshot) => [
+		snapshot.reducerName,
+		snapshot.index,
+		snapshot.updatedAt === null ? 0 : new Date(snapshot.updatedAt).getTime()
+	])
+}));
+const encodeRecords = (records) => records.map((record) => JSON.stringify(record)).join("\n") + "\n";
+const asCapturedAt = (value) => {
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) throw new TypeError("capturedAt must be a canonical ISO date");
+		return value.toISOString();
+	}
+	if (value === void 0) return (/* @__PURE__ */ new Date()).toISOString();
+	const parsed = new Date(value);
+	if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value) throw new TypeError("capturedAt must be a canonical ISO date string or Date");
+	return value;
+};
+async function encodeDevtoolsCapture(detail, options = {}) {
+	const manifest = {
+		kind: "a2.capture",
+		captureVersion: 1,
+		protocolVersion: 1,
+		contract: detail.contract,
+		sessionId: detail.sessionId,
+		revision: detail.revision,
+		capturedAt: asCapturedAt(options.capturedAt),
+		fidelity: "exact"
+	};
+	const events = detail.events.map((event) => ({
+		...event,
+		kind: "event"
+	}));
+	const snapshots = detail.snapshots.map((snapshot) => ({
+		...snapshot,
+		kind: "snapshot"
+	}));
+	const signedRecords = [
+		manifest,
+		...events,
+		...snapshots
+	];
+	validateCanonicalJsonValue(signedRecords, "capture");
+	const signed = encodeRecords(signedRecords);
+	const footer = {
+		kind: "end",
+		captureVersion: 1,
+		eventCount: events.length,
+		snapshotCount: snapshots.length,
+		maxIndex: events.at(-1)?.index ?? null,
+		sha256: `sha256:${await sha256(signed)}`
+	};
+	return `${signed}${JSON.stringify(footer)}\n`;
+}
+const recordsFromText = (text) => {
+	if (text.length === 0) throw captureError("capture is empty");
+	const lines = text.split("\n");
+	if (lines.pop() !== "") throw captureError("capture must end with a newline");
+	const records = lines.map((line, index) => {
+		if (line.length === 0) throw captureError(`record ${index + 1} is empty`);
+		try {
+			return JSON.parse(line);
+		} catch {
+			throw captureError(`record ${index + 1} is not valid JSON`);
+		}
+	});
+	if (encodeRecords(records) !== text) throw captureError("capture must use canonical UTF-8 NDJSON encoding");
+	return records;
+};
+const recordsFromValues = (records) => {
+	try {
+		validateCanonicalJsonValue(records, "capture.records");
+		return recordsFromText(encodeRecords(records));
+	} catch (error) {
+		if (error instanceof DevtoolsCaptureError) throw error;
+		throw captureError("capture records are not JSON-serializable");
+	}
+};
+const captureRecordsFrom = (value) => {
+	if (typeof value === "string") return recordsFromText(value);
+	if (value instanceof Uint8Array) try {
+		return recordsFromText(decoder.decode(value));
+	} catch (error) {
+		if (error instanceof DevtoolsCaptureError) throw error;
+		throw captureError("capture is not valid UTF-8");
+	}
+	if (Array.isArray(value)) return recordsFromValues(value);
+	const capture = objectValue(value);
+	if (capture) {
+		if (Array.isArray(capture["records"])) return recordsFromValues(capture["records"]);
+		const manifest = capture["manifest"];
+		const events = capture["events"];
+		const snapshots = capture["snapshots"];
+		const footer = capture["footer"];
+		if (Array.isArray(events) && Array.isArray(snapshots)) return recordsFromValues([
+			manifest,
+			...events,
+			...snapshots,
+			footer
+		]);
+	}
+	throw captureError("expected NDJSON text, bytes, records, or a capture");
+};
+const stringField = (value, field, record) => {
+	const candidate = value[field];
+	if (typeof candidate !== "string" || candidate.length === 0) throw captureError(`${record}.${field} must be a non-empty string`);
+	return candidate;
+};
+const integerField = (value, field, record) => {
+	const candidate = value[field];
+	if (!Number.isSafeInteger(candidate) || candidate < 0) throw captureError(`${record}.${field} must be a non-negative integer`);
+	return candidate;
+};
+const positiveInteger = (value) => Number.isSafeInteger(value) && value > 0;
+const nonNegativeInteger = (value) => Number.isSafeInteger(value) && value >= 0;
+const canonicalDate = (value) => {
+	if (typeof value !== "string") return false;
+	const parsed = new Date(value);
+	return !Number.isNaN(parsed.getTime()) && parsed.toISOString() === value;
+};
+const optionalDate = (value) => value === null || canonicalDate(value);
+const nullableString = (value) => value === null || typeof value === "string";
+const nullablePositiveInteger = (value) => value === null || positiveInteger(value);
+const validateDate = (value, field, record, nullable) => {
+	if (nullable ? optionalDate(value) : canonicalDate(value)) return;
+	throw captureError(`${record}.${field} has an invalid timestamp; expected a canonical ISO date${nullable ? " or null" : ""}`);
+};
+const validateCause = (value, record) => {
+	if (value === null) return;
+	const cause = objectValue(value);
+	if (cause === null || !positiveInteger(cause["index"]) || !positiveInteger(cause["attempt"]) || cause["batchSize"] !== void 0 && !positiveInteger(cause["batchSize"])) throw captureError(`${record}.cause is invalid`);
+};
+const validateEventRecord = (record, label) => {
+	stringField(record, "id", label);
+	stringField(record, "type", label);
+	stringField(record, "sessionId", label);
+	if (!Object.hasOwn(record, "payload")) throw captureError(`${label}.payload is required`);
+	if (!positiveInteger(record["index"])) throw captureError(`${label}.index must be a positive integer`);
+	validateDate(record["createdAt"], "createdAt", label, false);
+	validateCause(record["cause"], label);
+	if (!nullableString(record["lane"])) throw captureError(`${label}.lane must be a string or null`);
+	validateDate(record["processedAt"], "processedAt", label, true);
+	if (!nullablePositiveInteger(record["processedByAttempt"])) throw captureError(`${label}.processedByAttempt must be a positive integer or null`);
+	validateDate(record["firstClaimedAt"], "firstClaimedAt", label, true);
+	validateDate(record["lastClaimedAt"], "lastClaimedAt", label, true);
+	if (!nonNegativeInteger(record["attemptCount"])) throw captureError(`${label}.attemptCount must be a non-negative integer`);
+	if (!nullableString(record["claimHolder"])) throw captureError(`${label}.claimHolder must be a string or null`);
+	validateDate(record["claimExpiresAt"], "claimExpiresAt", label, true);
+	if (!nonNegativeInteger(record["failureCount"])) throw captureError(`${label}.failureCount must be a non-negative integer`);
+	validateDate(record["lastFailedAt"], "lastFailedAt", label, true);
+	if (!nullablePositiveInteger(record["lastFailedAttempt"])) throw captureError(`${label}.lastFailedAttempt must be a positive integer or null`);
+	if (!nullableString(record["lastError"])) throw captureError(`${label}.lastError must be a string or null`);
+	validateDate(record["failedAt"], "failedAt", label, true);
+	const returned = record["returnedEventIds"];
+	if (returned !== null && (!Array.isArray(returned) || returned.some((id) => typeof id !== "string" || id.length === 0))) throw captureError(`${label}.returnedEventIds is invalid`);
+};
+const validateSnapshotRecord = (record, label) => {
+	stringField(record, "reducerName", label);
+	if (!nonNegativeInteger(record["index"])) throw captureError(`${label}.index must be a non-negative integer`);
+	validateDate(record["updatedAt"], "updatedAt", label, true);
+};
+function validateCanonicalJsonValue(value, path, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || Object.is(value, -0)) throw captureError(`${path} is not a canonical JSON number`);
+		return;
+	}
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) throw captureError(`${path} is not a canonical JSON tree`);
+		ancestors.add(value);
+		try {
+			const keys = Object.keys(value);
+			const ownKeys = Reflect.ownKeys(value);
+			if (keys.length !== value.length || ownKeys.length !== keys.length + 1 || !ownKeys.includes("length") || keys.some((key, index) => key !== String(index))) throw captureError(`${path} is not a canonical JSON array`);
+			value.forEach((entry, index) => validateCanonicalJsonValue(entry, `${path}[${index}]`, ancestors));
+		} finally {
+			ancestors.delete(value);
+		}
+		return;
+	}
+	const object = objectValue(value);
+	if (object === null || Object.getPrototypeOf(object) !== Object.prototype && Object.getPrototypeOf(object) !== null) throw captureError(`${path} is not a canonical JSON value`);
+	if (ancestors.has(object)) throw captureError(`${path} is not a canonical JSON tree`);
+	ancestors.add(object);
+	try {
+		const keys = Object.keys(object);
+		if (Reflect.ownKeys(object).length !== keys.length || keys.some((key) => !Object.prototype.propertyIsEnumerable.call(object, key))) throw captureError(`${path} is not a canonical JSON object`);
+		for (const key of keys) validateCanonicalJsonValue(object[key], `${path}.${key}`, ancestors);
+	} finally {
+		ancestors.delete(object);
+	}
+}
+function parseDevtoolsCapture(value) {
+	const records = captureRecordsFrom(value);
+	if (records.length < 2) throw captureError("capture needs a manifest and footer");
+	const manifestValue = objectValue(records[0]);
+	if (manifestValue?.["kind"] !== "a2.capture") throw captureError("first record must have kind 'a2.capture'");
+	if (manifestValue["captureVersion"] !== 1) throw captureError(`unsupported capture version '${String(manifestValue["captureVersion"])}'`);
+	if (manifestValue["protocolVersion"] !== 1) throw captureError(`unsupported protocol version '${String(manifestValue["protocolVersion"])}'`);
+	if (manifestValue["fidelity"] !== "exact") throw captureError("manifest.fidelity must be 'exact'");
+	const manifest = manifestValue;
+	const contract = stringField(manifestValue, "contract", "manifest");
+	const sessionId = stringField(manifestValue, "sessionId", "manifest");
+	const revision = stringField(manifestValue, "revision", "manifest");
+	const capturedAt = stringField(manifestValue, "capturedAt", "manifest");
+	if (!canonicalDate(capturedAt)) throw captureError("manifest.capturedAt must be a canonical ISO date");
+	const footerValue = objectValue(records.at(-1));
+	if (footerValue?.["kind"] !== "end") throw captureError("last record must have kind 'end'");
+	if (footerValue["captureVersion"] !== 1) throw captureError("footer capture version does not match");
+	const footer = footerValue;
+	integerField(footerValue, "eventCount", "footer");
+	integerField(footerValue, "snapshotCount", "footer");
+	stringField(footerValue, "sha256", "footer");
+	if (footerValue["maxIndex"] !== null && (!Number.isSafeInteger(footerValue["maxIndex"]) || footerValue["maxIndex"] < 1)) throw captureError("footer.maxIndex must be null or a positive integer");
+	const events = [];
+	const snapshots = [];
+	let sawSnapshot = false;
+	for (let index = 1; index < records.length - 1; index += 1) {
+		const record = objectValue(records[index]);
+		if (record?.["kind"] === "event") {
+			if (sawSnapshot) throw captureError("event records must precede snapshot records");
+			validateEventRecord(record, `record ${index + 1}`);
+			events.push(record);
+		} else if (record?.["kind"] === "snapshot") {
+			sawSnapshot = true;
+			validateSnapshotRecord(record, `record ${index + 1}`);
+			snapshots.push(record);
+		} else throw captureError(`record ${index + 1} has an unknown kind`);
+	}
+	return {
+		contract,
+		sessionId,
+		revision,
+		capturedAt,
+		manifest,
+		events,
+		snapshots,
+		footer,
+		records
+	};
+}
+async function verifyDevtoolsCapture(capture) {
+	validateCanonicalJsonValue(capture.records, "capture.records");
+	parseDevtoolsCapture(capture.records);
+	const expectedRecords = [
+		capture.manifest,
+		...capture.events,
+		...capture.snapshots,
+		capture.footer
+	];
+	if (capture.records.length !== expectedRecords.length || capture.records.some((record, index) => record !== expectedRecords[index])) throw captureError("record sequence does not match the capture");
+	if (capture.contract !== capture.manifest.contract || capture.sessionId !== capture.manifest.sessionId || capture.revision !== capture.manifest.revision || capture.capturedAt !== capture.manifest.capturedAt) throw captureError("capture identity does not match its manifest");
+	if (!canonicalDate(capture.capturedAt)) throw captureError("manifest.capturedAt must be a canonical ISO date");
+	if (capture.footer.eventCount !== capture.events.length) throw captureError("footer event count does not match");
+	if (capture.footer.snapshotCount !== capture.snapshots.length) throw captureError("footer snapshot count does not match");
+	let previousIndex = 0;
+	const ids = /* @__PURE__ */ new Set();
+	for (const event of capture.events) {
+		if (event.kind !== "event") throw captureError("invalid event record kind");
+		validateEventRecord(event, `event #${event.index}`);
+		if (!Number.isSafeInteger(event.index) || event.index !== previousIndex + 1) throw captureError("event indexes must be contiguous from 1");
+		previousIndex = event.index;
+		if (event.sessionId !== capture.sessionId) throw captureError(`event #${event.index} belongs to another session`);
+		if (ids.has(event.id)) throw captureError(`event #${event.index} repeats id '${event.id}'`);
+		ids.add(event.id);
+	}
+	for (const snapshot of capture.snapshots) {
+		if (snapshot.kind !== "snapshot") throw captureError("invalid snapshot record kind");
+		validateSnapshotRecord(snapshot, `snapshot '${snapshot.reducerName}'`);
+		if (!Number.isSafeInteger(snapshot.index) || snapshot.index > previousIndex) throw captureError(`snapshot '${snapshot.reducerName}' is invalid`);
+	}
+	const maxIndex = capture.events.at(-1)?.index ?? null;
+	if (capture.footer.maxIndex !== maxIndex) throw captureError("footer max index does not match");
+	if (!/^sha256:[\da-f]{64}$/.test(capture.footer.sha256)) throw captureError("footer.sha256 is malformed");
+	const expected = `sha256:${await sha256(encodeRecords(capture.records.slice(0, -1)))}`;
+	if (capture.footer.sha256 !== expected) throw captureError("capture digest does not match");
+}
+//#endregion
+export { DEVTOOLS_SESSION_PAGE_LIMIT as a, encodeDevtoolsCapture as c, DEVTOOLS_PROTOCOL_VERSION as i, parseDevtoolsCapture as l, DEVTOOLS_CAPTURE_MEDIA_TYPE as n, DEVTOOLS_SESSION_PAGE_MAX_LIMIT as o, DEVTOOLS_CAPTURE_VERSION as r, devtoolsSessionRevision as s, DEVTOOLS_CAPABILITIES as t, verifyDevtoolsCapture as u };

package/dist/devtools-server.browser.js

@@ -1,4 +1,4 @@
 //#region src/devtools-server.browser.ts
-/** experimental-a2/devtools/server owns log access and is server-only. */
+/** experimental-a2/devtools/server owns store access and is server-only. */
 throw new Error("experimental-a2/devtools/server is server-only — mount its handler in a server route and open that URL in the browser.");
 //#endregion

package/dist/devtools-server.d.ts

@@ -9,8 +9,8 @@ type DevtoolsOptions = {
   servers: readonly DevtoolsServer[];
   /**
    * Application-owned access control. Returning a Response short-circuits
-   * the request. Without this option, devtools is available outside
-   * production and returns 404 in production.
+   * the request. Without this option, devtools is available only when
+   * NODE_ENV is exactly "development" and otherwise returns 404.
    */
   authorize?: DevtoolsAuthorization;
 };