veryfront 0.1.1047 → 0.1.1049

package/esm/src/workflow/executor/workflow-executor.js

@@ -21,6 +21,8 @@ const logger = baseLogger.component("workflow-executor");
 const DEFAULT_RESULT_POLL_INTERVAL_MS = 1_000;
 /** Default max time waitForResult() polls before giving up (5 minutes) */
 const DEFAULT_RESULT_WAIT_TIMEOUT_MS = 5 * 60 * 1_000;
+/** Time allowed for an aborted graph to finish its cooperative cleanup. */
+const DEFAULT_CANCELLATION_GRACE_PERIOD_MS = 1_000;
 /**
  * Workflow Executor class
  *
@@ -38,10 +40,8 @@ export class WorkflowExecutor {
     // deno-lint-ignore no-explicit-any -- type-erased registry: register() accepts WorkflowDefinition<TInput, TOutput> with arbitrary type params
     workflows = new Map();
     blobResolver;
-    /** Runs cancelled in-process; guards terminal writes from clobbering "cancelled". */
-    cancelledRuns = new Set();
-    /** Per-run aborters that stop in-flight execution when cancel() is called. */
-    cancelSignals = new Map();
+    activeRunControllers = new Map();
+    cancellationUpdates = new Map();
     /** Default lock duration: 30 seconds */
     static DEFAULT_LOCK_DURATION = 30_000;
     /** Heartbeat interval for long-running workflow liveness tracking */
@@ -54,6 +54,7 @@ export class WorkflowExecutor {
             ...config,
         };
         this.stepExecutor = new StepExecutor({
+            cancellationGracePeriod: this.config.cancellationGracePeriod,
             ...this.config.stepExecutor,
             blobStorage: this.config.blobStorage,
         });
