@webpresso/agent-kit 0.28.0 → 0.29.1

package/dist/esm/blueprint/db/paths.d.ts

@@ -9,12 +9,10 @@
  *
  * We adopt the **two-lock** policy:
  *
- * 1. **Projection DB lock — `'worktree'` scope.**
- *    The SQLite file at `getSurfacePath('blueprints/blueprints.db', 'worktree', cwd)`
- *    is a per-worktree derived artifact. Concurrent writers in the **same**
- *    worktree (cold-start + mutation re-ingest, two ingest paths, etc.) must
- *    serialize against the projection. Cross-worktree writers target distinct
- *    DB files, so they do not need this lock.
+ * 1. **Projection DB lock — `'repo'` scope.**
+ *    The SQLite file at `getSurfacePath('blueprints/blueprints.db', 'repo', cwd)`
+ *    is a per-repo derived artifact shared by worktrees of the same repository.
+ *    Concurrent writers therefore serialize at repo scope.
  *
  * 2. **Markdown-mutation lock — `'repo'` scope.**
  *    The `blueprints/` markdown directory is git-tracked and shared across
@@ -31,36 +29,27 @@
  * raise `LockTimeoutError` on failure. Read-only paths may proceed without a
  * lock (they take a consistent SQLite snapshot regardless).
  *
- * ## Legacy fallback
+ * ## Non-git fallback
  *
  * Non-git temp repos (most tests, ad-hoc directories) cannot resolve a repo
- * key. For those we keep the historical `<cwd>/.agent/.blueprints.db` layout
- * so existing fixtures and bootstrap flows continue to work.
- *
- * For git repos that still carry a stray `.agent/.blueprints.db` from a
- * previous webpresso version, see `legacy-migration.ts`.
+ * key. Those callers use a deterministic user-state path keyed by the absolute
+ * cwd rather than writing legacy `.agent/.blueprints.db` artifacts into the
+ * repo itself.
  */
-export declare const LEGACY_AGENT_DIR = ".agent";
-export declare const LEGACY_DB_FILENAME = ".blueprints.db";
-export declare const LEGACY_LOCK_FILENAME = ".blueprints.lock";
 export declare class LockTimeoutError extends Error {
     readonly lockPath: string;
     readonly nextAction: 'reingest_project';
     constructor(lockPath: string, cause?: unknown);
 }
 /**
- * Resolve the worktree-scoped projection DB path.
+ * Resolve the repo-scoped projection DB path.
  *
- * In a git repo: `<state-root>/<repoKey>/worktree/<wtKey>/blueprints/blueprints.db`.
- * Outside a git repo: legacy `<cwd>/.agent/.blueprints.db` (no isolation).
+ * In a git repo: `<state-root>/<repoKey>/blueprints/blueprints.db`.
+ * Outside a git repo: deterministic user-state fallback keyed by absolute cwd.
  */
 export declare function resolveBlueprintProjectionDbPath(cwd: string): string;
 /**
- * Resolve the worktree-scoped lock file for the projection DB.
- *
- * Lives next to the DB so a single `mkdir -p` covers both. Cross-worktree
- * writers do not contend on this lock; see `resolveBlueprintMarkdownLockPath`
- * for the cross-worktree case.
+ * Resolve the repo-scoped lock file for the projection DB.
  */
 export declare function resolveBlueprintProjectionDbLockPath(cwd: string): string;
 /**
@@ -77,7 +66,7 @@ export interface AcquireLockOptions {
     readonly staleMs?: number;
 }
 /**
- * Acquire the worktree-scoped projection-DB write lock.
+ * Acquire the repo-scoped projection-DB write lock.
  *
  * Throws `LockTimeoutError` on failure — there is no silent "proceeds anyway"
  * escape. Read-only callers should not use this helper.

package/dist/esm/blueprint/db/paths.js

@@ -9,12 +9,10 @@
  *
  * We adopt the **two-lock** policy:
  *
- * 1. **Projection DB lock — `'worktree'` scope.**
- *    The SQLite file at `getSurfacePath('blueprints/blueprints.db', 'worktree', cwd)`
- *    is a per-worktree derived artifact. Concurrent writers in the **same**
- *    worktree (cold-start + mutation re-ingest, two ingest paths, etc.) must
- *    serialize against the projection. Cross-worktree writers target distinct
- *    DB files, so they do not need this lock.
+ * 1. **Projection DB lock — `'repo'` scope.**
+ *    The SQLite file at `getSurfacePath('blueprints/blueprints.db', 'repo', cwd)`
+ *    is a per-repo derived artifact shared by worktrees of the same repository.
+ *    Concurrent writers therefore serialize at repo scope.
  *
  * 2. **Markdown-mutation lock — `'repo'` scope.**
  *    The `blueprints/` markdown directory is git-tracked and shared across
@@ -31,22 +29,18 @@
  * raise `LockTimeoutError` on failure. Read-only paths may proceed without a
  * lock (they take a consistent SQLite snapshot regardless).
  *
- * ## Legacy fallback
+ * ## Non-git fallback
  *
  * Non-git temp repos (most tests, ad-hoc directories) cannot resolve a repo
- * key. For those we keep the historical `<cwd>/.agent/.blueprints.db` layout
- * so existing fixtures and bootstrap flows continue to work.
- *
- * For git repos that still carry a stray `.agent/.blueprints.db` from a
- * previous webpresso version, see `legacy-migration.ts`.
+ * key. Those callers use a deterministic user-state path keyed by the absolute
+ * cwd rather than writing legacy `.agent/.blueprints.db` artifacts into the
+ * repo itself.
  */
