botmux-workflow-core 3.10.0

package/dist/types/src/workflows/v3/orchestrator.d.ts

@@ -0,0 +1,174 @@
+/**
+ * v3 orchestrator — pure decision layer.
+ *
+ * Mirrors v0.2's `orchestrator.ts` pattern: a pure function maps the current
+ * run state + DAG to a list of action descriptors.  The runtime (`runtime.ts`)
+ * owns every side effect — journal/STATE writes, ephemeral-worker dispatch via
+ * `runNode`, humanGate card posting — and the per-bot/per-CLI/global
+ * concurrency caps.  Keeping the decision pure makes the critical-path
+ * semantics testable without spawning workers or touching the filesystem.
+ *
+ * MVP scope: static DAG, fail-fast.  No loops / decisions / dynamic expand
+ * (those are deferred — design Q3/§7).  Gate set is frozen at authoring time;
+ * the orchestrator never invents or skips a gate (design Q10).
+ */
+import { type V3Dag } from './dag.js';
+import type { V3LoopRef, V3RunFailureReason } from './event-contract.js';
+export type V3NodeStatus = 'pending' | 'gateWaiting' | 'running' | 'done' | 'skipped' | 'cancelled' | 'blocked' | 'superseded' | 'failed';
+export interface V3NodeState {
+    status: V3NodeStatus;
+    /** True once an approved humanGate cleared this node — so after approval the
+     *  next tick dispatches work instead of re-dispatching the gate.  A rejected
+     *  gate transitions the node straight to `failed` (set by the runtime), so
+     *  this flag only ever records the approved case. */
+    gateCleared?: boolean;
+    /** Host-only: the frozen input approved by this gate. It must match the
+     * prepared sidecar before the runtime may publish hostEffectIntent. */
+    approvedHostInput?: {
+        attemptId: string;
+        approvalDigest: string;
+        inputHash: string;
+    };
+    /** The current live runtime instance of this DEFINITION node (`A#002`).
+     *  Set on dispatch; cleared when a revisit supersedes it (the node then
+     *  re-dispatches a fresh instance).  Absent on the pre-instance-layer path
+     *  (plain nodeId-keyed events) and loop body expansions. */
+    effectiveInstanceId?: string;
+}
+/** nodeId → state.  A node absent from the map is treated as `pending`. */
+export type V3RunState = Map<string, V3NodeState>;
+/**
+ * Per-loop composite state, folded from the loop lifecycle events.  A loop
+ * absent from the map has not started.  The loop's coarse status (running /
+ * blocked / done) lives in the regular node-state map under the loop's id;
+ * this struct carries what that one enum can't: where the iteration cursor is
+ * and what the last decision said.
+ */
+export interface V3LoopState {
+    /** Current iteration, 1-based; 0 between loopStarted and the first
+     *  loopIterationStarted. */
+    iteration: number;
+    /** True once the CURRENT iteration's decision event is recorded (reset by
+     *  the next loopIterationStarted). */
+    decided: boolean;
+    /** The latest decision — drives what the orchestrator does next. */
+    lastDecision?: 'exit' | 'continue' | 'exhausted';
+    /** Extra iterations granted (each loopIterationGranted adds one); the
+     *  effective budget is maxIterations + granted. */
+    granted: number;
+    /** An appended-but-unconsumed grant (cleared by the next
+     *  loopIterationStarted) — the idempotency key for "already granted". */
+    pendingGrant: boolean;
+}
+/** loopId → loop state. */
+export type V3LoopRunState = Map<string, V3LoopState>;
+export interface V3EdgeState {
+    active: boolean;
+    sourceAttemptId: string;
+}
+/** `${from}->${to}` → conditional edge state. */
+export type V3EdgeRunState = Map<string, V3EdgeState>;
+export interface V3OmittedInput {
+    from: string;
+    reason: 'edgeInactive' | 'sourceSkipped' | 'sourceCancelled' | 'earlyRelease';
+}
+export type V3Action = 
+/** Read one source result.json once and append edgeResolved. */
+{
+    kind: 'resolveEdge';
+    from: string;
+    to: string;
+}
+/** Mark a node skipped because its triggerRule cannot be satisfied. */
+ | {
+    kind: 'skipNode';
+    nodeId: string;
+    detail?: string;
+}
+/** Abort an early-release loser whose remaining products are no longer used. */
+ | {
+    kind: 'cancelNode';
+    nodeId: string;
+    byNodeId: string;
+    detail?: string;
+}
+/** Post the humanGate approval card + persist a `waits/<id>.json` (Q10). */
+ | {
+    kind: 'dispatchGate';
+    nodeId: string;
+    instanceId?: string;
+}
+/** Spawn an ephemeral worker via `runNode` for this node's goal.  `loop` is
+ *  set for body-instance dispatches (the runtime synthesizes the instance
+ *  node from the loop's body definition).  `instanceId` is set when this is a
+ *  cross-node-revisit RE-DISPATCH (`A#002`): the prior instance was
+ *  superseded, so decideNext computes the next instance number deterministically
+ *  from `state.instances` (constraint 4 — the action carries it, the runtime
+ *  does not guess).  Absent on a first dispatch / loop body (those keep the
+ *  pre-instance-layer path until the runtime brick threads instances through). */
+ | {
+    kind: 'dispatchWork';
+    nodeId: string;
+    instanceId?: string;
+    loop?: V3LoopRef;
+    omitted?: V3OmittedInput[];
+}
+/** Outer deps of a loop are done → append loopStarted. */
+ | {
+    kind: 'startLoop';
+    loopId: string;
+}
+/** Begin iteration N (first, after a continue-decision, or after a grant). */
+ | {
+    kind: 'startLoopIteration';
+    loopId: string;
+    iteration: number;
+}
+/** Current iteration's body is fully done and undecided → the runtime reads
+ *  the exit node's result.json, evaluates exit.when, appends the decision. */
+ | {
+    kind: 'evaluateLoopIteration';
+    loopId: string;
+    iteration: number;
+}
+/** Decision was 'exit' → seal the loop with a nodeSucceeded on the LOOP id
+ *  carrying the output projection's manifest (downstream inputs/deps then
+ *  treat the loop like any done node — zero special-casing). */
+ | {
+    kind: 'completeLoop';
+    loopId: string;
+    iteration: number;
+}
+/** Terminal: every node done; the run's product is the sink set. */
+ | {
+    kind: 'completeRunSucceeded';
+}
+/** Terminal (fail-fast): a node failed, so the run cannot proceed. */
+ | {
+    kind: 'completeRunFailed';
+    failedNodeId?: string;
+    reason?: V3RunFailureReason;
+    detail?: string;
+}
+/** Terminal-for-now: a node is blocked (contract failure, recoverable).
+ *  Halts dispatch like failed, but the run can resume via a retry event. */
+ | {
+    kind: 'completeRunBlocked';
+    blockedNodeId: string;
+};
+/**
+ * Pure decision: given the current `state`, return every action that can be
+ * taken *now*.  The runtime applies concurrency caps by acting on a prefix of
+ * the returned dispatch actions and re-invoking on the next tick — this
+ * function intentionally returns ALL ready dispatches (it does not throttle).
+ *
+ * Ordering follows topological order so callers see deps-ready nodes first.
+ * Fail-fast: the moment any node is `failed`, the only action is
+ * `completeRunFailed` (the runtime's attempt-quiescence barrier tears down and
+ * proves close for every in-flight peer before publishing the run terminal).
+ * When no dispatch is possible and nothing is pending, the run is complete.
+ */
+export declare function decideNext(dag: V3Dag, state: V3RunState, loops?: V3LoopRunState, edges?: V3EdgeRunState, instances?: V3RunState): V3Action[];
+/** Sink nodes — no other node depends on them.  Their products are the run's
+ *  output.  Pure helper for the runtime's success path. */
+export declare function findSinks(dag: V3Dag): string[];