@@ -196,23 +197,14 @@ export class WorkflowExecutor {
         const useLocking = this.config.enableLocking !== false && hasLockSupport(this.config.backend);
         const lockDuration = this.config.lockDuration ?? WorkflowExecutor.DEFAULT_LOCK_DURATION;
         let heartbeatInterval;
-        let heartbeatInFlight = false;
+        let heartbeatPromise;
         // If the heartbeat can no longer extend our lock, another worker may claim
-        // this run as stalled and execute it concurrently. We abort as soon as that
-        // happens: lockLostError, once set, is raced against the DAG execution so we
-        // stop acting on the run and skip writing any terminal status (which would
-        // clobber the new owner's progress).
+        // this run as stalled and execute it concurrently. Abort the DAG as soon as
+        // that happens, then wait for it to settle before releasing the lock. The
+        // new owner remains responsible for the terminal status.
         let lockLostError;
-        let signalLockLost;
-        const lockLostPromise = new Promise((_, reject) => {
-            signalLockLost = () => reject(lockLostError ??
-                ORCHESTRATION_ERROR.create({ detail: `Lost lock for run "${runId}"` }));
-        });
-        // Never let this reject go unobserved if execution finishes first.
-        lockLostPromise.catch(() => { });
-        // Acquire the lock BEFORE registering any per-run state (cancelSignals). If
-        // acquisition fails we throw here, and registering the cancel signal earlier
-        // would leak it (and later poison cancelledRuns) on every lost lock race.
+        // Acquire the lock before registering the per-run controller. A failed
+        // acquisition must not replace or leak active execution state.
         let lockToken = null;
         if (useLocking) {
             lockToken = await this.config.backend.acquireLock(runId, lockDuration);
@@ -224,18 +216,13 @@ export class WorkflowExecutor {
             }
             logger.debug("Acquired lock for run", { runId });
         }
-        // Cancellation: cancel() writes "cancelled" to the backend and triggers this
-        // signal so in-flight execution stops promptly (raced against DAG execution,
-        // mirroring the lock-lost abort). Once aborted we skip writing any terminal
-        // status so we don't clobber the persisted "cancelled" state. Registered only
-        // after a successful lock acquire so it is always cleaned up by the finally.
-        let signalCancelled;
-        const cancelledPromise = new Promise((_, reject) => {
-            signalCancelled = () => reject(ORCHESTRATION_ERROR.create({ detail: `Workflow run "${runId}" was cancelled` }));
-        });
-        cancelledPromise.catch(() => { });
-        this.cancelSignals.set(runId, () => signalCancelled?.());
+        const executionController = new AbortController();
+        this.activeRunControllers.set(runId, executionController);
         try {
+            const currentRun = await this.config.backend.getRun(runId);
+            if (currentRun?.status === "cancelled" || executionController.signal.aborted ||
+                !this.isCurrentExecution(runId, executionController))
+                return;
             const now = new Date();
             await this.config.backend.updateRun(runId, {
                 status: "running",
@@ -243,33 +230,56 @@ export class WorkflowExecutor {
                 heartbeatAt: now,
             });
             heartbeatInterval = dntShim.setInterval(() => {
-                if (heartbeatInFlight)
+                if (heartbeatPromise)
                     return;
-                heartbeatInFlight = true;
-                void (async () => {
-                    try {
-                        await this.config.backend.updateRun(runId, {
-                            heartbeatAt: new Date(),
-                        });
-                        if (useLocking && typeof this.config.backend.extendLock === "function") {
-                            const extended = await this.config.backend.extendLock(runId, lockDuration);
-                            if (!extended && !lockLostError) {
+                heartbeatPromise = (async () => {
+                    if (executionController.signal.aborted ||
+                        !this.isCurrentExecution(runId, executionController))
+                        return;
+                    if (useLocking && typeof this.config.backend.extendLock === "function") {
+                        let extended;
+                        try {
+                            extended = await this.config.backend.extendLock(runId, lockDuration);
+                        }
+                        catch (error) {
+                            if (!lockLostError) {
                                 lockLostError = ORCHESTRATION_ERROR.create({
-                                    detail: `Lost lock for run "${runId}" during heartbeat; aborting to avoid ` +
+                                    detail: `Could not renew lock for run "${runId}"; aborting to avoid ` +
                                         `concurrent execution by another worker.`,
+                                    cause: error instanceof Error ? error : undefined,
                                 });
-                                logger.error("Lost workflow lock; aborting run", { runId });
+                                logger.error("Could not renew workflow lock; aborting run", { runId }, error);
                                 if (heartbeatInterval)
                                     clearInterval(heartbeatInterval);
-                                signalLockLost?.();
+                                executionController.abort(lockLostError);
                             }
+                            return;
+                        }
+                        if (!extended && !lockLostError) {
+                            lockLostError = ORCHESTRATION_ERROR.create({
+                                detail: `Lost lock for run "${runId}" during heartbeat; aborting to avoid ` +
+                                    `concurrent execution by another worker.`,
+                            });
+                            logger.error("Lost workflow lock; aborting run", { runId });
+                            if (heartbeatInterval)
+                                clearInterval(heartbeatInterval);
+                            executionController.abort(lockLostError);
+                            return;
                         }
                     }
+                    if (executionController.signal.aborted ||
+                        !this.isCurrentExecution(runId, executionController))
+                        return;
+                    try {
+                        await this.config.backend.updateRun(runId, {
+                            heartbeatAt: new Date(),
+                        });
+                    }
                     catch (error) {
                         logger.warn("Heartbeat update failed", { runId }, error);
                     }
                     finally {
-                        heartbeatInFlight = false;
+                        heartbeatPromise = undefined;
                     }
                 })();
             }, WorkflowExecutor.HEARTBEAT_INTERVAL_MS);
@@ -282,16 +292,19 @@ export class WorkflowExecutor {
                     context: { ...run.context, _tenant: run._tenant },
                 }
                 : run;
-            const result = await runWithWorkflowTenant(run._tenant, () => this.executeWithTimeout(() => Promise.race([
-                this.dagExecutor.execute(nodes, runWithTenantContext, startFromNode),
-                lockLostPromise,
-                cancelledPromise,
-            ]), workflow.timeout));
+            const result = await runWithWorkflowTenant(run._tenant, () => this.executeWithTimeout(() => this.dagExecutor.execute(nodes, runWithTenantContext, startFromNode, executionController.signal), workflow.timeout, executionController));
+            if (executionController.signal.aborted) {
+                await this.waitForCancellationUpdate(runId);
+                const latestRun = await this.config.backend.getRun(runId);
+                if (latestRun?.status === "cancelled")
+                    return;
+                executionController.signal.throwIfAborted();
+            }
             if (result.completed) {
-                const finalRun = await this.completeRun(runId, result.context, result.nodeStates);
-                // A concurrent cancel() may have won: completeRun leaves the "cancelled"
-                // status intact, so don't run completion side-effects in that case.
-                if (this.cancelledRuns.has(runId) || finalRun.status === "cancelled")
+                const finalRun = await this.completeRun(runId, result.context, result.nodeStates, executionController);
+                if (!finalRun)
+                    return;
+                if (finalRun.status === "cancelled")
                     return;
                 workflow.outputSchema?.parse(finalRun.output);
                 await workflow.onComplete?.(finalRun.output, finalRun.context);
@@ -299,28 +312,21 @@ export class WorkflowExecutor {
                 return;
             }
             if (result.waiting) {
-                await this.pauseRun(runId, result.waitingNode, result.context, result.nodeStates);
+                const paused = await this.pauseRun(runId, result.waitingNode, result.context, result.nodeStates, executionController);
+                if (!paused)
+                    return;
                 const pausedRun = await this.config.backend.getRun(runId);
                 this.config.onWaiting?.(pausedRun, result.waitingNode);
                 return;
             }
-            // A concurrent cancel() takes precedence over a failure result.
-            if (this.cancelledRuns.has(runId))
-                return;
             const error = ORCHESTRATION_ERROR.create({ detail: result.error || "Unknown error" });
-            await this.failRun(runId, error, result.context, result.nodeStates);
+            if (!(await this.failRun(runId, error, result.context, result.nodeStates, executionController)))
+                return;
             await workflow.onError?.(error, result.context);
             this.config.onError?.(run, error);
         }
         catch (error) {
             const normalizedError = ensureError(error);
-            // Cancelled in-process: cancel() already persisted the "cancelled" status
-            // (and likely triggered this abort). Do not write a terminal status or fire
-            // error callbacks — that would clobber the cancellation.
-            if (this.cancelledRuns.has(runId)) {
-                logger.warn("Run cancelled; leaving cancelled status for run", { runId });
-                return;
-            }
             // Lock lost: we no longer own the run, so a new owner (via stalled-run
             // recovery) is responsible for it. Do NOT write a terminal status here or
             // we would overwrite that worker's progress. Just release and rethrow.
@@ -328,7 +334,12 @@ export class WorkflowExecutor {
                 logger.warn("Aborted run after losing lock; leaving status for new owner", { runId });
                 throw lockLostError;
             }
-            await this.failRun(runId, normalizedError, run.context, run.nodeStates);
+            await this.waitForCancellationUpdate(runId);
+            const latestRun = await this.config.backend.getRun(runId);
+            if (latestRun?.status === "cancelled")
+                return;
+            if (!(await this.failRun(runId, normalizedError, run.context, run.nodeStates, executionController)))
+                return;
             await workflow.onError?.(normalizedError, run.context);
             this.config.onError?.(run, normalizedError);
             throw normalizedError;
@@ -337,9 +348,18 @@ export class WorkflowExecutor {
             if (heartbeatInterval) {
                 clearInterval(heartbeatInterval);
             }
-            this.cancelSignals.delete(runId);
-            this.cancelledRuns.delete(runId);
-            if (useLocking && lockToken) {
+            if (heartbeatPromise) {
+                if (executionController.signal.aborted) {
+                    await this.waitForCancellationGrace(heartbeatPromise);
+                }
+                else {
+                    await heartbeatPromise;
+                }
+            }
+            if (this.activeRunControllers.get(runId) === executionController) {
+                this.activeRunControllers.delete(runId);
+            }
+            if (useLocking && !lockLostError && lockToken) {
                 await this.config.backend.releaseLock(runId, lockToken);
                 logger.debug("Released lock for run", { runId });
             }
@@ -409,32 +429,79 @@ export class WorkflowExecutor {
      * Uses Promise.race() to properly handle timeout cleanup.
      * The timeout is always cleared in the finally block to prevent memory leaks.
      */
-    async executeWithTimeout(fn, timeout) {
-        if (!timeout)
-            return fn();
-        const timeoutMs = parseDuration(timeout);
+    async executeWithTimeout(fn, timeout, executionController) {
+        executionController.signal.throwIfAborted();
+        const operation = Promise.resolve().then(fn);
+        const fencedOperation = operation.then((value) => {
+            executionController.signal.throwIfAborted();
+            return value;
+        });
         let timeoutId;
-        const timeoutPromise = new Promise((_, reject) => {
+        let rejectAbort;
+        const abortPromise = new Promise((_, reject) => {
+            rejectAbort = () => reject(executionController.signal.reason);
+            if (executionController.signal.aborted)
+                rejectAbort();
+            else
+                executionController.signal.addEventListener("abort", rejectAbort, { once: true });
+        });
+        if (timeout) {
+            const timeoutMs = parseDuration(timeout);
+            const timeoutError = TIMEOUT_ERROR.create({
+                detail: `Workflow timed out after ${timeoutMs}ms`,
+            });
             timeoutId = dntShim.setTimeout(() => {
-                reject(TIMEOUT_ERROR.create({ detail: `Workflow timed out after ${timeoutMs}ms` }));
+                if (!executionController.signal.aborted)
+                    executionController.abort(timeoutError);
             }, timeoutMs);
-        });
+        }
         try {
-            return await Promise.race([fn(), timeoutPromise]);
+            return await Promise.race([fencedOperation, abortPromise]);
+        }
+        catch (error) {
+            if (executionController.signal.aborted) {
+                await this.waitForCancellationGrace(fencedOperation);
+            }
+            throw error;
         }
         finally {
             if (timeoutId !== undefined)
                 clearTimeout(timeoutId);
+            if (rejectAbort)
+                executionController.signal.removeEventListener("abort", rejectAbort);
+        }
+    }
+    async waitForCancellationGrace(operation) {
+        const gracePeriod = Math.max(0, this.config.cancellationGracePeriod ?? DEFAULT_CANCELLATION_GRACE_PERIOD_MS);
+        let graceTimeoutId;
+        const settled = operation.then(() => undefined, () => undefined);
+        const graceExpired = new Promise((resolve) => {
+            graceTimeoutId = dntShim.setTimeout(resolve, gracePeriod);
+        });
+        try {
+            await Promise.race([settled, graceExpired]);
+        }
+        finally {
+            if (graceTimeoutId !== undefined)
+                clearTimeout(graceTimeoutId);
         }
     }
+    isCurrentExecution(runId, controller) {
+        return this.activeRunControllers.get(runId) === controller;
+    }
     /**
      * Mark run as completed
      */
-    async completeRun(runId, context, nodeStates) {
-        // Don't overwrite a run that was cancelled out from under us.
-        const current = await this.config.backend.getRun(runId);
-        if (current?.status === "cancelled")
-            return current;
+    async completeRun(runId, context, nodeStates, executionController) {
+        await this.waitForCancellationUpdate(runId);
+        const currentRun = await this.config.backend.getRun(runId);
+        if (!currentRun)
+            throw RESOURCE_NOT_FOUND.create({ detail: `Run not found: ${runId}` });
+        if (currentRun.status === "cancelled")
+            return currentRun;
+        if (executionController.signal.aborted ||
+            !this.isCurrentExecution(runId, executionController))
+            return null;
         const publicContext = this.toPublicContext(context);
         const output = this.determineOutput(publicContext);
         await this.config.backend.updateRun(runId, {
@@ -449,11 +516,13 @@ export class WorkflowExecutor {
     /**
      * Mark run as failed
      */
-    async failRun(runId, error, context, nodeStates) {
-        // Don't overwrite a run that was cancelled out from under us.
-        const current = await this.config.backend.getRun(runId);
-        if (current?.status === "cancelled")
-            return;
+    async failRun(runId, error, context, nodeStates, executionController) {
+        await this.waitForCancellationUpdate(runId);
+        const currentRun = await this.config.backend.getRun(runId);
+        if (currentRun?.status === "cancelled")
+            return false;
+        if (!this.isCurrentExecution(runId, executionController))
+            return false;
         const publicContext = this.toPublicContext(context);
         await this.config.backend.updateRun(runId, {
             status: "failed",
@@ -465,11 +534,19 @@ export class WorkflowExecutor {
             },
             completedAt: new Date(),
         });
+        return true;
     }
     /**
      * Mark run as waiting
      */
-    async pauseRun(runId, waitingNode, context, nodeStates) {
+    async pauseRun(runId, waitingNode, context, nodeStates, executionController) {
+        await this.waitForCancellationUpdate(runId);
+        const currentRun = await this.config.backend.getRun(runId);
+        if (currentRun?.status === "cancelled")
+            return false;
+        if (executionController.signal.aborted ||
+            !this.isCurrentExecution(runId, executionController))
+            return false;
         const publicContext = this.toPublicContext(context);
         await this.config.backend.updateRun(runId, {
             status: "waiting",
@@ -477,6 +554,7 @@ export class WorkflowExecutor {
             context: publicContext,
             nodeStates,
         });
+        return true;
     }
     /**
      * Remove execution-only metadata before exposing or persisting workflow context.
@@ -545,20 +623,23 @@ export class WorkflowExecutor {
                     `Only active runs (pending, running, waiting) can be cancelled.`,
             });
         }
-        // If this process is running the run, mark it cancelled before persisting so
-        // its in-flight executeAsync() sees the flag when the abort fires and skips
-        // writing a terminal status. Runs executing elsewhere are still protected by
-        // the cancelled-status re-read in completeRun()/failRun().
-        const activeAbort = this.cancelSignals.get(runId);
-        if (activeAbort)
-            this.cancelledRuns.add(runId);
-        await this.config.backend.updateRun(runId, {
+        const cancellationUpdate = Promise.resolve().then(() => this.config.backend.updateRun(runId, {
             status: "cancelled",
             completedAt: new Date(),
-        });
-        // Abort in-flight execution so it stops promptly instead of running to
-        // completion and clobbering the cancelled status.
-        activeAbort?.();
+        }));
+        this.cancellationUpdates.set(runId, cancellationUpdate);
+        this.activeRunControllers.get(runId)?.abort(ORCHESTRATION_ERROR.create({ detail: `Workflow run "${runId}" was cancelled` }));
+        try {
+            await cancellationUpdate;
+        }
+        finally {
+            if (this.cancellationUpdates.get(runId) === cancellationUpdate) {
+                this.cancellationUpdates.delete(runId);
+            }
+        }
+    }
+    async waitForCancellationUpdate(runId) {
+        await this.cancellationUpdates.get(runId);
     }
     /**
      * Get workflow run status

package/esm/src/workflow/react/use-approval.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "../../../react/react.js";
+import { useCallback, useEffect, useState } from "react";
 import { REQUEST_ERROR } from "../../errors/error-registry.js";
 /** Manage workflow approval interactions. */
 export function useApproval(options) {

package/esm/src/workflow/react/use-workflow-list.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "../../../react/react.js";
+import { useCallback, useEffect, useState } from "react";
 import { REQUEST_ERROR } from "../../errors/error-registry.js";
 /** Default interval for auto-refreshing the workflow list */
 const DEFAULT_REFRESH_INTERVAL_MS = 5_000;

package/esm/src/workflow/react/use-workflow-start.js

@@ -1,4 +1,4 @@
-import { useCallback, useState } from "../../../react/react.js";
+import { useCallback, useState } from "react";
 import { REQUEST_ERROR } from "../../errors/error-registry.js";
 /** React hook for workflow start. */
 export function useWorkflowStart(options) {

package/esm/src/workflow/react/use-workflow.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "../../../react/react.js";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { ORCHESTRATION_ERROR, REQUEST_ERROR } from "../../errors/error-registry.js";
 /** Default polling interval for workflow status updates */
 const DEFAULT_POLL_INTERVAL_MS = 2_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.1047",
+  "version": "0.1.1049",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",
@@ -322,7 +322,6 @@
   "dependencies": {
     "react": "19.2.4",
     "react-dom": "19.2.4",
-    "scheduler": "0.27.0",
     "zod": "4.3.6",
     "@deno/shim-deno": "0.18.0",
     "@deno/shim-crypto": "0.3.1",
@@ -330,9 +329,9 @@
     "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "ws": "8.21.0",
-    "@veryfront/ext-bundler-esbuild": "0.1.1047",
-    "@veryfront/ext-content-mdx": "0.1.1047",
-    "@veryfront/ext-css-tailwind": "0.1.1047"
+    "@veryfront/ext-bundler-esbuild": "0.1.1049",
+    "@veryfront/ext-content-mdx": "0.1.1049",
+    "@veryfront/ext-css-tailwind": "0.1.1049"
   },
   "devDependencies": {
     "@types/node": "20.9.0"

package/esm/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react-dom@19.2.4/client.d.ts */
-export * from "react-dom/client";
-export { default } from "react-dom/client";

package/esm/deps/esm.sh/react-dom@19.2.4/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react-dom@19.2.4/client.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react-dom@19.2.4/client.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react-dom@19.2.4/client.js */
-export * from "react-dom/client";
-export { default } from "react-dom/client";

package/esm/deps/esm.sh/react-dom@19.2.4/server.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react-dom@19.2.4/server.d.ts */
-export * from "react-dom/server";
-export { default } from "react-dom/server";

package/esm/deps/esm.sh/react-dom@19.2.4/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react-dom@19.2.4/server.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react-dom@19.2.4/server.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react-dom@19.2.4/server.js */
-export * from "react-dom/server";
-export { default } from "react-dom/server";

package/esm/deps/esm.sh/react-dom@19.2.4.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react-dom@19.2.4.d.ts */
-export * from "react-dom";
-export { default } from "react-dom";

package/esm/deps/esm.sh/react-dom@19.2.4.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-dom@19.2.4.d.ts","sourceRoot":"","sources":["../../../src/deps/esm.sh/react-dom@19.2.4.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react-dom@19.2.4.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react-dom@19.2.4.js */
-export * from "react-dom";
-export { default } from "react-dom";

package/esm/deps/esm.sh/react@19.2.4/jsx-dev-runtime.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react@19.2.4/jsx-dev-runtime.d.ts */
-export * from "react/jsx-dev-runtime";
-export { default } from "react/jsx-dev-runtime";

package/esm/deps/esm.sh/react@19.2.4/jsx-dev-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx-dev-runtime.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react@19.2.4/jsx-dev-runtime.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react@19.2.4/jsx-dev-runtime.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react@19.2.4/jsx-dev-runtime.js */
-export * from "react/jsx-dev-runtime";
-export { default } from "react/jsx-dev-runtime";

package/esm/deps/esm.sh/react@19.2.4/jsx-runtime.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react@19.2.4/jsx-runtime.d.ts */
-export * from "react/jsx-runtime";
-export { default } from "react/jsx-runtime";

package/esm/deps/esm.sh/react@19.2.4/jsx-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react@19.2.4/jsx-runtime.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react@19.2.4/jsx-runtime.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react@19.2.4/jsx-runtime.js */
-export * from "react/jsx-runtime";
-export { default } from "react/jsx-runtime";

package/esm/deps/esm.sh/react@19.2.4.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react@19.2.4.d.ts */
-export * from "react";
-export { default } from "react";

package/esm/deps/esm.sh/react@19.2.4.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react@19.2.4.d.ts","sourceRoot":"","sources":["../../../src/deps/esm.sh/react@19.2.4.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react@19.2.4.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh react@19.2.4.js */
-export * from "react";
-export { default } from "react";

package/esm/deps/esm.sh/scheduler@^0.27.0.d.ts

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh scheduler@^0.27.0.d.ts */
-export * from "scheduler";
-export { default } from "scheduler";

package/esm/deps/esm.sh/scheduler@^0.27.0.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler@^0.27.0.d.ts","sourceRoot":"","sources":["../../../src/deps/esm.sh/scheduler@^0.27.0.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/scheduler@^0.27.0.js

@@ -1,3 +0,0 @@
-/* npm package shim for esm.sh scheduler@^0.27.0.js */
-export * from "scheduler";
-export { default } from "scheduler";

package/esm/react/jsx-dev-runtime.d.ts

@@ -1,2 +0,0 @@
-export * from "../deps/esm.sh/react@19.2.4/jsx-dev-runtime.js";
-//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/esm/react/jsx-dev-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx-dev-runtime.d.ts","sourceRoot":"","sources":["../../src/react/jsx-dev-runtime.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC"}

package/esm/react/jsx-dev-runtime.js

@@ -1 +0,0 @@
-export * from "../deps/esm.sh/react@19.2.4/jsx-dev-runtime.js";

package/esm/react/jsx-runtime.d.ts

@@ -1,2 +0,0 @@
-export * from "../deps/esm.sh/react@19.2.4/jsx-runtime.js";
-//# sourceMappingURL=jsx-runtime.d.ts.map

package/esm/react/jsx-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../../src/react/jsx-runtime.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC"}

package/esm/react/jsx-runtime.js

@@ -1 +0,0 @@
-export * from "../deps/esm.sh/react@19.2.4/jsx-runtime.js";

package/esm/react/react-dom-client.d.ts

@@ -1,3 +0,0 @@
-export * from "../deps/esm.sh/react-dom@19.2.4/client.js";
-export { default } from "../deps/esm.sh/react-dom@19.2.4/client.js";
-//# sourceMappingURL=react-dom-client.d.ts.map

package/esm/react/react-dom-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-dom-client.d.ts","sourceRoot":"","sources":["../../src/react/react-dom-client.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC"}

package/esm/react/react-dom-client.js

@@ -1,2 +0,0 @@
-export * from "../deps/esm.sh/react-dom@19.2.4/client.js";
-export { default } from "../deps/esm.sh/react-dom@19.2.4/client.js";

package/esm/react/react-dom-server.d.ts

@@ -1,3 +0,0 @@
-export * from "../deps/esm.sh/react-dom@19.2.4/server.js";
-export { default } from "../deps/esm.sh/react-dom@19.2.4/server.js";
-//# sourceMappingURL=react-dom-server.d.ts.map

package/esm/react/react-dom-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-dom-server.d.ts","sourceRoot":"","sources":["../../src/react/react-dom-server.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC"}