@planu/cli 4.12.3 → 4.14.1

package/dist/engine/execution/context.js

@@ -0,0 +1,127 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+const executionStorage = new AsyncLocalStorage();
+export class ExecutionCancelledError extends Error {
+    code = 'EXECUTION_CANCELLED';
+    constructor(message = 'Execution was cancelled before commit') {
+        super(message);
+        this.name = 'ExecutionCancelledError';
+    }
+}
+export function getExecutionContext() {
+    return executionStorage.getStore();
+}
+export function getExecutionSignal() {
+    return getExecutionContext()?.signal;
+}
+export function remainingExecutionMs() {
+    return getExecutionContext()?.remainingMs() ?? Number.POSITIVE_INFINITY;
+}
+/**
+ * Must be called immediately before a mutation crosses its commit boundary.
+ * AsyncLocalStorage keeps the cancelled state visible to work that outlives its
+ * request, so abandoned handlers cannot commit after acknowledgement.
+ */
+export function assertExecutionCanCommit(signal) {
+    signal?.throwIfAborted();
+    const context = getExecutionContext();
+    if (context !== undefined) {
+        context.assertCanCommit();
+    }
+}
+export async function guardExecutionCommit(commit) {
+    assertExecutionCanCommit();
+    return commit();
+}
+export function createExecutionScope(options) {
+    const controller = new AbortController();
+    const state = { phase: 'running' };
+    const abortFromUpstream = () => {
+        cancel(options.upstreamSignal?.reason ?? new ExecutionCancelledError());
+    };
+    const cancel = (reason = new ExecutionCancelledError()) => {
+        if (state.phase !== 'acknowledged') {
+            state.phase = 'cancelled';
+        }
+        if (!controller.signal.aborted) {
+            controller.abort(reason);
+        }
+    };
+    if (options.upstreamSignal?.aborted === true) {
+        abortFromUpstream();
+    }
+    else {
+        options.upstreamSignal?.addEventListener('abort', abortFromUpstream, { once: true });
+    }
+    const context = {
+        requestId: options.requestId ?? randomUUID(),
+        ...(options.idempotencyKey === undefined ? {} : { idempotencyKey: options.idempotencyKey }),
+        deadlineAt: options.deadlineAt,
+        signal: controller.signal,
+        get phase() {
+            return state.phase;
+        },
+        remainingMs: () => Math.max(0, options.deadlineAt - Date.now()),
+        assertCanCommit: () => {
+            if (controller.signal.aborted ||
+                state.phase === 'cancelled' ||
+                state.phase === 'acknowledged') {
+                throw new ExecutionCancelledError();
+            }
+            if (state.phase === 'committed') {
+                throw new Error('Execution has already crossed its commit boundary');
+            }
+            if (Date.now() >= options.deadlineAt) {
+                cancel(new ExecutionCancelledError('Execution deadline elapsed before commit'));
+                throw new ExecutionCancelledError('Execution deadline elapsed before commit');
+            }
+        },
+        markCommitted: () => {
+            context.assertCanCommit();
+            state.phase = 'committed';
+        },
+    };
+    return {
+        context,
+        run: (fn) => executionStorage.run(context, fn),
+        cancel,
+        acknowledge: () => {
+            if (state.phase !== 'cancelled') {
+                state.phase = 'acknowledged';
+            }
+        },
+        dispose: () => {
+            options.upstreamSignal?.removeEventListener('abort', abortFromUpstream);
+        },
+    };
+}
+/** Creates a child cancellation node whose deadline never exceeds its parent. */
+export function createChildCancellationScope(requestedMs) {
+    const parent = getExecutionContext();
+    const parentRemaining = parent?.remainingMs() ?? Number.POSITIVE_INFINITY;
+    const normalizedMs = Number.isFinite(requestedMs) ? Math.max(0, requestedMs) : 0;
+    const timeoutMs = Math.max(0, Math.min(normalizedMs, parentRemaining));
+    const controller = new AbortController();
+    const abortFromParent = () => {
+        controller.abort(parent?.signal.reason ?? new ExecutionCancelledError());
+    };
+    if (parent?.signal.aborted === true) {
+        abortFromParent();
+    }
+    else {
+        parent?.signal.addEventListener('abort', abortFromParent, { once: true });
+    }
+    const timer = setTimeout(() => {
+        controller.abort(new ExecutionCancelledError(`Execution budget elapsed after ${String(timeoutMs)}ms`));
+    }, timeoutMs);
+    timer.unref();
+    return {
+        signal: controller.signal,
+        timeoutMs,
+        dispose: () => {
+            clearTimeout(timer);
+            parent?.signal.removeEventListener('abort', abortFromParent);
+        },
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/engine/execution/deadline-io.d.ts

@@ -0,0 +1,21 @@
+import type { MakeDirectoryOptions, WriteFileOptions } from 'node:fs';
+/** Fetch under the active request cancellation tree. */
+export declare function executionFetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+/** Create a directory only while the request remains pre-commit and active. */
+export declare function executionMkdir(path: string, options: MakeDirectoryOptions & {
+    recursive: true;
+}): Promise<string | undefined>;
+/** Exclusive-create helper for idempotency claims; never overwrites an owner. */
+export declare function executionWriteFileExclusive(path: string, content: string, options?: Omit<WriteFileOptions, 'flag'>): Promise<void>;
+export declare function executionRename(source: string, target: string): Promise<void>;
+export declare function executionLink(source: string, target: string): Promise<void>;
+export declare function executionRemove(path: string, options?: {
+    force?: boolean;
+    recursive?: boolean;
+}): Promise<void>;
+/** Roll back artifacts owned by the interrupted operation; never targets user input. */
+export declare function cleanupExecutionArtifact(path: string, options?: {
+    force?: boolean;
+    recursive?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=deadline-io.d.ts.map

package/dist/engine/execution/deadline-io.js

@@ -0,0 +1,45 @@
+import { link, mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { assertExecutionCanCommit, getExecutionSignal } from './context.js';
+function operationSignal(signal) {
+    const parent = getExecutionSignal();
+    if (!signal) {
+        return parent;
+    }
+    if (!parent || parent === signal) {
+        return signal;
+    }
+    return AbortSignal.any([parent, signal]);
+}
+/** Fetch under the active request cancellation tree. */
+export function executionFetch(input, init = {}) {
+    const signal = operationSignal(init.signal);
+    signal?.throwIfAborted();
+    return fetch(input, { ...init, ...(signal ? { signal } : {}) });
+}
+/** Create a directory only while the request remains pre-commit and active. */
+export async function executionMkdir(path, options) {
+    assertExecutionCanCommit();
+    return mkdir(path, options);
+}
+/** Exclusive-create helper for idempotency claims; never overwrites an owner. */
+export async function executionWriteFileExclusive(path, content, options = {}) {
+    assertExecutionCanCommit();
+    await writeFile(path, content, { ...options, flag: 'wx' });
+}
+export async function executionRename(source, target) {
+    assertExecutionCanCommit();
+    await rename(source, target);
+}
+export async function executionLink(source, target) {
+    assertExecutionCanCommit();
+    await link(source, target);
+}
+export async function executionRemove(path, options = {}) {
+    assertExecutionCanCommit();
+    await rm(path, options);
+}
+/** Roll back artifacts owned by the interrupted operation; never targets user input. */
+export async function cleanupExecutionArtifact(path, options = {}) {
+    await rm(path, options);
+}
+//# sourceMappingURL=deadline-io.js.map

package/dist/engine/execution/job-executor.d.ts

@@ -0,0 +1,16 @@
+import type { DurableJobExecutorOptions } from '../../types/durable-job.js';
+import type { DurableJobRecord } from '../../storage/runtime-db.js';
+/** Claims and executes allowlisted native jobs while preserving lease and cancellation fencing. */
+export declare class DurableJobExecutor {
+    private readonly runtime;
+    private readonly workerId;
+    private readonly leaseMs;
+    private readonly heartbeatMs;
+    private readonly maxConcurrency;
+    private readonly runNative;
+    constructor(options: DurableJobExecutorOptions);
+    /** Execute one bounded batch. Jobs not claimed by this worker remain untouched. */
+    runOnce(projectId: string, workspaceId?: string): Promise<readonly DurableJobRecord[]>;
+    private execute;
+}
+//# sourceMappingURL=job-executor.d.ts.map

package/dist/engine/execution/job-executor.js

@@ -0,0 +1,140 @@
+import { isNativeWorkerOperation } from './native-worker-protocol.js';
+import { runNativeWorkerOperation } from './native-worker-runtime.js';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+const DEFAULT_WORKSPACE_ID = 'global';
+const DEFAULT_LEASE_MS = 5_000;
+const DEFAULT_HEARTBEAT_MS = 25;
+const DEFAULT_MAX_CONCURRENCY = 2;
+const MAX_CONCURRENCY = 8;
+const RUNNABLE_STATES = new Set(['accepted', 'checkpointed']);
+/** Claims and executes allowlisted native jobs while preserving lease and cancellation fencing. */
+export class DurableJobExecutor {
+    runtime;
+    workerId;
+    leaseMs;
+    heartbeatMs;
+    maxConcurrency;
+    runNative;
+    constructor(options) {
+        requireIdentifier(options.workerId, 'workerId');
+        this.leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
+        this.heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+        this.maxConcurrency = options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY;
+        if (!Number.isSafeInteger(this.leaseMs) || this.leaseMs < 100 || this.leaseMs > 60_000) {
+            throw new Error('[Planu] executor leaseMs must be an integer between 100 and 60000');
+        }
+        if (!Number.isSafeInteger(this.heartbeatMs) ||
+            this.heartbeatMs < 10 ||
+            this.heartbeatMs >= this.leaseMs / 2) {
+            throw new Error('[Planu] executor heartbeatMs must be at least 10 and below half the lease');
+        }
+        if (!Number.isSafeInteger(this.maxConcurrency) ||
+            this.maxConcurrency < 1 ||
+            this.maxConcurrency > MAX_CONCURRENCY) {
+            throw new Error(`[Planu] executor maxConcurrency must be between 1 and ${String(MAX_CONCURRENCY)}`);
+        }
+        this.runtime = options.runtime;
+        this.workerId = options.workerId;
+        this.runNative = options.runNative ?? runNativeWorkerOperation;
+    }
+    /** Execute one bounded batch. Jobs not claimed by this worker remain untouched. */
+    async runOnce(projectId, workspaceId = DEFAULT_WORKSPACE_ID) {
+        requireIdentifier(projectId, 'projectId');
+        requireIdentifier(workspaceId, 'workspaceId');
+        const candidates = this.runtime
+            .list(projectId, workspaceId)
+            .filter((job) => RUNNABLE_STATES.has(job.state))
+            .slice(0, this.maxConcurrency);
+        return Promise.all(candidates.map((job) => this.execute({
+            operationId: job.id,
+            projectId: job.projectId,
+            workspaceId: job.workspaceId,
+        })));
+    }
+    async execute(identity) {
+        const claimed = this.runtime.claim({
+            ...identity,
+            workerId: this.workerId,
+            leaseMs: this.leaseMs,
+        });
+        if (!claimed) {
+            return this.runtime.get(identity);
+        }
+        const controller = new AbortController();
+        const heartbeat = setInterval(() => {
+            const current = this.runtime.get(identity);
+            if (current.state === 'cancelled' || current.cancelRequested) {
+                controller.abort(new Error('[Planu] Durable native job cancelled'));
+                return;
+            }
+            if (!this.runtime.renew({
+                ...identity,
+                workerId: this.workerId,
+                fencingToken: claimed.fencingToken,
+                leaseMs: this.leaseMs,
+            })) {
+                controller.abort(new Error('[Planu] Durable native job lease was lost'));
+            }
+        }, this.heartbeatMs);
+        heartbeat.unref();
+        try {
+            const payload = parseNativePayload(claimed.payload);
+            const value = await this.runNative({
+                projectId: identity.projectId,
+                operation: payload.operation,
+                payload: payload.payload,
+                deadlineAt: payload.deadlineAt,
+                requestId: identity.operationId,
+                cancellationId: payload.cancellationId ?? identity.operationId,
+                signal: controller.signal,
+            });
+            return this.runtime.complete({
+                ...identity,
+                workerId: this.workerId,
+                fencingToken: claimed.fencingToken,
+                result: value,
+            });
+        }
+        catch (error) {
+            /* reliability-optional: DURABLE_JOB_EXECUTION_FAILURE — runtime records typed failure below */
+            reportClassifiedDegradation('DURABLE_JOB_EXECUTION_FAILURE', error);
+            const current = this.runtime.get(identity);
+            if (current.state === 'cancelled') {
+                return current;
+            }
+            return this.runtime.fail({
+                ...identity,
+                workerId: this.workerId,
+                fencingToken: claimed.fencingToken,
+                error: boundedError(error),
+            });
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+    }
+}
+function parseNativePayload(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error('[Planu] Durable job payload must be an object');
+    }
+    const payload = value;
+    if (payload.kind !== 'native-worker' ||
+        !isNativeWorkerOperation(payload.operation) ||
+        !payload.payload ||
+        typeof payload.payload !== 'object' ||
+        !Number.isSafeInteger(payload.deadlineAt)) {
+        throw new Error('[Planu] Durable job payload is not an allowlisted native operation');
+    }
+    return payload;
+}
+function boundedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.slice(0, 4_096) || 'Native worker failed';
+}
+function requireIdentifier(value, label) {
+    if (!value || value.length > 128 || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value)) {
+        throw new Error(`[Planu] Invalid ${label}`);
+    }
+}
+//# sourceMappingURL=job-executor.js.map

package/dist/engine/execution/job-runtime.d.ts

@@ -0,0 +1,78 @@
+import { type DurableJobRecord } from '../../storage/runtime-db.js';
+import type { DurableJobIdentity, DurableJobRuntimeOptions, WatchJobInput } from '../../types/durable-job.js';
+import type { NativeWorkerOperation } from '../../types/native-worker.js';
+export declare class DurableJobNotFoundError extends Error {
+    constructor(operationId: string);
+}
+/** Durable control plane for locally accepted long-running operations. */
+export declare class DurableJobRuntime implements Disposable {
+    private readonly database;
+    private readonly ownsDatabase;
+    constructor(options?: DurableJobRuntimeOptions);
+    accept(input: {
+        readonly projectId: string;
+        readonly workspaceId?: string;
+        readonly operationId?: string;
+        readonly payload: unknown;
+        readonly maxAttempts?: number;
+    }): DurableJobRecord;
+    acceptNative(input: {
+        readonly projectId: string;
+        readonly workspaceId?: string;
+        readonly operationId?: string;
+        readonly operation: NativeWorkerOperation;
+        readonly payload: Readonly<Record<string, unknown>>;
+        readonly deadlineAt: number;
+        readonly cancellationId?: string;
+        readonly maxAttempts?: number;
+    }): DurableJobRecord;
+    get(input: DurableJobIdentity): DurableJobRecord;
+    list(projectId: string, workspaceId?: string): readonly DurableJobRecord[];
+    listRunnableScopes(): readonly {
+        projectId: string;
+        workspaceId: string;
+    }[];
+    claim(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly leaseMs: number;
+    }): DurableJobRecord | undefined;
+    renew(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly leaseMs: number;
+        readonly fencingToken: number;
+    }): boolean;
+    recordProgress(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly fencingToken: number;
+        readonly checkpoint: unknown;
+    }): DurableJobRecord;
+    checkpoint(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly fencingToken: number;
+        readonly checkpoint: unknown;
+    }): DurableJobRecord;
+    complete(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly fencingToken: number;
+        readonly result: unknown;
+    }): DurableJobRecord;
+    fail(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly fencingToken: number;
+        readonly error: string;
+    }): DurableJobRecord;
+    retry(input: DurableJobIdentity): DurableJobRecord;
+    restart(input: DurableJobIdentity): DurableJobRecord;
+    restartWithPayload(input: DurableJobIdentity & {
+        readonly payload: unknown;
+    }): DurableJobRecord;
+    cancel(input: DurableJobIdentity): DurableJobRecord;
+    watch(input: WatchJobInput): Promise<DurableJobRecord>;
+    close(): void;
+    [Symbol.dispose](): void;
+    private requireJob;
+    private leaseInput;
+}
+/** Stable watcher cursor that detects state changes even within one clock millisecond. */
+export declare function durableJobCursor(job: DurableJobRecord): string;
+//# sourceMappingURL=job-runtime.d.ts.map