package/dist/types/src/workflows/v3/portable-final-outputs.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Secure, host-neutral projection of terminal workflow artifacts.
+ *
+ * Journal entries are audit data, not filesystem authority. This module
+ * derives the only allowed artifact paths from the validated attempt identity,
+ * revalidates the manifest, and returns hash-bound snapshots for consumers.
+ */
+import type { Manifest, ValidateManifest } from './artifact-contract.js';
+import type { V3Dag } from './dag.js';
+export interface PortableWorkflowFinalOutput {
+    nodeId: string;
+    instanceId?: string;
+    attemptId: string;
+    /** Canonical path to the revalidated sink manifest. */
+    manifestPath: string;
+    /** SHA-256 of the exact manifest bytes validated for this projection. */
+    manifestSha256: string;
+    /** A detached snapshot of the validated manifest. */
+    manifest: Manifest;
+    /** Canonical directory containing the sink's validated files. */
+    outputDir: string;
+    /** Canonical path when the sink manifest publishes `result.json`. */
+    resultPath?: string;
+    /** SHA-256 of the exact `result.json` bytes captured by this projection. */
+    resultSha256?: string;
+    /** Parsed snapshot of `result.json`; prefer this over reopening resultPath. */
+    resultJson?: unknown;
+}
+/**
+ * Reconstruct final sink artifacts without trusting journal-supplied paths.
+ *
+ * This intentionally fails closed when a successful sink's artifact binding
+ * cannot be reproved. Callers receive parsed/hash-bound snapshots so a later
+ * filesystem replacement cannot silently change the delivered result.
+ */
+export declare function readPortableWorkflowFinalOutputs(dag: V3Dag, runDir: string, validateManifest: ValidateManifest): Promise<PortableWorkflowFinalOutput[]>;

