@workflow/cli 5.0.0-beta.47 → 5.0.0-beta.48

package/dist/lib/inspect/errors.test.js

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { logger } from '../config/log.js';
+import { reportActionableApiError } from './errors.js';
+const logged = () => vi.spyOn(logger, 'error').mockImplementation(() => undefined);
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+// The set three call sites depend on: handleApiError composes it, listSleeps
+// uses it to decide what not to degrade past, and cancel has no fallback at
+// all. A class dropped from here goes silent in all three.
+describe('reportActionableApiError', () => {
+    it('reports an argument the World rejected locally', () => {
+        const error = Object.assign(new Error('runs.list: pagination.limit must be an integer between 1 and 100 (received 500)'), { code: 'INVALID_ARGUMENT', field: 'pagination.limit' });
+        const error_ = logged();
+        expect(reportActionableApiError(error)).toBe(true);
+        expect(error_.mock.calls.flat().join(' ')).toContain('between 1 and 100');
+    });
+    it('reports the plan gate with its upgrade message', () => {
+        const error = { status: 402, code: 'observability-upgrade-required' };
+        const error_ = logged();
+        expect(reportActionableApiError(error)).toBe(true);
+        expect(error_.mock.calls.flat().join(' ')).toContain('Observability Plus');
+    });
+    // Only meaningful against the Vercel backend, which is the one that answers
+    // 403 for a project the token cannot read.
+    it('reports a Vercel 403 only when that is the backend', () => {
+        const error = { status: 403 };
+        const error_ = logged();
+        expect(reportActionableApiError(error, 'vercel')).toBe(true);
+        expect(error_).toHaveBeenCalled();
+        error_.mockClear();
+        expect(reportActionableApiError(error, 'local')).toBe(false);
+        expect(error_).not.toHaveBeenCalled();
+    });
+    // Availability failures are what listSleeps degrades on, so they must not
+    // be claimed here.
+    it.each([
+        ['a transport failure', new Error('fetch failed')],
+        ['a server error', { status: 503 }],
+        ['a plain 400', { status: 400 }],
+        ['a non-object', 'nope'],
+    ])('leaves %s to the caller', (_label, error) => {
+        const error_ = logged();
+        expect(reportActionableApiError(error)).toBe(false);
+        expect(error_).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inspect/flag-bounds.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Validate `--limit`. Returns an error message, or `undefined` when the value
+ * is an integer within [1, {@link MAX_LIMIT}].
+ */
+export declare function validateInspectLimit(limit: number): string | undefined;
+/**
+ * Validate `--runId`. Returns an error message, or `undefined` when the value
+ * is a well-formed run id.
+ *
+ * Checked here so a mistyped id names the flag and costs no round trip.
+ * `@workflow/world-vercel` validates the same shape and remains the
+ * authority.
+ */
+export declare function validateInspectRunId(runId: string): string | undefined;
+/**
+ * Validate that `--attribute` was given to a listing that consumes it.
+ *
+ * Only the runs listing filters by attributes. Every other resource parses
+ * the flag and ignores it, which is the silent drop these bounds exist to
+ * prevent — the flag is cheap to type onto the wrong subcommand and the
+ * result looks like a successful, unfiltered answer.
+ *
+ * `resource` is the normalized resource and `hasId` marks a single-item
+ * lookup, which reads one run directly and has nothing to filter.
+ * `opensWebUi` marks `--url`/`--web`, which hand the request to the
+ * dashboard rather than filtering here. `withData` marks the payload-
+ * resolving path, which reads from storage and has no attribute index.
+ */
+export declare function validateAttributeScope(resource: string, hasId: boolean, hasAttribute: boolean, opensWebUi?: boolean, withData?: boolean): string | undefined;
+/** Flags {@link validateInspectFlags} checks, as `inspect` parsed them. */
+export interface InspectFlagBounds {
+    /** Normalized resource, e.g. `run`, `steps` → `step`. */
+    resource: string;
+    /** True when the invocation names a single item (`inspect run <id>`). */
+    hasId: boolean;
+    limit?: number;
+    runId?: string;
+    /** Raw repeated `--attribute key=value` values. */
+    attribute?: string[];
+    /** True for `--url`, `--web`, or the `web` resource. */
+    opensWebUi: boolean;
+    withData?: boolean;
+}
+/**
+ * Check every bounded `inspect` flag and parse `--attribute`, returning
+ * either the first error to report or the parsed filters to pass on.
+ *
+ * One call, made before any backend setup: a mistyped flag should name
+ * itself rather than surface as a rejected argument from the read path, or —
+ * worse — be dropped and answered with a plausible unfiltered table.
+ */
+export declare function validateInspectFlags(flags: InspectFlagBounds): {
+    error: string;
+} | {
+    attributes: Record<string, string> | undefined;
+};
+//# sourceMappingURL=flag-bounds.d.ts.map

package/dist/lib/inspect/flag-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag-bounds.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/flag-bounds.ts"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKtE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,OAAO,EACrB,UAAU,UAAQ,EAClB,QAAQ,UAAQ,GACf,MAAM,GAAG,SAAS,CAsBpB;AAED,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,wDAAwD;IACxD,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,iBAAiB,GACvB;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;CAAE,CAyBxE"}

package/dist/lib/inspect/flag-bounds.js

@@ -0,0 +1,112 @@
+import { parseAttributeFilters } from './attribute-filter.js';
+/**
+ * Upper bound on `--limit`.
+ *
+ * 100 is the smallest cap any listing this flag reaches will accept: the
+ * cross-run analytics listings cap there, and so does the storage step
+ * listing that a run-scoped read falls back to. Allowing more meant
+ * `--limit 500` succeeded on some resources and failed on others — and on
+ * the same resource it depended on whether analytics had rows for that run.
+ *
+ * The failure was not uniform either. The cross-run listings reject it
+ * locally with a message naming the parameter; the run-scoped ones accept up
+ * to 1000 and then hit a storage fallback that caps at 100, so the same flag
+ * produced a clear error on one resource and an opaque backend 400 on
+ * another.
+ *
+ * Larger pages are still reachable by paging: the listings follow cursors,
+ * and `--interactive` walks them.
+ */
+const MAX_LIMIT = 100;
+/** `wrun_` plus a 26-character Crockford-Base32 ULID. */
+const RUN_ID_PATTERN = /^wrun_[01234567][0123456789ABCDEFGHJKMNPQRSTVWXYZ]{25}$/;
+/**
+ * Validate `--limit`. Returns an error message, or `undefined` when the value
+ * is an integer within [1, {@link MAX_LIMIT}].
+ */
+export function validateInspectLimit(limit) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+        return `--limit must be an integer between 1 and ${MAX_LIMIT}.`;
+    }
+    return undefined;
+}
+/**
+ * Validate `--runId`. Returns an error message, or `undefined` when the value
+ * is a well-formed run id.
+ *
+ * Checked here so a mistyped id names the flag and costs no round trip.
+ * `@workflow/world-vercel` validates the same shape and remains the
+ * authority.
+ */
+export function validateInspectRunId(runId) {
+    if (!RUN_ID_PATTERN.test(runId)) {
+        return `--runId must be a run id: 'wrun_' followed by a 26-character ULID. Received ${JSON.stringify(runId)}.`;
+    }
+    return undefined;
+}
+/**
+ * Validate that `--attribute` was given to a listing that consumes it.
+ *
+ * Only the runs listing filters by attributes. Every other resource parses
+ * the flag and ignores it, which is the silent drop these bounds exist to
+ * prevent — the flag is cheap to type onto the wrong subcommand and the
+ * result looks like a successful, unfiltered answer.
+ *
+ * `resource` is the normalized resource and `hasId` marks a single-item
+ * lookup, which reads one run directly and has nothing to filter.
+ * `opensWebUi` marks `--url`/`--web`, which hand the request to the
+ * dashboard rather than filtering here. `withData` marks the payload-
+ * resolving path, which reads from storage and has no attribute index.
+ */
+export function validateAttributeScope(resource, hasId, hasAttribute, opensWebUi = false, withData = false) {
+    if (!hasAttribute)
+        return undefined;
+    // --withData reads payloads, which only storage carries, and storage has
+    // no attribute index. Warning and returning every row was the failure this
+    // guard exists to prevent, and unlike a backend without analytics it is a
+    // conflict between two flags the caller passed.
+    if (withData) {
+        return '--attribute cannot be combined with --withData, which reads payloads from storage; drop one.';
+    }
+    // --url and --web hand off to the dashboard, which takes no attribute
+    // filter, and both return before the filter is parsed — so the flag was
+    // accepted, never validated, and the view opened unfiltered.
+    if (opensWebUi) {
+        return '--attribute cannot be forwarded to the web UI; drop it, or drop --url/--web to filter here.';
+    }
+    if (resource === 'run' && hasId) {
+        return '--attribute filters run listings; `inspect run <id>` already names one run. Drop the flag or the ID.';
+    }
+    if (resource !== 'run') {
+        return `--attribute filters run listings only, not ${resource}. Use \`workflow inspect runs --attribute key=value\`.`;
+    }
+    return undefined;
+}
+/**
+ * Check every bounded `inspect` flag and parse `--attribute`, returning
+ * either the first error to report or the parsed filters to pass on.
+ *
+ * One call, made before any backend setup: a mistyped flag should name
+ * itself rather than surface as a rejected argument from the read path, or —
+ * worse — be dropped and answered with a plausible unfiltered table.
+ */
+export function validateInspectFlags(flags) {
+    const error = (flags.limit !== undefined
+        ? validateInspectLimit(flags.limit)
+        : undefined) ??
+        (flags.runId !== undefined
+            ? validateInspectRunId(flags.runId)
+            : undefined) ??
+        validateAttributeScope(flags.resource, flags.hasId, Boolean(flags.attribute?.length), flags.opensWebUi, Boolean(flags.withData));
+    if (error)
+        return { error };
+    try {
+        return { attributes: parseAttributeFilters(flags.attribute) };
+    }
+    catch (parseError) {
+        return {
+            error: parseError instanceof Error ? parseError.message : String(parseError),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flag-bounds.js","sourceRoot":"","sources":["../../../src/lib/inspect/flag-bounds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,SAAS,GAAG,GAAG,CAAC;AAEtB,yDAAyD;AACzD,MAAM,cAAc,GAClB,yDAAyD,CAAC;AAE5D;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa;IAChD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;QAC/D,OAAO,4CAA4C,SAAS,GAAG,CAAC;IAClE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa;IAChD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,+EAA+E,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC;IACjH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,sBAAsB,CACpC,QAAgB,EAChB,KAAc,EACd,YAAqB,EACrB,UAAU,GAAG,KAAK,EAClB,QAAQ,GAAG,KAAK;IAEhB,IAAI,CAAC,YAAY;QAAE,OAAO,SAAS,CAAC;IACpC,yEAAyE;IACzE,2EAA2E;IAC3E,0EAA0E;IAC1E,gDAAgD;IAChD,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,8FAA8F,CAAC;IACxG,CAAC;IACD,sEAAsE;IACtE,wEAAwE;IACxE,6DAA6D;IAC7D,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,6FAA6F,CAAC;IACvG,CAAC;IACD,IAAI,QAAQ,KAAK,KAAK,IAAI,KAAK,EAAE,CAAC;QAChC,OAAO,sGAAsG,CAAC;IAChH,CAAC;IACD,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;QACvB,OAAO,8CAA8C,QAAQ,wDAAwD,CAAC;IACxH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAiBD;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAwB;IAExB,MAAM,KAAK,GACT,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS;QACxB,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,KAAK,CAAC;QACnC,CAAC,CAAC,SAAS,CAAC;QACd,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS;YACxB,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,KAAK,CAAC;YACnC,CAAC,CAAC,SAAS,CAAC;QACd,sBAAsB,CACpB,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,KAAK,EACX,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,EAChC,KAAK,CAAC,UAAU,EAChB,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CACxB,CAAC;IACJ,IAAI,KAAK;QAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAE5B,IAAI,CAAC;QACH,OAAO,EAAE,UAAU,EAAE,qBAAqB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;IAChE,CAAC;IAAC,OAAO,UAAU,EAAE,CAAC;QACpB,OAAO;YACL,KAAK,EACH,UAAU,YAAY,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;SACxE,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["import { parseAttributeFilters } from './attribute-filter.js';\n\n/**\n * Upper bound on `--limit`.\n *\n * 100 is the smallest cap any listing this flag reaches will accept: the\n * cross-run analytics listings cap there, and so does the storage step\n * listing that a run-scoped read falls back to. Allowing more meant\n * `--limit 500` succeeded on some resources and failed on others — and on\n * the same resource it depended on whether analytics had rows for that run.\n *\n * The failure was not uniform either. The cross-run listings reject it\n * locally with a message naming the parameter; the run-scoped ones accept up\n * to 1000 and then hit a storage fallback that caps at 100, so the same flag\n * produced a clear error on one resource and an opaque backend 400 on\n * another.\n *\n * Larger pages are still reachable by paging: the listings follow cursors,\n * and `--interactive` walks them.\n */\nconst MAX_LIMIT = 100;\n\n/** `wrun_` plus a 26-character Crockford-Base32 ULID. */\nconst RUN_ID_PATTERN =\n  /^wrun_[01234567][0123456789ABCDEFGHJKMNPQRSTVWXYZ]{25}$/;\n\n/**\n * Validate `--limit`. Returns an error message, or `undefined` when the value\n * is an integer within [1, {@link MAX_LIMIT}].\n */\nexport function validateInspectLimit(limit: number): string | undefined {\n  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {\n    return `--limit must be an integer between 1 and ${MAX_LIMIT}.`;\n  }\n  return undefined;\n}\n\n/**\n * Validate `--runId`. Returns an error message, or `undefined` when the value\n * is a well-formed run id.\n *\n * Checked here so a mistyped id names the flag and costs no round trip.\n * `@workflow/world-vercel` validates the same shape and remains the\n * authority.\n */\nexport function validateInspectRunId(runId: string): string | undefined {\n  if (!RUN_ID_PATTERN.test(runId)) {\n    return `--runId must be a run id: 'wrun_' followed by a 26-character ULID. Received ${JSON.stringify(runId)}.`;\n  }\n  return undefined;\n}\n\n/**\n * Validate that `--attribute` was given to a listing that consumes it.\n *\n * Only the runs listing filters by attributes. Every other resource parses\n * the flag and ignores it, which is the silent drop these bounds exist to\n * prevent — the flag is cheap to type onto the wrong subcommand and the\n * result looks like a successful, unfiltered answer.\n *\n * `resource` is the normalized resource and `hasId` marks a single-item\n * lookup, which reads one run directly and has nothing to filter.\n * `opensWebUi` marks `--url`/`--web`, which hand the request to the\n * dashboard rather than filtering here. `withData` marks the payload-\n * resolving path, which reads from storage and has no attribute index.\n */\nexport function validateAttributeScope(\n  resource: string,\n  hasId: boolean,\n  hasAttribute: boolean,\n  opensWebUi = false,\n  withData = false\n): string | undefined {\n  if (!hasAttribute) return undefined;\n  // --withData reads payloads, which only storage carries, and storage has\n  // no attribute index. Warning and returning every row was the failure this\n  // guard exists to prevent, and unlike a backend without analytics it is a\n  // conflict between two flags the caller passed.\n  if (withData) {\n    return '--attribute cannot be combined with --withData, which reads payloads from storage; drop one.';\n  }\n  // --url and --web hand off to the dashboard, which takes no attribute\n  // filter, and both return before the filter is parsed — so the flag was\n  // accepted, never validated, and the view opened unfiltered.\n  if (opensWebUi) {\n    return '--attribute cannot be forwarded to the web UI; drop it, or drop --url/--web to filter here.';\n  }\n  if (resource === 'run' && hasId) {\n    return '--attribute filters run listings; `inspect run <id>` already names one run. Drop the flag or the ID.';\n  }\n  if (resource !== 'run') {\n    return `--attribute filters run listings only, not ${resource}. Use \\`workflow inspect runs --attribute key=value\\`.`;\n  }\n  return undefined;\n}\n\n/** Flags {@link validateInspectFlags} checks, as `inspect` parsed them. */\nexport interface InspectFlagBounds {\n  /** Normalized resource, e.g. `run`, `steps` → `step`. */\n  resource: string;\n  /** True when the invocation names a single item (`inspect run <id>`). */\n  hasId: boolean;\n  limit?: number;\n  runId?: string;\n  /** Raw repeated `--attribute key=value` values. */\n  attribute?: string[];\n  /** True for `--url`, `--web`, or the `web` resource. */\n  opensWebUi: boolean;\n  withData?: boolean;\n}\n\n/**\n * Check every bounded `inspect` flag and parse `--attribute`, returning\n * either the first error to report or the parsed filters to pass on.\n *\n * One call, made before any backend setup: a mistyped flag should name\n * itself rather than surface as a rejected argument from the read path, or —\n * worse — be dropped and answered with a plausible unfiltered table.\n */\nexport function validateInspectFlags(\n  flags: InspectFlagBounds\n): { error: string } | { attributes: Record<string, string> | undefined } {\n  const error =\n    (flags.limit !== undefined\n      ? validateInspectLimit(flags.limit)\n      : undefined) ??\n    (flags.runId !== undefined\n      ? validateInspectRunId(flags.runId)\n      : undefined) ??\n    validateAttributeScope(\n      flags.resource,\n      flags.hasId,\n      Boolean(flags.attribute?.length),\n      flags.opensWebUi,\n      Boolean(flags.withData)\n    );\n  if (error) return { error };\n\n  try {\n    return { attributes: parseAttributeFilters(flags.attribute) };\n  } catch (parseError) {\n    return {\n      error:\n        parseError instanceof Error ? parseError.message : String(parseError),\n    };\n  }\n}\n"]}

package/dist/lib/inspect/flag-bounds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flag-bounds.test.d.ts.map

package/dist/lib/inspect/flag-bounds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag-bounds.test.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/flag-bounds.test.ts"],"names":[],"mappings":""}

package/dist/lib/inspect/flag-bounds.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { validateAttributeScope, validateInspectFlags, validateInspectLimit, validateInspectRunId, } from './flag-bounds.js';
+describe('validateInspectLimit', () => {
+    it.each([1, 20, 100])('accepts %s', (limit) => {
+        expect(validateInspectLimit(limit)).toBeUndefined();
+    });
+    // 101-1000 used to be accepted here and rejected downstream: the cross-run
+    // listings reject them locally, and the run-scoped ones take them as far as
+    // a storage fallback that caps at 100 and answers with an opaque 400.
+    it.each([
+        0,
+        -1,
+        101,
+        500,
+        1001,
+        1.5,
+        Number.NaN,
+        Number.POSITIVE_INFINITY,
+    ])('rejects %s and names the flag', (limit) => {
+        expect(validateInspectLimit(limit)).toBe('--limit must be an integer between 1 and 100.');
+    });
+});
+describe('validateInspectRunId', () => {
+    it('accepts a well-formed run id', () => {
+        expect(validateInspectRunId('wrun_01K4BZQ5T2J8HXFM6WD3PNAVCE')).toBeUndefined();
+    });
+    // The backend accepts neither of these, so catching them here saves a round
+    // trip and names the flag.
+    it.each([
+        ['a lowercase body', 'wrun_01k4bzq5t2j8hxfm6wd3pnavce'],
+        ['a first character above 7', 'wrun_81K4BZQ5T2J8HXFM6WD3PNAVCE'],
+        ['a non-Crockford character', 'wrun_01K4BZQ5T2J8HXFM6WD3PNAVCI'],
+        ['the wrong prefix', 'step_01K4BZQ5T2J8HXFM6WD3PNAVCE'],
+        ['no prefix', '01K4BZQ5T2J8HXFM6WD3PNAVCE'],
+        ['a truncated body', 'wrun_01K4BZQ'],
+        ['nothing', ''],
+    ])('rejects %s', (_label, runId) => {
+        expect(validateInspectRunId(runId)).toContain('--runId must be a run id');
+    });
+});
+describe('validateAttributeScope', () => {
+    it('is undefined when the flag is absent, whatever the resource', () => {
+        for (const resource of ['run', 'step', 'event', 'attribute', 'web']) {
+            expect(validateAttributeScope(resource, false, false)).toBeUndefined();
+            expect(validateAttributeScope(resource, true, false)).toBeUndefined();
+        }
+    });
+    it('allows it on the runs listing', () => {
+        expect(validateAttributeScope('run', false, true)).toBeUndefined();
+    });
+    // Every one of these parsed the flag and ignored it before. `web` is not
+    // listed: the command always passes `opensWebUi` for it, so it is rejected
+    // by that arm instead and this one is unreachable for that value.
+    it.each([
+        'step',
+        'event',
+        'hook',
+        'sleep',
+        'stream',
+        'attribute',
+    ])('rejects it on %s', (resource) => {
+        expect(validateAttributeScope(resource, false, true)).toContain('--attribute filters run listings only');
+    });
+    // A single-run lookup already names its run, so there is nothing to filter.
+    it('rejects it alongside a run ID', () => {
+        expect(validateAttributeScope('run', true, true)).toContain('already names one run');
+    });
+});
+describe('validateAttributeScope with the web UI', () => {
+    // Both flags return before the filter is parsed or forwarded, so the view
+    // opened unfiltered and a malformed pair was never checked.
+    it.each([
+        true,
+        false,
+    ])('rejects --attribute when handing off to the web UI (hasId=%s)', (hasId) => {
+        expect(validateAttributeScope('run', hasId, true, true)).toContain('cannot be forwarded to the web UI');
+    });
+    it('still allows it for a local runs listing', () => {
+        expect(validateAttributeScope('run', false, true, false)).toBeUndefined();
+    });
+    it('says nothing when the flag is absent', () => {
+        expect(validateAttributeScope('run', false, false, true)).toBeUndefined();
+    });
+});
+// The command calls this once, before any backend setup. It composes the
+// three checks above with the `--attribute` parse, so a malformed pair and an
+// out-of-range limit reach the user the same way.
+describe('validateInspectFlags', () => {
+    const base = { resource: 'run', hasId: false, opensWebUi: false };
+    it('returns the parsed filters when everything checks out', () => {
+        expect(validateInspectFlags({ ...base, attribute: ['tenant=acme'], limit: 50 })).toEqual({ attributes: { tenant: 'acme' } });
+    });
+    it('leaves attributes undefined when the flag was not given', () => {
+        expect(validateInspectFlags(base)).toEqual({ attributes: undefined });
+    });
+    it('reports a malformed pair rather than throwing', () => {
+        const result = validateInspectFlags({ ...base, attribute: ['tenant'] });
+        expect(result).toHaveProperty('error');
+    });
+    // Order matters: a bound that fails should be reported before the parse
+    // runs, so the message names the flag the caller can act on first.
+    it.each([
+        ['limit', { limit: 500 }, '--limit must be an integer'],
+        ['runId', { runId: 'nope' }, '--runId must be a run id'],
+        [
+            'scope',
+            { resource: 'step', attribute: ['a=b'] },
+            '--attribute filters run listings only',
+        ],
+        [
+            'withData',
+            { attribute: ['a=b'], withData: true },
+            'cannot be combined with --withData',
+        ],
+        [
+            'web UI',
+            { attribute: ['a=b'], opensWebUi: true },
+            'cannot be forwarded to the web UI',
+        ],
+    ])('reports a bad %s', (_label, flags, expected) => {
+        const result = validateInspectFlags({ ...base, ...flags });
+        expect(result).toHaveProperty('error');
+        expect(result.error).toContain(expected);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flag-bounds.test.js","sourceRoot":"","sources":["../../../src/lib/inspect/flag-bounds.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from 'vitest';\nimport {\n  validateAttributeScope,\n  validateInspectFlags,\n  validateInspectLimit,\n  validateInspectRunId,\n} from './flag-bounds.js';\n\ndescribe('validateInspectLimit', () => {\n  it.each([1, 20, 100])('accepts %s', (limit) => {\n    expect(validateInspectLimit(limit)).toBeUndefined();\n  });\n\n  // 101-1000 used to be accepted here and rejected downstream: the cross-run\n  // listings reject them locally, and the run-scoped ones take them as far as\n  // a storage fallback that caps at 100 and answers with an opaque 400.\n  it.each([\n    0,\n    -1,\n    101,\n    500,\n    1001,\n    1.5,\n    Number.NaN,\n    Number.POSITIVE_INFINITY,\n  ])('rejects %s and names the flag', (limit) => {\n    expect(validateInspectLimit(limit)).toBe(\n      '--limit must be an integer between 1 and 100.'\n    );\n  });\n});\n\ndescribe('validateInspectRunId', () => {\n  it('accepts a well-formed run id', () => {\n    expect(\n      validateInspectRunId('wrun_01K4BZQ5T2J8HXFM6WD3PNAVCE')\n    ).toBeUndefined();\n  });\n\n  // The backend accepts neither of these, so catching them here saves a round\n  // trip and names the flag.\n  it.each([\n    ['a lowercase body', 'wrun_01k4bzq5t2j8hxfm6wd3pnavce'],\n    ['a first character above 7', 'wrun_81K4BZQ5T2J8HXFM6WD3PNAVCE'],\n    ['a non-Crockford character', 'wrun_01K4BZQ5T2J8HXFM6WD3PNAVCI'],\n    ['the wrong prefix', 'step_01K4BZQ5T2J8HXFM6WD3PNAVCE'],\n    ['no prefix', '01K4BZQ5T2J8HXFM6WD3PNAVCE'],\n    ['a truncated body', 'wrun_01K4BZQ'],\n    ['nothing', ''],\n  ])('rejects %s', (_label, runId) => {\n    expect(validateInspectRunId(runId)).toContain('--runId must be a run id');\n  });\n});\n\ndescribe('validateAttributeScope', () => {\n  it('is undefined when the flag is absent, whatever the resource', () => {\n    for (const resource of ['run', 'step', 'event', 'attribute', 'web']) {\n      expect(validateAttributeScope(resource, false, false)).toBeUndefined();\n      expect(validateAttributeScope(resource, true, false)).toBeUndefined();\n    }\n  });\n\n  it('allows it on the runs listing', () => {\n    expect(validateAttributeScope('run', false, true)).toBeUndefined();\n  });\n\n  // Every one of these parsed the flag and ignored it before. `web` is not\n  // listed: the command always passes `opensWebUi` for it, so it is rejected\n  // by that arm instead and this one is unreachable for that value.\n  it.each([\n    'step',\n    'event',\n    'hook',\n    'sleep',\n    'stream',\n    'attribute',\n  ])('rejects it on %s', (resource) => {\n    expect(validateAttributeScope(resource, false, true)).toContain(\n      '--attribute filters run listings only'\n    );\n  });\n\n  // A single-run lookup already names its run, so there is nothing to filter.\n  it('rejects it alongside a run ID', () => {\n    expect(validateAttributeScope('run', true, true)).toContain(\n      'already names one run'\n    );\n  });\n});\n\ndescribe('validateAttributeScope with the web UI', () => {\n  // Both flags return before the filter is parsed or forwarded, so the view\n  // opened unfiltered and a malformed pair was never checked.\n  it.each([\n    true,\n    false,\n  ])('rejects --attribute when handing off to the web UI (hasId=%s)', (hasId) => {\n    expect(validateAttributeScope('run', hasId, true, true)).toContain(\n      'cannot be forwarded to the web UI'\n    );\n  });\n\n  it('still allows it for a local runs listing', () => {\n    expect(validateAttributeScope('run', false, true, false)).toBeUndefined();\n  });\n\n  it('says nothing when the flag is absent', () => {\n    expect(validateAttributeScope('run', false, false, true)).toBeUndefined();\n  });\n});\n\n// The command calls this once, before any backend setup. It composes the\n// three checks above with the `--attribute` parse, so a malformed pair and an\n// out-of-range limit reach the user the same way.\ndescribe('validateInspectFlags', () => {\n  const base = { resource: 'run', hasId: false, opensWebUi: false };\n\n  it('returns the parsed filters when everything checks out', () => {\n    expect(\n      validateInspectFlags({ ...base, attribute: ['tenant=acme'], limit: 50 })\n    ).toEqual({ attributes: { tenant: 'acme' } });\n  });\n\n  it('leaves attributes undefined when the flag was not given', () => {\n    expect(validateInspectFlags(base)).toEqual({ attributes: undefined });\n  });\n\n  it('reports a malformed pair rather than throwing', () => {\n    const result = validateInspectFlags({ ...base, attribute: ['tenant'] });\n    expect(result).toHaveProperty('error');\n  });\n\n  // Order matters: a bound that fails should be reported before the parse\n  // runs, so the message names the flag the caller can act on first.\n  it.each([\n    ['limit', { limit: 500 }, '--limit must be an integer'],\n    ['runId', { runId: 'nope' }, '--runId must be a run id'],\n    [\n      'scope',\n      { resource: 'step', attribute: ['a=b'] },\n      '--attribute filters run listings only',\n    ],\n    [\n      'withData',\n      { attribute: ['a=b'], withData: true },\n      'cannot be combined with --withData',\n    ],\n    [\n      'web UI',\n      { attribute: ['a=b'], opensWebUi: true },\n      'cannot be forwarded to the web UI',\n    ],\n  ])('reports a bad %s', (_label, flags, expected) => {\n    const result = validateInspectFlags({ ...base, ...flags });\n    expect(result).toHaveProperty('error');\n    expect((result as { error: string }).error).toContain(expected);\n  });\n});\n"]}

package/dist/lib/inspect/flags.d.ts

@@ -12,7 +12,7 @@ export declare const cliFlags: {
     noBrowser: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     localUi: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     standalone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    sort: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
     interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };

package/dist/lib/inspect/flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;CAyJpB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO;;CASnB,CAAC"}
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;CA4JpB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO;;CASnB,CAAC"}

package/dist/lib/inspect/flags.js

@@ -125,7 +125,10 @@ export const cliFlags = {
         description: 'sort order for list commands',
         required: false,
         options: ['asc', 'desc'],
-        default: 'desc',
+        // No parser-level default: every time-ordered listing already falls back
+        // to `desc` itself, and a default here made the flag indistinguishable
+        // from an explicit one, so `inspect attributes` could not tell that it
+        // should leave the backend's alphabetical key order alone.
         helpGroup: 'Filtering',
         helpLabel: '--sort',
         helpValue: ['asc', 'desc'],
@@ -162,4 +165,4 @@ export const urlFlag = {
         helpLabel: '--url',
     }),
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flags.js","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from '@oclif/core';\n\nexport const cliFlags = {\n  verbose: Flags.boolean({\n    description: 'Verbose output',\n    required: false,\n    char: 'v',\n    helpGroup: 'Output',\n    helpLabel: '-v, --verbose',\n    env: 'DEBUG',\n    default: false,\n  }),\n  json: Flags.boolean({\n    description: 'output JSON instead of human-readable tables/streams',\n    required: false,\n    char: 'j',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-j, --json',\n  }),\n  cursor: Flags.string({\n    description: 'pagination cursor for list commands',\n    required: false,\n    default: '',\n    helpGroup: 'Filtering',\n    helpLabel: '--cursor',\n    helpValue: 'CURSOR',\n  }),\n  backend: Flags.string({\n    description: 'backend to inspect',\n    required: false,\n    char: 'b',\n    default: 'local',\n    env: 'WORKFLOW_TARGET_WORLD',\n    helpGroup: 'Target',\n    helpLabel: '-b, --backend',\n    helpValue: ['local', 'vercel', '<your-package-name>'],\n    defaultHelp: 'local',\n  }),\n  authToken: Flags.string({\n    description:\n      'Authentication token to be passed to the backend. If not provided and the backend is vercel, will fall back to the token generated by `vc login`.',\n    required: false,\n    char: 'a',\n    dependsOn: ['backend'],\n    default: '',\n    env: 'WORKFLOW_VERCEL_AUTH_TOKEN',\n    helpGroup: 'Target',\n    helpLabel: '-a, --authToken',\n    helpValue: 'TOKEN',\n  }),\n  project: Flags.string({\n    description:\n      'If backend is vercel, the vercel project to authenticate against',\n    required: false,\n    default: '',\n    dependsOn: ['backend'],\n    env: 'WORKFLOW_VERCEL_PROJECT',\n    helpGroup: 'Target',\n    helpLabel: '--project',\n    helpValue: 'PROJECT',\n  }),\n  team: Flags.string({\n    description:\n      'If backend is vercel, the vercel team to authenticate against',\n    required: false,\n    dependsOn: ['backend'],\n    default: '',\n    env: 'WORKFLOW_VERCEL_TEAM',\n    helpGroup: 'Target',\n    helpLabel: '--team',\n    helpValue: 'TEAM',\n  }),\n  env: Flags.string({\n    description: 'If backend is vercel, the vercel environment to use',\n    required: false,\n    options: ['production', 'preview'],\n    default: 'production',\n    char: 'e',\n    dependsOn: ['backend'],\n    env: 'WORKFLOW_VERCEL_ENV',\n    helpGroup: 'Target',\n    helpLabel: '-e, --env',\n    helpValue: ['production', 'preview'],\n    defaultHelp: 'production',\n  }),\n  web: Flags.boolean({\n    description: 'Open the web UI instead of displaying in terminal',\n    required: false,\n    char: 'w',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-w, --web',\n  }),\n  webPort: Flags.integer({\n    description: 'Port to use when launching the web UI (default: 3456)',\n    required: false,\n    default: 3456,\n    helpGroup: 'Output',\n    helpLabel: '--webPort',\n    helpValue: 'WEB_PORT',\n    env: 'WORKFLOW_WEB_PORT',\n  }),\n  noBrowser: Flags.boolean({\n    description: 'Disable automatic browser opening when launching web UI',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_DISABLE_BROWSER_OPEN',\n    helpGroup: 'Output',\n    helpLabel: '--noBrowser',\n  }),\n  localUi: Flags.boolean({\n    description:\n      'Use local web UI instead of Vercel dashboard (when backend is vercel)',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_LOCAL_UI',\n    helpGroup: 'Output',\n    helpLabel: '--localUi',\n  }),\n  standalone: Flags.boolean({\n    description:\n      'Always start the standalone web UI, even if an embedded dashboard (e.g. /_workflow) is already running',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_STANDALONE_UI',\n    helpGroup: 'Output',\n    helpLabel: '--standalone',\n  }),\n  sort: Flags.string({\n    description: 'sort order for list commands',\n    required: false,\n    options: ['asc', 'desc'],\n    default: 'desc',\n    helpGroup: 'Filtering',\n    helpLabel: '--sort',\n    helpValue: ['asc', 'desc'],\n    defaultHelp: 'desc',\n  }),\n  limit: Flags.integer({\n    description: 'number of items to return per page',\n    required: false,\n    default: 20,\n    helpGroup: 'Filtering',\n    helpLabel: '--limit',\n    helpValue: 'NUMBER',\n  }),\n  interactive: Flags.boolean({\n    description: 'Enable interactive pagination with keyboard controls',\n    required: false,\n    char: 'i',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-i, --interactive',\n  }),\n};\n\n/**\n * Flag for printing a shareable deep-link URL instead of opening the web UI.\n * Only relevant to commands that can open a dashboard (`inspect`, `web`), so it\n * is exported separately rather than bundled into `cliFlags`.\n */\nexport const urlFlag = {\n  url: Flags.boolean({\n    description:\n      'Print the deep-link URL to the run/dashboard and exit (no browser, no server)',\n    required: false,\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '--url',\n  }),\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flags.js","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from '@oclif/core';\n\nexport const cliFlags = {\n  verbose: Flags.boolean({\n    description: 'Verbose output',\n    required: false,\n    char: 'v',\n    helpGroup: 'Output',\n    helpLabel: '-v, --verbose',\n    env: 'DEBUG',\n    default: false,\n  }),\n  json: Flags.boolean({\n    description: 'output JSON instead of human-readable tables/streams',\n    required: false,\n    char: 'j',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-j, --json',\n  }),\n  cursor: Flags.string({\n    description: 'pagination cursor for list commands',\n    required: false,\n    default: '',\n    helpGroup: 'Filtering',\n    helpLabel: '--cursor',\n    helpValue: 'CURSOR',\n  }),\n  backend: Flags.string({\n    description: 'backend to inspect',\n    required: false,\n    char: 'b',\n    default: 'local',\n    env: 'WORKFLOW_TARGET_WORLD',\n    helpGroup: 'Target',\n    helpLabel: '-b, --backend',\n    helpValue: ['local', 'vercel', '<your-package-name>'],\n    defaultHelp: 'local',\n  }),\n  authToken: Flags.string({\n    description:\n      'Authentication token to be passed to the backend. If not provided and the backend is vercel, will fall back to the token generated by `vc login`.',\n    required: false,\n    char: 'a',\n    dependsOn: ['backend'],\n    default: '',\n    env: 'WORKFLOW_VERCEL_AUTH_TOKEN',\n    helpGroup: 'Target',\n    helpLabel: '-a, --authToken',\n    helpValue: 'TOKEN',\n  }),\n  project: Flags.string({\n    description:\n      'If backend is vercel, the vercel project to authenticate against',\n    required: false,\n    default: '',\n    dependsOn: ['backend'],\n    env: 'WORKFLOW_VERCEL_PROJECT',\n    helpGroup: 'Target',\n    helpLabel: '--project',\n    helpValue: 'PROJECT',\n  }),\n  team: Flags.string({\n    description:\n      'If backend is vercel, the vercel team to authenticate against',\n    required: false,\n    dependsOn: ['backend'],\n    default: '',\n    env: 'WORKFLOW_VERCEL_TEAM',\n    helpGroup: 'Target',\n    helpLabel: '--team',\n    helpValue: 'TEAM',\n  }),\n  env: Flags.string({\n    description: 'If backend is vercel, the vercel environment to use',\n    required: false,\n    options: ['production', 'preview'],\n    default: 'production',\n    char: 'e',\n    dependsOn: ['backend'],\n    env: 'WORKFLOW_VERCEL_ENV',\n    helpGroup: 'Target',\n    helpLabel: '-e, --env',\n    helpValue: ['production', 'preview'],\n    defaultHelp: 'production',\n  }),\n  web: Flags.boolean({\n    description: 'Open the web UI instead of displaying in terminal',\n    required: false,\n    char: 'w',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-w, --web',\n  }),\n  webPort: Flags.integer({\n    description: 'Port to use when launching the web UI (default: 3456)',\n    required: false,\n    default: 3456,\n    helpGroup: 'Output',\n    helpLabel: '--webPort',\n    helpValue: 'WEB_PORT',\n    env: 'WORKFLOW_WEB_PORT',\n  }),\n  noBrowser: Flags.boolean({\n    description: 'Disable automatic browser opening when launching web UI',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_DISABLE_BROWSER_OPEN',\n    helpGroup: 'Output',\n    helpLabel: '--noBrowser',\n  }),\n  localUi: Flags.boolean({\n    description:\n      'Use local web UI instead of Vercel dashboard (when backend is vercel)',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_LOCAL_UI',\n    helpGroup: 'Output',\n    helpLabel: '--localUi',\n  }),\n  standalone: Flags.boolean({\n    description:\n      'Always start the standalone web UI, even if an embedded dashboard (e.g. /_workflow) is already running',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_STANDALONE_UI',\n    helpGroup: 'Output',\n    helpLabel: '--standalone',\n  }),\n  sort: Flags.string({\n    description: 'sort order for list commands',\n    required: false,\n    options: ['asc', 'desc'],\n    // No parser-level default: every time-ordered listing already falls back\n    // to `desc` itself, and a default here made the flag indistinguishable\n    // from an explicit one, so `inspect attributes` could not tell that it\n    // should leave the backend's alphabetical key order alone.\n    helpGroup: 'Filtering',\n    helpLabel: '--sort',\n    helpValue: ['asc', 'desc'],\n    defaultHelp: 'desc',\n  }),\n  limit: Flags.integer({\n    description: 'number of items to return per page',\n    required: false,\n    default: 20,\n    helpGroup: 'Filtering',\n    helpLabel: '--limit',\n    helpValue: 'NUMBER',\n  }),\n  interactive: Flags.boolean({\n    description: 'Enable interactive pagination with keyboard controls',\n    required: false,\n    char: 'i',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-i, --interactive',\n  }),\n};\n\n/**\n * Flag for printing a shareable deep-link URL instead of opening the web UI.\n * Only relevant to commands that can open a dashboard (`inspect`, `web`), so it\n * is exported separately rather than bundled into `cliFlags`.\n */\nexport const urlFlag = {\n  url: Flags.boolean({\n    description:\n      'Print the deep-link URL to the run/dashboard and exit (no browser, no server)',\n    required: false,\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '--url',\n  }),\n};\n"]}

package/dist/lib/inspect/hydration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/hydration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAQL,KAAK,QAAQ,EAEd,MAAM,qCAAqC,CAAC;AAK7C;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC7B,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,GACpD,IAAI,CAAC;AAGT,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,KAAK,QAAQ,EACb,eAAe,EACf,KAAK,SAAS,EACd,UAAU,GACX,MAAM,qCAAqC,CAAC;AA8B7C;;;;;;GAMG;AACH,cAAM,gBAAgB;IACpB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAExE;AAMD;;;;;;GAMG;AACH,cAAM,cAAc;IAClB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAEpE;AAwED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CA6DzC;AAgID;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,EACX,WAAW,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,CAAC,CASZ"}
+{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/hydration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAQL,KAAK,QAAQ,EAEd,MAAM,qCAAqC,CAAC;AAK7C;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC7B,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,GACpD,IAAI,CAAC;AAGT,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,KAAK,QAAQ,EACb,eAAe,EACf,KAAK,SAAS,EACd,UAAU,GACX,MAAM,qCAAqC,CAAC;AA8B7C;;;;;;GAMG;AACH,cAAM,gBAAgB;IACpB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAExE;AAMD;;;;;;GAMG;AACH,cAAM,cAAc;IAClB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAEpE;AAyED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CA6DzC;AAgID;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,EACX,WAAW,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,CAAC,CASZ"}