-import { mkdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { mkdirSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import lockfile from 'proper-lockfile';
-import { getSurfacePath, NotInGitRepoError } from '#paths/state-root.js';
-export const LEGACY_AGENT_DIR = '.agent';
-export const LEGACY_DB_FILENAME = '.blueprints.db';
-export const LEGACY_LOCK_FILENAME = '.blueprints.lock';
+import { getStateRoot, getSurfacePath, NotInGitRepoError } from '#paths/state-root.js';
 const SURFACE_DB = 'blueprints/blueprints.db';
 const SURFACE_DB_LOCK = 'blueprints/blueprints.db.lock';
 const SURFACE_MARKDOWN_LOCK = 'blueprints/markdown.lock';
@@ -64,39 +58,37 @@ export class LockTimeoutError extends Error {
         }
     }
 }
-function legacyAgentPath(cwd, filename) {
-    return path.join(cwd, LEGACY_AGENT_DIR, filename);
+function nonGitStatePath(cwd, filename) {
+    const absoluteCwd = realpathSync(cwd);
+    const cwdKey = createHash('sha256').update(absoluteCwd).digest('hex').slice(0, 16);
+    return path.join(getStateRoot(), 'non-git', cwdKey, filename);
 }
 /**
- * Resolve the worktree-scoped projection DB path.
+ * Resolve the repo-scoped projection DB path.
  *
- * In a git repo: `<state-root>/<repoKey>/worktree/<wtKey>/blueprints/blueprints.db`.
- * Outside a git repo: legacy `<cwd>/.agent/.blueprints.db` (no isolation).
+ * In a git repo: `<state-root>/<repoKey>/blueprints/blueprints.db`.
+ * Outside a git repo: deterministic user-state fallback keyed by absolute cwd.
  */
 export function resolveBlueprintProjectionDbPath(cwd) {
     try {
-        return getSurfacePath(SURFACE_DB, 'worktree', cwd);
+        return getSurfacePath(SURFACE_DB, 'repo', cwd);
     }
     catch (err) {
         if (err instanceof NotInGitRepoError)
-            return legacyAgentPath(cwd, LEGACY_DB_FILENAME);
+            return nonGitStatePath(cwd, '.blueprints.db');
         throw err;
     }
 }
 /**
- * Resolve the worktree-scoped lock file for the projection DB.
- *
- * Lives next to the DB so a single `mkdir -p` covers both. Cross-worktree
- * writers do not contend on this lock; see `resolveBlueprintMarkdownLockPath`
- * for the cross-worktree case.
+ * Resolve the repo-scoped lock file for the projection DB.
  */
 export function resolveBlueprintProjectionDbLockPath(cwd) {
     try {
-        return getSurfacePath(SURFACE_DB_LOCK, 'worktree', cwd);
+        return getSurfacePath(SURFACE_DB_LOCK, 'repo', cwd);
     }
     catch (err) {
         if (err instanceof NotInGitRepoError)
-            return legacyAgentPath(cwd, LEGACY_LOCK_FILENAME);
+            return nonGitStatePath(cwd, '.blueprints.lock');
         throw err;
     }
 }
@@ -112,7 +104,7 @@ export function resolveBlueprintMarkdownLockPath(cwd) {
     }
     catch (err) {
         if (err instanceof NotInGitRepoError) {
-            return legacyAgentPath(cwd, '.blueprints.markdown.lock');
+            return nonGitStatePath(cwd, '.blueprints.markdown.lock');
         }
         throw err;
     }
@@ -145,7 +137,7 @@ async function acquireWriteLockAt(lockPath, opts) {
     }
 }
 /**
- * Acquire the worktree-scoped projection-DB write lock.
+ * Acquire the repo-scoped projection-DB write lock.
  *
  * Throws `LockTimeoutError` on failure — there is no silent "proceeds anyway"
  * escape. Read-only callers should not use this helper.

package/dist/esm/blueprint/execution/progress-bridge.js

@@ -72,7 +72,7 @@ function applyProjectedIntent(taskStatuses, intent) {
         return;
     }
     const nextStatus = intent.type === 'task_start'
-        ? 'in_progress'
+        ? 'in-progress'
         : intent.type === 'task_verify'
             ? 'done'
             : intent.type === 'task_block'
@@ -222,11 +222,11 @@ function shouldFinalizeBlueprint(markdown, blueprint, snapshot) {
         blueprint.status === 'completed' ||
         blueprint.status === 'archived' ||
         blueprint.tasks.length === 0 ||
-        !blueprint.tasks.every((task) => task.status === 'done')) {
+        !blueprint.tasks.every((task) => task.status === 'done' || task.status === 'dropped')) {
         return false;
     }
     try {
-        assertAllTasksHaveCanonicalPassingEvidence(markdown, blueprint.tasks.map((task) => task.id));
+        assertAllTasksHaveCanonicalPassingEvidence(markdown, blueprint.tasks.filter((task) => task.status === 'done').map((task) => task.id));
         return true;
     }
     catch {
@@ -270,6 +270,7 @@ export function applyRuntimeProgressSnapshot(markdown, slug, input) {
         }
         if ((snapshot.status === 'blocked' || snapshot.status === 'failed') &&
             task.status !== 'done' &&
+            task.status !== 'dropped' &&
             task.status !== 'blocked') {
             nextMarkdown = applyIntent(nextMarkdown, slug, appliedTransitions, {
                 type: 'task_block',
@@ -278,7 +279,7 @@ export function applyRuntimeProgressSnapshot(markdown, slug, input) {
             });
             nextBlueprint = parseBlueprint(nextMarkdown, slug);
         }
-        if (snapshot.status === 'completed' && task.status !== 'done') {
+        if (snapshot.status === 'completed' && task.status !== 'done' && task.status !== 'dropped') {
             const verifyIntent = taskVerifyIntent(snapshot.taskId, snapshot.evidence);
             nextMarkdown = applyIntent(nextMarkdown, slug, appliedTransitions, verifyIntent ?? {
                 type: 'task_block',

package/dist/esm/blueprint/freshness.d.ts

@@ -39,6 +39,8 @@ export interface ProjectionMetadata {
     readonly head_at_ingest: string | null;
     /** Epoch milliseconds at which the projection was last written. */
     readonly ingested_at: number;
