rivet-design 0.26.2 → 0.27.1

package/dist/services/directionRefs.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDirectionAddress = exports.parseDirectionAddress = exports.withDirectionRefs = exports.nextDirectionRef = exports.slugifyDirectionLabel = exports.isDirectionActive = void 0;
+const SLUG_MAX_LENGTH = 40;
+const EMPTY_LABEL_SLUG = 'direction';
+const LAST_KEYWORD = 'last';
+const FIRST_COLLISION_SUFFIX = 2;
+const MIN_VARIANT_ID_PREFIX_LENGTH = 4;
+const MAX_UNKNOWN_CANDIDATES = 10;
+const TOKEN_PATTERN = /^[A-Za-z0-9_-]+$/;
+const INACTIVE_STATUSES = new Set([
+    'removed',
+    'cancelled',
+]);
+const isDirectionActive = (status) => !INACTIVE_STATUSES.has(status);
+exports.isDirectionActive = isDirectionActive;
+const slugifyDirectionLabel = (label) => {
+    const slug = label
+        .normalize('NFKD')
+        .replace(/\p{M}/gu, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!slug)
+        return EMPTY_LABEL_SLUG;
+    if (slug.length <= SLUG_MAX_LENGTH)
+        return slug;
+    const boundary = slug.lastIndexOf('-', SLUG_MAX_LENGTH);
+    return slug.slice(0, boundary > 0 ? boundary : SLUG_MAX_LENGTH);
+};
+exports.slugifyDirectionLabel = slugifyDirectionLabel;
+const nextDirectionRef = (args) => {
+    const slug = (0, exports.slugifyDirectionLabel)(args.label);
+    const isTaken = (candidate) => candidate === LAST_KEYWORD || args.taken.has(candidate);
+    let candidate = slug;
+    for (let suffix = FIRST_COLLISION_SUFFIX; isTaken(candidate); suffix++)
+        candidate = `${slug}-${suffix}`;
+    return candidate;
+};
+exports.nextDirectionRef = nextDirectionRef;
+const directionKey = (manifest) => `${manifest.sessionId}:${manifest.variantId}`;
+const byCreation = (a, b) => a.manifest.createdAt.localeCompare(b.manifest.createdAt) ||
+    a.manifest.sessionId.localeCompare(b.manifest.sessionId) ||
+    a.manifest.variantId.localeCompare(b.manifest.variantId);
+const withDirectionRefs = (entries) => {
+    const taken = new Set(entries.flatMap(({ manifest }) => manifest.directionRef ? [manifest.directionRef] : []));
+    const legacyRefs = new Map();
+    const legacyRefOf = (manifest) => {
+        const key = directionKey(manifest);
+        const known = legacyRefs.get(key);
+        if (known)
+            return known;
+        const directionRef = (0, exports.nextDirectionRef)({ label: manifest.label, taken });
+        taken.add(directionRef);
+        legacyRefs.set(key, directionRef);
+        return directionRef;
+    };
+    for (const { manifest } of [...entries].sort(byCreation))
+        if (!manifest.directionRef)
+            legacyRefOf(manifest);
+    return entries.map((entry) => ({
+        ...entry,
+        directionRef: entry.manifest.directionRef ?? legacyRefOf(entry.manifest),
+    }));
+};
+exports.withDirectionRefs = withDirectionRefs;
+const parseDirectionIds = (raw) => {
+    const projectSeparator = raw.indexOf('/');
+    const projectId = projectSeparator === -1 ? undefined : raw.slice(0, projectSeparator);
+    const direction = projectSeparator === -1 ? raw : raw.slice(projectSeparator + 1);
+    if (projectSeparator !== -1 && (!projectId || direction.includes('/')))
+        return null;
+    const variantSeparator = direction.indexOf(':');
+    if (variantSeparator <= 0 || variantSeparator === direction.length - 1)
+        return null;
+    if (direction.indexOf(':', variantSeparator + 1) !== -1)
+        return null;
+    const sessionId = direction.slice(0, variantSeparator).trim();
+    const variantId = direction.slice(variantSeparator + 1).trim();
+    if (!sessionId || !variantId)
+        return null;
+    return {
+        kind: 'ids',
+        ...(projectId ? { projectId } : {}),
+        sessionId,
+        variantId,
+    };
+};
+const parseDirectionAddress = (raw) => {
+    const value = raw.trim();
+    if (value.toLowerCase() === LAST_KEYWORD)
+        return { kind: 'last' };
+    if (value.includes(':') || value.includes('/'))
+        return parseDirectionIds(value);
+    return TOKEN_PATTERN.test(value) ? { kind: 'token', token: value } : null;
+};
+exports.parseDirectionAddress = parseDirectionAddress;
+const newestFirst = (a, b) => b.createdAt.localeCompare(a.createdAt);
+const notFound = (args) => {
+    const candidates = args.newest.slice(0, MAX_UNKNOWN_CANDIDATES);
+    const knownRefs = candidates.map((candidate) => candidate.directionRef);
+    const knownRefsSentence = knownRefs.length > 0 ? ` Known refs: ${knownRefs.join(', ')}.` : '';
+    return {
+        isResolved: false,
+        code: 'WORK_ITEM_NOT_FOUND',
+        message: `No direction matches "${args.input}".${knownRefsSentence}`,
+        candidates,
+    };
+};
+const resolveToken = (args) => {
+    const needle = args.token.toLowerCase();
+    const exact = args.newest.filter((candidate) => candidate.directionRef.toLowerCase() === needle);
+    const prefixed = needle.length >= MIN_VARIANT_ID_PREFIX_LENGTH
+        ? args.newest.filter((candidate) => candidate.variantId.toLowerCase().startsWith(needle))
+        : [];
+    const matches = exact.length > 0 ? exact : prefixed;
+    if (matches.length === 1)
+        return { isResolved: true, direction: matches[0] };
+    if (matches.length === 0)
+        return notFound({ input: args.token, newest: args.newest });
+    return {
+        isResolved: false,
+        code: 'DIRECTION_AMBIGUOUS',
+        message: `"${args.token}" matches ${matches.length} directions: ${matches
+            .map((candidate) => candidate.directionRef)
+            .join(', ')}.`,
+        candidates: matches,
+    };
+};
+const resolveDirectionAddress = (args) => {
+    const newest = [...args.candidates].sort(newestFirst);
+    switch (args.address.kind) {
+        case 'last': {
+            const direction = newest.find((candidate) => (0, exports.isDirectionActive)(candidate.status));
+            return direction
+                ? { isResolved: true, direction }
+                : notFound({ input: LAST_KEYWORD, newest });
+        }
+        case 'token':
+            return resolveToken({ token: args.address.token, newest });
+        default: {
+            const unhandled = args.address;
+            return unhandled;
+        }
+    }
+};
+exports.resolveDirectionAddress = resolveDirectionAddress;
+//# sourceMappingURL=directionRefs.js.map

