@workflow/core 5.0.0-beta.5 → 5.0.0-beta.50

package/dist/runtime/wait-continuation.js

@@ -0,0 +1,136 @@
+/**
+ * Wait-continuation dispatch: delay + idempotency-key selection.
+ *
+ * When V2 suspension processing observes a pending wait, it enqueues a
+ * delayed "continuation" message that fires once the wait elapses and
+ * drives the next replay (which completes the wait via the "complete
+ * elapsed waits" pass). This module decides the message's `delaySeconds`
+ * and `idempotencyKey`.
+ *
+ * The continuation is keyed on the wait's correlationId: while a wait is
+ * pending, every replay pass over the run re-observes it (e.g., once per
+ * step completion in `Promise.all([steps..., sleep()])`), and without
+ * dedupe each pass would enqueue another delayed continuation: each one
+ * a spurious full replay when the wait elapses, and each a fresh message
+ * that resets the delivery-attempt runaway guard. A key is attached in
+ * all cases: some worlds (e.g. world-postgres) serialize key-less
+ * workflow messages per run, which would park the continuation behind
+ * the handler's own inline step execution and defeat the race semantics
+ * the continuation exists to provide.
+ *
+ * The bare correlationId cannot be the key in every case, though: world
+ * dedupe windows outlive the first delivery (VQS keeps idempotency
+ * records until message-retention TTL; world-postgres keeps a
+ * completed-keys cache), so once a key has been used, a later enqueue
+ * under the same key is silently dropped. Any situation where a
+ * continuation is delivered while its wait is still pending therefore
+ * needs a fresh key for the re-enqueue, or the wait's timer is lost and
+ * the run stalls until unrelated traffic happens to wake it. Two such
+ * situations exist, each with its own key variation:
+ *
+ * - Waits longer than the maximum queue delay are chained: the delay is
+ *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h: VQS messages
+ *   have a 24h retention limit, and one hour of buffer matches
+ *   world-vercel's own clamp for delayed re-enqueues), so the
+ *   continuation intentionally fires early, re-observes the wait, and
+ *   must enqueue the next hop. The key is suffixed with the hop index
+ *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation
+ *   within the same hop window (so passes dedupe), decremented at each
+ *   hop delivery (so the chain always advances). Worlds without a delay
+ *   limit (world-postgres, world-local) take the same ≤23h hops.
+ *
+ * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A
+ *   continuation delivered marginally early (clock skew between the
+ *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0
+ *   margin) re-observes the wait as pending with ~1s remaining and must
+ *   be able to enqueue a fresh short-delay retry. The bucket suffix
+ *   keeps that retry enqueueable (its ≥1s delay guarantees a later
+ *   bucket) while still collapsing same-instant duplicates.
+ *
+ * Mid-range waits (more than the near-elapsed threshold, at most one
+ * hop) use the bare correlationId: every re-observation targets the same
+ * deadline, so deduping to the first message is semantically lossless.
+ *
+ * That last case used to be the one hole in the scheme, and it was not
+ * theoretical. Any delivery early enough to re-observe its own wait as
+ * pending burns the bare key on the way in: the re-enqueue is dropped by
+ * the dedupe window, nothing else is scheduled to wake the run, and no
+ * backstop exists for a wait the way inline step ownership provides one
+ * for a step. The run sleeps forever. Waits over the threshold have zero
+ * tolerance for it, which is why an infrastructure change in delivery
+ * timing was able to strand runs across every published SDK version at
+ * once, all of them keyed this way.
+ *
+ * So the key is no longer derived from the wait alone. A continuation
+ * carries the wait it was armed for and its attempt number
+ * ({@link WorkflowInvokePayload.waitContinuation}), and an invocation
+ * that recognizes itself as the continuation for a wait that is still
+ * pending arms the next one at `attempt + 1`. Attempts advance ONLY when
+ * an early delivery actually happens, so the normal path is untouched:
+ * attempt 0 keys exactly as before, and every re-observation within one
+ * attempt still collapses to a single message.
+ */
+import { envNumber } from '@workflow/world';
+/**
+ * Maximum `delaySeconds` for a single wait-continuation message. Waits
+ * longer than this are chained across multiple hops. 23 hours leaves a 1h
+ * buffer under Vercel Queues' default 24h message TTL and mirrors
+ * world-vercel's `MAX_DELAY_SECONDS`.
+ */
+export const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82_800;
+/**
+ * Waits with at most this many seconds remaining use a second-bucketed
+ * idempotency key so an early-delivered continuation can re-enqueue its
+ * short-delay retry. This is also the host clock-skew tolerance for
+ * mid-range waits keyed on the bare correlationId.
+ */
+export const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;
+/** Effective max continuation delay. Override: `WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS`. */
+const getWaitContinuationMaxDelaySeconds = () => envNumber('WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS', WAIT_CONTINUATION_MAX_DELAY_SECONDS, { integer: true, min: 1 });
+/** Effective near-elapsed threshold. Override: `WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS`. */
+const getNearElapsedWaitThresholdSeconds = () => envNumber('WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS', NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS);
+/**
+ * Computes the queue delay and idempotency key for a wait-continuation
+ * message. `timeoutSeconds` is the time until the wait's `resumeAt`
+ * (floored at 1s by the suspension handler); `waitCorrelationId`
+ * identifies the wait so repeated suspension passes dedupe.
+ *
+ * `attempt` is the number of continuations already spent on this wait, taken
+ * from the incoming message when this invocation IS one of them (see
+ * {@link WorkflowInvokePayload.waitContinuation}). It only ever moves when a
+ * continuation arrived before its wait elapsed, which is exactly when the
+ * previous key is spent and re-using it would drop the message. Attempt 0
+ * keys identically to the scheme before attempts existed, so the ordinary
+ * path — arm once, deliver once, complete — is byte-for-byte unchanged.
+ */
+export function getWaitContinuationDispatch(timeoutSeconds, waitCorrelationId, now = Date.now(), attempt = 0) {
+    const dispatch = waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now);
+    if (attempt <= 0)
+        return dispatch;
+    return {
+        delaySeconds: dispatch.delaySeconds,
+        idempotencyKey: `${dispatch.idempotencyKey}:a${attempt}`,
+    };
+}
+function waitContinuationDispatchForAttemptZero(timeoutSeconds, waitCorrelationId, now) {
+    const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();
+    // The near-elapsed branch returns the full remaining time as the delay, so
+    // its threshold can never exceed the max delay. Otherwise a wait between the
+    // max and the threshold would be dispatched with a delay above the max. Cap
+    // the threshold at the max so every branch yields a delay within it. (With
+    // defaults, threshold 2s and max 82_800s, this is a no-op; it only bites
+    // when the max is tuned down below the threshold for testing.)
+    const nearElapsedThreshold = Math.min(getNearElapsedWaitThresholdSeconds(), maxDelaySeconds);
+    if (timeoutSeconds <= nearElapsedThreshold) {
+        return {
+            delaySeconds: timeoutSeconds,
+            idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,
+        };
+    }
+    const hop = Math.ceil(timeoutSeconds / maxDelaySeconds);
+    return {
+        delaySeconds: Math.min(timeoutSeconds, maxDelaySeconds),
+        idempotencyKey: hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait-continuation.js","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAErD,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,EACnC,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AAEJ,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,CACpC,CAAC;AAOJ;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,2BAA2B,CACzC,cAAsB,EACtB,iBAAyB,EACzB,MAAc,IAAI,CAAC,GAAG,EAAE,EACxB,OAAO,GAAG,CAAC;IAEX,MAAM,QAAQ,GAAG,sCAAsC,CACrD,cAAc,EACd,iBAAiB,EACjB,GAAG,CACJ,CAAC;IACF,IAAI,OAAO,IAAI,CAAC;QAAE,OAAO,QAAQ,CAAC;IAClC,OAAO;QACL,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,cAAc,EAAE,GAAG,QAAQ,CAAC,cAAc,KAAK,OAAO,EAAE;KACzD,CAAC;AACJ,CAAC;AAED,SAAS,sCAAsC,CAC7C,cAAsB,EACtB,iBAAyB,EACzB,GAAW;IAEX,MAAM,eAAe,GAAG,kCAAkC,EAAE,CAAC;IAC7D,2EAA2E;IAC3E,6EAA6E;IAC7E,4EAA4E;IAC5E,2EAA2E;IAC3E,yEAAyE;IACzE,+DAA+D;IAC/D,MAAM,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACnC,kCAAkC,EAAE,EACpC,eAAe,CAChB,CAAC;IACF,IAAI,cAAc,IAAI,oBAAoB,EAAE,CAAC;QAC3C,OAAO;YACL,YAAY,EAAE,cAAc;YAC5B,cAAc,EAAE,GAAG,iBAAiB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE;SACjE,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;IACxD,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,eAAe,CAAC;QACvD,cAAc,EACZ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,QAAQ,GAAG,EAAE;KACpE,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Wait-continuation dispatch: delay + idempotency-key selection.\n *\n * When V2 suspension processing observes a pending wait, it enqueues a\n * delayed \"continuation\" message that fires once the wait elapses and\n * drives the next replay (which completes the wait via the \"complete\n * elapsed waits\" pass). This module decides the message's `delaySeconds`\n * and `idempotencyKey`.\n *\n * The continuation is keyed on the wait's correlationId: while a wait is\n * pending, every replay pass over the run re-observes it (e.g., once per\n * step completion in `Promise.all([steps..., sleep()])`), and without\n * dedupe each pass would enqueue another delayed continuation: each one\n * a spurious full replay when the wait elapses, and each a fresh message\n * that resets the delivery-attempt runaway guard. A key is attached in\n * all cases: some worlds (e.g. world-postgres) serialize key-less\n * workflow messages per run, which would park the continuation behind\n * the handler's own inline step execution and defeat the race semantics\n * the continuation exists to provide.\n *\n * The bare correlationId cannot be the key in every case, though: world\n * dedupe windows outlive the first delivery (VQS keeps idempotency\n * records until message-retention TTL; world-postgres keeps a\n * completed-keys cache), so once a key has been used, a later enqueue\n * under the same key is silently dropped. Any situation where a\n * continuation is delivered while its wait is still pending therefore\n * needs a fresh key for the re-enqueue, or the wait's timer is lost and\n * the run stalls until unrelated traffic happens to wake it. Two such\n * situations exist, each with its own key variation:\n *\n * - Waits longer than the maximum queue delay are chained: the delay is\n *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h: VQS messages\n *   have a 24h retention limit, and one hour of buffer matches\n *   world-vercel's own clamp for delayed re-enqueues), so the\n *   continuation intentionally fires early, re-observes the wait, and\n *   must enqueue the next hop. The key is suffixed with the hop index\n *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation\n *   within the same hop window (so passes dedupe), decremented at each\n *   hop delivery (so the chain always advances). Worlds without a delay\n *   limit (world-postgres, world-local) take the same ≤23h hops.\n *\n * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A\n *   continuation delivered marginally early (clock skew between the\n *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0\n *   margin) re-observes the wait as pending with ~1s remaining and must\n *   be able to enqueue a fresh short-delay retry. The bucket suffix\n *   keeps that retry enqueueable (its ≥1s delay guarantees a later\n *   bucket) while still collapsing same-instant duplicates.\n *\n * Mid-range waits (more than the near-elapsed threshold, at most one\n * hop) use the bare correlationId: every re-observation targets the same\n * deadline, so deduping to the first message is semantically lossless.\n *\n * That last case used to be the one hole in the scheme, and it was not\n * theoretical. Any delivery early enough to re-observe its own wait as\n * pending burns the bare key on the way in: the re-enqueue is dropped by\n * the dedupe window, nothing else is scheduled to wake the run, and no\n * backstop exists for a wait the way inline step ownership provides one\n * for a step. The run sleeps forever. Waits over the threshold have zero\n * tolerance for it, which is why an infrastructure change in delivery\n * timing was able to strand runs across every published SDK version at\n * once, all of them keyed this way.\n *\n * So the key is no longer derived from the wait alone. A continuation\n * carries the wait it was armed for and its attempt number\n * ({@link WorkflowInvokePayload.waitContinuation}), and an invocation\n * that recognizes itself as the continuation for a wait that is still\n * pending arms the next one at `attempt + 1`. Attempts advance ONLY when\n * an early delivery actually happens, so the normal path is untouched:\n * attempt 0 keys exactly as before, and every re-observation within one\n * attempt still collapses to a single message.\n */\n\nimport { envNumber } from '@workflow/world';\n\n/**\n * Maximum `delaySeconds` for a single wait-continuation message. Waits\n * longer than this are chained across multiple hops. 23 hours leaves a 1h\n * buffer under Vercel Queues' default 24h message TTL and mirrors\n * world-vercel's `MAX_DELAY_SECONDS`.\n */\nexport const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82_800;\n\n/**\n * Waits with at most this many seconds remaining use a second-bucketed\n * idempotency key so an early-delivered continuation can re-enqueue its\n * short-delay retry. This is also the host clock-skew tolerance for\n * mid-range waits keyed on the bare correlationId.\n */\nexport const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;\n\n/** Effective max continuation delay. Override: `WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS`. */\nconst getWaitContinuationMaxDelaySeconds = (): number =>\n  envNumber(\n    'WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS',\n    WAIT_CONTINUATION_MAX_DELAY_SECONDS,\n    { integer: true, min: 1 }\n  );\n\n/** Effective near-elapsed threshold. Override: `WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS`. */\nconst getNearElapsedWaitThresholdSeconds = (): number =>\n  envNumber(\n    'WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS',\n    NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS\n  );\n\nexport interface WaitContinuationDispatch {\n  delaySeconds: number;\n  idempotencyKey: string;\n}\n\n/**\n * Computes the queue delay and idempotency key for a wait-continuation\n * message. `timeoutSeconds` is the time until the wait's `resumeAt`\n * (floored at 1s by the suspension handler); `waitCorrelationId`\n * identifies the wait so repeated suspension passes dedupe.\n *\n * `attempt` is the number of continuations already spent on this wait, taken\n * from the incoming message when this invocation IS one of them (see\n * {@link WorkflowInvokePayload.waitContinuation}). It only ever moves when a\n * continuation arrived before its wait elapsed, which is exactly when the\n * previous key is spent and re-using it would drop the message. Attempt 0\n * keys identically to the scheme before attempts existed, so the ordinary\n * path — arm once, deliver once, complete — is byte-for-byte unchanged.\n */\nexport function getWaitContinuationDispatch(\n  timeoutSeconds: number,\n  waitCorrelationId: string,\n  now: number = Date.now(),\n  attempt = 0\n): WaitContinuationDispatch {\n  const dispatch = waitContinuationDispatchForAttemptZero(\n    timeoutSeconds,\n    waitCorrelationId,\n    now\n  );\n  if (attempt <= 0) return dispatch;\n  return {\n    delaySeconds: dispatch.delaySeconds,\n    idempotencyKey: `${dispatch.idempotencyKey}:a${attempt}`,\n  };\n}\n\nfunction waitContinuationDispatchForAttemptZero(\n  timeoutSeconds: number,\n  waitCorrelationId: string,\n  now: number\n): WaitContinuationDispatch {\n  const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();\n  // The near-elapsed branch returns the full remaining time as the delay, so\n  // its threshold can never exceed the max delay. Otherwise a wait between the\n  // max and the threshold would be dispatched with a delay above the max. Cap\n  // the threshold at the max so every branch yields a delay within it. (With\n  // defaults, threshold 2s and max 82_800s, this is a no-op; it only bites\n  // when the max is tuned down below the threshold for testing.)\n  const nearElapsedThreshold = Math.min(\n    getNearElapsedWaitThresholdSeconds(),\n    maxDelaySeconds\n  );\n  if (timeoutSeconds <= nearElapsedThreshold) {\n    return {\n      delaySeconds: timeoutSeconds,\n      idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,\n    };\n  }\n\n  const hop = Math.ceil(timeoutSeconds / maxDelaySeconds);\n  return {\n    delaySeconds: Math.min(timeoutSeconds, maxDelaySeconds),\n    idempotencyKey:\n      hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,\n  };\n}\n"]}

