@sinestack/workflow-sdk 0.0.0-stage → 0.1.1-oidc.0

package/LICENSE.workflow.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        <http://www.apache.org/licenses/>
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Vercel Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,68 @@
-# Temporary Holding Version
+# @sinestack/workflow-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+One fixed `runWorkflow(ticket)` calls the product's trusted `advanceWorkflow(ticket)` step, then sleeps durably until `wakeAt`. Node and Cloudflare use the same compiled orchestration. Domain state, permissions, credentials, provider submission safety, results and billing remain in the consuming product.
+
+After this version is published to npm:
+
+```sh
+pnpm add --save-exact @sinestack/workflow-core@0.1.1-oidc.0 @sinestack/workflow-sdk@0.1.1-oidc.0 workflow@5.2.3
+```
+
+Use Node **24.19+** for the builder and Node executor. Install `workflow@5.2.3`
+directly in the build host: the upstream compiler resolves its built-in steps
+from the generated output directory. The SDK installs the exact matching core
+and Cloudflare World versions. Add `@sinestack/workflow-world-cloudflare@0.1.1-oidc.0`
+directly only if your application imports it. The SDK exposes `/build`, `/node`
+and `/runtime`; there is no root import.
+
+Keep all three Sine Workflow packages at the same release and commit the
+consumer lockfile. Registry installations need no overrides. For local tarball
+installation, use package-manager overrides to direct transitive
+`@sinestack/workflow-core` and `@sinestack/workflow-world-cloudflare` to the same local
+artifacts. When moving an existing consumer to the registry, remove those old
+tarball overrides and regenerate the lockfile. See the repository's
+[publishing guide](https://github.com/fei-bai-inc/workflow/blob/main/PUBLISHING.md)
+for registry access and upgrade instructions.
+
+```ts
+import { buildWorkflow } from '@sinestack/workflow-sdk/build';
+await buildWorkflow({
+  root: process.cwd(), target: 'cloudflare', deploymentPrefix: 'myappwf',
+  identityInputs: ['src/task-effects', 'package.json', 'pnpm-lock.yaml'],
+  runtimeService: { service: 'my-app', entrypoint: 'WorkflowRuntime' },
+});
+```
+
+The builder writes `.generated/workflow/flow.mjs`, `node-identity.mjs`, and `.output/workflow/{index.mjs,*.wasm,wrangler.json,manifest.json}` for Cloudflare. Optional `generatedDir` and `outputDir` override these paths. Consumer identity inputs must include all effect/state-machine code, schema contracts and dependency locks. Both infrastructure source and consumer inputs participate in immutable deployment identity.
+
+Cloudflare exports `WorkflowService` with private `enqueue(ticket)` and `wake(ticket)`, plus `RunObject`, `TokenObject`, `StreamObject`, `StepRunner`. The executor's private `SINE_WORKFLOW_RUNTIME` service binding calls the consumer's `advanceWorkflow(ticket)`. Public fetch always returns 404. Retain each old immutable Worker, namespaces and encryption secret until its tasks drain; no in-flight migration is promised.
+
+For each new immutable Cloudflare Worker, deploy the generated configuration,
+then provision `WORKFLOW_ENCRYPTION_SECRET` before directing tasks to it:
+
+```sh
+pnpm exec wrangler deploy --config .output/workflow/wrangler.json
+pnpm exec wrangler secret put WORKFLOW_ENCRYPTION_SECRET --config .output/workflow/wrangler.json
+```
+
+Supply base64 encoding of exactly 32 random bytes from your secret manager at
+the secret prompt. Missing or malformed secrets fail closed before a run can
+be accepted. Keep that key stable for the release's full retention period;
+changing it makes prior payloads and snapshots unreadable. Local workerd
+fixtures must supply the same binding explicitly. Executor service bindings
+should be enabled only after this provisioning succeeds.
+
+For Node, import `createNodeWorkflow` from `@sinestack/workflow-sdk/node` and pass `{dataDir,advance,workflowId,deploymentId,createFlowRoute}` using the generated modules. Call `start()` after configuring the durable product runtime, and `close()` before shutting that runtime down. Preserve both product data and the `workflow/` directory. Local World has one exclusive owner, not a distributed multi-host queue.
+
+The pinned Node Local World does not require `WORKFLOW_ENCRYPTION_SECRET` and
+does not encrypt its journal using the Cloudflare secret. Protect its data
+directory with host storage controls. Shared tickets carry identifiers only;
+product payloads and credentials stay in the product's encrypted task storage.
+
+The Node owner database permanently pins its immutable deployment before delivery. A different build cannot adopt the same directory or replay old work with new code, even after process restart. Legacy unpinned Local World directories also require explicit migration after draining; preserve the old executor directory and use a fresh executor directory for the new release. Product databases can remain separate from executor state.
+
+Retaining a Cloudflare executor alone is insufficient if its runtime service is replaced by incompatible effect code or schema. The callback host must continue to support that ticket's original driver/schema version or reject it before provider I/O. Retain a matching callback host when compatibility cannot be maintained; no adapter performs an implicit in-flight migration.
+
+The SDK can replay steps. Product state must atomically persist tasks/outbox, fence leases, checkpoint results, and mark uncertain external side effects without resubmitting them. Cancel/timeout does not prove that an external request was undone.
+
+`advanceRun` disables SDK-level step retries. A thrown host/storage/network error is caught by the fixed workflow, which durably sleeps for 30 seconds and tries the same fenced task again. A temporary host outage therefore does not leave the SDK run permanently failed after a finite retry budget. The product owner must return `completed` for absent/terminal tasks and apply its own bounded task deadline; restoring an incompatible driver/schema remains an explicit host responsibility.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,15 @@
+# Third-party notices
+
+This package adapts selected source from [vercel/workflow PR #4682](https://github.com/vercel/workflow/pull/4682), exact commit [`a555966986af83b94cb77d1d427dfdb18a2732cc`](https://github.com/vercel/workflow/tree/a555966986af83b94cb77d1d427dfdb18a2732cc).
+
+Upstream project: Workflow Development Kit, Vercel, Inc. Licensed under Apache License 2.0. The complete upstream license is preserved in `LICENSE.workflow.txt`. `SOURCE_ORIGINS.json` identifies every imported source file, its exact source URL, and the SHA-256 of the unmodified fetched source.
+
+Imported scope is `packages/world-cloudflare/src` and only `packages/world-sim/src/store.ts` plus its `ids.ts` dependency. The monorepo and simulator runtime were not imported. The former simulator store is maintained here as the production journal projection, `createJournalStore`; Durable Objects own its serialized write boundary, transactional journal, cold reconstruction, token registry, and durable alarms.
+
+Local modifications include strict SDK/Workers typing; real required World listing methods; required environment-bound encryption; bounded delivery with durable restart; explicit deployment mismatch errors; terminal queue deduplication; transactional streams and snapshots; removal of simulator fault injection and fake Workers ambient declarations; and behavior-test sources. `src/directory.ts` and the tests are local additions.
+
+QuickJS is supplied by pinned `quickjs-wasi@3.4.0` through its own package license. This package does not copy its Wasm binaries: the host statically imports them through the SDK build. Pinned SDK packages retain their distributed licenses and notices.
+
+The shared `@sinestack/workflow-sdk` source `packages/sdk/src/compatibility.ts` maintains the pinned SDK build adaptation for lazy compute-instance identity, based on upstream's lazy initialization fix. It is part of host bundling rather than a second World or a mutable runtime-code loader.
+
+The maintained adaptation was extracted from SinePowers commit `09f80f7463c07f17bc53ad7a80717214433b9211` into `fei-bai-inc/workflow`. Consumers install its generated package artifacts; no consumer-maintained source fork is required.

package/dist/build.d.ts

@@ -0,0 +1,23 @@
+export interface WorkflowBuildOptions {
+    root: string;
+    target: 'node' | 'cloudflare';
+    generatedDir?: string;
+    outputDir?: string;
+    deploymentPrefix?: string;
+    identityInputs: readonly string[];
+    runtimeService?: {
+        service: string;
+        entrypoint: string;
+    };
+    compatibilityDate?: string;
+}
+export interface WorkflowBuildResult {
+    workflowId: string;
+    deploymentId: string;
+    generatedDir: string;
+    outputDir?: string;
+    configPath?: string;
+    manifestPath: string;
+}
+/** Build-time only: fixed infrastructure code; never evaluate provider or caller payloads. */
+export declare function buildWorkflow(options: WorkflowBuildOptions): Promise<WorkflowBuildResult>;

package/dist/build.js

@@ -0,0 +1,143 @@
+import { BaseBuilder } from '@workflow/builders';
+import { build } from 'esbuild';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile, cp, readdir, stat } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { workflowCompatibilityPlugin } from "./compatibility.js";
+/** Build-time only: fixed infrastructure code; never evaluate provider or caller payloads. */
+export async function buildWorkflow(options) {
+    const root = resolve(options.root);
+    const sdkSource = resolve(dirname(fileURLToPath(import.meta.url)), '../src');
+    const sdkManifest = await readFile(resolve(sdkSource, '../package.json'));
+    const sdkPackage = JSON.parse(sdkManifest.toString('utf8'));
+    const implementation = `${sdkPackage.name}@${sdkPackage.version}`;
+    const generated = resolve(root, options.generatedDir ?? '.generated/workflow');
+    const target = options.target;
+    if (target !== 'node' && target !== 'cloudflare')
+        throw new Error('Expected node or cloudflare workflow target.');
+    const prefix = options.deploymentPrefix ?? 'sinewf';
+    if (!/^[a-z][a-z0-9-]{0,24}$/u.test(prefix))
+        throw new TypeError('Invalid immutable deployment prefix.');
+    if (!options.identityInputs.length)
+        throw new TypeError('Consumer effect code and contracts must participate in deployment identity.');
+    if (target === 'cloudflare' && (!options.runtimeService || !/^[a-z0-9][a-z0-9-]{0,62}$/u.test(options.runtimeService.service) || !/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(options.runtimeService.entrypoint)))
+        throw new TypeError('A trusted private runtime service and named entrypoint are required.');
+    const output = resolve(root, options.outputDir ?? '.output/workflow');
+    async function addConsumerIdentity(digest) {
+        // Pin infrastructure changes as well as product-owned side effects.
+        digest.update(sdkManifest);
+        for (const name of (await readdir(sdkSource)).filter(name => name.endsWith('.ts')).sort())
+            digest.update(name).update(await readFile(resolve(sdkSource, name)));
+        for (const path of [...options.identityInputs].sort()) {
+            const absolute = resolve(root, path), info = await stat(absolute);
+            if (info.isDirectory()) {
+                for (const name of (await readdir(absolute, { recursive: true })).sort()) {
+                    const file = resolve(absolute, name);
+                    if ((await stat(file)).isFile())
+                        digest.update(`${path}/${name}`).update(await readFile(file));
+                }
+            }
+            else if (info.isFile())
+                digest.update(path).update(await readFile(absolute));
+            else
+                throw new TypeError(`Unsupported workflow identity input: ${path}`);
+        }
+    }
+    class WorkflowBuilder extends BaseBuilder {
+        workflowId = '';
+        // Upstream normally adds .gitignore entries under workingDir. Here that is
+        // an installed immutable package; build outputs belong to the consumer.
+        async ensureSwcIgnored() { }
+        async build() {
+            const inputs = [resolve(sdkSource, 'workflow.ts'), resolve(sdkSource, 'step.ts')];
+            const tsconfigPath = resolve(root, 'tsconfig.json');
+            const entries = await this.discoverEntries(inputs, generated, tsconfigPath);
+            await this.createStepsBundle({ inputFiles: inputs, outfile: resolve(generated, 'steps.mjs'), format: 'esm', tsconfigPath,
+                discoveredEntries: entries, skipEsmRequireBanner: true });
+            const result = await this.createWorkflowsBundle({ inputFiles: inputs, outfile: resolve(generated, 'flow.mjs'), format: 'esm',
+                tsconfigPath, discoveredEntries: entries, bundleFinalOutput: false });
+            if (result.interimBundleText === undefined)
+                throw new Error('Workflow compiler did not emit the fixed workflow bundle.');
+            const workflows = result.manifest.workflows ?? {};
+            const matches = Object.values(workflows).flatMap(value => Object.entries(value)).filter(([name]) => name === 'runWorkflow');
+            if (matches.length !== 1 || !matches[0])
+                throw new Error('The workflow must have exactly one compiled identity.');
+            this.workflowId = matches[0][1].workflowId;
+            if (!/^[a-zA-Z0-9_./@()[\]-]+$/u.test(this.workflowId) || /node_modules|\.bun|\.pnpm/u.test(this.workflowId)) {
+                throw new Error('The fixed workflow identity must not contain an installation path or package-manager encoding.');
+            }
+            await writeFile(resolve(generated, 'flow.mjs'), `import './steps.mjs';\nimport { workflowEntrypoint } from 'workflow/runtime';\nconst code = ${JSON.stringify(result.interimBundleText)};\nexport const createFlowRoute = () => workflowEntrypoint(code);\n`);
+            await writeFile(resolve(generated, 'flow.d.mts'), 'export declare function createFlowRoute(): (request: Request) => Promise<Response>;\n');
+        }
+    }
+    await mkdir(generated, { recursive: true });
+    if (target === 'cloudflare')
+        await mkdir(output, { recursive: true });
+    // The compiler uses workingDir for non-exported source identities. Consumer
+    // node_modules layouts (notably Bun's '+' paths) must never become durable IDs.
+    // Every input/output and the consumer tsconfig are absolute, so only the fixed
+    // infrastructure module identities are rooted here.
+    const builder = new WorkflowBuilder({ buildTarget: 'standalone', workingDir: sdkSource, projectRoot: root, moduleSpecifierRoot: sdkSource,
+        dirs: [sdkSource], stepsBundlePath: resolve(generated, 'steps.mjs'), workflowsBundlePath: resolve(generated, 'flow.mjs'),
+        webhookBundlePath: resolve(generated, 'webhook.mjs'), sourcemap: false, discoverWorkflowsInNodeModules: false, externalPackages: ['cloudflare:workers'] });
+    await builder.build();
+    // Both hosts execute the same compiler output. Node bundles this fixed route
+    // into Nitro; source discovery and compilation never happen during a request.
+    const nodeDigest = createHash('sha256');
+    for (const filename of ['flow.mjs', 'steps.mjs'])
+        nodeDigest.update(filename).update(await readFile(resolve(generated, filename)));
+    await addConsumerIdentity(nodeDigest);
+    const nodeDeploymentId = `${prefix}-node-${nodeDigest.digest('hex').slice(0, 24)}`;
+    await writeFile(resolve(generated, 'node-identity.mjs'), `export const workflowId = ${JSON.stringify(builder.workflowId)};\nexport const deploymentId = ${JSON.stringify(nodeDeploymentId)};\n`);
+    await writeFile(resolve(generated, 'node-identity.d.mts'), 'export declare const workflowId: string;\nexport declare const deploymentId: string;\n');
+    await writeFile(resolve(generated, 'manifest.node.json'), JSON.stringify({ schemaVersion: 1, workflowId: builder.workflowId, deploymentId: nodeDeploymentId, implementation, consumerIdentityInputs: options.identityInputs }, null, 2) + '\n');
+    if (target === 'node') {
+        return { workflowId: builder.workflowId, deploymentId: nodeDeploymentId, generatedDir: generated, manifestPath: resolve(generated, 'manifest.node.json') };
+    }
+    else {
+        const wasmFiles = [
+            ['quickjs-wasi/quickjs.wasm', 'quickjs.wasm'], ['quickjs-wasi/encoding.so', 'encoding.wasm'],
+            ['quickjs-wasi/headers.so', 'headers.wasm'], ['quickjs-wasi/url.so', 'url.wasm'],
+            ['quickjs-wasi/structured-clone.so', 'structured-clone.wasm'],
+        ];
+        for (const [specifier, name] of wasmFiles)
+            await cp(fileURLToPath(import.meta.resolve(specifier)), resolve(output, name));
+        await writeFile(resolve(generated, 'assets.mjs'), wasmFiles.map(([, name], index) => `import module${index} from './${name}';`).join('\n') +
+            '\nexport const modules = {quickjs:module0,encoding:module1,headers:module2,url:module3,structuredClone:module4};\n');
+        await writeFile(resolve(generated, 'assets.d.mts'), 'export declare const modules: { quickjs: WebAssembly.Module; encoding: WebAssembly.Module; headers: WebAssembly.Module; url: WebAssembly.Module; structuredClone: WebAssembly.Module };\n');
+        const result = await build({ absWorkingDir: root, entryPoints: [resolve(sdkSource, 'worker.ts')], outfile: resolve(output, 'index.mjs'),
+            bundle: true, format: 'esm', platform: 'neutral', target: 'es2023', conditions: ['workerd', 'worker', 'browser'],
+            external: ['cloudflare:*', 'node:*', './*.wasm'], minify: true, metafile: true,
+            plugins: [workflowCompatibilityPlugin()],
+            alias: { '@sine-workflow/generated/flow': resolve(generated, 'flow.mjs'), '@sine-workflow/generated/assets': resolve(generated, 'assets.mjs') },
+            define: { '__SINE_WORKFLOW_ID__': JSON.stringify(builder.workflowId), '__SINE_WORKFLOW_DEPLOYMENT__': JSON.stringify('sine-workflow-immutable-build') },
+        });
+        // The immutable deployment identity includes code, compiled engine contracts and Wasm.
+        const digest = createHash('sha256');
+        for (const filename of ['index.mjs', ...wasmFiles.map(([, name]) => name)])
+            digest.update(filename).update(await readFile(resolve(output, filename)));
+        await addConsumerIdentity(digest);
+        const deploymentId = `${prefix}-${digest.digest('hex').slice(0, 24)}`;
+        const index = await readFile(resolve(output, 'index.mjs'), 'utf8');
+        await writeFile(resolve(output, 'index.mjs'), index.replaceAll('sine-workflow-immutable-build', deploymentId));
+        const configuration = {
+            name: deploymentId, main: 'index.mjs', compatibility_date: options.compatibilityDate ?? '2026-10-06', compatibility_flags: ['nodejs_compat', 'enable_ctx_exports'],
+            no_bundle: true, workers_dev: false, preview_urls: false,
+            rules: [{ type: 'CompiledWasm', globs: ['**/*.wasm'], fallthrough: true }],
+            vars: { WORKFLOW_VM: 'quickjs', WORKFLOW_COMPRESSION_CODEC: 'gzip', SINE_WORKFLOW_DEPLOYMENT: deploymentId },
+            durable_objects: { bindings: [{ name: 'WORKFLOW_RUNS', class_name: 'RunObject' }, { name: 'WORKFLOW_TOKENS', class_name: 'TokenObject' }, { name: 'WORKFLOW_STREAMS', class_name: 'StreamObject' }] },
+            migrations: [{ tag: 'v1', new_sqlite_classes: ['RunObject', 'TokenObject', 'StreamObject'] }],
+            services: [{ binding: 'SINE_WORKFLOW_RUNTIME', ...options.runtimeService }],
+            observability: { enabled: true },
+        };
+        const worldRoot = dirname(fileURLToPath(import.meta.resolve('@sinestack/workflow-world-cloudflare/package.json')));
+        for (const name of ['LICENSE.workflow.txt', 'THIRD_PARTY_NOTICES.md', 'SOURCE_ORIGINS.json'])
+            await cp(resolve(worldRoot, name), resolve(output, name));
+        await writeFile(resolve(output, 'wrangler.json'), JSON.stringify(configuration, null, 2) + '\n');
+        await writeFile(resolve(output, 'manifest.json'), JSON.stringify({ schemaVersion: 1, deploymentId, workflowId: builder.workflowId, implementation, consumerIdentityInputs: options.identityInputs,
+            source: { repository: 'https://github.com/vercel/workflow', commit: 'a555966986af83b94cb77d1d427dfdb18a2732cc', pullRequest: 4682 },
+            inputs: Object.keys(result.metafile.inputs).sort(), files: (await readdir(output)).sort() }, null, 2) + '\n');
+        return { workflowId: builder.workflowId, deploymentId, generatedDir: generated, outputDir: output, configPath: resolve(output, 'wrangler.json'), manifestPath: resolve(output, 'manifest.json') };
+    }
+}

package/dist/compatibility.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'esbuild';
+/** Narrow, hash-bound upstream compatibility port; never mutates node_modules or evaluates input code. */
+export declare function workflowCompatibilityPlugin(): Plugin;

package/dist/compatibility.js

@@ -0,0 +1,75 @@
+// Build-only adaptation of vercel/workflow PR #4682 (Apache-2.0), commit a555966986af83b94cb77d1d427dfdb18a2732cc.
+// SDK 5.2.3 still generates compute telemetry IDs at module load; Workers only permit randomness during requests.
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import ts from 'typescript';
+const fingerprints = {
+    'runtime/compute-instance.js': 'fb94134ecb1aa7f5dc2f4dfe38e073e24f023743d2538a9ed1be3781ec5fb01f',
+    'runtime.js': '1e7a1dffc2dbb91668f07e6fe4dbcf6b245c2a22dfeb604655e4bf2e9ca2ef35',
+    'runtime/step-executor.js': '9ba44e47d56f5deae57ff8e46560094dd614161b89241824715230ae07b7c963',
+    'runtime/suspension-handler.js': 'a86dac33cc640ad757e7e252ae4dd1d0f7a230cb2d0f0bd10b41ea5e2cc33322',
+    'runtime/world.js': '6051f9184059de80a1b1fa61c2403d25354fc3c6b6aa83f4015dd7b8893efa48',
+};
+/** Narrow, hash-bound upstream compatibility port; never mutates node_modules or evaluates input code. */
+export function workflowCompatibilityPlugin() {
+    return { name: 'sine-workflow-compatibility', setup(builder) {
+            builder.onLoad({ filter: /@workflow\/core\/dist\/(runtime\.js|runtime\/(world|compute-instance|step-executor|suspension-handler)\.js)$/ }, async (args) => {
+                const name = args.path.split('/@workflow/core/dist/')[1];
+                const expected = name === undefined ? undefined : fingerprints[name];
+                if (!expected)
+                    throw new Error('Unexpected Workflow compatibility input.');
+                const source = await readFile(args.path, 'utf8');
+                if (createHash('sha256').update(source).digest('hex') !== expected)
+                    throw new Error(`Workflow SDK compatibility input changed: ${name}. Review the upstream update before building.`);
+                const file = ts.createSourceFile(args.path, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+                if (name === 'runtime/compute-instance.js') {
+                    return { contents: "import { ulid } from 'ulid';\nlet instanceId;\nexport function getComputeInstanceId() { return instanceId ??= `cinst_${ulid()}`; }\n", loader: 'js' };
+                }
+                if (name === 'runtime/world.js') {
+                    // This deployment injects its World explicitly. Retain upstream caches and protocol checks,
+                    // but remove ambient package discovery and unselected Node/Vercel backend imports.
+                    const removeFunctions = { getRuntimeRequire: true, resolveModulePath: true };
+                    let replaced = 0;
+                    const printer = ts.createPrinter({ removeComments: true });
+                    const statements = file.statements.flatMap(statement => {
+                        if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) &&
+                            ['node:module', 'node:url', '@workflow/utils', '@workflow/world-local', '@workflow/world-vercel'].includes(statement.moduleSpecifier.text))
+                            return [];
+                        if (ts.isFunctionDeclaration(statement) && statement.name && removeFunctions[statement.name.text])
+                            return [];
+                        if (ts.isVariableStatement(statement) && statement.declarationList.declarations.some(declaration => ts.isIdentifier(declaration.name) && declaration.name.text === 'createWorld')) {
+                            replaced++;
+                            return ["export const createWorld = async () => { throw new Error('Cloudflare workflow World must be explicitly injected before use.'); };"];
+                        }
+                        return [printer.printNode(ts.EmitHint.Unspecified, statement, file)];
+                    });
+                    if (replaced !== 1)
+                        throw new Error('Workflow World initialization changed.');
+                    return { contents: statements.join('\n'), loader: 'js' };
+                }
+                let imports = 0, usages = 0;
+                const transformed = ts.transform(file, [context => root => {
+                        const visitor = node => {
+                            if (ts.isImportSpecifier(node) && node.name.text === 'COMPUTE_INSTANCE_ID') {
+                                imports++;
+                                return ts.factory.updateImportSpecifier(node, false, undefined, ts.factory.createIdentifier('getComputeInstanceId'));
+                            }
+                            if (ts.isIdentifier(node) && node.text === 'COMPUTE_INSTANCE_ID') {
+                                usages++;
+                                return ts.factory.createCallExpression(ts.factory.createIdentifier('getComputeInstanceId'), undefined, []);
+                            }
+                            return ts.visitEachChild(node, visitor, context);
+                        };
+                        return ts.visitNode(root, visitor, ts.isSourceFile) ?? root;
+                    }]);
+                try {
+                    if (imports !== 1 || usages !== 1 || !transformed.transformed[0])
+                        throw new Error('Workflow lazy ID adaptation did not match its reviewed shape.');
+                    return { contents: ts.createPrinter({ removeComments: true }).printFile(transformed.transformed[0]), loader: 'js' };
+                }
+                finally {
+                    transformed.dispose();
+                }
+            });
+        } };
+}