package/dist/services/profiles/DesignProfiles.js

@@ -417,18 +417,25 @@ class DesignProfiles {
                         instructions: `The source changed after this verifier was saved. ${VERIFICATION_TARGET_INSTRUCTIONS} Revise and execute a temporary recipe against the supplied source before offering to replace the saved verifier.`,
                     },
                 };
+            if (!verifier.package) {
+                return {
+                    ...resolved,
+                    verifier,
+                    verifierState: 'ready',
+                    nextAction: {
+                        action: 'execute_context_recipe',
+                        instructions: `This saved verifier is a Markdown recipe without an executable package, so \`rivet context verify\` cannot run it. Follow the recipe once with the host's own tools against this source and the user-selected target. ${VERIFICATION_TARGET_INSTRUCTIONS} Report pass, fail, or unable to verify with evidence. Retrieval has not executed any checks.`,
+                    },
+                };
+            }
             return {
                 ...resolved,
                 verifier,
                 verifierState: 'ready',
-                ...(verifier.package
-                    ? {
-                        packageDirectory: await (0, retainedTextFiles_1.materializeTextFiles)({
-                            files: verifier.package.files,
-                            directory: path_1.default.join(records.directory, 'guidance-verifiers'),
-                        }),
-                    }
-                    : {}),
+                packageDirectory: await (0, retainedTextFiles_1.materializeTextFiles)({
+                    files: verifier.package.files,
+                    directory: path_1.default.join(records.directory, 'guidance-verifiers'),
+                }),
                 nextAction: {
                     action: 'run_context_verifier',
                     instructions: `Execute the saved verifier against this source and the user-selected target. ${VERIFICATION_TARGET_INSTRUCTIONS} Report pass, fail, or unable to verify with evidence. Retrieval has not executed any checks.`,
@@ -1388,6 +1395,7 @@ class DesignProfiles {
                 operation: 'import',
                 outcome: 'failed',
                 durationMs: Date.now() - started,
+                error,
             });
             if (!context.abort.signal.aborted &&
                 context.records.jobs().find((item) => item.id === id)?.state ===

package/dist/services/projectDirections.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectLibrary } from './ProjectLibrary';
+import type { VariantHistoryEntry, VariantHistoryService } from './VariantHistoryService';
+import type { DirectionRef, DirectionResolution, DirectionSearchAddress } from '../types/direction-ref';
+export type ProjectDirectionSource = {
+    kind: 'library';
+    library: ProjectLibrary;
+    projectId: string;
+} | {
+    kind: 'history';
+    history: VariantHistoryService;
+    projectPath: string;
+};
+export type ProjectDirection = VariantHistoryEntry & {
+    projectPath: string;
+    directionRef: DirectionRef;
+};
+export declare const listProjectDirections: (source: ProjectDirectionSource) => Promise<ProjectDirection[]>;
+export declare const resolveProjectDirection: (args: {
+    source: ProjectDirectionSource;
+    address: DirectionSearchAddress;
+}) => Promise<DirectionResolution>;
+//# sourceMappingURL=projectDirections.d.ts.map

package/dist/services/projectDirections.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectDirection = exports.listProjectDirections = void 0;
+const directionRefs_1 = require("./directionRefs");
+const historyRoots_1 = require("./historyRoots");
+const listSourceEntries = async (source) => {
+    switch (source.kind) {
+        case 'library':
+            return source.library.listVariants(source.projectId, {
+                isRemovedIncluded: true,
+            });
+        case 'history':
+            return (await Promise.all([
+                source.projectPath,
+                ...(0, historyRoots_1.nestedFreshSessionWorkdirs)(source.projectPath),
+            ].map(async (projectPath) => (await source.history.listVariants({ projectPath })).map((entry) => ({ ...entry, projectPath }))))).flat();
+        default: {
+            const unhandled = source;
+            return unhandled;
+        }
+    }
+};
+const listProjectDirections = async (source) => (0, directionRefs_1.withDirectionRefs)(await listSourceEntries(source));
+exports.listProjectDirections = listProjectDirections;
+const directionCandidateOf = (direction) => ({
+    directionRef: direction.directionRef,
+    sessionId: direction.manifest.sessionId,
+    variantId: direction.manifest.variantId,
+    label: direction.manifest.label,
+    status: direction.manifest.status,
+    createdAt: direction.manifest.createdAt,
+});
+const resolveProjectDirection = async (args) => (0, directionRefs_1.resolveDirectionAddress)({
+    address: args.address,
+    candidates: (await (0, exports.listProjectDirections)(args.source)).map(directionCandidateOf),
+});
+exports.resolveProjectDirection = resolveProjectDirection;
+//# sourceMappingURL=projectDirections.js.map

package/dist/types/direction-ref.d.ts

@@ -0,0 +1,36 @@
+import type { VariantHistoryStatus } from './variant-history';
+export type DirectionRef = string & {
+    readonly __brand: 'DirectionRef';
+};
+export type DirectionAddress = {
+    kind: 'ids';
+    projectId?: string;
+    sessionId: string;
+    variantId: string;
+} | {
+    kind: 'token';
+    token: string;
+} | {
+    kind: 'last';
+};
+export type DirectionSearchAddress = Exclude<DirectionAddress, {
+    kind: 'ids';
+}>;
+export interface DirectionCandidate {
+    directionRef: DirectionRef;
+    sessionId: string;
+    variantId: string;
+    label: string;
+    status: VariantHistoryStatus;
+    createdAt: string;
+}
+export type DirectionResolution = {
+    isResolved: true;
+    direction: DirectionCandidate;
+} | {
+    isResolved: false;
+    code: 'WORK_ITEM_NOT_FOUND' | 'DIRECTION_AMBIGUOUS';
+    message: string;
+    candidates: DirectionCandidate[];
+};
+//# sourceMappingURL=direction-ref.d.ts.map

package/dist/types/direction-ref.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=direction-ref.js.map

package/dist/types/guidance-verifier.d.ts

@@ -23,8 +23,8 @@ export declare const GuidanceVerifierResultSchema: z.ZodObject<{
             mediaType: z.ZodString;
             label: z.ZodString;
             role: z.ZodEnum<{
-                reference: "reference";
                 observed: "observed";
+                reference: "reference";
             }>;
         }, z.core.$strict>>;
         comparison: z.ZodOptional<z.ZodObject<{
@@ -49,8 +49,8 @@ export declare const GuidanceVerifierResultSchema: z.ZodObject<{
             mediaType: z.ZodString;
             label: z.ZodString;
             role: z.ZodEnum<{
-                reference: "reference";
                 observed: "observed";
+                reference: "reference";
             }>;
         }, z.core.$strict>>;
         comparison: z.ZodOptional<z.ZodObject<{
@@ -75,8 +75,8 @@ export declare const GuidanceVerifierResultSchema: z.ZodObject<{
             mediaType: z.ZodString;
             label: z.ZodString;
             role: z.ZodEnum<{
-                reference: "reference";
                 observed: "observed";
+                reference: "reference";
             }>;
         }, z.core.$strict>>;
         comparison: z.ZodOptional<z.ZodObject<{
@@ -90,6 +90,8 @@ export declare const GuidanceVerifierResultSchema: z.ZodObject<{
     }, z.core.$strict>], "status">>;
 }, z.core.$strict>;
 export type GuidanceVerifierResult = z.infer<typeof GuidanceVerifierResultSchema>;
+export declare const GUIDANCE_VERIFIER_ERROR_REASONS: readonly ["package_required", "verifier_missing", "verifier_stale", "cancelled", "timeout", "output_limit", "process_failed", "invalid_result", "invalid_evidence", "cleanup_failed", "setup_failed"];
+export type GuidanceVerifierErrorReason = (typeof GUIDANCE_VERIFIER_ERROR_REASONS)[number];
 export type GuidanceVerifierRun = {
     schemaVersion: 1;
     verifier: {
@@ -105,7 +107,7 @@ export type GuidanceVerifierRun = {
     checks: GuidanceVerifierResult['checks'];
 } | {
     execution: 'error';
-    reason: 'package_required' | 'verifier_missing' | 'verifier_stale' | 'cancelled' | 'timeout' | 'output_limit' | 'process_failed' | 'invalid_result' | 'invalid_evidence' | 'cleanup_failed' | 'setup_failed';
+    reason: GuidanceVerifierErrorReason;
 });
 export interface GuidanceVerifierInput {
     source: GuidanceDocument;
@@ -156,7 +158,7 @@ export type GuidanceVerification = GuidanceVerificationSource & ({
     verifierState: 'ready';
     verifier: GuidanceVerifier;
     nextAction: {
-        action: 'run_context_verifier';
+        action: 'run_context_verifier' | 'execute_context_recipe';
         instructions: string;
     };
 });

package/dist/types/guidance-verifier.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSeparateVerifierUpdate = exports.GuidanceVerifierSummarySchema = exports.GuidanceVerifierSchema = exports.GuidanceVerifierResultSchema = exports.GuidanceVerifierPackageSchema = void 0;
+exports.isSeparateVerifierUpdate = exports.GuidanceVerifierSummarySchema = exports.GuidanceVerifierSchema = exports.GUIDANCE_VERIFIER_ERROR_REASONS = exports.GuidanceVerifierResultSchema = exports.GuidanceVerifierPackageSchema = void 0;
 const zod_1 = require("zod");
 const guidance_references_1 = require("./guidance-references");
 exports.GuidanceVerifierPackageSchema = zod_1.z
@@ -72,6 +72,19 @@ exports.GuidanceVerifierResultSchema = zod_1.z
     .strict()
     .refine((value) => new Set(value.checks.map((check) => check.id)).size ===
     value.checks.length, 'Check IDs must be unique');
+exports.GUIDANCE_VERIFIER_ERROR_REASONS = [
+    'package_required',
+    'verifier_missing',
+    'verifier_stale',
+    'cancelled',
+    'timeout',
+    'output_limit',
+    'process_failed',
+    'invalid_result',
+    'invalid_evidence',
+    'cleanup_failed',
+    'setup_failed',
+];
 exports.GuidanceVerifierSchema = zod_1.z
     .object({
     markdown: zod_1.z

package/dist/types/variant-history.d.ts

@@ -1,3 +1,4 @@
+import type { DirectionRef } from './direction-ref';
 import type { VariantReference } from './variant-reference';
 export type { VariantReference } from './variant-reference';
 export type VariantHistoryStatus = 'completed' | 'committed' | 'rejected' | 'cancelled' | 'removed';
@@ -91,6 +92,7 @@ export interface VariantHistoryManifest {
     variantId: string;
     sessionId: string;
     requestId?: string;
+    directionRef?: DirectionRef;
     label: string;
     brief: string;
     references?: VariantReference[];
@@ -120,7 +122,7 @@ export interface VariantHistoryManifest {
     deployments?: VariantDeployment[];
     runtime?: import('../agent-variants/contracts').WorkerRuntimeInfo;
 }
-export type VariantHistoryRow = Pick<VariantHistoryManifest, 'sessionId' | 'variantId' | 'requestId' | 'label' | 'brief' | 'references' | 'previewRoutes' | 'runLabel' | 'projectKind' | 'status' | 'createdAt' | 'statusChangedAt' | 'changedFilesCount' | 'preview' | 'artifact' | 'parentVariant' | 'serve' | 'runtime'> & {
+export type VariantHistoryRow = Pick<VariantHistoryManifest, 'sessionId' | 'variantId' | 'requestId' | 'directionRef' | 'label' | 'brief' | 'references' | 'previewRoutes' | 'runLabel' | 'projectKind' | 'status' | 'createdAt' | 'statusChangedAt' | 'changedFilesCount' | 'preview' | 'artifact' | 'parentVariant' | 'serve' | 'runtime'> & {
     kind: VariantHistoryKind;
     hasStaticPreview: boolean;
     hasTree: boolean;

package/dist/utils/devServerError.d.ts

@@ -1,3 +1,4 @@
+import type { FailureReasonCode } from './failureReason';
 export type DevServerFailureReason = 'spawn_error' | 'exited' | 'timeout' | 'missing_dev_script' | 'compile_error' | 'dependency_install_failed';
 export declare const isCompilationFailureOutput: (output: string) => boolean;
 export declare function isPortInUseOutput(output: string): boolean;
@@ -8,6 +9,8 @@ export declare class DevServerStartError extends Error {
     readonly detail: string;
     readonly exitCode: number | null;
     readonly signal: NodeJS.Signals | null;
+    readonly reasonCode?: FailureReasonCode;
+    readonly summary?: string;
     constructor(opts: {
         message: string;
         reason: DevServerFailureReason;
@@ -15,6 +18,8 @@ export declare class DevServerStartError extends Error {
         detail: string;
         exitCode?: number | null;
         signal?: NodeJS.Signals | null;
+        reasonCode?: FailureReasonCode;
+        summary?: string;
     });
 }
 export declare function isDevServerStartError(err: unknown): err is DevServerStartError;

package/dist/utils/devServerError.js

@@ -21,6 +21,8 @@ class DevServerStartError extends Error {
     detail;
     exitCode;
     signal;
+    reasonCode;
+    summary;
     constructor(opts) {
         super(opts.message);
         this.name = 'DevServerStartError';
@@ -29,6 +31,8 @@ class DevServerStartError extends Error {
         this.detail = opts.detail;
         this.exitCode = opts.exitCode ?? null;
         this.signal = opts.signal ?? null;
+        this.reasonCode = opts.reasonCode;
+        this.summary = opts.summary;
     }
 }
 exports.DevServerStartError = DevServerStartError;

package/dist/utils/failureReason.d.ts

@@ -0,0 +1,16 @@
+export declare const FAILURE_REASON_CODES: readonly ["multiple_lockfiles", "unsupported_package_manager", "invalid_package_manager_field", "invalid_manifest", "invalid_workspace", "path_outside_workspace", "dangling_symlink", "version_unreadable", "version_mismatch", "no_install_command", "install_failed", "installer_unstoppable", "inputs_changed", "ENOENT", "EACCES", "EPERM", "EEXIST", "ENOTDIR", "EISDIR", "ELOOP", "ENOSPC", "EMFILE", "EADDRINUSE", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "EBUSY", "ENOTSUP", "EINVAL", "ENOTEMPTY", "EROFS", "EAI_AGAIN", "timeout", "aborted", "unknown"];
+export type FailureReasonCode = (typeof FAILURE_REASON_CODES)[number];
+export interface FailureReason {
+    reasonCode: FailureReasonCode;
+    reasonDetail?: string;
+}
+export declare const failureReasonCode: (error: unknown) => FailureReasonCode;
+export declare const failureReason: (error: unknown) => FailureReason;
+export declare const failureReasonProperties: (error: unknown) => {
+    reason_code?: FailureReasonCode;
+    reason_detail?: string;
+};
+export declare const failureReasonCodeProperties: (error: unknown) => {
+    reason_code?: FailureReasonCode;
+};
+//# sourceMappingURL=failureReason.d.ts.map

package/dist/utils/failureReason.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failureReasonCodeProperties = exports.failureReasonProperties = exports.failureReason = exports.failureReasonCode = exports.FAILURE_REASON_CODES = void 0;
+const errnoCode_1 = require("./errnoCode");
+const errorMessage_1 = require("./errorMessage");
+const devServerError_1 = require("./devServerError");
+const hostedLogPrivacy_1 = require("./hostedLogPrivacy");
+const DEPENDENCY_REASON_CODES = [
+    'multiple_lockfiles',
+    'unsupported_package_manager',
+    'invalid_package_manager_field',
+    'invalid_manifest',
+    'invalid_workspace',
+    'path_outside_workspace',
+    'dangling_symlink',
+    'version_unreadable',
+    'version_mismatch',
+    'no_install_command',
+    'install_failed',
+    'installer_unstoppable',
+    'inputs_changed',
+];
+const ERRNO_REASON_CODES = [
+    'ENOENT',
+    'EACCES',
+    'EPERM',
+    'EEXIST',
+    'ENOTDIR',
+    'EISDIR',
+    'ELOOP',
+    'ENOSPC',
+    'EMFILE',
+    'EADDRINUSE',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'ETIMEDOUT',
+    'EBUSY',
+    'ENOTSUP',
+    'EINVAL',
+    'ENOTEMPTY',
+    'EROFS',
+    'EAI_AGAIN',
+];
+const GENERAL_REASON_CODES = ['timeout', 'aborted', 'unknown'];
+exports.FAILURE_REASON_CODES = [
+    ...DEPENDENCY_REASON_CODES,
+    ...ERRNO_REASON_CODES,
+    ...GENERAL_REASON_CODES,
+];
+const REASON_DETAIL_LIMIT = 400;
+const REDACTION_INPUT_LIMIT = 4_000;
+const ABSOLUTE_PATH = /(?<![\w.:/\\])\/(?:[\w.@+~-]+\/)+[\w.@+~-]*/g;
+const REASON_CODES = new Set(exports.FAILURE_REASON_CODES);
+const ERRNO_CODES = new Set(ERRNO_REASON_CODES);
+const ERROR_NAME_REASON_CODES = new Map([
+    ['AbortError', 'aborted'],
+    ['TimeoutError', 'timeout'],
+]);
+const propertyOf = (error, key) => typeof error === 'object' && error !== null
+    ? Reflect.get(error, key)
+    : undefined;
+const isFailureReasonCode = (value) => typeof value === 'string' && REASON_CODES.has(value);
+const isErrnoReasonCode = (value) => value !== undefined && ERRNO_CODES.has(value);
+const failureReasonCode = (error) => {
+    const declared = propertyOf(error, 'reasonCode');
+    if (isFailureReasonCode(declared))
+        return declared;
+    const code = (0, errnoCode_1.errnoCode)(error);
+    if (isErrnoReasonCode(code))
+        return code;
+    return (ERROR_NAME_REASON_CODES.get(String(propertyOf(error, 'name'))) ?? 'unknown');
+};
+exports.failureReasonCode = failureReasonCode;
+const failureText = (error) => {
+    if (!(0, devServerError_1.isDevServerStartError)(error))
+        return (0, errorMessage_1.errorMessage)(error);
+    return error.summary ?? '';
+};
+const failureDetail = (error) => (0, hostedLogPrivacy_1.redactSensitiveText)(failureText(error)
+    .slice(-REDACTION_INPUT_LIMIT)
+    .replace(/\s+/g, ' ')
+    .trim())
+    .replace(ABSOLUTE_PATH, '[redacted]')
+    .slice(-REASON_DETAIL_LIMIT)
+    .trim() || undefined;
+const failureReason = (error) => {
+    const reasonDetail = failureDetail(error);
+    return {
+        reasonCode: (0, exports.failureReasonCode)(error),
+        ...(reasonDetail ? { reasonDetail } : {}),
+    };
+};
+exports.failureReason = failureReason;
+const failureReasonProperties = (error) => {
+    if (error === undefined)
+        return {};
+    const { reasonCode, reasonDetail } = (0, exports.failureReason)(error);
+    return {
+        reason_code: reasonCode,
+        ...(reasonDetail ? { reason_detail: reasonDetail } : {}),
+    };
+};
+exports.failureReasonProperties = failureReasonProperties;
+const failureReasonCodeProperties = (error) => error === undefined ? {} : { reason_code: (0, exports.failureReasonCode)(error) };
+exports.failureReasonCodeProperties = failureReasonCodeProperties;
+//# sourceMappingURL=failureReason.js.map

package/dist/utils/hostedLogPrivacy.d.ts

@@ -1,2 +1,3 @@
+export declare const redactSensitiveText: (text: string) => string;
 export declare const hostedLogValues: (message: unknown, values: unknown[]) => unknown[];
 //# sourceMappingURL=hostedLogPrivacy.d.ts.map

package/dist/utils/hostedLogPrivacy.js

@@ -1,19 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hostedLogValues = void 0;
+exports.hostedLogValues = exports.redactSensitiveText = void 0;
 const DETAILS_OMITTED = '[details omitted]';
 const MAX_LABEL_LENGTH = 2_048;
 const HOSTED_LABEL_REDACTIONS = [
     /(?:https?|wss?):\/\/[^\s"'<>]+/gi,
     /\bBearer\s+[^\s,;"']+/gi,
     /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
-    /(?:[A-Z]:[\\/]|\/)(?:Users|home|private|tmp|var|opt|workspace)[\\/][^\s"'<>]+/gi,
-    /\b(?:sk-|sb_secret_|phx_|ghp_|gho_)[A-Za-z0-9_-]+/g,
+    /(?:[A-Z]:[\\/]|\/)(?:Users|home|private|tmp|var|opt|workspace|Volumes|root|mnt|srv)[\\/][^\s"'<>]+/gi,
+    /\b[A-Z]:[\\/][^\s"'<>]+/gi,
+    /\b[\w.-]{0,32}(?:token|secret|password|passwd|api[_-]?key)[\w.-]{0,32}["']?\s{0,3}[=:]\s{0,3}["']?[^\s,;"'<>]{1,256}/gi,
+    /\b(?:sk-|sk_live_|sk_test_|rk_live_|rk_test_|sb_secret_|phx_|ghp_|gho_|ghs_|ghu_|github_pat_|glpat-|xox[abprs]-)[A-Za-z0-9_-]+/g,
+    /\bnpm_[A-Za-z0-9]{36}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
     /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
 ];
+const redactSensitiveText = (text) => HOSTED_LABEL_REDACTIONS.reduce((current, pattern) => current.replace(pattern, '[redacted]'), text);
+exports.redactSensitiveText = redactSensitiveText;
 const hostedLogValues = (message, values) => {
     const label = typeof message === 'string' ? message : DETAILS_OMITTED;
-    const redacted = HOSTED_LABEL_REDACTIONS.reduce((current, pattern) => current.replace(pattern, '[redacted]'), label).slice(0, MAX_LABEL_LENGTH);
+    const redacted = (0, exports.redactSensitiveText)(label).slice(0, MAX_LABEL_LENGTH);
     return [
         redacted,
         ...values.map((value) => {

package/dist/utils/skills/claude-skill.d.ts

@@ -1,4 +1,4 @@
-export declare const CLAUDE_SKILL_VERSION = 61;
+export declare const CLAUDE_SKILL_VERSION = 62;
 export declare const CLAUDE_SKILL_DIR = "rivet";
 export declare const CLAUDE_SKILL_FILENAME = "SKILL.md";
 export declare const CLAUDE_SKILL_CONTENT: string;

package/dist/utils/skills/claude-skill.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLAUDE_SKILL_CONTENT = exports.CLAUDE_SKILL_FILENAME = exports.CLAUDE_SKILL_DIR = exports.CLAUDE_SKILL_VERSION = void 0;
 const cli_guidance_1 = require("./cli-guidance");
-exports.CLAUDE_SKILL_VERSION = 61;
+exports.CLAUDE_SKILL_VERSION = 62;
 const CLAUDE_SKILL_VERSION_MARKER = `[//]: # (rivet-skill-version: ${exports.CLAUDE_SKILL_VERSION})`;
 exports.CLAUDE_SKILL_DIR = 'rivet';
 exports.CLAUDE_SKILL_FILENAME = 'SKILL.md';

package/dist/utils/skills/cli-guidance.d.ts

@@ -1,4 +1,4 @@
-export declare const CLI_GUIDANCE_VERSION = 57;
+export declare const CLI_GUIDANCE_VERSION = 58;
 export declare const CLI_GUIDANCE_BODY: string;
 export declare const CLI_GUIDANCE_DESCRIPTION = "Rivet \u2014 open the visual editor or explore design directions for a web app.";
 //# sourceMappingURL=cli-guidance.d.ts.map