package/dist/types/src/workflows/v3/portable-runtime.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Host-neutral adapter for the complete v3 Node runtime.
+ *
+ * The action realization remains single-sourced in shared-node-runtime.ts;
+ * this adapter only translates execution profiles and agent calls.
+ */
+import type { ValidateManifest } from './artifact-contract.js';
+import { type V3Dag } from './dag.js';
+import type { PortableWorkflowFinalOutput } from './portable-final-outputs.js';
+import type { AgentExecutor, AttemptLeaseProvider, ExecutionContextSnapshot, ExecutionProfileSnapshot, GateResolver, HostExecutorRegistry, HostExecutorPolicy, ProviderReconciler } from './runtime-host-contract.js';
+export interface PortableWorkflowPendingGate {
+    nodeId: string;
+    waitId: string;
+    prompt: string;
+    options: string[];
+    approveOptions: string[];
+    approvers: string[];
+    hostApproval?: {
+        attemptId: string;
+        approvalDigest: string;
+        inputHash: string;
+    };
+}
+export { readPortableWorkflowFinalOutputs, } from './portable-final-outputs.js';
+export type { PortableWorkflowFinalOutput, } from './portable-final-outputs.js';
+export type PortableWorkflowRunOutcome = {
+    reason: 'terminal';
+    runStatus: 'succeeded' | 'failed' | 'blocked' | 'cancelled';
+    failedNodeId?: string;
+    blockedNodeId?: string;
+    failureReason?: 'allSinksSkipped';
+    failureDetail?: string;
+    uncertainHostEffects?: Array<{
+        nodeId: string;
+        instanceId: string;
+        attemptId: string;
+        executor: string;
+        errorCode: string;
+    }>;
+    finalOutputs: PortableWorkflowFinalOutput[];
+    runDir: string;
+} | {
+    reason: 'awaitingGate';
+    pendingWaits: PortableWorkflowPendingGate[];
+    runDir: string;
+};
+export interface PortableWorkflowRuntimeDeps {
+    executeAgent: AgentExecutor;
+    validateManifest: ValidateManifest;
+    resolveExecutionProfile: (selector: string | undefined) => ExecutionProfileSnapshot;
+    validateExecutionProfile?: (profile: ExecutionProfileSnapshot, selector: string) => void;
+    /**
+     * Optional only for fresh process-local runs. The default provider cannot
+     * prove old attempts closed after recovery and therefore returns `unknown`.
+     * Desktop and other durable hosts must inject a durable provider.
+     */
+    attemptLeaseProvider?: AttemptLeaseProvider;
+    hostExecutors?: HostExecutorRegistry;
+    hostReconcilers?: Map<string, ProviderReconciler>;
+    hostExecutorPolicy?: HostExecutorPolicy;
+    now?: () => number;
+    resolveGate?: GateResolver;
+}
+export interface PortableWorkflowRuntimeOptions {
+    /**
+     * Durable run root. Reusing the same baseDir + dag.runId formally resumes
+     * the existing journal and does not redispatch settled nodes.
+     */
+    baseDir: string;
+    gateMode?: 'blocking' | 'suspend';
+    globalConcurrency?: number;
+    frozenExecutionProfiles?: ReadonlyMap<string, ExecutionProfileSnapshot>;
+    perProfileConcurrency?: number;
+    perExecutorConcurrency?: number;
+    cancelSignal?: AbortSignal;
+    authorizedArtifacts?: boolean;
+    executionContext?: ExecutionContextSnapshot;
+    /** @deprecated Use `executionContext`. */
+    resolvedWorkflowData?: ExecutionContextSnapshot;
+    hostResponseWaitMs?: number;
+}
+export declare function runPortableWorkflow(dag: V3Dag, deps: PortableWorkflowRuntimeDeps, options: PortableWorkflowRuntimeOptions): Promise<PortableWorkflowRunOutcome>;