package/dist/node.d.ts

@@ -0,0 +1,12 @@
+import { type WorkflowTicket, type WorkflowAdvance, type WorkflowScheduler } from '@sinestack/workflow-core';
+/** One process owns this directory; Local World is not a distributed scheduler. */
+export declare function createNodeWorkflow(options: {
+    dataDir: string;
+    deploymentId: string;
+    workflowId: string;
+    createFlowRoute(): (request: Request) => Promise<Response>;
+    advance(ticket: WorkflowTicket): Promise<WorkflowAdvance>;
+}): Promise<WorkflowScheduler & {
+    start(): Promise<void>;
+    close(): Promise<void>;
+}>;

package/dist/node.js

@@ -0,0 +1,109 @@
+import { mkdir, readdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { createWorld } from '@workflow/world-local';
+import { getQueueTopicPrefix, resolveQueueNamespace } from '@workflow/world';
+import { start } from 'workflow/api';
+import { setWorld } from 'workflow/runtime';
+import { bindWorkflowRuntime } from "./runtime.js";
+import { deriveWorkflowRunId, validateWorkflowTicket } from '@sinestack/workflow-core';
+/** One process owns this directory; Local World is not a distributed scheduler. */
+export async function createNodeWorkflow(options) {
+    const { deploymentId, workflowId, createFlowRoute } = options;
+    const directory = resolve(options.dataDir, 'workflow');
+    await mkdir(directory, { recursive: true });
+    const existingLocalState = await readdir(resolve(directory, 'local')).catch((error) => {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT')
+            return [];
+        throw error;
+    });
+    // SQLite's OS-backed exclusive lock is released even after SIGKILL. Do not
+    // infer stale ownership from timeouts or delete another process's lock file.
+    const owner = new DatabaseSync(resolve(directory, 'owner.sqlite'));
+    // Pin the SDK sandbox for creation and replay. The SDK persists this choice
+    // on each run; no application source is evaluated through Node's vm engine.
+    if (process.env.WORKFLOW_VM && process.env.WORKFLOW_VM !== 'quickjs') {
+        owner.close();
+        throw new Error('The Node workflow executor requires WORKFLOW_VM=quickjs.');
+    }
+    process.env.WORKFLOW_VM = 'quickjs';
+    try {
+        owner.exec('BEGIN EXCLUSIVE');
+        owner.exec('CREATE TABLE IF NOT EXISTS workflow_owner (id INTEGER PRIMARY KEY CHECK(id=1), deployment_id TEXT NOT NULL)');
+        const prior = owner.prepare('SELECT deployment_id FROM workflow_owner WHERE id=1').get();
+        if (prior && prior.deployment_id !== deploymentId)
+            throw new Error('This workflow directory is pinned to another immutable deployment. Retain its original build until drained and use a separate executor data directory for the new release.');
+        if (!prior && existingLocalState.length)
+            throw new Error('Existing Local World data has no verified deployment pin. Retain the original build and data; implicit adoption by a new executor is refused.');
+        owner.prepare('INSERT OR IGNORE INTO workflow_owner(id,deployment_id) VALUES(1,?)').run(deploymentId);
+        // Commit the pin before holding the lifetime lock, so SIGKILL cannot erase it.
+        owner.exec('COMMIT');
+        owner.exec('BEGIN EXCLUSIVE');
+        if (owner.prepare('SELECT deployment_id FROM workflow_owner WHERE id=1').get()?.deployment_id !== deploymentId)
+            throw new Error('The workflow deployment ownership changed before acquiring its lifetime lock.');
+    }
+    catch (cause) {
+        owner.close();
+        if (cause instanceof Error && /deployment|implicit adoption/u.test(cause.message))
+            throw cause;
+        throw new Error('The Node workflow data directory already has an active owner.', { cause });
+    }
+    let unbind;
+    let closing = false;
+    const active = new Set();
+    const submissions = new Set();
+    const world = createWorld({ dataDir: resolve(directory, 'local'), recoverActiveRuns: true });
+    world.getDeploymentId = async () => deploymentId;
+    try {
+        unbind = bindWorkflowRuntime(ticket => options.advance(validateWorkflowTicket(ticket, { deploymentId })));
+        setWorld(world);
+        const route = createFlowRoute();
+        world.registerHandler(getQueueTopicPrefix('workflow', resolveQueueNamespace()), request => {
+            if (closing)
+                return Promise.resolve(new Response(null, { status: 503 }));
+            const delivery = route(request);
+            active.add(delivery);
+            void delivery.finally(() => active.delete(delivery)).catch(() => { });
+            return delivery;
+        });
+    }
+    catch (error) {
+        await world.close?.();
+        unbind?.();
+        owner.close();
+        throw error;
+    }
+    function submit(value, wake) {
+        if (closing)
+            return Promise.reject(new Error('The Node workflow executor is closing.'));
+        const work = (async () => {
+            const ticket = validateWorkflowTicket(value, { deploymentId });
+            const id = await deriveWorkflowRunId(ticket);
+            const run = await start({ workflowId }, [ticket], { world: { ...world, createRunId: () => id } });
+            if (wake)
+                await run.wakeUp();
+        })();
+        submissions.add(work);
+        void work.finally(() => submissions.delete(work)).catch(() => { });
+        return work;
+    }
+    let closed;
+    return {
+        deploymentId,
+        async start() { await world.start?.(); },
+        enqueue: ticket => submit(ticket, false),
+        wake: ticket => submit(ticket, true),
+        close() {
+            return closed ??= (async () => {
+                closing = true;
+                await Promise.allSettled([...submissions]);
+                await world.close?.();
+                // close() stops future deliveries but SDK direct handlers can still be
+                // finishing. Keep Runtime, authorization and secrets alive until drained.
+                await Promise.allSettled([...active]);
+                unbind?.();
+                owner.close();
+            })();
+        },
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowTicket, WorkflowAdvance } from '@sinestack/workflow-core';
+type Advance = (ticket: WorkflowTicket) => Promise<WorkflowAdvance>;
+export declare function bindWorkflowRuntime(advance: Advance): () => void;
+export declare function advanceWorkflow(ticket: WorkflowTicket): Promise<WorkflowAdvance>;
+export {};

package/dist/runtime.js

@@ -0,0 +1,17 @@
+// The compiler bundles steps separately. A process-global symbol keeps the
+// trusted host callback identical in those bundles; it is never an HTTP port.
+const key = Symbol.for('sine.workflow.runtime.v1');
+const state = globalThis;
+export function bindWorkflowRuntime(advance) {
+    if (state[key])
+        throw new Error('A workflow runtime is already bound in this process.');
+    state[key] = advance;
+    return () => { if (state[key] === advance)
+        delete state[key]; };
+}
+export async function advanceWorkflow(ticket) {
+    const advance = state[key];
+    if (!advance)
+        throw new Error('The trusted workflow runtime is unavailable.');
+    return advance(ticket);
+}

package/dist/step.d.ts

@@ -0,0 +1,6 @@
+import { type WorkflowTicket, type WorkflowAdvance } from '@sinestack/workflow-core';
+/** The runtime owner performs current authorization and durable phase deduplication on every invocation. */
+export declare function advanceRun(ticket: WorkflowTicket): Promise<WorkflowAdvance>;
+export declare namespace advanceRun {
+    var maxRetries: number;
+}

package/dist/step.js

@@ -0,0 +1,11 @@
+import { validateWorkflowAdvance } from '@sinestack/workflow-core';
+import { advanceWorkflow } from "./runtime.js";
+/** The runtime owner performs current authorization and durable phase deduplication on every invocation. */
+export async function advanceRun(ticket) {
+    'use step';
+    const result = await advanceWorkflow(ticket);
+    return validateWorkflowAdvance(result);
+}
+// One attempt per durable step. The owner handles provider retries, and the
+// fixed workflow handles host outages without implicitly replaying effects.
+advanceRun.maxRetries = 0;

package/dist/workflow.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowTicket } from '@sinestack/workflow-core';
+/** Fixed project orchestration. Neither caller code nor provider payloads enter this workflow. */
+export declare function runWorkflow(ticket: WorkflowTicket): Promise<void>;

package/dist/workflow.js

@@ -0,0 +1,20 @@
+import { sleep } from 'workflow';
+import { advanceRun } from "./step.js";
+/** Fixed project orchestration. Neither caller code nor provider payloads enter this workflow. */
+export async function runWorkflow(ticket) {
+    'use workflow';
+    for (;;) {
+        try {
+            const result = await advanceRun(ticket);
+            if (result.kind === 'completed')
+                return;
+            await sleep(new Date(result.wakeAt));
+        }
+        catch {
+            // A temporarily unavailable state owner must not permanently fail the
+            // workflow after the SDK's finite step retries. Only the owner decides
+            // the business deadline and terminal outcome; retry its fenced advance.
+            await sleep('30s');
+        }
+    }
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@sinestack/workflow-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1-oidc.0",
+  "type": "module",
+  "license": "UNLICENSED",
+  "description": "Shared fixed Workflow SDK orchestration, Node host and immutable Cloudflare builder.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fei-bai-inc/workflow.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://github.com/fei-bai-inc/workflow/tree/main/packages/sdk#readme",
+  "bugs": {
+    "url": "https://github.com/fei-bai-inc/workflow/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=24.19.0"
+  },
+  "exports": {
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./build": {
+      "types": "./dist/build.d.ts",
+      "default": "./dist/build.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE.workflow.txt"
+  ],
+  "dependencies": {
+    "@sinestack/workflow-core": "0.1.1-oidc.0",
+    "@sinestack/workflow-world-cloudflare": "0.1.1-oidc.0",
+    "@workflow/builders": "5.0.6",
+    "@workflow/world": "5.0.5",
+    "@workflow/world-local": "5.1.2",
+    "quickjs-wasi": "3.4.0",
+    "esbuild": "0.28.1",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "workflow": "5.2.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
 }

package/src/build.ts

@@ -0,0 +1,140 @@
+import { BaseBuilder, type WorkflowManifest } from '@workflow/builders';
+import { build } from 'esbuild';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile, cp, readdir, stat } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { workflowCompatibilityPlugin } from './compatibility.ts';
+
+export interface WorkflowBuildOptions {
+  root: string;
+  target: 'node' | 'cloudflare';
+  generatedDir?: string;
+  outputDir?: string;
+  deploymentPrefix?: string;
+  identityInputs: readonly string[];
+  runtimeService?: { service: string; entrypoint: string };
+  compatibilityDate?: string;
+}
+export interface WorkflowBuildResult { workflowId: string; deploymentId: string; generatedDir: string; outputDir?: string; configPath?: string; manifestPath: string }
+
+/** Build-time only: fixed infrastructure code; never evaluate provider or caller payloads. */
+export async function buildWorkflow(options: WorkflowBuildOptions): Promise<WorkflowBuildResult> {
+const root = resolve(options.root);
+const sdkSource = resolve(dirname(fileURLToPath(import.meta.url)), '../src');
+const sdkManifest = await readFile(resolve(sdkSource, '../package.json'));
+const sdkPackage = JSON.parse(sdkManifest.toString('utf8')) as { name: string; version: string };
+const implementation = `${sdkPackage.name}@${sdkPackage.version}`;
+const generated = resolve(root, options.generatedDir ?? '.generated/workflow');
+const target = options.target;
+if (target !== 'node' && target !== 'cloudflare') throw new Error('Expected node or cloudflare workflow target.');
+const prefix = options.deploymentPrefix ?? 'sinewf';
+if (!/^[a-z][a-z0-9-]{0,24}$/u.test(prefix)) throw new TypeError('Invalid immutable deployment prefix.');
+if (!options.identityInputs.length) throw new TypeError('Consumer effect code and contracts must participate in deployment identity.');
+if (target === 'cloudflare' && (!options.runtimeService || !/^[a-z0-9][a-z0-9-]{0,62}$/u.test(options.runtimeService.service) || !/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(options.runtimeService.entrypoint))) throw new TypeError('A trusted private runtime service and named entrypoint are required.');
+const output = resolve(root, options.outputDir ?? '.output/workflow');
+async function addConsumerIdentity(digest: ReturnType<typeof createHash>) {
+  // Pin infrastructure changes as well as product-owned side effects.
+  digest.update(sdkManifest);
+  for (const name of (await readdir(sdkSource)).filter(name => name.endsWith('.ts')).sort()) digest.update(name).update(await readFile(resolve(sdkSource, name)));
+  for (const path of [...options.identityInputs].sort()) {
+    const absolute = resolve(root, path), info = await stat(absolute);
+    if (info.isDirectory()) {
+      for (const name of (await readdir(absolute, { recursive: true })).sort()) {
+        const file = resolve(absolute, name);
+        if ((await stat(file)).isFile()) digest.update(`${path}/${name}`).update(await readFile(file));
+      }
+    } else if (info.isFile()) digest.update(path).update(await readFile(absolute));
+    else throw new TypeError(`Unsupported workflow identity input: ${path}`);
+  }
+}
+
+class WorkflowBuilder extends BaseBuilder {
+  workflowId = '';
+  // Upstream normally adds .gitignore entries under workingDir. Here that is
+  // an installed immutable package; build outputs belong to the consumer.
+  protected override async ensureSwcIgnored(): Promise<void> {}
+  async build() {
+    const inputs = [resolve(sdkSource, 'workflow.ts'), resolve(sdkSource, 'step.ts')];
+    const tsconfigPath = resolve(root, 'tsconfig.json');
+    const entries = await this.discoverEntries(inputs, generated, tsconfigPath);
+    await this.createStepsBundle({ inputFiles: inputs, outfile: resolve(generated, 'steps.mjs'), format: 'esm', tsconfigPath,
+      discoveredEntries: entries, skipEsmRequireBanner: true });
+    const result = await this.createWorkflowsBundle({ inputFiles: inputs, outfile: resolve(generated, 'flow.mjs'), format: 'esm',
+      tsconfigPath, discoveredEntries: entries, bundleFinalOutput: false });
+    if (result.interimBundleText === undefined) throw new Error('Workflow compiler did not emit the fixed workflow bundle.');
+    const workflows: NonNullable<WorkflowManifest['workflows']> = result.manifest.workflows ?? {};
+    const matches = Object.values(workflows).flatMap(value => Object.entries(value)).filter(([name]) => name === 'runWorkflow');
+    if (matches.length !== 1 || !matches[0]) throw new Error('The workflow must have exactly one compiled identity.');
+    this.workflowId = matches[0][1].workflowId;
+    if (!/^[a-zA-Z0-9_./@()[\]-]+$/u.test(this.workflowId) || /node_modules|\.bun|\.pnpm/u.test(this.workflowId)) {
+      throw new Error('The fixed workflow identity must not contain an installation path or package-manager encoding.');
+    }
+    await writeFile(resolve(generated, 'flow.mjs'), `import './steps.mjs';\nimport { workflowEntrypoint } from 'workflow/runtime';\nconst code = ${JSON.stringify(result.interimBundleText)};\nexport const createFlowRoute = () => workflowEntrypoint(code);\n`);
+    await writeFile(resolve(generated, 'flow.d.mts'), 'export declare function createFlowRoute(): (request: Request) => Promise<Response>;\n');
+  }
+}
+await mkdir(generated, { recursive: true });
+if (target === 'cloudflare') await mkdir(output, { recursive: true });
+// The compiler uses workingDir for non-exported source identities. Consumer
+// node_modules layouts (notably Bun's '+' paths) must never become durable IDs.
+// Every input/output and the consumer tsconfig are absolute, so only the fixed
+// infrastructure module identities are rooted here.
+const builder = new WorkflowBuilder({ buildTarget: 'standalone', workingDir: sdkSource, projectRoot: root, moduleSpecifierRoot: sdkSource,
+  dirs: [sdkSource], stepsBundlePath: resolve(generated, 'steps.mjs'), workflowsBundlePath: resolve(generated, 'flow.mjs'),
+  webhookBundlePath: resolve(generated, 'webhook.mjs'), sourcemap: false, discoverWorkflowsInNodeModules: false, externalPackages: ['cloudflare:workers'] });
+await builder.build();
+// Both hosts execute the same compiler output. Node bundles this fixed route
+// into Nitro; source discovery and compilation never happen during a request.
+const nodeDigest = createHash('sha256');
+for (const filename of ['flow.mjs', 'steps.mjs']) nodeDigest.update(filename).update(await readFile(resolve(generated, filename)));
+await addConsumerIdentity(nodeDigest);
+const nodeDeploymentId = `${prefix}-node-${nodeDigest.digest('hex').slice(0, 24)}`;
+await writeFile(resolve(generated, 'node-identity.mjs'), `export const workflowId = ${JSON.stringify(builder.workflowId)};\nexport const deploymentId = ${JSON.stringify(nodeDeploymentId)};\n`);
+await writeFile(resolve(generated, 'node-identity.d.mts'), 'export declare const workflowId: string;\nexport declare const deploymentId: string;\n');
+await writeFile(resolve(generated, 'manifest.node.json'), JSON.stringify({ schemaVersion: 1, workflowId: builder.workflowId, deploymentId: nodeDeploymentId, implementation, consumerIdentityInputs: options.identityInputs }, null, 2) + '\n');
+if (target === 'node') {
+  return { workflowId: builder.workflowId, deploymentId: nodeDeploymentId, generatedDir: generated, manifestPath: resolve(generated, 'manifest.node.json') };
+} else {
+const wasmFiles = [
+  ['quickjs-wasi/quickjs.wasm', 'quickjs.wasm'], ['quickjs-wasi/encoding.so', 'encoding.wasm'],
+  ['quickjs-wasi/headers.so', 'headers.wasm'], ['quickjs-wasi/url.so', 'url.wasm'],
+  ['quickjs-wasi/structured-clone.so', 'structured-clone.wasm'],
+] as const;
+for (const [specifier, name] of wasmFiles) await cp(fileURLToPath(import.meta.resolve(specifier)), resolve(output, name));
+await writeFile(resolve(generated, 'assets.mjs'), wasmFiles.map(([, name], index) => `import module${index} from './${name}';`).join('\n') +
+  '\nexport const modules = {quickjs:module0,encoding:module1,headers:module2,url:module3,structuredClone:module4};\n');
+await writeFile(resolve(generated, 'assets.d.mts'), 'export declare const modules: { quickjs: WebAssembly.Module; encoding: WebAssembly.Module; headers: WebAssembly.Module; url: WebAssembly.Module; structuredClone: WebAssembly.Module };\n');
+const result = await build({ absWorkingDir: root, entryPoints: [resolve(sdkSource, 'worker.ts')], outfile: resolve(output, 'index.mjs'),
+  bundle: true, format: 'esm', platform: 'neutral', target: 'es2023', conditions: ['workerd', 'worker', 'browser'],
+  external: ['cloudflare:*', 'node:*', './*.wasm'], minify: true, metafile: true,
+  plugins: [workflowCompatibilityPlugin()],
+  alias: { '@sine-workflow/generated/flow': resolve(generated, 'flow.mjs'), '@sine-workflow/generated/assets': resolve(generated, 'assets.mjs') },
+  define: { '__SINE_WORKFLOW_ID__': JSON.stringify(builder.workflowId), '__SINE_WORKFLOW_DEPLOYMENT__': JSON.stringify('sine-workflow-immutable-build') },
+});
+// The immutable deployment identity includes code, compiled engine contracts and Wasm.
+const digest = createHash('sha256');
+for (const filename of ['index.mjs', ...wasmFiles.map(([, name]) => name)]) digest.update(filename).update(await readFile(resolve(output, filename)));
+await addConsumerIdentity(digest);
+const deploymentId = `${prefix}-${digest.digest('hex').slice(0, 24)}`;
+const index = await readFile(resolve(output, 'index.mjs'), 'utf8');
+await writeFile(resolve(output, 'index.mjs'), index.replaceAll('sine-workflow-immutable-build', deploymentId));
+const configuration = {
+  name: deploymentId, main: 'index.mjs', compatibility_date: options.compatibilityDate ?? '2026-10-06', compatibility_flags: ['nodejs_compat', 'enable_ctx_exports'],
+  no_bundle: true, workers_dev: false, preview_urls: false,
+  rules: [{ type: 'CompiledWasm', globs: ['**/*.wasm'], fallthrough: true }],
+  vars: { WORKFLOW_VM: 'quickjs', WORKFLOW_COMPRESSION_CODEC: 'gzip', SINE_WORKFLOW_DEPLOYMENT: deploymentId },
+  durable_objects: { bindings: [{ name: 'WORKFLOW_RUNS', class_name: 'RunObject' }, { name: 'WORKFLOW_TOKENS', class_name: 'TokenObject' }, { name: 'WORKFLOW_STREAMS', class_name: 'StreamObject' }] },
+  migrations: [{ tag: 'v1', new_sqlite_classes: ['RunObject', 'TokenObject', 'StreamObject'] }],
+  services: [{ binding: 'SINE_WORKFLOW_RUNTIME', ...options.runtimeService }],
+  observability: { enabled: true },
+};
+const worldRoot = dirname(fileURLToPath(import.meta.resolve('@sinestack/workflow-world-cloudflare/package.json')));
+for (const name of ['LICENSE.workflow.txt', 'THIRD_PARTY_NOTICES.md', 'SOURCE_ORIGINS.json']) await cp(resolve(worldRoot, name), resolve(output, name));
+await writeFile(resolve(output, 'wrangler.json'), JSON.stringify(configuration, null, 2) + '\n');
+await writeFile(resolve(output, 'manifest.json'), JSON.stringify({ schemaVersion: 1, deploymentId, workflowId: builder.workflowId, implementation, consumerIdentityInputs: options.identityInputs,
+  source: { repository: 'https://github.com/vercel/workflow', commit: 'a555966986af83b94cb77d1d427dfdb18a2732cc', pullRequest: 4682 },
+  inputs: Object.keys(result.metafile.inputs).sort(), files: (await readdir(output)).sort() }, null, 2) + '\n');
+return { workflowId: builder.workflowId, deploymentId, generatedDir: generated, outputDir: output, configPath: resolve(output, 'wrangler.json'), manifestPath: resolve(output, 'manifest.json') };
+}
+}

package/src/compatibility.ts

@@ -0,0 +1,69 @@
+// Build-only adaptation of vercel/workflow PR #4682 (Apache-2.0), commit a555966986af83b94cb77d1d427dfdb18a2732cc.
+// SDK 5.2.3 still generates compute telemetry IDs at module load; Workers only permit randomness during requests.
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import type { Plugin } from 'esbuild';
+import ts from 'typescript';
+
+const fingerprints: Readonly<Record<string, string>> = {
+  'runtime/compute-instance.js': 'fb94134ecb1aa7f5dc2f4dfe38e073e24f023743d2538a9ed1be3781ec5fb01f',
+  'runtime.js': '1e7a1dffc2dbb91668f07e6fe4dbcf6b245c2a22dfeb604655e4bf2e9ca2ef35',
+  'runtime/step-executor.js': '9ba44e47d56f5deae57ff8e46560094dd614161b89241824715230ae07b7c963',
+  'runtime/suspension-handler.js': 'a86dac33cc640ad757e7e252ae4dd1d0f7a230cb2d0f0bd10b41ea5e2cc33322',
+  'runtime/world.js': '6051f9184059de80a1b1fa61c2403d25354fc3c6b6aa83f4015dd7b8893efa48',
+};
+
+/** Narrow, hash-bound upstream compatibility port; never mutates node_modules or evaluates input code. */
+export function workflowCompatibilityPlugin(): Plugin {
+  return { name: 'sine-workflow-compatibility', setup(builder) {
+    builder.onLoad({ filter: /@workflow\/core\/dist\/(runtime\.js|runtime\/(world|compute-instance|step-executor|suspension-handler)\.js)$/ }, async args => {
+      const name = args.path.split('/@workflow/core/dist/')[1];
+      const expected = name === undefined ? undefined : fingerprints[name];
+      if (!expected) throw new Error('Unexpected Workflow compatibility input.');
+      const source = await readFile(args.path, 'utf8');
+      if (createHash('sha256').update(source).digest('hex') !== expected) throw new Error(`Workflow SDK compatibility input changed: ${name}. Review the upstream update before building.`);
+      const file = ts.createSourceFile(args.path, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+      if (name === 'runtime/compute-instance.js') {
+        return { contents: "import { ulid } from 'ulid';\nlet instanceId;\nexport function getComputeInstanceId() { return instanceId ??= `cinst_${ulid()}`; }\n", loader: 'js' };
+      }
+      if (name === 'runtime/world.js') {
+        // This deployment injects its World explicitly. Retain upstream caches and protocol checks,
+        // but remove ambient package discovery and unselected Node/Vercel backend imports.
+        const removeFunctions: Readonly<Record<string, true>> = { getRuntimeRequire: true, resolveModulePath: true };
+        let replaced = 0;
+        const printer = ts.createPrinter({ removeComments: true });
+        const statements = file.statements.flatMap(statement => {
+          if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) &&
+              ['node:module', 'node:url', '@workflow/utils', '@workflow/world-local', '@workflow/world-vercel'].includes(statement.moduleSpecifier.text)) return [];
+          if (ts.isFunctionDeclaration(statement) && statement.name && removeFunctions[statement.name.text]) return [];
+          if (ts.isVariableStatement(statement) && statement.declarationList.declarations.some(declaration => ts.isIdentifier(declaration.name) && declaration.name.text === 'createWorld')) {
+            replaced++;
+            return ["export const createWorld = async () => { throw new Error('Cloudflare workflow World must be explicitly injected before use.'); };"];
+          }
+          return [printer.printNode(ts.EmitHint.Unspecified, statement, file)];
+        });
+        if (replaced !== 1) throw new Error('Workflow World initialization changed.');
+        return { contents: statements.join('\n'), loader: 'js' };
+      }
+      let imports = 0, usages = 0;
+      const transformed = ts.transform(file, [context => root => {
+        const visitor: ts.Visitor = node => {
+          if (ts.isImportSpecifier(node) && node.name.text === 'COMPUTE_INSTANCE_ID') {
+            imports++;
+            return ts.factory.updateImportSpecifier(node, false, undefined, ts.factory.createIdentifier('getComputeInstanceId'));
+          }
+          if (ts.isIdentifier(node) && node.text === 'COMPUTE_INSTANCE_ID') {
+            usages++;
+            return ts.factory.createCallExpression(ts.factory.createIdentifier('getComputeInstanceId'), undefined, []);
+          }
+          return ts.visitEachChild(node, visitor, context);
+        };
+        return ts.visitNode(root, visitor, ts.isSourceFile) ?? root;
+      }]);
+      try {
+        if (imports !== 1 || usages !== 1 || !transformed.transformed[0]) throw new Error('Workflow lazy ID adaptation did not match its reviewed shape.');
+        return { contents: ts.createPrinter({ removeComments: true }).printFile(transformed.transformed[0]), loader: 'js' };
+      } finally { transformed.dispose(); }
+    });
+  } };
+}