package/dist/runtime/wait-until.d.ts

@@ -0,0 +1,18 @@
+export declare function waitUntil(promise: Promise<unknown>): void;
+/**
+ * Schedule a background promise via `waitUntil`, guaranteeing that the
+ * promise handed to `waitUntil` can never reject. Nothing consumes a
+ * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
+ * and can crash the process, even when the same underlying error is
+ * correctly handled by an awaited copy elsewhere.
+ *
+ * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)
+ * are ignored. Any other error is passed to `onError` and swallowed.
+ */
+export declare function safeWaitUntil(promise: Promise<unknown>, onError: (err: unknown) => void): void;
+/**
+ * A small wrapper around `waitUntil` that also returns
+ * the result of the awaited promise.
+ */
+export declare function waitedUntil<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=wait-until.d.ts.map

package/dist/runtime/wait-until.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-until.d.ts","sourceRoot":"","sources":["../../src/runtime/wait-until.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAIzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACzB,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC9B,IAAI,CAcN;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUrE"}

package/dist/runtime/wait-until.js

@@ -0,0 +1,42 @@
+export function waitUntil(promise) {
+    void import('@vercel/functions').then(({ waitUntil }) => {
+        waitUntil(promise);
+    });
+}
+/**
+ * Schedule a background promise via `waitUntil`, guaranteeing that the
+ * promise handed to `waitUntil` can never reject. Nothing consumes a
+ * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
+ * and can crash the process, even when the same underlying error is
+ * correctly handled by an awaited copy elsewhere.
+ *
+ * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)
+ * are ignored. Any other error is passed to `onError` and swallowed.
+ */
+export function safeWaitUntil(promise, onError) {
+    waitUntil(promise.catch((err) => {
+        const isAbortError = err?.name === 'AbortError' || err?.name === 'ResponseAborted';
+        if (!isAbortError) {
+            try {
+                onError(err);
+            }
+            catch {
+                // Never let onError break the no-reject guarantee.
+            }
+        }
+    }));
+}
+/**
+ * A small wrapper around `waitUntil` that also returns
+ * the result of the awaited promise.
+ */
+export async function waitedUntil(fn) {
+    const result = fn();
+    waitUntil(result.catch(() => {
+        // Ignore error from the promise being rejected.
+        // It's expected that the invoker of `waitedUntil`
+        // will handle the error.
+    }));
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world-compatibility.d.ts

@@ -0,0 +1,32 @@
+import type { World } from '@workflow/world';
+type WorldSpecVersionMetadata = Pick<World, 'specVersion'>;
+/**
+ * Rejects a World this runtime cannot speak to.
+ *
+ * The accepted range is
+ * `[SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, SPEC_VERSION_MAX_SUPPORTED]`. Below
+ * the floor means an old World package paired with a new runtime, which cannot
+ * serve the protocol this runtime speaks. A World that does not number events
+ * by position allocates ids the runtime cannot read positions out of. Above the
+ * ceiling means a World built against a newer spec than this runtime knows how
+ * to read.
+ *
+ * The floor is deliberately the slot-identity version rather than
+ * `SPEC_VERSION_CURRENT`, which now sits one above it at the sealed log. Two
+ * reasons, and both are about the window a spec bump is staged over:
+ *
+ * - `WORKFLOW_SEALED_LOG=0` puts a deployment back on slot identity, so its
+ *   World declares the lower version. Flooring at the version we stamp by
+ *   default would make that kill switch reject the very World it selects,
+ *   turning a rollback into a startup failure.
+ * - A World package one version behind the runtime it ships alongside is the
+ *   normal state mid-bump, and it can still serve the protocol: slot identity
+ *   is what the runtime actually requires, and sealed logs are a capability on
+ *   top of it that only the backend implements.
+ *
+ * The range narrows again when the sealed log becomes mandatory and the flag
+ * goes away, exactly as slot identity's own floor did.
+ */
+export declare function assertWorldSupportsRuntimeProtocol(world: WorldSpecVersionMetadata): void;
+export {};
+//# sourceMappingURL=world-compatibility.d.ts.map

package/dist/runtime/world-compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-compatibility.d.ts","sourceRoot":"","sources":["../../src/runtime/world-compatibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAM7C,KAAK,wBAAwB,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,wBAAwB,GAC9B,IAAI,CAkBN"}

package/dist/runtime/world-compatibility.js

@@ -0,0 +1,44 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
+import { SPEC_VERSION_MAX_SUPPORTED, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from '@workflow/world';
+/**
+ * Rejects a World this runtime cannot speak to.
+ *
+ * The accepted range is
+ * `[SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, SPEC_VERSION_MAX_SUPPORTED]`. Below
+ * the floor means an old World package paired with a new runtime, which cannot
+ * serve the protocol this runtime speaks. A World that does not number events
+ * by position allocates ids the runtime cannot read positions out of. Above the
+ * ceiling means a World built against a newer spec than this runtime knows how
+ * to read.
+ *
+ * The floor is deliberately the slot-identity version rather than
+ * `SPEC_VERSION_CURRENT`, which now sits one above it at the sealed log. Two
+ * reasons, and both are about the window a spec bump is staged over:
+ *
+ * - `WORKFLOW_SEALED_LOG=0` puts a deployment back on slot identity, so its
+ *   World declares the lower version. Flooring at the version we stamp by
+ *   default would make that kill switch reject the very World it selects,
+ *   turning a rollback into a startup failure.
+ * - A World package one version behind the runtime it ships alongside is the
+ *   normal state mid-bump, and it can still serve the protocol: slot identity
+ *   is what the runtime actually requires, and sealed logs are a capability on
+ *   top of it that only the backend implements.
+ *
+ * The range narrows again when the sealed log becomes mandatory and the flag
+ * goes away, exactly as slot identity's own floor did.
+ */
+export function assertWorldSupportsRuntimeProtocol(world) {
+    const declared = world.specVersion;
+    if (declared !== undefined &&
+        declared !== null &&
+        declared >= SPEC_VERSION_SUPPORTS_SLOT_IDENTITY &&
+        declared <= SPEC_VERSION_MAX_SUPPORTED) {
+        return;
+    }
+    const supportedVersion = declared ?? 'none';
+    throw new WorkflowRuntimeError(`This Workflow runtime supports Worlds with spec version ${SPEC_VERSION_SUPPORTS_SLOT_IDENTITY} ` +
+        `through ${SPEC_VERSION_MAX_SUPPORTED}, ` +
+        `but the configured World declares spec version ${supportedVersion}. ` +
+        'Install a World package version compatible with the current Workflow runtime.');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGQtY29tcGF0aWJpbGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL3dvcmxkLWNvbXBhdGliaWxpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFeEQsT0FBTyxFQUNMLDBCQUEwQixFQUMxQixtQ0FBbUMsR0FDcEMsTUFBTSxpQkFBaUIsQ0FBQztBQUl6Qjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0EwQkc7QUFDSCxNQUFNLFVBQVUsa0NBQWtDLENBQ2hELEtBQStCO0lBRS9CLE1BQU0sUUFBUSxHQUFHLEtBQUssQ0FBQyxXQUFXLENBQUM7SUFDbkMsSUFDRSxRQUFRLEtBQUssU0FBUztRQUN0QixRQUFRLEtBQUssSUFBSTtRQUNqQixRQUFRLElBQUksbUNBQW1DO1FBQy9DLFFBQVEsSUFBSSwwQkFBMEIsRUFDdEMsQ0FBQztRQUNELE9BQU87SUFDVCxDQUFDO0lBRUQsTUFBTSxnQkFBZ0IsR0FBRyxRQUFRLElBQUksTUFBTSxDQUFDO0lBQzVDLE1BQU0sSUFBSSxvQkFBb0IsQ0FDNUIsMkRBQTJELG1DQUFtQyxHQUFHO1FBQy9GLFdBQVcsMEJBQTBCLElBQUk7UUFDekMsa0RBQWtELGdCQUFnQixJQUFJO1FBQ3RFLCtFQUErRSxDQUNsRixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdvcmtmbG93UnVudGltZUVycm9yIH0gZnJvbSAnQHdvcmtmbG93L2Vycm9ycyc7XG5pbXBvcnQgdHlwZSB7IFdvcmxkIH0gZnJvbSAnQHdvcmtmbG93L3dvcmxkJztcbmltcG9ydCB7XG4gIFNQRUNfVkVSU0lPTl9NQVhfU1VQUE9SVEVELFxuICBTUEVDX1ZFUlNJT05fU1VQUE9SVFNfU0xPVF9JREVOVElUWSxcbn0gZnJvbSAnQHdvcmtmbG93L3dvcmxkJztcblxudHlwZSBXb3JsZFNwZWNWZXJzaW9uTWV0YWRhdGEgPSBQaWNrPFdvcmxkLCAnc3BlY1ZlcnNpb24nPjtcblxuLyoqXG4gKiBSZWplY3RzIGEgV29ybGQgdGhpcyBydW50aW1lIGNhbm5vdCBzcGVhayB0by5cbiAqXG4gKiBUaGUgYWNjZXB0ZWQgcmFuZ2UgaXNcbiAqIGBbU1BFQ19WRVJTSU9OX1NVUFBPUlRTX1NMT1RfSURFTlRJVFksIFNQRUNfVkVSU0lPTl9NQVhfU1VQUE9SVEVEXWAuIEJlbG93XG4gKiB0aGUgZmxvb3IgbWVhbnMgYW4gb2xkIFdvcmxkIHBhY2thZ2UgcGFpcmVkIHdpdGggYSBuZXcgcnVudGltZSwgd2hpY2ggY2Fubm90XG4gKiBzZXJ2ZSB0aGUgcHJvdG9jb2wgdGhpcyBydW50aW1lIHNwZWFrcy4gQSBXb3JsZCB0aGF0IGRvZXMgbm90IG51bWJlciBldmVudHNcbiAqIGJ5IHBvc2l0aW9uIGFsbG9jYXRlcyBpZHMgdGhlIHJ1bnRpbWUgY2Fubm90IHJlYWQgcG9zaXRpb25zIG91dCBvZi4gQWJvdmUgdGhlXG4gKiBjZWlsaW5nIG1lYW5zIGEgV29ybGQgYnVpbHQgYWdhaW5zdCBhIG5ld2VyIHNwZWMgdGhhbiB0aGlzIHJ1bnRpbWUga25vd3MgaG93XG4gKiB0byByZWFkLlxuICpcbiAqIFRoZSBmbG9vciBpcyBkZWxpYmVyYXRlbHkgdGhlIHNsb3QtaWRlbnRpdHkgdmVyc2lvbiByYXRoZXIgdGhhblxuICogYFNQRUNfVkVSU0lPTl9DVVJSRU5UYCwgd2hpY2ggbm93IHNpdHMgb25lIGFib3ZlIGl0IGF0IHRoZSBzZWFsZWQgbG9nLiBUd29cbiAqIHJlYXNvbnMsIGFuZCBib3RoIGFyZSBhYm91dCB0aGUgd2luZG93IGEgc3BlYyBidW1wIGlzIHN0YWdlZCBvdmVyOlxuICpcbiAqIC0gYFdPUktGTE9XX1NFQUxFRF9MT0c9MGAgcHV0cyBhIGRlcGxveW1lbnQgYmFjayBvbiBzbG90IGlkZW50aXR5LCBzbyBpdHNcbiAqICAgV29ybGQgZGVjbGFyZXMgdGhlIGxvd2VyIHZlcnNpb24uIEZsb29yaW5nIGF0IHRoZSB2ZXJzaW9uIHdlIHN0YW1wIGJ5XG4gKiAgIGRlZmF1bHQgd291bGQgbWFrZSB0aGF0IGtpbGwgc3dpdGNoIHJlamVjdCB0aGUgdmVyeSBXb3JsZCBpdCBzZWxlY3RzLFxuICogICB0dXJuaW5nIGEgcm9sbGJhY2sgaW50byBhIHN0YXJ0dXAgZmFpbHVyZS5cbiAqIC0gQSBXb3JsZCBwYWNrYWdlIG9uZSB2ZXJzaW9uIGJlaGluZCB0aGUgcnVudGltZSBpdCBzaGlwcyBhbG9uZ3NpZGUgaXMgdGhlXG4gKiAgIG5vcm1hbCBzdGF0ZSBtaWQtYnVtcCwgYW5kIGl0IGNhbiBzdGlsbCBzZXJ2ZSB0aGUgcHJvdG9jb2w6IHNsb3QgaWRlbnRpdHlcbiAqICAgaXMgd2hhdCB0aGUgcnVudGltZSBhY3R1YWxseSByZXF1aXJlcywgYW5kIHNlYWxlZCBsb2dzIGFyZSBhIGNhcGFiaWxpdHkgb25cbiAqICAgdG9wIG9mIGl0IHRoYXQgb25seSB0aGUgYmFja2VuZCBpbXBsZW1lbnRzLlxuICpcbiAqIFRoZSByYW5nZSBuYXJyb3dzIGFnYWluIHdoZW4gdGhlIHNlYWxlZCBsb2cgYmVjb21lcyBtYW5kYXRvcnkgYW5kIHRoZSBmbGFnXG4gKiBnb2VzIGF3YXksIGV4YWN0bHkgYXMgc2xvdCBpZGVudGl0eSdzIG93biBmbG9vciBkaWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnRXb3JsZFN1cHBvcnRzUnVudGltZVByb3RvY29sKFxuICB3b3JsZDogV29ybGRTcGVjVmVyc2lvbk1ldGFkYXRhXG4pOiB2b2lkIHtcbiAgY29uc3QgZGVjbGFyZWQgPSB3b3JsZC5zcGVjVmVyc2lvbjtcbiAgaWYgKFxuICAgIGRlY2xhcmVkICE9PSB1bmRlZmluZWQgJiZcbiAgICBkZWNsYXJlZCAhPT0gbnVsbCAmJlxuICAgIGRlY2xhcmVkID49IFNQRUNfVkVSU0lPTl9TVVBQT1JUU19TTE9UX0lERU5USVRZICYmXG4gICAgZGVjbGFyZWQgPD0gU1BFQ19WRVJTSU9OX01BWF9TVVBQT1JURURcbiAgKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgY29uc3Qgc3VwcG9ydGVkVmVyc2lvbiA9IGRlY2xhcmVkID8/ICdub25lJztcbiAgdGhyb3cgbmV3IFdvcmtmbG93UnVudGltZUVycm9yKFxuICAgIGBUaGlzIFdvcmtmbG93IHJ1bnRpbWUgc3VwcG9ydHMgV29ybGRzIHdpdGggc3BlYyB2ZXJzaW9uICR7U1BFQ19WRVJTSU9OX1NVUFBPUlRTX1NMT1RfSURFTlRJVFl9IGAgK1xuICAgICAgYHRocm91Z2ggJHtTUEVDX1ZFUlNJT05fTUFYX1NVUFBPUlRFRH0sIGAgK1xuICAgICAgYGJ1dCB0aGUgY29uZmlndXJlZCBXb3JsZCBkZWNsYXJlcyBzcGVjIHZlcnNpb24gJHtzdXBwb3J0ZWRWZXJzaW9ufS4gYCArXG4gICAgICAnSW5zdGFsbCBhIFdvcmxkIHBhY2thZ2UgdmVyc2lvbiBjb21wYXRpYmxlIHdpdGggdGhlIGN1cnJlbnQgV29ya2Zsb3cgcnVudGltZS4nXG4gICk7XG59XG4iXX0=

package/dist/runtime/world-init.d.ts

@@ -1,35 +1,22 @@
 /**
  * Server-only side-effect module that ensures `world.ts` is loaded so its
- * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * module-load side effect (`globalThis[GetWorldFnKey] ??= getWorld`)
  * fires in host bundles.
  *
  * # Why this exists
  *
  * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
- * (populated by `world.ts`'s module-load side effect) before falling back
- * to a runtime-built dynamic `import('./world.js')`. When a server route
- * only consumes a single helper that goes through `getWorldLazy` — most
- * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
- * named import `{ getWorld } from './runtime/world.js'` out of
- * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * populated by `world.ts`'s module-load side effect. When a server route
+ * only consumes a helper that goes through `getWorldLazy` (for example
+ * `start` from `workflow/api`, or `defineHook().resume()` from `workflow`),
+ * webpack/turbopack can tree-shake the named import `{ getWorld }` out
+ * of `runtime.ts`, taking `world.ts`'s module evaluation with it. The
  * globalThis registration never fires.
  *
- * `getWorldLazy` then falls through to its dynamic-import fallback, which
- * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
- * file, so the relative specifier `./world.js` resolves against
- * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
- * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
- * cold-start regression: the very first user request that goes through
- * `start()` fails until some other code path (typically the queue-driven
- * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
- * via `workflowEntrypoint`) has loaded `world.ts` and populated the
- * cache.
- *
- * Importing this module for its side effect — exactly once, from the
- * host-side `workflow/api` (`packages/workflow/src/api.ts`) — guarantees
- * `world.ts` enters the bundle, the global is registered at module load,
- * and `getWorldLazy()` short-circuits to the registered function on the
- * first call.
+ * Importing this module for its side effect from the host-side `workflow`
+ * and `workflow/api` entries guarantees `world.ts` enters the bundle, the
+ * global is registered at module load, and `getWorldLazy()` short-circuits
+ * to the registered function on the first call.
  *
  * # Why a separate module instead of importing `./world.js` directly
  *
@@ -47,29 +34,17 @@
  * `workflow` condition active, so they pick up the stub and never reach
  * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
  * `default` (or `node`) condition and pick up this file, loading
- * `world.ts` as intended. The split keeps `@workflow/world-vercel`,
- * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
- * the workflow sandbox bundle.
- *
- * # Why we keep the `getWorldLazy` dynamic-import fallback
- *
- * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
- * environments we haven't accounted for (CJS test runners, scripts that
- * import `start` without going through `workflow/api`, future bundlers
- * with stricter tree-shaking). With this init module in place, the
- * fallback should never fire in normal use — but if it does, the
- * dynamic-import branch still resolves correctly when `world.js` is
- * physically adjacent on disk (e.g., direct Node.js execution of
- * unbundled source).
+ * `world.ts` as intended. The split keeps the configured world package
+ * and other server-only deps out of the workflow sandbox bundle.
  *
  * # Maintenance notes
  *
  * If you add another `getWorldLazy()` consumer that's reachable from a
- * host route without going through `workflow/api` (e.g., a new helper in
- * `workflow/runtime`), make sure that entry also imports this module —
- * or that it transitively reaches `world.ts` via a non-tree-shakeable
- * path. Adding a regression test in `world-init.test.ts` is preferred to
- * relying on careful manual tracing.
+ * host route without going through `workflow` or `workflow/api`, make
+ * sure that entry also imports this module, or that it transitively
+ * reaches `world.ts` via a non-tree-shakeable path. Adding a regression
+ * test in `world-init.test.ts` is preferred to relying on careful manual
+ * tracing.
  */
 import './world.js';
 //# sourceMappingURL=world-init.d.ts.map

package/dist/runtime/world-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world-init.d.ts","sourceRoot":"","sources":["../../src/runtime/world-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,OAAO,YAAY,CAAC"}
+{"version":3,"file":"world-init.d.ts","sourceRoot":"","sources":["../../src/runtime/world-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,YAAY,CAAC"}

package/dist/runtime/world-init.js

@@ -1,35 +1,22 @@
 /**
  * Server-only side-effect module that ensures `world.ts` is loaded so its
- * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * module-load side effect (`globalThis[GetWorldFnKey] ??= getWorld`)
  * fires in host bundles.
  *
  * # Why this exists
  *
  * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
- * (populated by `world.ts`'s module-load side effect) before falling back
- * to a runtime-built dynamic `import('./world.js')`. When a server route
- * only consumes a single helper that goes through `getWorldLazy` — most
- * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
- * named import `{ getWorld } from './runtime/world.js'` out of
- * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * populated by `world.ts`'s module-load side effect. When a server route
+ * only consumes a helper that goes through `getWorldLazy` (for example
+ * `start` from `workflow/api`, or `defineHook().resume()` from `workflow`),
+ * webpack/turbopack can tree-shake the named import `{ getWorld }` out
+ * of `runtime.ts`, taking `world.ts`'s module evaluation with it. The
  * globalThis registration never fires.
  *
- * `getWorldLazy` then falls through to its dynamic-import fallback, which
- * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
- * file, so the relative specifier `./world.js` resolves against
- * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
- * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
- * cold-start regression: the very first user request that goes through
- * `start()` fails until some other code path (typically the queue-driven
- * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
- * via `workflowEntrypoint`) has loaded `world.ts` and populated the
- * cache.
- *
- * Importing this module for its side effect — exactly once, from the
- * host-side `workflow/api` (`packages/workflow/src/api.ts`) — guarantees
- * `world.ts` enters the bundle, the global is registered at module load,
- * and `getWorldLazy()` short-circuits to the registered function on the
- * first call.
+ * Importing this module for its side effect from the host-side `workflow`
+ * and `workflow/api` entries guarantees `world.ts` enters the bundle, the
+ * global is registered at module load, and `getWorldLazy()` short-circuits
+ * to the registered function on the first call.
  *
  * # Why a separate module instead of importing `./world.js` directly
  *
@@ -47,29 +34,17 @@
  * `workflow` condition active, so they pick up the stub and never reach
  * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
  * `default` (or `node`) condition and pick up this file, loading
- * `world.ts` as intended. The split keeps `@workflow/world-vercel`,
- * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
- * the workflow sandbox bundle.
- *
- * # Why we keep the `getWorldLazy` dynamic-import fallback
- *
- * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
- * environments we haven't accounted for (CJS test runners, scripts that
- * import `start` without going through `workflow/api`, future bundlers
- * with stricter tree-shaking). With this init module in place, the
- * fallback should never fire in normal use — but if it does, the
- * dynamic-import branch still resolves correctly when `world.js` is
- * physically adjacent on disk (e.g., direct Node.js execution of
- * unbundled source).
+ * `world.ts` as intended. The split keeps the configured world package
+ * and other server-only deps out of the workflow sandbox bundle.
  *
  * # Maintenance notes
  *
  * If you add another `getWorldLazy()` consumer that's reachable from a
- * host route without going through `workflow/api` (e.g., a new helper in
- * `workflow/runtime`), make sure that entry also imports this module —
- * or that it transitively reaches `world.ts` via a non-tree-shakeable
- * path. Adding a regression test in `world-init.test.ts` is preferred to
- * relying on careful manual tracing.
+ * host route without going through `workflow` or `workflow/api`, make
+ * sure that entry also imports this module, or that it transitively
+ * reaches `world.ts` via a non-tree-shakeable path. Adding a regression
+ * test in `world-init.test.ts` is preferred to relying on careful manual
+ * tracing.
  */
 import './world.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world.d.ts

@@ -1,4 +1,16 @@
 import type { World } from '@workflow/world';
+export type WorldFactoryModule = {
+    createWorld?: () => World | Promise<World>;
+    default?: (() => World | Promise<World>) | World;
+};
+/**
+ * Create a World instance from a world factory module. Shared by
+ * `createWorld()` (for the world package named by WORKFLOW_TARGET_WORLD) and
+ * tooling that loads a world module dynamically (e.g. the Nitro dev
+ * handler and `@workflow/world-testing`). World packages should export
+ * `createWorld()`.
+ */
+export declare function createWorldFromModule(mod: WorldFactoryModule): World | Promise<World>;
 /**
  * Create a new world instance based on environment variables.
  * WORKFLOW_TARGET_WORLD is used to determine the target world.
@@ -8,8 +20,8 @@ import type { World } from '@workflow/world';
  * and should not affect runtime behavior. The Vercel runtime provides
  * authentication via OIDC tokens and project context via system env vars
  * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env
- * vars should call createVercelWorld() directly with an explicit config and
- * use setWorld() to inject the instance.
+ * vars should call the Vercel world's createWorld() directly with an explicit
+ * config and use setWorld() to inject the instance.
  */
 export declare const createWorld: () => Promise<World>;
 export type WorldHandlers = Pick<World, 'createQueueHandler' | 'specVersion'>;

package/dist/runtime/world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AA4D7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CAqDjD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,aAAa,CAkB9D,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,KAAK,CAc9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAKnD,CAAC"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAiD7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;CAClD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,kBAAkB,GACtB,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAcxB;AA8CD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CA6DjD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,aAAa,CAoB9D,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,KAAK,CAgB9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAKnD,CAAC"}