rivet-design 0.26.2 → 0.27.1

package/dist/services/ProjectPackageManager.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveProjectPackageManager = exports.readProjectFile = exports.isInstallOutputPath = exports.forEveryPackageManager = exports.INSTALL_CONTENT_GLOBS = exports.INSTALL_ARTIFACTS = exports.INSTALL_CONFIG_FILES = exports.LOCKFILES = void 0;
+exports.resolveProjectPackageManager = exports.readProjectFile = exports.isInstallOutputPath = exports.forEveryPackageManager = exports.INSTALL_CONTENT_GLOBS = exports.INSTALL_ARTIFACTS = exports.INSTALL_CONFIG_FILES = exports.LOCKFILES = exports.PackageManagerError = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const glob_1 = require("glob");
@@ -11,6 +11,15 @@ const js_yaml_1 = require("js-yaml");
 const package_manager_detector_1 = require("package-manager-detector");
 const errnoCode_1 = require("../utils/errnoCode");
 const pathContainment_1 = require("../utils/pathContainment");
+class PackageManagerError extends Error {
+    reasonCode;
+    constructor(reasonCode, message) {
+        super(message);
+        this.reasonCode = reasonCode;
+        this.name = 'PackageManagerError';
+    }
+}
+exports.PackageManagerError = PackageManagerError;
 exports.LOCKFILES = {
     npm: ['package-lock.json', 'npm-shrinkwrap.json'],
     yarn: ['yarn.lock'],
@@ -79,13 +88,26 @@ const readProjectFile = async (file) => {
 exports.readProjectFile = readProjectFile;
 const readManifest = async (root) => {
     const source = await (0, exports.readProjectFile)(path_1.default.join(root, 'package.json'));
-    return source === null ? null : JSON.parse(source);
+    if (source === null)
+        return null;
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        throw new PackageManagerError('invalid_manifest', 'package.json is not valid JSON');
+    }
+};
+const readPnpmWorkspace = (source) => {
+    try {
+        return (0, js_yaml_1.load)(source, { schema: js_yaml_1.JSON_SCHEMA });
+    }
+    catch {
+        throw new PackageManagerError('invalid_workspace', 'pnpm-workspace.yaml is not valid YAML');
+    }
 };
 const packagePathsFor = async (root, manifest) => {
     const pnpmSource = await (0, exports.readProjectFile)(path_1.default.join(root, 'pnpm-workspace.yaml'));
-    const pnpmConfig = pnpmSource === null
-        ? null
-        : (0, js_yaml_1.load)(pnpmSource, { schema: js_yaml_1.JSON_SCHEMA });
+    const pnpmConfig = pnpmSource === null ? null : readPnpmWorkspace(pnpmSource);
     const patterns = pnpmConfig?.packages ??
         (Array.isArray(manifest.workspaces)
             ? manifest.workspaces
@@ -93,7 +115,7 @@ const packagePathsFor = async (root, manifest) => {
         [];
     if (!Array.isArray(patterns) ||
         patterns.some((pattern) => typeof pattern !== 'string')) {
-        throw new Error('Workspace packages must be an array of directory patterns');
+        throw new PackageManagerError('invalid_workspace', 'Workspace packages must be an array of directory patterns');
     }
     const included = patterns.filter((pattern) => !pattern.startsWith('!'));
     const excluded = patterns
@@ -107,7 +129,7 @@ const packagePathsFor = async (root, manifest) => {
     });
     const members = await Promise.all(files.map((file) => promises_1.default.realpath(path_1.default.dirname(file))));
     if (members.some((member) => !(0, pathContainment_1.isPathWithinRoot)(root, member))) {
-        throw new Error('A workspace package resolves outside the preview workspace');
+        throw new PackageManagerError('path_outside_workspace', 'A workspace package resolves outside the preview workspace');
     }
     return [...new Set([root, ...members.sort()])];
 };
@@ -115,7 +137,7 @@ const resolveProjectPackageManager = async (options) => {
     const cwd = await promises_1.default.realpath(options.cwd);
     const boundary = await promises_1.default.realpath(options.workspaceRoot);
     if (!(0, pathContainment_1.isPathWithinRoot)(boundary, cwd)) {
-        throw new Error('Dependency preparation directory is outside the preview workspace');
+        throw new PackageManagerError('path_outside_workspace', 'Dependency preparation directory is outside the preview workspace');
     }
     let rootPath = cwd;
     let manifest = await readManifest(cwd);
@@ -139,7 +161,7 @@ const resolveProjectPackageManager = async (options) => {
     const declared = manifest.packageManager;
     const declaration = declared ? parsePackageManagerDeclaration(declared) : null;
     if (declared && !declaration) {
-        throw new Error(`Unsupported packageManager declaration: ${declared}. Preview preparation supports pinned npm, Yarn, and pnpm versions.`);
+        throw new PackageManagerError('invalid_package_manager_field', `Unsupported packageManager declaration: ${declared}. Preview preparation supports pinned npm, Yarn, and pnpm versions.`);
     }
     const managersWithLockfiles = [];
     for (const name of Object.keys(exports.LOCKFILES)) {
@@ -164,7 +186,7 @@ const resolveProjectPackageManager = async (options) => {
         !manifest.devEngines?.packageManager &&
         managersWithLockfiles.length > 1 &&
         !selectedManager) {
-        throw new Error('Multiple package manager lockfiles found. Set package.json packageManager to select the project tool.');
+        throw new PackageManagerError('multiple_lockfiles', 'Multiple package manager lockfiles found. Set package.json packageManager to select the project tool.');
     }
     const detected = selectedManager
         ? null
@@ -175,7 +197,7 @@ const resolveProjectPackageManager = async (options) => {
         });
     const name = selectedManager ?? detected?.name ?? 'npm';
     if (name !== 'npm' && name !== 'yarn' && name !== 'pnpm') {
-        throw new Error(`Preview dependency preparation does not support ${name}`);
+        throw new PackageManagerError('unsupported_package_manager', `Preview dependency preparation does not support ${name}`);
     }
     let agent = selectedManager ?? detected?.agent ?? name;
     if (name === 'yarn' &&

package/dist/services/ProjectRuntimeService.d.ts

@@ -1,7 +1,15 @@
 import type { ProjectRegistry } from './ProjectRegistry';
+import { type ServerUnavailableReason } from '../cli/telemetry';
 interface ProjectRuntime {
     editorUrl: string;
 }
+export declare class ProjectRuntimeUnavailable extends Error {
+    readonly serverUnavailableReason?: ServerUnavailableReason;
+    constructor({ message, serverUnavailableReason, }: {
+        message: string;
+        serverUnavailableReason?: ServerUnavailableReason;
+    });
+}
 export declare class ProjectRuntimeService {
     private readonly registry;
     private readonly activations;

package/dist/services/ProjectRuntimeService.js

@@ -36,14 +36,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectRuntimeService = void 0;
+exports.ProjectRuntimeService = exports.ProjectRuntimeUnavailable = void 0;
 const fs_1 = __importDefault(require("fs"));
 const zod_1 = require("zod");
 const installationChannel_1 = require("../install/installationChannel");
 const libraryErrors_1 = require("./libraryErrors");
 const serverHandshake_1 = require("../cli/serverHandshake");
 const shared_1 = require("../cli/commands/shared");
+const telemetry_1 = require("../cli/telemetry");
 const HEALTH_TIMEOUT_MS = 2_000;
+class ProjectRuntimeUnavailable extends Error {
+    serverUnavailableReason;
+    constructor({ message, serverUnavailableReason, }) {
+        super(message);
+        this.name = 'ProjectRuntimeUnavailable';
+        this.serverUnavailableReason = serverUnavailableReason;
+    }
+}
+exports.ProjectRuntimeUnavailable = ProjectRuntimeUnavailable;
 class ProjectRuntimeService {
     registry;
     activations = new Map();
@@ -118,7 +128,10 @@ class ProjectRuntimeService {
             writeEnvelope: () => { },
         });
         if (!result.envelope.ok)
-            throw new Error(result.envelope.error.message);
+            throw new ProjectRuntimeUnavailable({
+                message: result.envelope.error.message,
+                serverUnavailableReason: (0, telemetry_1.serverUnavailableReasonForEnvelope)(result.envelope),
+            });
         const data = zod_1.z
             .object({ editorUrl: zod_1.z.string().url() })
             .parse(result.envelope.data);

package/dist/services/TelemetryService.d.ts

@@ -1,8 +1,9 @@
 import { type AccountIdentity } from './ConfigManager';
-import type { BrowserMetadata, DesignContextKind, ServerUnavailableReason, VariantContextMetadata } from '../cli/telemetry';
+import type { BrowserMetadata, DesignContextKind, ServerUnavailableReason, VariantContextMetadata, VerificationMetadata } from '../cli/telemetry';
 import type { GuidanceErrorCode, GuidanceSelection } from '../types/guidance';
 import type { MCPAuthMethod, MCPAuthState, MCPOnboardingCorrelation, MCPOAuthCallbackResult } from './MCPOnboardingTelemetry';
 import { type MCPVariantsTelemetryMetadata } from './MCPVariantsTelemetry';
+export type RequestRejectionReason = 'host_not_allowed' | 'origin_not_allowed' | 'editor_token_on_preview';
 export type TelemetryOptions = {
     enabled?: boolean;
     source?: 'cli' | 'mcp' | 'core';
@@ -17,6 +18,7 @@ export interface LibraryOperation {
     operation: 'project_open' | 'project_rename' | 'project_remove' | 'project_pin' | 'project_unpin' | 'folder_select' | 'workspace_open' | 'preview_open' | 'thumbnail_capture' | 'direction_update' | 'navigation';
     outcome: 'completed' | 'failed';
     durationMs: number;
+    error?: unknown;
 }
 export interface ProfileOperation {
     stage: 'action' | 'import' | 'preparation' | 'maintenance';
@@ -25,6 +27,7 @@ export interface ProfileOperation {
     durationMs: number;
     referenceCount?: number;
     status?: 'selected' | 'empty' | 'off' | 'unavailable' | 'timeout';
+    error?: unknown;
 }
 export interface GuidanceOperation {
     operation: 'add' | 'update' | 'remove' | 'resolve' | 'delivery' | 'verifier';
@@ -39,12 +42,14 @@ export declare class TelemetryService {
     trackGuidanceOperation(data: GuidanceOperation): void;
     trackProfileOperation(data: ProfileOperation): void;
     trackLibraryOperation(data: LibraryOperation): void;
+    trackRequestRejected(reason: RequestRejectionReason): void;
     private hashTelemetryValue;
     private posthog;
     private isEnabled;
     private readonly defaultSource;
     private readonly editor?;
     private readonly identifiedAccounts;
+    private readonly reportedRequestRejections;
     constructor(options?: boolean | TelemetryOptions);
     private get distinctId();
     identifyUser(identity?: AccountIdentity): void;
@@ -70,9 +75,10 @@ export declare class TelemetryService {
         callerAgent?: string;
         callerModel?: string;
         callerAgentSource?: 'handoff' | 'env';
+        callerRunId?: string;
         designContextKind?: DesignContextKind;
         source?: 'cli' | 'mcp';
-    } & VariantContextMetadata & BrowserMetadata): void;
+    } & VariantContextMetadata & BrowserMetadata & VerificationMetadata): void;
     trackAuthStarted(data: {
         surface: AuthTelemetrySurface;
         authAttemptId: string;
@@ -128,6 +134,7 @@ export declare class TelemetryService {
         stage: 'resolve_dev_server' | 'start_editor_server' | 'port_exhausted';
         failureReason: 'operation_failed' | 'port_unavailable';
         durationMs: number;
+        error?: unknown;
     }): void;
     trackServerStarted(data: {
         mode: 'attached' | 'static';
@@ -265,6 +272,7 @@ export declare class TelemetryService {
         exitCode?: number | null;
         signal?: string | null;
         missingDeps?: boolean;
+        error?: unknown;
     }): void;
     trackAgentVariantsPreviewStarted(data: {
         sessionId: string;
@@ -280,6 +288,7 @@ export declare class TelemetryService {
         hasPort: boolean;
         port?: number;
         durationMs?: number | null;
+        staticEntrySource?: string;
     }): void;
     trackAgentVariantsPreviewFailed(data: {
         sessionId: string;
@@ -293,6 +302,8 @@ export declare class TelemetryService {
         exitCode?: number | null;
         signal?: string | null;
         missingDeps?: boolean;
+        staticEntrySource?: string;
+        error?: unknown;
     }): void;
     trackAgentVariantsPreviewSwitchStarted(data: {
         sessionId: string;

package/dist/services/TelemetryService.js

@@ -10,10 +10,20 @@ const telemetry_1 = require("../config/telemetry");
 const telemetryPolicy_1 = require("../config/telemetryPolicy");
 const pluginMetrics_1 = require("../config/pluginMetrics");
 const telemetryContract_1 = require("../config/telemetryContract");
+const failureReason_1 = require("../utils/failureReason");
 const proxy_1 = require("../config/proxy");
 const MCPVariantsTelemetry_1 = require("./MCPVariantsTelemetry");
 const errorMessage_1 = require("../utils/errorMessage");
+const serverUnavailable_1 = require("../cli/serverUnavailable");
 const log = (0, logger_1.createLogger)('TelemetryService');
+const serverUnavailableReasonProperties = (error) => {
+    const reason = typeof error === 'object' && error !== null
+        ? Reflect.get(error, 'serverUnavailableReason')
+        : undefined;
+    return (0, serverUnavailable_1.isServerUnavailableReason)(reason)
+        ? { server_unavailable_reason: reason }
+        : {};
+};
 const KNOWN_MCP_EDITORS = new Set([
     'cursor',
     'codex',
@@ -53,13 +63,22 @@ class TelemetryService {
                 ? { reference_count: data.referenceCount }
                 : {}),
             ...(data.status ? { status: data.status } : {}),
+            ...(0, failureReason_1.failureReasonCodeProperties)(data.error),
         });
     }
     trackLibraryOperation(data) {
         this.track(`library_${data.operation}_${data.outcome}`, {
             duration_ms: data.durationMs,
+            ...(0, failureReason_1.failureReasonCodeProperties)(data.error),
+            ...serverUnavailableReasonProperties(data.error),
         });
     }
+    trackRequestRejected(reason) {
+        if (this.reportedRequestRejections.has(reason))
+            return;
+        this.reportedRequestRejections.add(reason);
+        this.track('server_request_rejected', { reason });
+    }
     hashTelemetryValue(value) {
         return (0, crypto_1.createHash)('sha256')
             .update(value)
@@ -71,6 +90,7 @@ class TelemetryService {
     defaultSource;
     editor;
     identifiedAccounts = new Set();
+    reportedRequestRejections = new Set();
     constructor(options = true) {
         const opts = typeof options === 'boolean' ? { enabled: options } : options;
         this.isEnabled = (opts.enabled ?? true) && (0, telemetryPolicy_1.getTelemetryMode)() !== 'off';
@@ -290,6 +310,10 @@ class TelemetryService {
             caller_agent: data.callerAgent,
             caller_model: data.callerModel,
             caller_agent_source: data.callerAgentSource,
+            caller_run_id: data.callerRunId,
+            verification_outcome: data.verificationOutcome,
+            verification_check_count: data.verificationCheckCount,
+            verification_duration_ms: data.verificationDurationMs,
             design_context_kind: data.designContextKind,
             design_context_kinds: data.contextKinds,
             context_image_count: data.contextImageCount,
@@ -372,6 +396,7 @@ class TelemetryService {
             stage: data.stage,
             failure_reason: data.failureReason,
             duration_ms: data.durationMs,
+            ...(0, failureReason_1.failureReasonCodeProperties)(data.error),
         });
     }
     trackServerStarted(data) {
@@ -652,6 +677,7 @@ class TelemetryService {
             exit_code: data.exitCode,
             term_signal: data.signal,
             missing_deps: data.missingDeps,
+            ...(0, failureReason_1.failureReasonProperties)(data.error),
             source: 'mcp',
         });
     }
@@ -673,6 +699,7 @@ class TelemetryService {
             has_port: data.hasPort,
             port: data.port,
             duration_ms: data.durationMs,
+            static_entry_source: data.staticEntrySource,
             source: 'mcp',
         });
     }
@@ -689,6 +716,8 @@ class TelemetryService {
             exit_code: data.exitCode,
             term_signal: data.signal,
             missing_deps: data.missingDeps,
+            static_entry_source: data.staticEntrySource,
+            ...(0, failureReason_1.failureReasonProperties)(data.error),
             source: 'mcp',
         });
     }

package/dist/services/VariantHistoryService.d.ts

@@ -3,6 +3,7 @@ import type { GuidanceDocument } from '../types/guidance';
 import { type ReferenceImage } from './referenceImages';
 import { type VariantReference } from '../types/variant-reference';
 import type { VariantHistoryStatus, VariantHistoryKind, PersistVariantPreview, VariantServeSpec, VariantDesignSource, VariantDeployment, VariantCanvasDeployment, VariantHistoryManifest } from '../types/variant-history';
+import type { DirectionRef } from '../types/direction-ref';
 export type { VariantHistoryStatus, VariantHistoryKind, VariantHistoryPreview, PersistVariantPreview, VariantTreePointer, VariantBasePointer, DevServerRecipe, VariantServeSpec, VariantHistoryArtifact, VariantDesignSource, VariantDeployment, VariantCanvasDeployment, VariantHistoryManifest, VariantHistorySessionFile, } from '../types/variant-history';
 import type { BundleMetadataStore } from '../storage/library/BundleMetadataStore';
 import { TreeStore } from './TreeStore';
@@ -13,6 +14,7 @@ export interface PersistVariantArgs {
     sessionId: string;
     variantId: string;
     requestId?: string;
+    directionRef?: DirectionRef;
     label: string;
     brief: string;
     references?: VariantReference[];
@@ -116,6 +118,12 @@ export declare class VariantHistoryService {
         label?: string;
         runLabel?: string;
     }): Promise<void>;
+    assignDirectionRef(args: {
+        projectPath: string;
+        sessionId: string;
+        variantId: string;
+        directionRef: DirectionRef;
+    }): Promise<void>;
     renameRun(args: {
         projectPath: string;
         sessionId: string;

package/dist/services/VariantHistoryService.js

@@ -203,6 +203,7 @@ class VariantHistoryService {
         let preservedDestinationPath;
         let preservedCreatedAt;
         let preservedRequestId;
+        let preservedDirectionRef;
         let preservedReferences;
         let preservedPreviewRoutes;
         let preservedTree;
@@ -219,6 +220,7 @@ class VariantHistoryService {
                 });
             preservedCreatedAt = prior.createdAt;
             preservedRequestId = prior.requestId;
+            preservedDirectionRef = prior.directionRef;
             preservedReferences = prior.references;
             preservedPreviewRoutes = prior.previewRoutes;
             preservedTree = prior.tree;
@@ -363,6 +365,9 @@ class VariantHistoryService {
             ...((args.requestId ?? preservedRequestId)
                 ? { requestId: args.requestId ?? preservedRequestId }
                 : {}),
+            ...((preservedDirectionRef ?? args.directionRef)
+                ? { directionRef: preservedDirectionRef ?? args.directionRef }
+                : {}),
             label: args.label,
             brief: args.brief,
             references: (0, variant_reference_1.mergeVariantReferences)(references),
@@ -527,6 +532,41 @@ class VariantHistoryService {
             manifest,
         });
     }
+    async assignDirectionRef(args) {
+        assertSafeId(args.sessionId, 'sessionId');
+        assertSafeId(args.variantId, 'variantId');
+        const bundle = this.bundleFor(args.projectPath);
+        if (bundle) {
+            bundle.updateVariant({
+                ...args,
+                update: (manifest) => {
+                    manifest.directionRef ??= args.directionRef;
+                },
+            });
+            return;
+        }
+        const manifestPath = path_1.default.join(this.variantDir(args.projectPath, args.sessionId, args.variantId), MANIFEST_FILENAME);
+        let manifest;
+        try {
+            const raw = await promises_1.default.readFile(manifestPath, 'utf8');
+            manifest = JSON.parse(raw);
+        }
+        catch (err) {
+            const code = (0, errnoCode_1.errnoCode)(err);
+            if (code !== 'ENOENT') {
+                log.warn(`assignDirectionRef: manifest read failed at ${manifestPath} (session ${args.sessionId} variant ${args.variantId})`, err);
+            }
+            return;
+        }
+        if (manifest.directionRef)
+            return;
+        manifest.directionRef = args.directionRef;
+        await writeManifestFile(manifestPath, manifest);
+        await this.projectManifestToIndex({
+            projectPath: args.projectPath,
+            manifest,
+        });
+    }
     async renameRun(args) {
         const entries = await this.listVariants({ projectPath: args.projectPath });
         const targets = entries.filter((entry) => {

package/dist/services/WorktreeManager.d.ts

@@ -23,6 +23,7 @@ export declare class WorktreeManager {
     createWorktrees(sessionId: string, count: number, instanceKeyPrefix?: string): Promise<string[]>;
     forkWorktreesFrom(sourceWorktreePath: string, sessionId: string, count: number, instanceKeyPrefix?: string): Promise<string[]>;
     getDiff(worktreePath: string): Promise<string>;
+    getChangedFiles(worktreePath: string): Promise<string[]>;
     getFreePort(): Promise<number>;
     findFreePortFrom(startPort: number, scanWindow?: number): Promise<number>;
     releasePort(port: number): void;

package/dist/services/WorktreeManager.js

@@ -22,6 +22,7 @@ const ProjectPackageManager_1 = require("./ProjectPackageManager");
 const OperatingSystemServices_1 = require("./OperatingSystemServices");
 const errnoCode_1 = require("../utils/errnoCode");
 const errorMessage_1 = require("../utils/errorMessage");
+const failureReason_1 = require("../utils/failureReason");
 const log = (0, logger_1.createLogger)('WorktreeManager');
 const DEV_SERVER_READY_INACTIVITY_MS = 30_000;
 const DEV_SERVER_READY_MAX_MS = 120_000;
@@ -275,6 +276,18 @@ class WorktreeManager {
         await git.raw(['add', '--intent-to-add', '.']).catch(() => { });
         return git.diff(['--binary', '--full-index', 'HEAD']);
     }
+    async getChangedFiles(worktreePath) {
+        const git = (0, simple_git_1.simpleGit)(worktreePath, GIT_OPTS);
+        await git.raw(['add', '--intent-to-add', '.']).catch(() => { });
+        const names = await git.raw([
+            'diff',
+            '--name-only',
+            '--diff-filter=d',
+            '-z',
+            'HEAD',
+        ]);
+        return names.split('\0').filter(Boolean);
+    }
     getFreePort() {
         return new Promise((resolve, reject) => {
             const server = net_1.default.createServer();
@@ -403,6 +416,10 @@ class WorktreeManager {
                 detail,
                 exitCode: term.exited?.code ?? null,
                 signal: term.exited?.signal ?? null,
+                reasonCode: term.spawnError
+                    ? (0, failureReason_1.failureReasonCode)(term.spawnError)
+                    : undefined,
+                summary: term.spawnError ? message : undefined,
             });
         };
         const hardDeadline = Date.now() + DEV_SERVER_READY_MAX_MS;

package/dist/services/createAgentVariantsOrchestrator.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAgentVariantsOrchestrator = exports.withVariantsSessionReplayLinking = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const index_core_1 = require("../index-core");
 const agent_variants_1 = require("../agent-variants");
 const devServerCommand_1 = require("../utils/devServerCommand");
@@ -69,11 +74,13 @@ const createAgentVariantsOrchestrator = (options) => {
                         targetPath: projectPath,
                         entryPath: options.staticEntry,
                     }).entryPath;
-                    log.info(`Resolved env for variants session ${sessionId}: static/${entryPath}`);
+                    const hasEntry = options.staticEntry !== undefined ||
+                        fs_1.default.existsSync(path_1.default.join(projectPath, entryPath));
+                    log.info(`Resolved env for variants session ${sessionId}: static/${hasEntry ? entryPath : '(no entry page)'}`);
                     return {
                         projectPath,
                         framework,
-                        entryPath,
+                        ...(hasEntry ? { entryPath } : {}),
                     };
                 }
                 const packageManager = await detection.detectPackageManager(projectPath);

package/dist/services/directionRefs.d.ts

@@ -0,0 +1,21 @@
+import type { DirectionAddress, DirectionCandidate, DirectionRef, DirectionResolution, DirectionSearchAddress } from '../types/direction-ref';
+import type { VariantHistoryManifest, VariantHistoryStatus } from '../types/variant-history';
+export declare const isDirectionActive: (status: VariantHistoryStatus) => boolean;
+type DirectionRefSource = {
+    manifest: Pick<VariantHistoryManifest, 'sessionId' | 'variantId' | 'label' | 'createdAt' | 'directionRef'>;
+};
+export declare const slugifyDirectionLabel: (label: string) => string;
+export declare const nextDirectionRef: (args: {
+    label: string;
+    taken: ReadonlySet<string>;
+}) => DirectionRef;
+export declare const withDirectionRefs: <Entry extends DirectionRefSource>(entries: readonly Entry[]) => Array<Entry & {
+    directionRef: DirectionRef;
+}>;
+export declare const parseDirectionAddress: (raw: string) => DirectionAddress | null;
+export declare const resolveDirectionAddress: (args: {
+    address: DirectionSearchAddress;
+    candidates: readonly DirectionCandidate[];
+}) => DirectionResolution;
+export {};
+//# sourceMappingURL=directionRefs.d.ts.map