package/src/generated.d.ts

@@ -0,0 +1,7 @@
+/** Build-owned static modules; emitted only by buildWorkflow, never supplied by API callers. */
+declare module '@sine-workflow/generated/flow' {
+  export function createFlowRoute(): (request: Request) => Promise<Response>;
+}
+declare module '@sine-workflow/generated/assets' {
+  export const modules: { quickjs: WebAssembly.Module; encoding: WebAssembly.Module; headers: WebAssembly.Module; url: WebAssembly.Module; structuredClone: WebAssembly.Module };
+}

package/src/node.ts

@@ -0,0 +1,106 @@
+import { mkdir, readdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { createWorld } from '@workflow/world-local';
+import { getQueueTopicPrefix, resolveQueueNamespace } from '@workflow/world';
+import { start } from 'workflow/api';
+import { setWorld } from 'workflow/runtime';
+import { bindWorkflowRuntime } from './runtime.ts';
+import { deriveWorkflowRunId, validateWorkflowTicket, type WorkflowTicket, type WorkflowAdvance, type WorkflowScheduler } from '@sinestack/workflow-core';
+
+/** One process owns this directory; Local World is not a distributed scheduler. */
+export async function createNodeWorkflow(options: {
+  dataDir: string;
+  deploymentId: string;
+  workflowId: string;
+  createFlowRoute(): (request: Request) => Promise<Response>;
+  advance(ticket: WorkflowTicket): Promise<WorkflowAdvance>;
+}): Promise<WorkflowScheduler & { start(): Promise<void>; close(): Promise<void> }> {
+  const { deploymentId, workflowId, createFlowRoute } = options;
+  const directory = resolve(options.dataDir, 'workflow');
+  await mkdir(directory, { recursive: true });
+  const existingLocalState = await readdir(resolve(directory, 'local')).catch((error: unknown) => {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') return [];
+    throw error;
+  });
+  // SQLite's OS-backed exclusive lock is released even after SIGKILL. Do not
+  // infer stale ownership from timeouts or delete another process's lock file.
+  const owner = new DatabaseSync(resolve(directory, 'owner.sqlite'));
+  // Pin the SDK sandbox for creation and replay. The SDK persists this choice
+  // on each run; no application source is evaluated through Node's vm engine.
+  if (process.env.WORKFLOW_VM && process.env.WORKFLOW_VM !== 'quickjs') {
+    owner.close();
+    throw new Error('The Node workflow executor requires WORKFLOW_VM=quickjs.');
+  }
+  process.env.WORKFLOW_VM = 'quickjs';
+  try {
+    owner.exec('BEGIN EXCLUSIVE');
+    owner.exec('CREATE TABLE IF NOT EXISTS workflow_owner (id INTEGER PRIMARY KEY CHECK(id=1), deployment_id TEXT NOT NULL)');
+    const prior = owner.prepare('SELECT deployment_id FROM workflow_owner WHERE id=1').get();
+    if (prior && prior.deployment_id !== deploymentId) throw new Error('This workflow directory is pinned to another immutable deployment. Retain its original build until drained and use a separate executor data directory for the new release.');
+    if (!prior && existingLocalState.length) throw new Error('Existing Local World data has no verified deployment pin. Retain the original build and data; implicit adoption by a new executor is refused.');
+    owner.prepare('INSERT OR IGNORE INTO workflow_owner(id,deployment_id) VALUES(1,?)').run(deploymentId);
+    // Commit the pin before holding the lifetime lock, so SIGKILL cannot erase it.
+    owner.exec('COMMIT');
+    owner.exec('BEGIN EXCLUSIVE');
+    if (owner.prepare('SELECT deployment_id FROM workflow_owner WHERE id=1').get()?.deployment_id !== deploymentId) throw new Error('The workflow deployment ownership changed before acquiring its lifetime lock.');
+  } catch (cause) {
+    owner.close();
+    if (cause instanceof Error && /deployment|implicit adoption/u.test(cause.message)) throw cause;
+    throw new Error('The Node workflow data directory already has an active owner.', { cause });
+  }
+  let unbind: (() => void) | undefined;
+  let closing = false;
+  const active = new Set<Promise<Response>>();
+  const submissions = new Set<Promise<void>>();
+  const world = createWorld({ dataDir: resolve(directory, 'local'), recoverActiveRuns: true });
+  world.getDeploymentId = async () => deploymentId;
+  try {
+    unbind = bindWorkflowRuntime(ticket => options.advance(validateWorkflowTicket(ticket, { deploymentId })));
+    setWorld(world);
+    const route = createFlowRoute();
+    world.registerHandler(getQueueTopicPrefix('workflow', resolveQueueNamespace()), request => {
+      if (closing) return Promise.resolve(new Response(null, { status: 503 }));
+      const delivery = route(request);
+      active.add(delivery);
+      void delivery.finally(() => active.delete(delivery)).catch(() => {});
+      return delivery;
+    });
+  } catch (error) {
+    await world.close?.();
+    unbind?.();
+    owner.close();
+    throw error;
+  }
+  function submit(value: WorkflowTicket, wake: boolean): Promise<void> {
+    if (closing) return Promise.reject(new Error('The Node workflow executor is closing.'));
+    const work = (async () => {
+      const ticket = validateWorkflowTicket(value, { deploymentId });
+      const id = await deriveWorkflowRunId(ticket);
+      const run = await start({ workflowId }, [ticket], { world: { ...world, createRunId: () => id } });
+      if (wake) await run.wakeUp();
+    })();
+    submissions.add(work);
+    void work.finally(() => submissions.delete(work)).catch(() => {});
+    return work;
+  }
+  let closed: Promise<void> | undefined;
+  return {
+    deploymentId,
+    async start() { await world.start?.(); },
+    enqueue: ticket => submit(ticket, false),
+    wake: ticket => submit(ticket, true),
+    close() {
+      return closed ??= (async () => {
+        closing = true;
+        await Promise.allSettled([...submissions]);
+        await world.close?.();
+        // close() stops future deliveries but SDK direct handlers can still be
+        // finishing. Keep Runtime, authorization and secrets alive until drained.
+        await Promise.allSettled([...active]);
+        unbind?.();
+        owner.close();
+      })();
+    },
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,19 @@
+import type { WorkflowTicket, WorkflowAdvance } from '@sinestack/workflow-core';
+
+type Advance = (ticket: WorkflowTicket) => Promise<WorkflowAdvance>;
+// The compiler bundles steps separately. A process-global symbol keeps the
+// trusted host callback identical in those bundles; it is never an HTTP port.
+const key = Symbol.for('sine.workflow.runtime.v1');
+const state = globalThis as typeof globalThis & { [key]?: Advance };
+
+export function bindWorkflowRuntime(advance: Advance): () => void {
+  if (state[key]) throw new Error('A workflow runtime is already bound in this process.');
+  state[key] = advance;
+  return () => { if (state[key] === advance) delete state[key]; };
+}
+
+export async function advanceWorkflow(ticket: WorkflowTicket): Promise<WorkflowAdvance> {
+  const advance = state[key];
+  if (!advance) throw new Error('The trusted workflow runtime is unavailable.');
+  return advance(ticket);
+}

package/src/step.ts

@@ -0,0 +1,13 @@
+import { validateWorkflowAdvance, type WorkflowTicket, type WorkflowAdvance } from '@sinestack/workflow-core';
+import { advanceWorkflow } from './runtime.ts';
+
+/** The runtime owner performs current authorization and durable phase deduplication on every invocation. */
+export async function advanceRun(ticket: WorkflowTicket): Promise<WorkflowAdvance> {
+  'use step';
+  const result: unknown = await advanceWorkflow(ticket);
+  return validateWorkflowAdvance(result);
+}
+
+// One attempt per durable step. The owner handles provider retries, and the
+// fixed workflow handles host outages without implicitly replaying effects.
+advanceRun.maxRetries = 0;

package/src/worker.ts

@@ -0,0 +1,35 @@
+import { WorkerEntrypoint, env } from 'cloudflare:workers';
+import { start } from 'workflow/api';
+import { setWorld } from 'workflow/runtime';
+import { setupCloudflareWorld } from '@sinestack/workflow-world-cloudflare';
+import { createFlowRoute } from '@sine-workflow/generated/flow';
+import { modules } from '@sine-workflow/generated/assets';
+import { deriveWorkflowRunId, validateWorkflowTicket, validateWorkflowAdvance, type WorkflowTicket, type WorkflowAdvance } from '@sinestack/workflow-core';
+import { bindWorkflowRuntime } from './runtime.ts';
+
+export { RunObject, StepRunner, StreamObject, TokenObject } from '@sinestack/workflow-world-cloudflare';
+declare const __SINE_WORKFLOW_ID__: string;
+declare const __SINE_WORKFLOW_DEPLOYMENT__: string;
+
+const world = setupCloudflareWorld({ deploymentId: __SINE_WORKFLOW_DEPLOYMENT__, createFlowRoute, setWorld, quickjs: modules });
+bindWorkflowRuntime(async (ticket: WorkflowTicket): Promise<WorkflowAdvance> => {
+  const binding = (env as Record<string, unknown>).SINE_WORKFLOW_RUNTIME;
+  if (typeof binding !== 'object' || binding === null || !('advanceWorkflow' in binding) || typeof binding.advanceWorkflow !== 'function') {
+    throw new Error('The private workflow runtime binding is unavailable.');
+  }
+  return validateWorkflowAdvance(await binding.advanceWorkflow(ticket));
+});
+
+/** Only a named private service binding can submit work. The public fetch surface is closed. */
+export class WorkflowService extends WorkerEntrypoint {
+  private async submit(value: unknown, wake: boolean): Promise<void> {
+    const ticket = validateWorkflowTicket(value, { deploymentId: __SINE_WORKFLOW_DEPLOYMENT__ });
+    const id = await deriveWorkflowRunId(ticket);
+    const run = await start({ workflowId: __SINE_WORKFLOW_ID__ }, [ticket], { world: { ...world, createRunId: () => id } });
+    if (wake) await run.wakeUp();
+  }
+  async enqueue(value: unknown): Promise<void> { return this.submit(value, false); }
+  async wake(value: unknown): Promise<void> { return this.submit(value, true); }
+}
+
+export default { fetch(): Response { return new Response(null, { status: 404 }); } };

package/src/workflow.ts

@@ -0,0 +1,20 @@
+import { sleep } from 'workflow';
+import type { WorkflowTicket } from '@sinestack/workflow-core';
+import { advanceRun } from './step.ts';
+
+/** Fixed project orchestration. Neither caller code nor provider payloads enter this workflow. */
+export async function runWorkflow(ticket: WorkflowTicket): Promise<void> {
+  'use workflow';
+  for (;;) {
+    try {
+      const result = await advanceRun(ticket);
+      if (result.kind === 'completed') return;
+      await sleep(new Date(result.wakeAt));
+    } catch {
+      // A temporarily unavailable state owner must not permanently fail the
+      // workflow after the SDK's finite step retries. Only the owner decides
+      // the business deadline and terminal outcome; retry its fenced advance.
+      await sleep('30s');
+    }
+  }
+}