runwork 0.13.4 → 0.15.0

package/dist/deploy/__tests__/deploy-status.test.js

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+const fs = await import('fs');
+const { writeDeployStatus, readDeployStatus, deployLogPath } = await import('../deploy-status.js');
+describe('deploy/deploy-status', () => {
+    beforeEach(() => vi.clearAllMocks());
+    it('writes status JSON, creating .runwork when missing', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        writeDeployStatus('/repo', { state: 'in-progress', startedAt: '2026-06-05T00:00:00Z', pid: 123 });
+        expect(fs.mkdirSync).toHaveBeenCalled();
+        const written = vi.mocked(fs.writeFileSync).mock.calls[0][1];
+        expect(JSON.parse(written)).toEqual({ state: 'in-progress', startedAt: '2026-06-05T00:00:00Z', pid: 123 });
+    });
+    it('reads back a valid status', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ state: 'succeeded', startedAt: 't', finishedAt: 'u', url: 'https://app', sha: 'abc' }));
+        expect(readDeployStatus('/repo')).toMatchObject({ state: 'succeeded', url: 'https://app', sha: 'abc' });
+    });
+    it('returns null when the file is missing', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        expect(readDeployStatus('/repo')).toBeNull();
+    });
+    it('rejects a malformed state', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ state: 'weird', startedAt: 't' }));
+        expect(readDeployStatus('/repo')).toBeNull();
+    });
+    it('rejects invalid JSON', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue('{ not json');
+        expect(readDeployStatus('/repo')).toBeNull();
+    });
+    it('deployLogPath points at .runwork/deploy-stdout.log', () => {
+        expect(deployLogPath('/repo')).toContain('deploy-stdout.log');
+    });
+});

package/dist/deploy/__tests__/detach-args.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/deploy/__tests__/detach-args.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { buildDeployChildArgs, isInternalDeployChild, DEPLOY_DETACHED_CHILD_FLAG, } from '../detach.js';
+describe('deploy/detach arg handling', () => {
+    describe('buildDeployChildArgs()', () => {
+        it('drops --detach and appends exactly one child marker', () => {
+            const out = buildDeployChildArgs(['node', '/p/runwork', 'deploy', '--detach']);
+            expect(out).toEqual(['/p/runwork', 'deploy', DEPLOY_DETACHED_CHILD_FLAG]);
+        });
+        it('preserves other flags like --json', () => {
+            const out = buildDeployChildArgs(['node', '/p/runwork', 'deploy', '--detach', '--json']);
+            expect(out).toEqual(['/p/runwork', 'deploy', '--json', DEPLOY_DETACHED_CHILD_FLAG]);
+        });
+        it('does not duplicate the marker when already present', () => {
+            const out = buildDeployChildArgs(['node', '/p/runwork', 'deploy', DEPLOY_DETACHED_CHILD_FLAG]);
+            expect(out.filter(a => a === DEPLOY_DETACHED_CHILD_FLAG)).toHaveLength(1);
+        });
+        it('skips a Bun-on-Windows virtual-FS argv[1]', () => {
+            const out = buildDeployChildArgs(['runwork.exe', 'B:/~BUN/root/runwork-windows-x64.exe', 'deploy', '--detach']);
+            expect(out).toEqual(['deploy', DEPLOY_DETACHED_CHILD_FLAG]);
+        });
+    });
+    describe('isInternalDeployChild()', () => {
+        it('detects the marker', () => {
+            expect(isInternalDeployChild(['node', 'runwork', 'deploy', DEPLOY_DETACHED_CHILD_FLAG])).toBe(true);
+        });
+        it('is false without the marker', () => {
+            expect(isInternalDeployChild(['node', 'runwork', 'deploy'])).toBe(false);
+        });
+    });
+});