package/dist/types/src/workflows/v3/runtime-host-contract.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Host-neutral contracts for embedding the v3 workflow runtime.
+ *
+ * These types deliberately avoid daemon, Lark, worker-fence, and Botmux bot
+ * configuration details. A host may keep its own durable state and adapt it
+ * into this boundary.
+ */
+import type { V3GoalNode } from './dag.js';
+export interface ExecutionContextSnapshot {
+    /** Immutable workflow parameters resolved when the run is authorized. */
+    readonly params: Readonly<Record<string, unknown>>;
+    /** Immutable host identity/context values resolved when the run is authorized. */
+    readonly context: Readonly<Record<string, string>>;
+}
+/**
+ * One scheduler-owned execution lease. The id is durable while the signal is
+ * process-local; hosts should use the id for audit and the signal for teardown.
+ */
+export interface AttemptLease {
+    readonly attemptId: string;
+    readonly signal: AbortSignal;
+    /** Opaque provider token passed from the scheduler to the agent executor. */
+    readonly hostToken?: unknown;
+}
+export type AttemptLeaseCloseReason = 'pre_aborted' | 'setup_failed';
+export interface AttemptLeaseBinding {
+    runId: string;
+    attemptId: string;
+    attemptDir: string;
+}
+export interface AttemptLeaseAcquisition {
+    hostToken?: unknown;
+    /** Preserve the legacy Botmux journal marker without imposing it on hosts. */
+    auditKind: 'workerFence' | 'attemptLease';
+}
+export type AttemptLeaseDrainResult = 
+/** Exact external ownership is proven closed; journal proof precedes finalization. */
+{
+    status: 'closed';
+    finalizeAfterProof(): void;
+}
+/** `pending` is known live ownership; `unknown` means the host cannot prove either state. */
+ | {
+    status: 'pending' | 'unknown';
+};
+export interface AttemptLeaseProvider {
+    /**
+     * Durable/restartable hosts (including Desktop) must back this contract with
+     * host-owned execution state. Recovery may return `closed` only after proving
+     * the exact executor/terminal attempt stopped; `finalizeAfterProof` runs only
+     * after the workflow journal durably records that close.
+     */
+    acquire(binding: AttemptLeaseBinding): AttemptLeaseAcquisition;
+    closeBeforeExecution(binding: AttemptLeaseBinding, acquisition: AttemptLeaseAcquisition, reason: AttemptLeaseCloseReason): void;
+    drainExternallyOwned(binding: AttemptLeaseBinding): AttemptLeaseDrainResult;
+    cleanupSettled(binding: AttemptLeaseBinding, acquisition?: AttemptLeaseAcquisition): void;
+}
+export interface ExecutionProfileSnapshot {
+    /** Stable profile selector frozen for this run. */
+    readonly profileId: string;
+    /** Concurrency/capability domain, e.g. a CLI or remote execution backend. */
+    readonly executorId: string;
+    readonly workingDirectory: string;
+    readonly model?: string;
+    /**
+     * Host-owned, JSON-safe, non-secret adapter configuration. Persist stable
+     * credential references here; the executor resolves live secrets itself.
+     */
+    readonly adapterData?: unknown;
+}
+export interface AgentSessionInfo {
+    sessionId: string;
+    webPort?: number;
+    token?: string;
+}
+export interface AgentExecutionRequest {
+    runId: string;
+    attemptId: string;
+    attemptLease: AttemptLease;
+    node: V3GoalNode;
+    executionProfile: ExecutionProfileSnapshot;
+    runDir: string;
+    attemptDir: string;
+    inputsPath: string;
+    outputDir: string;
+    env: Record<string, string>;
+    timeoutMs: number;
+    onSessionReady?: (info: AgentSessionInfo & {
+        ptyLogPath?: string;
+    }) => void | Promise<void>;
+    stdoutPath?: string;
+    stderrPath?: string;
+}
+export interface AgentExecutionResult {
+    status: 'ok' | 'fail' | 'cancelled';
+    cancelReason?: unknown;
+    manifestPath: string;
+    sessionInfo?: AgentSessionInfo;
+}
+export type AgentExecutor = (request: AgentExecutionRequest) => Promise<AgentExecutionResult>;
+export type ExecutorErrorClassification = {
+    errorCode: string;
+    errorClass: 'retryable' | 'fatal' | 'userFault' | 'manual';
+    errorMessage: string;
+};
+export interface HostSideEffectExecutor<Input = unknown, Output = unknown> {
+    readonly provider: string;
+    readonly idempotencyTtlMs: number;
+    canonicalInput(input: Input): unknown;
+    validateBeforeIntent?(input: Input, nowMs: number): {
+        ok: true;
+    } | {
+        ok: false;
+        errorCode: string;
+        message: string;
+    };
+    invoke(input: Input, idempotencyKey: string): Promise<{
+        output: Output;
+        externalRefs: Record<string, unknown>;
+    }>;
+    classifyError?(error: unknown): ExecutorErrorClassification | null;
+}
+export type RegisteredHostExecutor<Input = unknown, Output = unknown> = {
+    executor: HostSideEffectExecutor<Input, Output>;
+    parseInput(input: unknown): Input;
+};
+export type HostExecutorRegistry = Map<string, RegisteredHostExecutor>;
+export type ReadOnlyLookupResult = {
+    found: true;
+    externalRefs: Record<string, unknown>;
+    evidence?: Record<string, unknown>;
+} | {
+    found: false;
+    evidence?: Record<string, unknown>;
+};
+export type IdempotentSubmitResult = {
+    ok: true;
+    externalRefs: Record<string, unknown>;
+    evidence?: Record<string, unknown>;
+} | {
+    ok: false;
+    errorCode: string;
+    errorClass: 'retryable' | 'fatal' | 'userFault' | 'manual';
+    errorMessage: string;
+    evidence?: Record<string, unknown>;
+};
+export interface ProviderReconciler {
+    readonly provider: string;
+    readonly requiresEffectInput?: boolean;
+    readOnlyLookup?(idempotencyKey: string, input: unknown): Promise<ReadOnlyLookupResult>;
+    idempotentSubmit?(idempotencyKey: string, input: unknown): Promise<IdempotentSubmitResult>;
+    canonicalInput?(input: unknown): unknown;
+}
+export interface HostExecutorPolicyRequest {
+    readonly nodeId: string;
+    readonly executor: string;
+    readonly input: unknown;
+    readonly executionContext?: ExecutionContextSnapshot;
+}
+/**
+ * Synchronous by design: authorization must finish before a prepared host
+ * effect can be committed or presented for approval.
+ */
+export type HostExecutorPolicy = (request: HostExecutorPolicyRequest) => void;
+export interface GateResolutionRequest {
+    nodeId: string;
+    prompt: string;
+    waitId: string;
+    runDir: string;
+    hostApproval?: {
+        attemptId: string;
+        approvalDigest: string;
+        inputHash: string;
+    };
+}
+export interface GateResolution {
+    resolution: 'approved' | 'rejected';
+    by: string;
+    selected?: string;
+}
+export type GateResolver = (request: GateResolutionRequest) => Promise<GateResolution>;