+    /** Absolute worktree path that produced this projection, when known. */
+    readonly worktree_path?: string;
 }
 export type FreshnessResult = {
     readonly ok: true;

package/dist/esm/blueprint/freshness.js

@@ -51,7 +51,8 @@ function isProjectionMetadata(value) {
     const obj = value;
     const headOk = obj.head_at_ingest === null || typeof obj.head_at_ingest === 'string';
     const tsOk = typeof obj.ingested_at === 'number' && Number.isFinite(obj.ingested_at);
-    return headOk && tsOk;
+    const worktreeOk = obj.worktree_path === undefined || typeof obj.worktree_path === 'string';
+    return headOk && tsOk && worktreeOk;
 }
 // ---------------------------------------------------------------------------
 // Public API
@@ -85,6 +86,7 @@ export function recordProjectionMetadata(input) {
     const metadata = {
         head_at_ingest: readCurrentHead(input.cwd),
         ingested_at: input.ingestedAt,
+        worktree_path: input.cwd,
     };
     writeFileSync(sidecarPath(input.dbPath), JSON.stringify(metadata, null, 2) + '\n', 'utf8');
     return metadata;

package/dist/esm/blueprint/lifecycle/audit.js

@@ -141,11 +141,11 @@ function validateBlueprintEngineSemantics(file, blueprint) {
     const issues = [];
     if (blueprint.status === 'completed') {
         for (const task of blueprint.tasks) {
-            if (task.status !== 'done') {
+            if (task.status !== 'done' && task.status !== 'dropped') {
                 issues.push({
                     file,
                     level: 'error',
-                    message: `Blueprint status is completed but task ${task.id} is "${task.status}" (expected "done").`,
+                    message: `Blueprint status is completed but task ${task.id} is "${task.status}" (expected "done" or "dropped").`,
                 });
             }
         }
@@ -186,7 +186,7 @@ function validateExecutionMetadataTruth(file, blueprint) {
         });
     }
     if (metadata.status === 'completed') {
-        const incompleteTasks = blueprint.tasks.filter((task) => task.status !== 'done');
+        const incompleteTasks = blueprint.tasks.filter((task) => task.status !== 'done' && task.status !== 'dropped');
         if (blueprint.status !== 'completed') {
             issues.push({
                 file,
@@ -228,16 +228,16 @@ function validateExecutionMetadataTruth(file, blueprint) {
     }
     if ((metadata.status === 'blocked' || metadata.status === 'failed') &&
         blueprint.tasks.length > 0 &&
-        blueprint.tasks.every((task) => task.status === 'done')) {
+        blueprint.tasks.every((task) => task.status === 'done' || task.status === 'dropped')) {
         issues.push({
             file,
             level: 'error',
-            message: `Blueprint execution is ${metadata.status} but every task is marked done; failed or blocked runtime work must not appear completed.`,
+            message: `Blueprint execution is ${metadata.status} but every task is marked done/dropped; failed or blocked runtime work must not appear completed.`,
         });
     }
     return issues;
 }
-const lifecycleTaskStatuses = new Set(['todo', 'in_progress', 'blocked', 'done']);
+const lifecycleTaskStatuses = new Set(['todo', 'in-progress', 'blocked', 'done', 'dropped']);
 function validateBlueprintPlacement(file, blueprint) {
     const issues = [];
     const normalized = normalizePath(file);

package/dist/esm/blueprint/lifecycle/engine.d.ts

@@ -1,7 +1,7 @@
 import type { Blueprint } from '#core/parser';
 import type { LifecycleBlueprintStatus } from '#core/schema';
 import type { Evidence } from '#evidence.js';
-export type LifecycleTaskStatus = 'todo' | 'in_progress' | 'blocked' | 'done';
+export type LifecycleTaskStatus = 'todo' | 'in-progress' | 'blocked' | 'done' | 'dropped';
 export type BlueprintLifecycleIntent = {
     type: 'start';
 } | {

package/dist/esm/blueprint/lifecycle/engine.js

@@ -27,7 +27,7 @@ function assertExecutableStatus(status) {
 }
 function formatProgress(blueprint) {
     const total = blueprint.tasks.length;
-    const done = blueprint.tasks.filter((task) => task.status === 'done').length;
+    const done = blueprint.tasks.filter((task) => task.status === 'done' || task.status === 'dropped').length;
     const blocked = blueprint.tasks.filter((task) => task.status === 'blocked').length;
     const percent = total === 0 ? 0 : Math.round((done / total) * 100);
     return `${percent}% (${done}/${total} tasks done, ${blocked} blocked, updated ${todayIsoDate()})`;
@@ -46,29 +46,33 @@ function assertTaskExists(blueprint, taskId) {
     return task;
 }
 function assertTaskDoneRequirements(markdown, blueprint) {
+    const tasksRequiringEvidence = [];
     for (const task of blueprint.tasks) {
-        if (task.status !== 'done') {
+        if (task.status !== 'done' && task.status !== 'dropped') {
             throw new Error(`Blueprint ${blueprint.name} cannot finalize: Task ${task.id} is ${task.status}`);
         }
         const { checked, total } = task.acceptanceCriteria;
-        if (total > 0 && checked !== total) {
+        if (task.status === 'done' && total > 0 && checked !== total) {
             throw new Error(`Blueprint ${blueprint.name} cannot finalize: Task ${task.id} has ${checked}/${total} acceptance criteria checked`);
         }
+        if (task.status === 'done') {
+            tasksRequiringEvidence.push(task.id);
+        }
     }
-    assertAllTasksHaveCanonicalPassingEvidence(markdown, blueprint.tasks.map((task) => task.id));
+    assertAllTasksHaveCanonicalPassingEvidence(markdown, tasksRequiringEvidence);
 }
 function applyTaskIntent(markdown, blueprint, intent) {
     const task = assertTaskExists(blueprint, intent.taskId);
     switch (intent.type) {
         case 'task_start': {
-            if (task.status === 'done') {
-                throw new Error(`Task ${task.id} is already done`);
+            if (task.status === 'done' || task.status === 'dropped') {
+                throw new Error(`Task ${task.id} is already ${task.status}`);
             }
-            return updateBlockedReason(updateTaskStatus(markdown, task.id, 'in_progress'), task.id, '');
+            return updateBlockedReason(updateTaskStatus(markdown, task.id, 'in-progress'), task.id, '');
         }
         case 'task_block': {
-            if (task.status === 'done') {
-                throw new Error(`Task ${task.id} is already done`);
+            if (task.status === 'done' || task.status === 'dropped') {
+                throw new Error(`Task ${task.id} is already ${task.status}`);
             }
             const reason = intent.reason.trim();
             if (!reason) {

package/dist/esm/blueprint/lifecycle/transition-matrix.d.ts

@@ -0,0 +1,5 @@
+import type { LifecycleBlueprintStatus } from '#core/schema.js';
+export declare function parseLifecycleBlueprintStatus(value: string): LifecycleBlueprintStatus | null;
+export declare function getLegalLifecycleTargets(from: LifecycleBlueprintStatus): readonly LifecycleBlueprintStatus[];
+export declare function isLegalLifecycleTransition(from: LifecycleBlueprintStatus, to: LifecycleBlueprintStatus): boolean;
+//# sourceMappingURL=transition-matrix.d.ts.map

package/dist/esm/blueprint/lifecycle/transition-matrix.js

@@ -0,0 +1,20 @@
+import { lifecycleBlueprintStatusSchema } from '#core/schema.js';
+const LEGAL_TRANSITIONS = {
+    draft: ['planned', 'archived'],
+    planned: ['in-progress', 'parked', 'archived'],
+    'in-progress': ['completed', 'parked', 'archived'],
+    parked: ['in-progress', 'planned', 'archived'],
+    completed: ['in-progress', 'archived'],
+    archived: [],
+};
+export function parseLifecycleBlueprintStatus(value) {
+    const parsed = lifecycleBlueprintStatusSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+export function getLegalLifecycleTargets(from) {
+    return LEGAL_TRANSITIONS[from];
+}
+export function isLegalLifecycleTransition(from, to) {
+    return getLegalLifecycleTargets(from).includes(to);
+}
+//# sourceMappingURL=transition-matrix.js.map

package/dist/esm/blueprint/markdown/helpers.d.ts

@@ -13,5 +13,5 @@ export declare function checkFirstCheckbox(content: string, taskId: string): str
 export declare function checkAllCheckboxes(content: string, taskId: string): string;
 export declare function completeTask(content: string, taskId: string): string;
 export declare function updateBlockedReason(content: string, taskId: string, reason: string): string;
-export declare function updateTaskStatus(content: string, taskId: string, status: 'todo' | 'in_progress' | 'blocked' | 'done'): string;
+export declare function updateTaskStatus(content: string, taskId: string, status: 'todo' | 'in-progress' | 'blocked' | 'done' | 'dropped'): string;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/esm/blueprint/projection-ready.js

@@ -2,11 +2,13 @@ import { mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { coldStartIfNeeded } from '#db/cold-start.js';
 import { openDb } from '#db/connection.js';
+import { pruneProjectionArtifacts } from '#db/gc.js';
 import { ingestAll } from '#db/ingester.js';
 import { resolveBlueprintProjectionDbPath, withProjectionDbWriteLock } from '#db/paths.js';
 import { recordProjectionMetadata } from './freshness.js';
 export async function reIngestProjection(cwd) {
     const target = resolveBlueprintProjectionDbPath(cwd);
+    pruneProjectionArtifacts({ preserveDbPath: target });
     await withProjectionDbWriteLock(cwd, async () => {
         mkdirSync(path.dirname(target), { recursive: true });
         const conn = openDb(target);

package/dist/esm/blueprint/service/BlueprintService.js

@@ -49,7 +49,7 @@ export class BlueprintService extends TrackedDocumentService {
     }
     parseSummary(content, slug) {
         const plan = parseBlueprint(content, slug);
-        const doneCount = plan.tasks.filter((t) => t.status === 'done').length;
+        const doneCount = plan.tasks.filter((t) => t.status === 'done' || t.status === 'dropped').length;
         return {
             name: plan.name,
             title: plan.title,

package/dist/esm/blueprint/service/blueprint-records.js

@@ -9,7 +9,7 @@ export async function toBlueprintRecord(filePath, slug, group) {
         const planStatus = isBlueprintStatus(plan.status) ? plan.status : 'draft';
         const lastUpdated = plan.lastUpdated ? new Date(plan.lastUpdated) : new Date();
         const freshness = calculateFreshness(lastUpdated, planStatus);
-        const tasksCompleted = plan.tasks.filter((task) => task.status === 'done').length;
+        const tasksCompleted = plan.tasks.filter((task) => task.status === 'done' || task.status === 'dropped').length;
         return {
             name: slug,
             title: extractTitle(plan.raw) ?? slug,

package/dist/esm/blueprint/tracked-document/parser.js

@@ -42,7 +42,7 @@ export function extractCheckboxStatus(section) {
             status = 'done';
         }
         else if (checked > 0) {
-            status = 'in_progress';
+            status = 'in-progress';
         }
     }
     return { total, checked, status };

package/dist/esm/blueprint/utils/archive.d.ts

@@ -18,8 +18,8 @@ export interface ValidationResult {
  * Validates that all tasks in a plan are complete.
  *
  * A task is considered complete when:
- * - status === 'done'
- * - All acceptance criteria checkboxes are checked
+ * - status === 'done' or 'dropped'
+ * - If status === 'done', all acceptance criteria checkboxes are checked
  *
  * @param plan - The plan to validate
  * @returns Validation result with details of incomplete tasks

package/dist/esm/blueprint/utils/archive.js

@@ -11,8 +11,8 @@ import { resolveBlueprintRoot } from './blueprint-root.js';
  * Validates that all tasks in a plan are complete.
  *
  * A task is considered complete when:
- * - status === 'done'
- * - All acceptance criteria checkboxes are checked
+ * - status === 'done' or 'dropped'
+ * - If status === 'done', all acceptance criteria checkboxes are checked
  *
  * @param plan - The plan to validate
  * @returns Validation result with details of incomplete tasks
@@ -59,6 +59,9 @@ function findIncompleteTasks(tasks) {
  * @returns True if task is complete
  */
 function isTaskComplete(task) {
+    if (task.status === 'dropped') {
+        return true;
+    }
     // Task must have status 'done'
     if (task.status !== 'done') {
         return false;

package/dist/esm/blueprint/utils/package-assets.d.ts

@@ -1,3 +1,15 @@
+interface FindPackageAssetOptions {
+    readonly moduleUrl?: string;
+    readonly cwd?: string;
+    readonly execPath?: string;
+    readonly argv0?: string;
+    readonly argv1?: string;
+}
+/**
+ * Walk up from this file's location looking for `relativeFromRoot`. Returns the
+ * first existing match, or `null` if none is found within the ancestor budget.
+ */
+export declare function findPackageAsset(relativeFromRoot: string, options?: FindPackageAssetOptions): string | null;
 /**
  * Walk up from this file's location until the given path (relative to the
  * package root) is found. Works whether running from src/ or dist/esm/.
@@ -14,4 +26,5 @@ export declare function resolvePackageAsset(relativeFromRoot: string): string;
  * exist, matching `resolvePackageAsset`'s last-resort behavior.
  */
 export declare function resolvePackageAssetPreferred(candidates: readonly string[]): string;
+export {};
 //# sourceMappingURL=package-assets.d.ts.map

package/dist/esm/blueprint/utils/package-assets.js

@@ -1,11 +1,22 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-/**
- * Walk up from this file's location looking for `relativeFromRoot`. Returns the
- * first existing match, or `null` if none is found within the ancestor budget.
- */
-function findPackageAsset(relativeFromRoot) {
-    let dir = path.dirname(new URL(import.meta.url).pathname);
+import { fileURLToPath } from 'node:url';
+function isBunVirtualPath(filePath) {
+    return filePath === '/$bunfs/root' || filePath.startsWith('/$bunfs/root/');
+}
+function modulePathFromUrl(moduleUrl) {
+    try {
+        return fileURLToPath(moduleUrl);
+    }
+    catch {
+        return null;
+    }
+}
+function isUsableStartPath(filePath) {
+    return typeof filePath === 'string' && filePath.length > 0 && !isBunVirtualPath(filePath);
+}
+function findFromStartPath(startPath, relativeFromRoot) {
+    let dir = path.dirname(startPath);
     for (let i = 0; i < 8; i++) {
         const candidate = path.join(dir, relativeFromRoot);
         if (existsSync(candidate))
@@ -17,6 +28,27 @@ function findPackageAsset(relativeFromRoot) {
     }
     return null;
 }
+/**
+ * Walk up from this file's location looking for `relativeFromRoot`. Returns the
+ * first existing match, or `null` if none is found within the ancestor budget.
+ */
+export function findPackageAsset(relativeFromRoot, options = {}) {
+    const starts = [
+        modulePathFromUrl(options.moduleUrl ?? import.meta.url),
+        options.argv1 ?? process.argv[1],
+        options.execPath ?? process.execPath,
+        options.argv0 ?? process.argv[0],
+        path.join(options.cwd ?? process.cwd(), 'package.json'),
+    ];
+    for (const start of starts) {
+        if (!isUsableStartPath(start))
+            continue;
+        const found = findFromStartPath(start, relativeFromRoot);
+        if (found)
+            return found;
+    }
+    return null;
+}
 /**
  * Walk up from this file's location until the given path (relative to the
  * package root) is found. Works whether running from src/ or dist/esm/.

package/dist/esm/build/normalize-tsconfig-json-exports.d.ts

@@ -0,0 +1,13 @@
+type ExportEntry = string | {
+    import?: string | {
+        default?: string;
+        types?: string;
+    };
+    default?: string;
+};
+type PackageManifest = {
+    exports?: Record<string, ExportEntry>;
+};
+export declare function normalizeTsconfigJsonExports(manifest: PackageManifest): PackageManifest;
+export {};
+//# sourceMappingURL=normalize-tsconfig-json-exports.d.ts.map

package/dist/esm/build/normalize-tsconfig-json-exports.js

@@ -0,0 +1,39 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const TSCONFIG_EXPORT_PREFIX = './tsconfig/';
+export function normalizeTsconfigJsonExports(manifest) {
+    if (!manifest.exports)
+        return manifest;
+    let changed = false;
+    const normalizedExports = { ...manifest.exports };
+    for (const [subpath, entry] of Object.entries(manifest.exports)) {
+        if (!subpath.startsWith(TSCONFIG_EXPORT_PREFIX) || !subpath.endsWith('.json'))
+            continue;
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        if (typeof entry.default === 'string')
+            continue;
+        const importDefault = typeof entry.import === 'string'
+            ? entry.import
+            : entry.import && typeof entry.import === 'object'
+                ? entry.import.default
+                : undefined;
+        if (typeof importDefault !== 'string')
+            continue;
+        normalizedExports[subpath] = {
+            ...entry,
+            default: importDefault,
+        };
+        changed = true;
+    }
+    return changed ? { ...manifest, exports: normalizedExports } : manifest;
+}
+if (import.meta.main) {
+    const packageJsonPath = join(process.cwd(), 'package.json');
+    const manifest = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const normalized = normalizeTsconfigJsonExports(manifest);
+    if (normalized !== manifest) {
+        writeFileSync(packageJsonPath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+    }
+}
+//# sourceMappingURL=normalize-tsconfig-json-exports.js.map