package/dist/deploy/deploy-state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Record of the last deploy triggered from this machine, persisted to
+ * `.runwork/last-deploy.json`. `sha` is the commit that was pushed and
+ * deployed (local HEAD at deploy time), so comparing it to the current HEAD
+ * cheaply answers "is what I have locally what's deployed?" without scraping
+ * the production bundle (friction log #8).
+ *
+ * NOTE: this reflects deploys from THIS machine. A teammate deploying
+ * elsewhere won't update this file -- an authoritative production-build SHA
+ * would require the deploy API to return it (tracked as a follow-up).
+ */
+export interface DeployState {
+    sha: string;
+    deployedAt: string;
+    url: string;
+}
+export interface DeploySummary {
+    deployedSha: string | null;
+    deployedShortSha: string | null;
+    deployedAt: string | null;
+    url: string | null;
+    localSha: string | null;
+    localShortSha: string | null;
+    /** true/false when both SHAs are known; null when undeterminable. */
+    inSync: boolean | null;
+}
+/** Current git HEAD commit SHA, or null if not a repo / no commits. */
+export declare function getHeadSha(cwd: string): string | null;
+/** Persist the deploy state for `cwd`. Creates `.runwork/` if needed. */
+export declare function writeDeployState(cwd: string, state: DeployState): void;
+/** Read the recorded deploy state for `cwd`, or null if none/unreadable. */
+export declare function readDeployState(cwd: string): DeployState | null;
+/** Compare the local HEAD against a recorded deploy. Pure (no IO). */
+export declare function summarizeDeploy(localSha: string | null, state: DeployState | null): DeploySummary;
+/** Convenience: read git HEAD + recorded deploy and summarize the comparison. */
+export declare function getDeploySummary(cwd: string): DeploySummary;

package/dist/deploy/deploy-state.js

@@ -0,0 +1,63 @@
+import { execFileSync } from '../utils/subprocess.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+function deployStatePath(cwd) {
+    return join(cwd, '.runwork', 'last-deploy.json');
+}
+/** Current git HEAD commit SHA, or null if not a repo / no commits. */
+export function getHeadSha(cwd) {
+    try {
+        return execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist the deploy state for `cwd`. Creates `.runwork/` if needed. */
+export function writeDeployState(cwd, state) {
+    const path = deployStatePath(cwd);
+    try {
+        if (!existsSync(dirname(path)))
+            mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(state, null, 2));
+    }
+    catch {
+        // Best-effort: a failure to record state must never fail a deploy.
+    }
+}
+/** Read the recorded deploy state for `cwd`, or null if none/unreadable. */
+export function readDeployState(cwd) {
+    const path = deployStatePath(cwd);
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (typeof parsed.sha === 'string' && typeof parsed.deployedAt === 'string') {
+            return { sha: parsed.sha, deployedAt: parsed.deployedAt, url: parsed.url ?? '' };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Compare the local HEAD against a recorded deploy. Pure (no IO). */
+export function summarizeDeploy(localSha, state) {
+    const deployedSha = state?.sha ?? null;
+    const inSync = deployedSha && localSha ? deployedSha === localSha : null;
+    return {
+        deployedSha,
+        deployedShortSha: deployedSha ? deployedSha.slice(0, 7) : null,
+        deployedAt: state?.deployedAt ?? null,
+        url: state?.url ?? null,
+        localSha,
+        localShortSha: localSha ? localSha.slice(0, 7) : null,
+        inSync,
+    };
+}
+/** Convenience: read git HEAD + recorded deploy and summarize the comparison. */
+export function getDeploySummary(cwd) {
+    return summarizeDeploy(getHeadSha(cwd), readDeployState(cwd));
+}

package/dist/deploy/deploy-status.d.ts

@@ -0,0 +1,21 @@
+/** Lifecycle state of a (possibly detached) deploy run. */
+export type DeployRunState = 'in-progress' | 'succeeded' | 'failed';
+/**
+ * Status of the most recent deploy started from this machine, persisted to
+ * `.runwork/deploy-status.json`. Lets `runwork deploy --status` report
+ * progress/outcome of a `--detach`ed deploy that outlived the shell that
+ * launched it (friction log #7).
+ */
+export interface DeployStatus {
+    state: DeployRunState;
+    startedAt: string;
+    finishedAt?: string;
+    url?: string;
+    sha?: string;
+    error?: string;
+    pid?: number;
+}
+/** Path of the detached deploy's stdout log (mirrors dev's log convention). */
+export declare function deployLogPath(cwd: string): string;
+export declare function writeDeployStatus(cwd: string, status: DeployStatus): void;
+export declare function readDeployStatus(cwd: string): DeployStatus | null;

package/dist/deploy/deploy-status.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+function statusPath(cwd) {
+    return join(cwd, '.runwork', 'deploy-status.json');
+}
+/** Path of the detached deploy's stdout log (mirrors dev's log convention). */
+export function deployLogPath(cwd) {
+    return join(cwd, '.runwork', 'deploy-stdout.log');
+}
+export function writeDeployStatus(cwd, status) {
+    const path = statusPath(cwd);
+    try {
+        if (!existsSync(dirname(path)))
+            mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(status, null, 2));
+    }
+    catch {
+        // Best-effort: status recording must never fail a deploy.
+    }
+}
+export function readDeployStatus(cwd) {
+    const path = statusPath(cwd);
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if ((parsed.state === 'in-progress' || parsed.state === 'succeeded' || parsed.state === 'failed') &&
+            typeof parsed.startedAt === 'string') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/deploy/detach.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `runwork deploy --detach` orchestration.
+ *
+ * Unlike `runwork dev --detach`, a deploy has no "ready" rendezvous to wait
+ * for -- it's fire-and-forget-then-poll. So the parent simply spawns a
+ * detached child (whose stdout/stderr go to `.runwork/deploy-*.log`), records
+ * an `in-progress` status, prints a poll hint, and exits. The child runs the
+ * real deploy and finalizes the status file to `succeeded`/`failed`.
+ *
+ * This exists so agents whose shell tool times out (~45s) can launch a deploy
+ * that survives, then poll `runwork deploy --status` (friction log #7).
+ */
+/** Hidden marker passed to the spawned child. Not shown in --help. */
+export declare const DEPLOY_DETACHED_CHILD_FLAG = "--internal-detached-deploy-child";
+/** Whether this invocation is the detached deploy child. */
+export declare function isInternalDeployChild(argv?: readonly string[]): boolean;
+/**
+ * Build the args for the spawned child so it re-runs the same deploy in the
+ * foreground (the child must NOT re-detach). Drops `--detach`, any stale
+ * marker, and a Bun-on-Windows virtual-FS path; re-adds exactly one marker.
+ * Pure for testability.
+ */
+export declare function buildDeployChildArgs(parentArgv: readonly string[]): string[];
+export interface SpawnedDeployHandle {
+    pid: number;
+}
+/**
+ * Spawn the detached deploy child with stdout/stderr routed to
+ * `.runwork/deploy-{stdout,stderr}.log`. Cross-platform: uses
+ * `process.execPath` so it never depends on PATH (Bun-standalone-safe).
+ */
+export declare function spawnDetachedDeploy(childArgs: string[], cwd: string): SpawnedDeployHandle;

package/dist/deploy/detach.js

@@ -0,0 +1,71 @@
+/**
+ * `runwork deploy --detach` orchestration.
+ *
+ * Unlike `runwork dev --detach`, a deploy has no "ready" rendezvous to wait
+ * for -- it's fire-and-forget-then-poll. So the parent simply spawns a
+ * detached child (whose stdout/stderr go to `.runwork/deploy-*.log`), records
+ * an `in-progress` status, prints a poll hint, and exits. The child runs the
+ * real deploy and finalizes the status file to `succeeded`/`failed`.
+ *
+ * This exists so agents whose shell tool times out (~45s) can launch a deploy
+ * that survives, then poll `runwork deploy --status` (friction log #7).
+ */
+import * as fs from 'fs';
+import * as child_process from 'child_process';
+import { join } from 'path';
+import { looksLikeBunStandaloneArtifact } from '../dev/detach.js';
+/** Hidden marker passed to the spawned child. Not shown in --help. */
+export const DEPLOY_DETACHED_CHILD_FLAG = '--internal-detached-deploy-child';
+/** Whether this invocation is the detached deploy child. */
+export function isInternalDeployChild(argv = process.argv) {
+    return argv.includes(DEPLOY_DETACHED_CHILD_FLAG);
+}
+/**
+ * Build the args for the spawned child so it re-runs the same deploy in the
+ * foreground (the child must NOT re-detach). Drops `--detach`, any stale
+ * marker, and a Bun-on-Windows virtual-FS path; re-adds exactly one marker.
+ * Pure for testability.
+ */
+export function buildDeployChildArgs(parentArgv) {
+    const rest = [];
+    for (let i = 1; i < parentArgv.length; i++) {
+        if (i === 1 && looksLikeBunStandaloneArtifact(parentArgv[i]))
+            continue;
+        rest.push(parentArgv[i]);
+    }
+    const filtered = rest.filter((a) => a !== DEPLOY_DETACHED_CHILD_FLAG && a !== '--detach');
+    return [...filtered, DEPLOY_DETACHED_CHILD_FLAG];
+}
+/**
+ * Spawn the detached deploy child with stdout/stderr routed to
+ * `.runwork/deploy-{stdout,stderr}.log`. Cross-platform: uses
+ * `process.execPath` so it never depends on PATH (Bun-standalone-safe).
+ */
+export function spawnDetachedDeploy(childArgs, cwd) {
+    const dir = join(cwd, '.runwork');
+    fs.mkdirSync(dir, { recursive: true });
+    const stdoutFd = fs.openSync(join(dir, 'deploy-stdout.log'), 'w');
+    const stderrFd = fs.openSync(join(dir, 'deploy-stderr.log'), 'w');
+    try {
+        const proc = child_process.spawn(process.execPath, childArgs, {
+            cwd,
+            env: process.env,
+            detached: true,
+            stdio: ['ignore', stdoutFd, stderrFd],
+            windowsHide: true,
+        });
+        if (proc.pid !== undefined)
+            proc.unref();
+        return { pid: proc.pid ?? 0 };
+    }
+    finally {
+        try {
+            fs.closeSync(stdoutFd);
+        }
+        catch { /* ignore */ }
+        try {
+            fs.closeSync(stderrFd);
+        }
+        catch { /* ignore */ }
+    }
+}

package/dist/dev/__tests__/session.test.js

@@ -368,6 +368,45 @@ describe('session lifecycle primitives', () => {
             });
             expect(file.noSync).toBe(true);
         });
+        it('omits startupSync when not provided, includes it when provided', () => {
+            const base = {
+                pid: 1, sessionId: 's', appId: 'a', previewUrl: '', cliVersion: '0.0.0',
+                mode: 'detached', deps: { bootTime: () => 0 },
+            };
+            expect(buildSessionFile(base).startupSync).toBeUndefined();
+            const withSync = buildSessionFile({
+                ...base,
+                startupSync: { syncStatus: 'sync-failed', syncFailed: true, staleCode: true },
+            });
+            expect(withSync.startupSync).toEqual({ syncStatus: 'sync-failed', syncFailed: true, staleCode: true });
+        });
+    });
+    describe('startupSync field back-compat', () => {
+        it('round-trips startupSync through write/read', () => {
+            const file = buildSessionFile({
+                pid: process.pid,
+                sessionId: 's',
+                appId: 'a',
+                previewUrl: 'https://x',
+                cliVersion: '0.0.0',
+                mode: 'detached',
+                startupSync: { syncStatus: 'sync-failed', syncFailed: true, staleCode: true },
+                deps: { bootTime: () => 0 },
+            });
+            writeSessionFile(appDir, file);
+            const read = readSessionFile(appDir);
+            expect(read?.startupSync).toEqual({ syncStatus: 'sync-failed', syncFailed: true, staleCode: true });
+        });
+        it('accepts an older session file with no startupSync field', () => {
+            const file = buildSessionFile({
+                pid: process.pid, sessionId: 's', appId: 'a', previewUrl: 'https://x',
+                cliVersion: '0.0.0', mode: 'detached', deps: { bootTime: () => 0 },
+            });
+            writeSessionFile(appDir, file);
+            const read = readSessionFile(appDir);
+            expect(read).not.toBeNull();
+            expect(read?.startupSync).toBeUndefined();
+        });
     });
     describe('noSync field back-compat', () => {
         it('round-trips noSync through write/read', () => {

package/dist/dev/__tests__/startup-sync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/__tests__/startup-sync.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { buildStartupSyncSummary } from '../startup-sync.js';
+describe('dev/startup-sync', () => {
+    it('reports no-sync mode as neither failed nor stale', () => {
+        expect(buildStartupSyncSummary({ noSync: true })).toEqual({
+            syncStatus: 'no-sync',
+            syncFailed: false,
+            staleCode: false,
+        });
+    });
+    it('flags a failed startup sync as stale (preview serving old code)', () => {
+        expect(buildStartupSyncSummary({ noSync: false, status: 'sync-failed' })).toEqual({
+            syncStatus: 'sync-failed',
+            syncFailed: true,
+            staleCode: true,
+        });
+    });
+    it.each(['synced', 'merged', 'skipped'])('treats a %s startup sync as live (not stale)', (status) => {
+        expect(buildStartupSyncSummary({ noSync: false, status })).toEqual({
+            syncStatus: status,
+            syncFailed: false,
+            staleCode: false,
+        });
+    });
+    it('defaults to skipped when no status is provided', () => {
+        expect(buildStartupSyncSummary({ noSync: false })).toEqual({
+            syncStatus: 'skipped',
+            syncFailed: false,
+            staleCode: false,
+        });
+    });
+});

package/dist/dev/session.d.ts

@@ -14,6 +14,7 @@
  * See `docs/plans/2026-05-06-runwork-dev-lifecycle-design.md` for the full
  * lifecycle contract.
  */
+import type { StartupSyncSummary } from './startup-sync.js';
 export declare const SESSION_FILE_SCHEMA_VERSION = 1;
 /**
  * Tolerance (ms) when comparing the stored bootTime to the currently
@@ -40,6 +41,13 @@ export interface SessionFile {
      * treated as `false`.
      */
     noSync?: boolean;
+    /**
+     * Startup sync outcome, so a detached parent can relay stale-code warnings
+     * to the caller instead of those signals only living in the child's log
+     * (friction log #2). Optional for back-compat with session files that
+     * predate the field.
+     */
+    startupSync?: StartupSyncSummary;
 }
 export type SessionStaleReason = 'malformed' | 'version-mismatch' | 'app-id-mismatch' | 'boot-time-mismatch' | 'pid-dead';
 export type SessionState = {
@@ -161,6 +169,7 @@ export declare function buildSessionFile(input: {
     cliVersion: string;
     mode: SessionMode;
     noSync?: boolean;
+    startupSync?: StartupSyncSummary;
     startedAt?: number;
     deps?: SessionDeps;
 }): SessionFile;

package/dist/dev/session.js

@@ -113,7 +113,9 @@ function validateSessionFile(raw) {
         typeof r.cliVersion === 'string' &&
         (r.mode === 'foreground' || r.mode === 'detached') &&
         // Optional for back-compat: v1 files lack the field. Accept absent or boolean.
-        (r.noSync === undefined || typeof r.noSync === 'boolean'));
+        (r.noSync === undefined || typeof r.noSync === 'boolean') &&
+        // Optional: absent on older files; otherwise an object (shape from buildStartupSyncSummary).
+        (r.startupSync === undefined || (typeof r.startupSync === 'object' && r.startupSync !== null)));
 }
 /**
  * Read and parse the session file. Returns `null` for a missing file or
@@ -251,5 +253,6 @@ export function buildSessionFile(input) {
         cliVersion: input.cliVersion,
         mode: input.mode,
         noSync: input.noSync ?? false,
+        ...(input.startupSync ? { startupSync: input.startupSync } : {}),
     };
 }

package/dist/dev/startup-sync.d.ts

@@ -0,0 +1,23 @@
+import type { SyncResult } from '../git/sync.js';
+/**
+ * Summary of the startup sync outcome, surfaced on the `session_started`
+ * event so agents can tell whether the preview reflects their latest edits.
+ * `staleCode` is the key signal: when true, the initial sync failed and the
+ * preview is serving the last good state, NOT the current working tree
+ * (friction log #2).
+ */
+export interface StartupSyncSummary {
+    syncStatus: SyncResult['status'] | 'no-sync';
+    syncFailed: boolean;
+    staleCode: boolean;
+}
+/**
+ * Derive the startup sync summary from how dev started:
+ * - no-sync mode never mutates the tree, so it's neither failed nor stale.
+ * - otherwise it mirrors the syncWithRemote() status; a `sync-failed` status
+ *   means the preview is stale.
+ */
+export declare function buildStartupSyncSummary(input: {
+    noSync: boolean;
+    status?: SyncResult['status'];
+}): StartupSyncSummary;

package/dist/dev/startup-sync.js

@@ -0,0 +1,14 @@
+/**
+ * Derive the startup sync summary from how dev started:
+ * - no-sync mode never mutates the tree, so it's neither failed nor stale.
+ * - otherwise it mirrors the syncWithRemote() status; a `sync-failed` status
+ *   means the preview is stale.
+ */
+export function buildStartupSyncSummary(input) {
+    if (input.noSync) {
+        return { syncStatus: 'no-sync', syncFailed: false, staleCode: false };
+    }
+    const status = input.status ?? 'skipped';
+    const failed = status === 'sync-failed';
+    return { syncStatus: status, syncFailed: failed, staleCode: failed };
+}

package/dist/generated/bundled-types.js

@@ -37,7 +37,7 @@ export const BUNDLED_TYPES = {
     "core-types.d.ts": "/**\n * This file defines default types provided by the platform.\n * DO NOT EDIT THIS FILE. You can define your own types in `shared/types.ts` file.\n */\nexport interface ApiResponse<T = unknown> {\n    success: boolean;\n    data?: T;\n    error?: string;\n}\n/**\n * Response from a Nango action or sync trigger\n */\nexport interface NangoActionResponse<T = unknown> {\n    success: boolean;\n    data?: T;\n    error?: string;\n    /** True if error is due to missing integration connection (user hasn't connected yet) */\n    isConnectionError?: boolean;\n    /** True if error is due to insufficient permissions/scopes (401/403 from external API) */\n    isPermissionError?: boolean;\n    /** HTTP status code from the external API (if available) */\n    statusCode?: number;\n}\n/**\n * Nango proxy request options - used for direct API calls through Nango\n */\nexport interface NangoProxyOptions {\n    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n    endpoint: string;\n    providerConfigKey: string;\n    data?: Record<string, unknown>;\n    headers?: Record<string, string>;\n    params?: Record<string, string>;\n    retries?: number;\n}\n/**\n * Metadata for a stored file\n */\nexport interface FileMetadata {\n    id: string;\n    key: string;\n    name: string;\n    size: number;\n    contentType: string;\n    uploadedAt: number;\n    uploadedBy?: string;\n    customMetadata?: Record<string, string>;\n}\n/**\n * Options for uploading a file\n */\nexport interface UploadOptions {\n    key?: string;\n    name?: string;\n    contentType?: string;\n    uploadedBy?: string;\n    customMetadata?: Record<string, string>;\n}\n/**\n * Options for downloading a file\n */\nexport interface DownloadOptions {\n    range?: {\n        offset?: number;\n        length?: number;\n    };\n}\n/**\n * Options for listing files\n */\nexport interface ListFilesOptions {\n    prefix?: string;\n    limit?: number;\n    cursor?: string;\n    delimiter?: string;\n}\n/**\n * Result of listing files\n */\nexport interface ListFilesResult {\n    files: FileMetadata[];\n    cursor?: string;\n    truncated: boolean;\n}\n/**\n * Request for generating a presigned URL\n */\nexport interface PresignedUrlRequest {\n    appId: string;\n    key: string;\n    action: 'read' | 'write';\n    contentType?: string;\n    expiresIn?: number;\n}\n/**\n * Response containing a presigned URL\n */\nexport interface PresignedUrlResponse {\n    url: string;\n    expiresAt: number;\n}\n",
     "core-workflow-types.d.ts": "/**\n * Workflow Types - Shared types for native workflow engine\n * DO NOT MODIFY THIS FILE - You may break the project functionality\n */\nimport type { Env } from './core-utils';\nimport type { IntegrationClient } from './core-integrations';\nexport type NativeWorkflowStatus = 'pending' | 'running' | 'sleeping' | 'waiting' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'timedOut';\nexport type NativeStepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';\nexport type NativeStepType = 'do' | 'sleep' | 'sleepUntil' | 'waitEvent';\nexport interface NativeWorkflowError {\n    code: string;\n    message: string;\n    stack?: string;\n    retryable: boolean;\n}\nexport interface NativeStepAttempt {\n    attemptNumber: number;\n    startedAt: number;\n    completedAt?: number;\n    error?: NativeWorkflowError;\n}\nexport interface NativeStepExecution {\n    id: string;\n    name: string;\n    type: NativeStepType;\n    status: NativeStepStatus;\n    input?: unknown;\n    output?: unknown;\n    error?: NativeWorkflowError;\n    attempts: NativeStepAttempt[];\n    maxRetries: number;\n    startedAt?: number;\n    completedAt?: number;\n    timeoutMs?: number;\n    sleepUntil?: number;\n    eventType?: string;\n    eventTimeoutAt?: number;\n}\nexport interface NativeWorkflowInstance {\n    id: string;\n    workflowName: string;\n    status: NativeWorkflowStatus;\n    input: unknown;\n    output?: unknown;\n    error?: NativeWorkflowError;\n    createdAt: number;\n    startedAt?: number;\n    completedAt?: number;\n    steps: NativeStepExecution[];\n    currentStepId?: string;\n    config: NativeWorkflowConfig;\n    metadata?: Record<string, unknown>;\n}\nexport interface NativeWorkflowConfig {\n    maxRetries: number;\n    retryBackoffMs: number;\n    stepTimeoutMs: number;\n    workflowTimeoutMs: number;\n}\nexport declare const DEFAULT_WORKFLOW_CONFIG: NativeWorkflowConfig;\nexport interface NativeStepContext {\n    /** Unique instance ID for this workflow execution */\n    instanceId: string;\n    /** Input passed when workflow was started */\n    workflowInput: unknown;\n    /** Results from previous steps */\n    previousSteps: Record<string, {\n        output: unknown;\n        status: NativeStepStatus;\n    }>;\n}\nexport interface WorkflowIndexEntry {\n    instanceId: string;\n    workflowName: string;\n    status: NativeWorkflowStatus;\n    createdAt: number;\n    completedAt?: number;\n}\nexport interface ListWorkflowsOptions {\n    workflowName?: string;\n    status?: NativeWorkflowStatus;\n    limit?: number;\n    offset?: number;\n}\nexport interface ExecuteStepRequest {\n    instanceId: string;\n    stepId: string;\n    stepName: string;\n    workflowName: string;\n    workflowInput: unknown;\n    previousSteps: Record<string, {\n        output: unknown;\n        status: NativeStepStatus;\n    }>;\n}\nexport interface ExecuteStepResponse {\n    success: boolean;\n    output?: unknown;\n    error?: NativeWorkflowError;\n}\nexport interface PendingEvent {\n    instanceId: string;\n    stepId: string;\n    eventType: string;\n    waitingSince: number;\n    timeoutAt?: number;\n}\nexport interface ReceivedEvent {\n    type: string;\n    payload: unknown;\n    timestamp: number;\n}\n/**\n * Result returned by a workflow execution\n */\nexport interface WorkflowResult {\n    success: boolean;\n    [key: string]: unknown;\n}\n/**\n * Possible states of a workflow instance\n */\nexport type WorkflowStatus = 'queued' | 'running' | 'paused' | 'errored' | 'terminated' | 'complete' | 'waiting';\n/**\n * Information about a workflow instance\n */\nexport interface WorkflowInstanceInfo {\n    id: string;\n    workflowName: string;\n    status: WorkflowStatus;\n    params?: Record<string, unknown>;\n    createdAt: number;\n    startedAt?: number;\n    completedAt?: number;\n    error?: string;\n    result?: WorkflowResult;\n}\n/**\n * Interface for WorkflowInstance DO stub methods\n * Used to type the DurableObjectStub without importing the class\n */\nexport interface WorkflowInstanceStub {\n    create(workflowName: string, params: Record<string, unknown>, instanceId: string, config?: Partial<NativeWorkflowConfig>, metadata?: Record<string, unknown>): Promise<void>;\n    getStatus(): Promise<NativeWorkflowInstance | null>;\n    signal(eventType: string, payload: unknown): Promise<void>;\n    pause(): Promise<void>;\n    resume(): Promise<void>;\n    cancel(): Promise<void>;\n}\n/**\n * Interface for WorkflowCoordinator DO stub methods\n * Used to type the DurableObjectStub without importing the class\n */\nexport interface WorkflowCoordinatorStub {\n    create(workflowName: string, params: Record<string, unknown>, config?: Partial<NativeWorkflowConfig>, metadata?: Record<string, unknown>): Promise<string>;\n    signal(instanceId: string, eventType: string, payload: unknown): Promise<void>;\n    getInstanceInfo(instanceId: string): Promise<WorkflowInstanceInfo | null>;\n    listInstances(options?: ListWorkflowsOptions): Promise<WorkflowInstanceInfo[]>;\n    updateIndex(instanceId: string, workflowName: string, status: NativeWorkflowStatus): Promise<void>;\n    pause(instanceId: string): Promise<void>;\n    resume(instanceId: string): Promise<void>;\n    cancel(instanceId: string): Promise<void>;\n}\n/**\n * Definition for a workflow handler\n */\nexport interface WorkflowDefinition<TParams = unknown, TResult = unknown> {\n    /** Unique name for this workflow (kebab-case, e.g., \"order-fulfillment\") */\n    name: string;\n    /** Human-readable description of what this workflow does */\n    description?: string;\n    /** The workflow handler function */\n    handler: (ctx: WorkflowContext<TParams>) => Promise<TResult>;\n    /** Whether the workflow is enabled (default: true) */\n    enabled?: boolean;\n}\n/**\n * Context passed to workflow handlers\n */\nexport interface WorkflowContext<TParams = unknown> {\n    /** Environment bindings */\n    env: Env;\n    /** Unique instance ID for this workflow execution */\n    instanceId: string;\n    /** Parameters passed when workflow was started */\n    params: TParams;\n    /** Step utilities for durable execution */\n    step: WorkflowStepUtilities;\n    /** Integration client for external service calls */\n    integrations: IntegrationClient;\n    /** Logger for structured workflow logging */\n    logger: WorkflowLogger;\n}\n/**\n * Step utilities for durable workflow execution\n */\nexport interface WorkflowStepUtilities {\n    /** Execute a step with automatic retry and persistence */\n    do<T>(name: string, fn: () => Promise<T>): Promise<T>;\n    do<T>(name: string, options: StepOptions, fn: () => Promise<T>): Promise<T>;\n    /** Sleep for a duration (e.g., '5 minutes', '1 hour', '24 hours') */\n    sleep(name: string, duration: string): Promise<void>;\n    /** Sleep until a specific timestamp */\n    sleepUntil(name: string, timestamp: Date): Promise<void>;\n    /** Wait for an external event */\n    waitForEvent<T = unknown>(name: string, options?: WaitEventOptions): Promise<T>;\n}\n/**\n * Options for step execution\n */\nexport interface StepOptions {\n    retries?: {\n        limit: number;\n        delay: string;\n        backoff?: 'constant' | 'linear' | 'exponential';\n    };\n    timeout?: string;\n}\n/**\n * Options for waitForEvent\n */\nexport interface WaitEventOptions {\n    type?: string;\n    timeout?: string;\n}\n/**\n * Logger interface for workflow execution\n */\nexport interface WorkflowLogger {\n    info(message: string, data?: Record<string, unknown>): void;\n    warn(message: string, data?: Record<string, unknown>): void;\n    error(message: string, data?: Record<string, unknown>): void;\n}\n/**\n * State of a registered workflow\n */\nexport interface WorkflowState {\n    name: string;\n    description?: string;\n    enabled: boolean;\n    activeInstances: number;\n    totalRuns: number;\n    lastRun: number | null;\n    lastError?: string;\n}\n/**\n * Response from workflow status API\n */\nexport interface WorkflowStatusResponse {\n    workflows: WorkflowState[];\n}\n",
     "workflows.d.ts": "import type { WorkflowDefinition } from './core-workflow-types';\n/**\n * APP_WORKFLOWS - runtime accessor for registered workflow definitions.\n * Used by internal dynamic imports in core-workflow-cloudflare and core-workflow-instance.\n * This is a getter-backed constant so it always reflects the current registry state.\n */\nexport declare const APP_WORKFLOWS: WorkflowDefinition[];\nexport { triggerWorkflow, sendWorkflowEvent, getWorkflowStatus, workflowRoutes, } from './core-workflows';\nexport type { WorkflowResult, WorkflowStatus, WorkflowInstanceInfo, WorkflowDefinition, WorkflowContext, WorkflowStepUtilities, StepOptions, WaitEventOptions, WorkflowLogger, WorkflowState, WorkflowStatusResponse, } from './core-workflows';\nexport type { NativeWorkflowStatus, NativeStepStatus, NativeStepType, NativeWorkflowError, NativeStepAttempt, NativeStepExecution, NativeWorkflowInstance, NativeWorkflowConfig, NativeStepContext, WorkflowIndexEntry, ListWorkflowsOptions, ExecuteStepRequest, ExecuteStepResponse, PendingEvent, ReceivedEvent, WorkflowInstanceStub, WorkflowCoordinatorStub, } from './core-workflow-types';\nexport { DEFAULT_WORKFLOW_CONFIG } from './core-workflow-types';\nexport { WORKFLOW_INFRA_MODE } from './core-workflow-config';\nexport { WorkflowInstanceDO } from './core-workflow-instance';\nexport { WorkflowCoordinator } from './core-workflow-coordinator';\nexport { WorkflowPausedError, isWorkflowControlSignal } from './core-workflow-instance';\n",
-    "core-endpoints.d.ts": "/**\n * Core Public Endpoints Framework\n * DO NOT MODIFY THIS FILE - You may break the project functionality\n *\n * This module provides the infrastructure for exposing public API endpoints\n * that external systems can consume with API key authentication or public access.\n */\nimport { type Env } from './core-utils';\nimport { z } from 'zod';\nimport type { Hono } from 'hono';\ntype ZodSchema = z.ZodType<any, any, any>;\n/**\n * Authentication type for public endpoints\n */\nexport type EndpointAuthType = 'apiKey' | 'public';\n/**\n * HTTP methods supported by endpoints\n */\nexport type EndpointMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n/**\n * Schema definition for endpoint validation\n */\nexport interface EndpointSchema<TQuery = unknown, TBody = unknown, TResponse = unknown> {\n    /** Query parameters schema */\n    query?: ZodSchema;\n    /** Request body schema (for POST/PUT/PATCH) */\n    body?: ZodSchema;\n    /** Response schema for documentation */\n    response?: ZodSchema;\n}\n/**\n * Context provided to endpoint handlers\n */\nexport interface EndpointContext<TQuery = Record<string, unknown>, TBody = unknown> {\n    /** Environment bindings */\n    env: Env;\n    /** Original request object */\n    request: Request;\n    /** Validated query parameters */\n    query: TQuery;\n    /** Validated request body (null for GET/DELETE) */\n    body: TBody | null;\n    /** Path parameters extracted from URL */\n    params: Record<string, string>;\n    /** Authentication information */\n    auth: EndpointAuthInfo;\n    /** Request headers */\n    headers: Headers;\n    /** Logger for endpoint operations */\n    logger: EndpointLogger;\n}\n/**\n * Authentication information passed to handlers\n */\nexport interface EndpointAuthInfo {\n    /** Authentication type used */\n    type: EndpointAuthType;\n    /** API key ID (if authenticated with API key) */\n    apiKeyId?: string;\n    /** Scopes granted to the API key */\n    scopes?: string[];\n    /** Whether request is authenticated */\n    authenticated: boolean;\n}\n/**\n * Logger for endpoint operations\n */\nexport interface EndpointLogger {\n    info(message: string, data?: Record<string, unknown>): void;\n    warn(message: string, data?: Record<string, unknown>): void;\n    error(message: string, data?: Record<string, unknown>): void;\n}\n/**\n * Metadata for endpoint documentation\n */\nexport interface EndpointMeta {\n    /** Human-readable description */\n    description?: string;\n    /** Tags for grouping in documentation */\n    tags?: string[];\n    /** Deprecated flag */\n    deprecated?: boolean;\n    /** Deprecation message */\n    deprecationMessage?: string;\n}\n/**\n * Public endpoint definition\n */\nexport interface EndpointDefinition<TQuery = Record<string, unknown>, TBody = unknown, TResponse = unknown> {\n    /** URL path (e.g., '/v1/todos', '/users/:id') */\n    path: string;\n    /** HTTP method */\n    method: EndpointMethod;\n    /** Authentication requirement */\n    auth: EndpointAuthType;\n    /** Validation schemas */\n    schema?: EndpointSchema<TQuery, TBody, TResponse>;\n    /** Request handler */\n    handler: EndpointHandler<TQuery, TBody, TResponse>;\n    /** Endpoint metadata for documentation */\n    meta?: EndpointMeta;\n}\n/**\n * Endpoint handler function type\n */\nexport type EndpointHandler<TQuery = Record<string, unknown>, TBody = unknown, TResponse = unknown> = (ctx: EndpointContext<TQuery, TBody>) => Promise<TResponse>;\n/** Type guard to distinguish EndpointDefinition from function-based route registrars */\nexport declare function isEndpointDefinition(entry: unknown): entry is EndpointDefinition;\n/**\n * Internal: Parsed endpoint info from request headers\n */\nexport interface ParsedEndpointRequest {\n    endpointId: string;\n    appId: string;\n    authType: EndpointAuthType;\n    apiKeyId?: string;\n    scopes?: string[];\n}\n/**\n * Create a JSON response\n */\nexport declare function jsonResponse<T>(data: T, status?: number): Response;\n/**\n * Create an error response\n */\nexport declare function errorResponse(message: string, status?: number, code?: string): Response;\n/**\n * Convert Zod schema to JSON Schema for documentation\n * This is a simplified conversion that handles common cases\n */\nexport declare function zodToJsonSchema(schema: ZodSchema | undefined): Record<string, unknown> | undefined;\n/**\n * Endpoint router that matches requests to handlers\n */\nexport declare class EndpointRouter {\n    private endpoints;\n    /**\n     * Register endpoints\n     */\n    register(endpoints: EndpointDefinition<unknown, unknown, unknown>[]): void;\n    /**\n     * Find endpoint matching the request\n     */\n    findEndpoint(method: string, path: string): {\n        endpoint: EndpointDefinition<unknown, unknown, unknown>;\n        params: Record<string, string>;\n    } | null;\n    /**\n     * Get all registered endpoints for documentation\n     */\n    getAllEndpoints(): EndpointDefinition<unknown, unknown, unknown>[];\n}\n/**\n * Mount an EndpointDefinition as a native Hono route.\n *\n * Registers the endpoint at its natural path using the correct HTTP method,\n * with Zod validation for query/body schemas and full EndpointContext support.\n * This allows EndpointDefinition entries in APP_ROUTES to work as first-class\n * Hono routes with middleware, streaming, and WebSocket support intact.\n */\nexport declare function mountEndpointAsHonoRoute(app: Hono<{\n    Bindings: Env;\n}>, endpoint: EndpointDefinition): void;\n/**\n * Handle an incoming public endpoint request.\n * Called by the platform when routing requests to the app.\n */\nexport declare function handleEndpointRequest<TQuery = unknown, TBody = unknown, TResponse = unknown>(request: Request, env: Env, endpoints: EndpointDefinition<TQuery, TBody, TResponse>[]): Promise<Response>;\n/**\n * Custom error for endpoint handlers\n * Use this to return specific HTTP status codes\n */\nexport declare class EndpointError extends Error {\n    status: number;\n    code?: string | undefined;\n    constructor(message: string, status?: number, code?: string | undefined);\n    static badRequest(message: string): EndpointError;\n    static unauthorized(message?: string): EndpointError;\n    static forbidden(message?: string): EndpointError;\n    static notFound(message?: string): EndpointError;\n    static conflict(message: string): EndpointError;\n}\n/**\n * Convert endpoint definition to registration data for workspace\n */\nexport declare function endpointToRegistration<TQuery = unknown, TBody = unknown, TResponse = unknown>(endpoint: EndpointDefinition<TQuery, TBody, TResponse>): {\n    path: string;\n    method: EndpointMethod;\n    auth: EndpointAuthType;\n    description?: string;\n    tags?: string[];\n    schema?: {\n        query?: Record<string, unknown>;\n        body?: Record<string, unknown>;\n        response?: Record<string, unknown>;\n    };\n};\nexport {};\n",
+    "core-endpoints.d.ts": "/**\n * Core Public Endpoints Framework\n * DO NOT MODIFY THIS FILE - You may break the project functionality\n *\n * This module provides the infrastructure for exposing public API endpoints\n * that external systems can consume with API key authentication or public access.\n */\nimport { type Env } from './core-utils';\nimport { z } from 'zod';\nimport type { Hono } from 'hono';\ntype ZodSchema = z.ZodType<any, any, any>;\n/**\n * Authentication requirement declared by an endpoint definition.\n */\nexport type EndpointAuthType = 'apiKey' | 'public';\n/**\n * Caller principal type resolved by the platform and passed via the\n * `X-Public-Endpoint-Auth-Type` header. `user` and `workspace_key` are\n * authenticated principals the platform has already authorized; `api_key`\n * additionally carries a validated key id; `none` is unauthenticated.\n */\nexport type EndpointPrincipalType = 'none' | 'api_key' | 'workspace_key' | 'user';\n/**\n * HTTP methods supported by endpoints\n */\nexport type EndpointMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n/**\n * Schema definition for endpoint validation\n */\nexport interface EndpointSchema<TQuery = unknown, TBody = unknown, TResponse = unknown> {\n    /** Query parameters schema */\n    query?: ZodSchema;\n    /** Request body schema (for POST/PUT/PATCH) */\n    body?: ZodSchema;\n    /** Response schema for documentation */\n    response?: ZodSchema;\n}\n/**\n * Context provided to endpoint handlers\n */\nexport interface EndpointContext<TQuery = Record<string, unknown>, TBody = unknown> {\n    /** Environment bindings */\n    env: Env;\n    /** Original request object */\n    request: Request;\n    /** Validated query parameters */\n    query: TQuery;\n    /** Validated request body (null for GET/DELETE) */\n    body: TBody | null;\n    /** Path parameters extracted from URL */\n    params: Record<string, string>;\n    /** Authentication information */\n    auth: EndpointAuthInfo;\n    /** Request headers */\n    headers: Headers;\n    /** Logger for endpoint operations */\n    logger: EndpointLogger;\n}\n/**\n * Authentication information passed to handlers\n */\nexport interface EndpointAuthInfo {\n    /** Authentication requirement declared by the endpoint */\n    type: EndpointAuthType;\n    /** Resolved caller principal type (api_key, workspace_key, user, none) */\n    principalType?: EndpointPrincipalType;\n    /** API key ID (if authenticated with an API key) */\n    apiKeyId?: string;\n    /** User ID (if authenticated as a workspace member) */\n    userId?: string;\n    /** Scopes granted to the API key */\n    scopes?: string[];\n    /** Whether request is authenticated */\n    authenticated: boolean;\n}\n/**\n * Logger for endpoint operations\n */\nexport interface EndpointLogger {\n    info(message: string, data?: Record<string, unknown>): void;\n    warn(message: string, data?: Record<string, unknown>): void;\n    error(message: string, data?: Record<string, unknown>): void;\n}\n/**\n * Metadata for endpoint documentation\n */\nexport interface EndpointMeta {\n    /** Human-readable description */\n    description?: string;\n    /** Tags for grouping in documentation */\n    tags?: string[];\n    /** Deprecated flag */\n    deprecated?: boolean;\n    /** Deprecation message */\n    deprecationMessage?: string;\n}\n/**\n * Public endpoint definition\n */\nexport interface EndpointDefinition<TQuery = Record<string, unknown>, TBody = unknown, TResponse = unknown> {\n    /** URL path (e.g., '/v1/todos', '/users/:id') */\n    path: string;\n    /** HTTP method */\n    method: EndpointMethod;\n    /** Authentication requirement */\n    auth: EndpointAuthType;\n    /** Validation schemas */\n    schema?: EndpointSchema<TQuery, TBody, TResponse>;\n    /** Request handler */\n    handler: EndpointHandler<TQuery, TBody, TResponse>;\n    /** Endpoint metadata for documentation */\n    meta?: EndpointMeta;\n}\n/**\n * Endpoint handler function type\n */\nexport type EndpointHandler<TQuery = Record<string, unknown>, TBody = unknown, TResponse = unknown> = (ctx: EndpointContext<TQuery, TBody>) => Promise<TResponse>;\n/** Type guard to distinguish EndpointDefinition from function-based route registrars */\nexport declare function isEndpointDefinition(entry: unknown): entry is EndpointDefinition;\n/**\n * Internal: Parsed endpoint info from request headers\n */\nexport interface ParsedEndpointRequest {\n    endpointId: string;\n    appId: string;\n    authType: EndpointPrincipalType;\n    apiKeyId?: string;\n    userId?: string;\n    scopes?: string[];\n}\n/**\n * Create a JSON response\n */\nexport declare function jsonResponse<T>(data: T, status?: number): Response;\n/**\n * Create an error response\n */\nexport declare function errorResponse(message: string, status?: number, code?: string): Response;\n/**\n * Convert Zod schema to JSON Schema for documentation\n * This is a simplified conversion that handles common cases\n */\nexport declare function zodToJsonSchema(schema: ZodSchema | undefined): Record<string, unknown> | undefined;\n/**\n * Endpoint router that matches requests to handlers\n */\nexport declare class EndpointRouter {\n    private endpoints;\n    /**\n     * Register endpoints\n     */\n    register(endpoints: EndpointDefinition<unknown, unknown, unknown>[]): void;\n    /**\n     * Find endpoint matching the request\n     */\n    findEndpoint(method: string, path: string): {\n        endpoint: EndpointDefinition<unknown, unknown, unknown>;\n        params: Record<string, string>;\n    } | null;\n    /**\n     * Get all registered endpoints for documentation\n     */\n    getAllEndpoints(): EndpointDefinition<unknown, unknown, unknown>[];\n}\n/**\n * Mount an EndpointDefinition as a native Hono route.\n *\n * Registers the endpoint at its natural path using the correct HTTP method,\n * with Zod validation for query/body schemas and full EndpointContext support.\n * This allows EndpointDefinition entries in APP_ROUTES to work as first-class\n * Hono routes with middleware, streaming, and WebSocket support intact.\n */\nexport declare function mountEndpointAsHonoRoute(app: Hono<{\n    Bindings: Env;\n}>, endpoint: EndpointDefinition): void;\n/**\n * Handle an incoming public endpoint request.\n * Called by the platform when routing requests to the app.\n */\nexport declare function handleEndpointRequest<TQuery = unknown, TBody = unknown, TResponse = unknown>(request: Request, env: Env, endpoints: EndpointDefinition<TQuery, TBody, TResponse>[]): Promise<Response>;\n/**\n * Custom error for endpoint handlers\n * Use this to return specific HTTP status codes\n */\nexport declare class EndpointError extends Error {\n    status: number;\n    code?: string | undefined;\n    constructor(message: string, status?: number, code?: string | undefined);\n    static badRequest(message: string): EndpointError;\n    static unauthorized(message?: string): EndpointError;\n    static forbidden(message?: string): EndpointError;\n    static notFound(message?: string): EndpointError;\n    static conflict(message: string): EndpointError;\n}\n/**\n * Convert endpoint definition to registration data for workspace\n */\nexport declare function endpointToRegistration<TQuery = unknown, TBody = unknown, TResponse = unknown>(endpoint: EndpointDefinition<TQuery, TBody, TResponse>): {\n    path: string;\n    method: EndpointMethod;\n    auth: EndpointAuthType;\n    description?: string;\n    tags?: string[];\n    schema?: {\n        query?: Record<string, unknown>;\n        body?: Record<string, unknown>;\n        response?: Record<string, unknown>;\n    };\n};\nexport {};\n",
     "core-utils.d.ts": "/**\n * Core Utilities\n * DO NOT MODIFY THIS FILE - You may break the project functionality\n *\n * This module provides:\n * - Env type: Environment bindings for Cloudflare Workers\n * - API helpers: Response utilities for Hono routes\n *\n * Entity System: See core-entities.ts\n * Workspace Context: See core-workspace.ts\n * Scheduler: See core-scheduler.ts\n */\nimport type { Context } from 'hono';\nimport type { EntityDO } from './core-entity-do';\nimport type { SchedulerDO } from './core-scheduler';\nimport type { BaseAgent } from './core-base-agent';\n/**\n * Environment bindings for Cloudflare Workers\n */\nexport interface Env {\n    EntityDO: DurableObjectNamespace<EntityDO>;\n    SchedulerDO: DurableObjectNamespace<SchedulerDO>;\n    BaseAgent?: DurableObjectNamespace<BaseAgent>;\n    WorkspaceObject?: DurableObjectNamespace;\n    WorkflowInstance: DurableObjectNamespace;\n    WorkflowCoordinator: DurableObjectNamespace;\n    BUCKET?: R2Bucket;\n    WORKSPACE_ID?: string;\n    APP_ID?: string;\n    APP_NAME?: string;\n    WORKSPACE_API_URL?: string;\n    WORKSPACE_API_BASE_URL?: string;\n    WORKSPACE_API_KEY?: string;\n    DEPLOYMENT_MODE?: 'preview' | 'production';\n    VITE_DEPLOYMENT_MODE?: 'preview' | 'production';\n    RUNWORK_AI_PROXY_URL?: string;\n    RUNWORK_PROXY_TOKEN?: string;\n    INTEGRATIONS_PROXY_URL?: string;\n    ALLOWED_ORIGINS?: string;\n}\n/**\n * Return a successful JSON response.\n * Returns the data directly as the response body with 200 status.\n */\nexport declare const ok: <T>(c: Context, data: T) => Response & import(\"hono\").TypedResponse<{\n    [x: string]: import(\"hono/utils/types\").JSONValue;\n}, import(\"hono/utils/http-status\").ContentfulStatusCode, \"json\">;\n/**\n * Return a 400 Bad Request response\n * Automatically logs the error for debugging in production logs\n */\nexport declare const bad: (c: Context, error: string) => Response & import(\"hono\").TypedResponse<{\n    error: string;\n}, 400, \"json\">;\n/**\n * Return a 404 Not Found response\n * Automatically logs the error for debugging in production logs\n */\nexport declare const notFound: (c: Context, error?: string) => Response & import(\"hono\").TypedResponse<{\n    error: string;\n}, 404, \"json\">;\n/**\n * Type guard for non-empty strings\n */\nexport declare const isStr: (s: unknown) => s is string;\n/**\n * Safely clone a value for Durable Object storage.\n * Strips non-serializable references (R2Bucket, D1Database, DO stubs, etc.)\n * that would cause structured clone to fail in ctx.storage.put().\n */\nexport declare function safeClone<T>(value: T, fallback?: T): T;\nexport declare function platformFetch(env: Env, url: string | URL, init?: RequestInit): Promise<Response>;\n/**\n * Workspace API fetch - routes workspace service requests through WorkspaceObject DO\n * for production WfP workers, avoiding 522 recursive invocation errors.\n *\n * Workers for Platforms workers cannot HTTP-fetch back to their dispatcher domain.\n * This routes through the WorkspaceObject DO binding in production, and falls back\n * to standard HTTP with x-workspace-key auth header in preview/sandbox.\n *\n * @param env - Environment with workspace bindings\n * @param path - Workspace API sub-path (e.g., '/ingest-event')\n * @param init - Standard fetch options\n */\nexport declare function workspaceApiFetch(env: Pick<Env, 'WORKSPACE_API_URL' | 'WORKSPACE_API_KEY' | 'WORKSPACE_ID' | 'DEPLOYMENT_MODE' | 'WorkspaceObject'>, path: string, init?: RequestInit): Promise<Response>;\n",
     "vite.d.ts": "import { defineConfig, type Plugin } from \"vite\";\nexport interface RunworkPluginOptions {\n    /**\n     * Override the detected mode. By default, the plugin detects sandbox mode\n     * when DEPLOYMENT_MODE or WORKSPACE_ID environment variables are present.\n     */\n    mode?: \"sandbox\" | \"local\";\n    /**\n     * Root directory of the project. Defaults to process.cwd().\n     */\n    root?: string;\n    /**\n     * Path aliases to configure. Defaults to { \"@\": \"./src\", \"@shared\": \"./shared\" }.\n     */\n    aliases?: Record<string, string>;\n    /**\n     * Whether to use JSON logging (pino) in sandbox mode.\n     * Defaults to true when VITE_LOGGER_TYPE=json.\n     */\n    jsonLogger?: boolean;\n}\nexport declare function runwork(options?: RunworkPluginOptions): ReturnType<typeof defineConfig>;\nexport type { Plugin };\n",
     "core-channels.d.ts": "/**\n * Core Channels\n * DO NOT MODIFY THIS FILE - You may break the project functionality\n *\n * This module provides:\n * - postToChannel(): Post rich markdown messages to workspace channels\n *\n * Channels are auto-created if they don't exist, with automatic app event filtering.\n * When running outside a workspace (standalone mode), calls are silently skipped.\n */\nexport interface PostToChannelParams {\n    /** Channel name (e.g., \"#inventory-alerts\" or \"inventory-alerts\"). Auto-normalized: # stripped, lowercased, trimmed. */\n    channel: string;\n    /** Markdown message content */\n    content: string;\n    /** Optional structured metadata attached to the message */\n    metadata?: Record<string, unknown>;\n}\ninterface ChannelEnv {\n    WORKSPACE_API_URL?: string;\n    WORKSPACE_API_KEY?: string;\n    WORKSPACE_ID?: string;\n    APP_ID?: string;\n    APP_NAME?: string;\n    DEPLOYMENT_MODE?: 'preview' | 'production';\n    WorkspaceObject?: DurableObjectNamespace;\n}\n/**\n * Any context that supports waitUntil - compatible with both\n * ExecutionContext (Hono route handlers) and DurableObjectState (DOs).\n */\ntype WaitUntilContext = Pick<ExecutionContext, 'waitUntil'>;\n/**\n * Post a rich markdown message to a workspace channel.\n * Fire-and-forget: uses ctx.waitUntil so it doesn't block the response.\n * Silently skips if workspace env vars are not configured (standalone mode).\n *\n * Channels are auto-created on first use. The channel will automatically\n * include this app's system events via filter projection.\n */\nexport declare function postToChannel(ctx: WaitUntilContext, env: ChannelEnv, params: PostToChannelParams): void;\nexport {};\n",

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.13.4";
+export declare const VERSION = "0.15.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.13.4";
+export const VERSION = "0.15.0";

package/dist/git/__tests__/classify-sync-error.test.d.ts

@@ -0,0 +1 @@
+export {};