package/dist/engine/execution/job-runtime.js

@@ -0,0 +1,220 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { RuntimeDatabase, } from '../../storage/runtime-db.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { isNativeWorkerOperation } from './native-worker-protocol.js';
+import { getExecutionContext } from './context.js';
+const DEFAULT_WORKSPACE_ID = 'global';
+const MAX_WATCH_MS = 30_000;
+const TERMINAL_STATES = new Set(['cancelled', 'failed', 'dead-letter', 'completed']);
+export class DurableJobNotFoundError extends Error {
+    constructor(operationId) {
+        super(`[Planu] Job ${operationId} was not found`);
+        this.name = 'DurableJobNotFoundError';
+    }
+}
+/** Durable control plane for locally accepted long-running operations. */
+export class DurableJobRuntime {
+    database;
+    ownsDatabase;
+    constructor(options = {}) {
+        this.database = new RuntimeDatabase({
+            path: options.databasePath ?? resolveStorageLayout().runtimeDatabase,
+        });
+        this.ownsDatabase = true;
+        this.database.recoverExpiredJobs();
+    }
+    accept(input) {
+        const operationId = input.operationId ?? randomUUID();
+        const workspaceId = input.workspaceId ?? DEFAULT_WORKSPACE_ID;
+        this.database.enqueueJob({
+            id: operationId,
+            projectId: input.projectId,
+            workspaceId,
+            payload: input.payload,
+            maxAttempts: input.maxAttempts,
+        });
+        return this.requireJob({ operationId, projectId: input.projectId, workspaceId });
+    }
+    acceptNative(input) {
+        if (!isNativeWorkerOperation(input.operation)) {
+            throw new Error('[Planu] Native worker operation is not allowlisted');
+        }
+        if (!Number.isSafeInteger(input.deadlineAt) || input.deadlineAt <= Date.now()) {
+            throw new Error('[Planu] Native durable job requires a future absolute deadline');
+        }
+        const payload = {
+            kind: 'native-worker',
+            operation: input.operation,
+            payload: input.payload,
+            deadlineAt: input.deadlineAt,
+            ...(input.cancellationId === undefined ? {} : { cancellationId: input.cancellationId }),
+        };
+        return this.accept({
+            projectId: input.projectId,
+            workspaceId: input.workspaceId,
+            operationId: input.operationId,
+            payload,
+            maxAttempts: input.maxAttempts,
+        });
+    }
+    get(input) {
+        return this.requireJob(input);
+    }
+    list(projectId, workspaceId = DEFAULT_WORKSPACE_ID) {
+        return this.database.listJobs(projectId, workspaceId);
+    }
+    listRunnableScopes() {
+        return this.database.listRunnableJobScopes();
+    }
+    claim(input) {
+        return this.database.claimJob(this.leaseInput(input));
+    }
+    renew(input) {
+        return this.database.renewJobLease(this.leaseInput(input));
+    }
+    recordProgress(input) {
+        return this.database.recordJobProgress({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            checkpoint: input.checkpoint,
+        });
+    }
+    checkpoint(input) {
+        return this.database.checkpointJob({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            checkpoint: input.checkpoint,
+        });
+    }
+    complete(input) {
+        return this.database.completeJob({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            result: input.result,
+        });
+    }
+    fail(input) {
+        return this.database.failJob({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            error: input.error,
+        });
+    }
+    retry(input) {
+        return this.database.retryJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+    }
+    restart(input) {
+        return this.database.restartJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+    }
+    restartWithPayload(input) {
+        return this.database.restartJobWithPayload(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId, input.payload);
+    }
+    cancel(input) {
+        try {
+            return this.database.cancelJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.endsWith('was not found')) {
+                throw new DurableJobNotFoundError(input.operationId);
+            }
+            throw error;
+        }
+    }
+    async watch(input) {
+        const requestedTimeoutMs = input.timeoutMs ?? 10_000;
+        const pollIntervalMs = input.pollIntervalMs ?? 50;
+        if (!Number.isSafeInteger(requestedTimeoutMs) ||
+            requestedTimeoutMs < 0 ||
+            requestedTimeoutMs > MAX_WATCH_MS) {
+            throw new Error(`[Planu] timeoutMs must be an integer between 0 and ${String(MAX_WATCH_MS)}`);
+        }
+        if (!Number.isSafeInteger(pollIntervalMs) || pollIntervalMs < 10 || pollIntervalMs > 1_000) {
+            throw new Error('[Planu] pollIntervalMs must be an integer between 10 and 1000');
+        }
+        const parent = getExecutionContext();
+        const timeoutMs = Math.min(requestedTimeoutMs, Math.floor(parent?.remainingMs() ?? MAX_WATCH_MS));
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const job = this.requireJob(input);
+            if (TERMINAL_STATES.has(job.state) ||
+                input.afterCursor === undefined ||
+                durableJobCursor(job) !== input.afterCursor ||
+                Date.now() >= deadline) {
+                return job;
+            }
+            await abortableDelay(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())), [
+                input.signal,
+                parent?.signal,
+            ]);
+        }
+    }
+    close() {
+        if (this.ownsDatabase) {
+            this.database.close();
+        }
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+    requireJob(input) {
+        const job = this.database.getJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+        if (!job) {
+            throw new DurableJobNotFoundError(input.operationId);
+        }
+        return job;
+    }
+    leaseInput(input) {
+        return {
+            id: input.operationId,
+            projectId: input.projectId,
+            workspaceId: input.workspaceId ?? DEFAULT_WORKSPACE_ID,
+            workerId: input.workerId,
+            leaseMs: input.leaseMs,
+            fencingToken: input.fencingToken,
+        };
+    }
+}
+/** Stable watcher cursor that detects state changes even within one clock millisecond. */
+export function durableJobCursor(job) {
+    return createHash('sha256')
+        .update(JSON.stringify({
+        state: job.state,
+        checkpoint: job.checkpoint,
+        result: job.result,
+        error: job.error,
+        attempts: job.attempts,
+        cancelRequested: job.cancelRequested,
+        leaseOwner: job.leaseOwner,
+        leaseExpiresAt: job.leaseExpiresAt,
+        updatedAt: job.updatedAt,
+    }))
+        .digest('hex');
+}
+function abortableDelay(delayMs, signals) {
+    const activeSignals = signals.filter((signal) => signal !== undefined);
+    const aborted = activeSignals.find((signal) => signal.aborted);
+    if (aborted) {
+        return Promise.reject(abortReason(aborted));
+    }
+    return new Promise((resolve, reject) => {
+        const listeners = new Map();
+        const cleanup = () => {
+            for (const [signal, listener] of listeners) {
+                signal.removeEventListener('abort', listener);
+            }
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, delayMs);
+        for (const signal of activeSignals) {
+            const listener = () => {
+                clearTimeout(timer);
+                cleanup();
+                reject(abortReason(signal));
+            };
+            listeners.set(signal, listener);
+            signal.addEventListener('abort', listener, { once: true });
+        }
+    });
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error('[Planu] Job watch cancelled');
+}
+//# sourceMappingURL=job-runtime.js.map

package/dist/engine/execution/native-relevance-scorer.d.ts

@@ -0,0 +1,6 @@
+export declare function findRelevantFilesNative(input: {
+    rootPath: string;
+    keywords: readonly string[];
+    limit: number;
+}): string[];
+//# sourceMappingURL=native-relevance-scorer.d.ts.map