package/dist/types/src/workflows/v3/shared-runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Supported daemon-independent v3 workflow surface.
+ *
+ * Keep this module limited to schema, pure scheduling/control policy, and
+ * host contracts. Node filesystem stores and Botmux/Lark adapters live behind
+ * separate modules.
+ */
+export { DEFAULT_HUMAN_GATE_OPTIONS, DEFAULT_REVISIT_BUDGET_PER_PAIR, DEFAULT_REVISIT_BUDGET_PER_RUN, isGoalNode, isHostNode, isLoopNode, loopInstanceId, topologicalOrder, validateDag, } from './dag.js';
+export type { V3Dag, V3DependRef, V3EdgeWhen, V3GoalNode, V3HostNode, V3HumanGate, V3LoopExitWhen, V3LoopNode, V3Node, V3TriggerRule, } from './dag.js';
+export { decideNext, findSinks, } from './orchestrator.js';
+export type { V3Action, V3EdgeRunState, V3LoopRunState, V3NodeState, V3NodeStatus, V3RunState, } from './orchestrator.js';
+export { matchLoopExitWhen, revisitBudgetStatus, } from './core-control.js';
+export { canResolveGateWait, normalizeGateWaitInput, selectedResolution, } from './gate-policy.js';
+export type { NormalizedGatePolicy } from './gate-policy.js';
+export type { AttemptLease, ExecutionContextSnapshot, GateResolution, GateResolutionRequest, GateResolver, HostExecutorPolicy, HostExecutorPolicyRequest, } from './runtime-host-contract.js';
+export type { StoredEvent, V3Event, V3LoopRef, } from './event-contract.js';

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "botmux-workflow-core",
+  "version": "3.10.0",
+  "description": "Daemon-independent Workflow v3 schema, scheduler, control policy, and host contracts",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/packages/workflow-core/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/packages/workflow-core/src/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    },
+    "./schema": {
+      "types": "./dist/types/packages/workflow-core/src/schema.d.ts",
+      "import": "./dist/esm/schema.js",
+      "require": "./dist/cjs/schema.cjs"
+    },
+    "./engine": {
+      "types": "./dist/types/packages/workflow-core/src/engine.d.ts",
+      "import": "./dist/esm/engine.js",
+      "require": "./dist/cjs/engine.cjs"
+    },
+    "./control": {
+      "types": "./dist/types/packages/workflow-core/src/control.d.ts",
+      "import": "./dist/esm/control.js",
+      "require": "./dist/cjs/control.cjs"
+    },
+    "./gate-policy": {
+      "types": "./dist/types/packages/workflow-core/src/gate-policy.d.ts",
+      "import": "./dist/esm/gate-policy.js",
+      "require": "./dist/cjs/gate-policy.cjs"
+    },
+    "./host-contract": {
+      "types": "./dist/types/packages/workflow-core/src/host-contract.d.ts",
+      "import": "./dist/esm/host-contract.js",
+      "require": "./dist/cjs/host-contract.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/types/packages/workflow-core/src/runtime.d.ts",
+      "import": "./dist/esm/runtime.js",
+      "require": "./dist/cjs/runtime.cjs"
+    },
+    "./events": {
+      "types": "./dist/types/packages/workflow-core/src/events.d.ts",
+      "import": "./dist/esm/events.js",
+      "require": "./dist/cjs/events.cjs"
+    },
+    "./host-bindings": {
+      "types": "./dist/types/packages/workflow-core/src/host-bindings.d.ts",
+      "import": "./dist/esm/host-bindings.js",
+      "require": "./dist/cjs/host-bindings.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/build-workflow-core-package.mjs",
+    "test": "pnpm run build && node ../../scripts/test-workflow-core-package.mjs",
+    "pack:local": "pnpm run build && node ../../scripts/pack-workflow-core-package.mjs",
+    "prepare": "pnpm run build",
+    "prepublishOnly": "pnpm run test"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.19",
+    "esbuild": "0.28.0",
+    "typescript": "5.9.3"
+  },
+  "license": "MIT"
+}