@hatchet-dev/typescript-sdk 1.34.0-alpha.1 → 1.34.0

package/core/run-ref.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRunRef = exports.MAX_POLL_INTERVAL_MS = exports.INITIAL_POLL_INTERVAL_MS = void 0;
+const hatchet_error_1 = __importDefault(require("../util/errors/hatchet-error"));
+const abort_error_1 = require("../util/abort-error");
+const data_contracts_1 = require("../clients/rest/generated/data-contracts");
+const run_detail_1 = require("./run-detail");
+/** The first wait between two `GetRunDetails` polls. */
+exports.INITIAL_POLL_INTERVAL_MS = 250;
+/** The longest wait between two polls; the interval doubles until it gets here. */
+exports.MAX_POLL_INTERVAL_MS = 5000;
+/**
+ * The signal one poll is issued with: it fires when the caller's signal fires or when the
+ * deadline arrives, whichever is first. `AbortSignal.any` and `AbortSignal.timeout` are
+ * missing on some runtimes the core entry targets, so a plain controller, timer and
+ * forwarded abort are used everywhere; the timer is also one a test's fake clock controls.
+ */
+function pollSignal(signal, remainingMs) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const forwardAbort = () => controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason);
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', forwardAbort, { once: true });
+    const timer = remainingMs === undefined
+        ? undefined
+        : setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, remainingMs);
+    return {
+        signal: controller.signal,
+        timedOut: () => timedOut,
+        dispose: () => {
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', forwardAbort);
+            if (timer !== undefined)
+                clearTimeout(timer);
+        },
+    };
+}
+function wait(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * A reference to a triggered run. `result()` polls `GetRunDetails` until the run is done,
+ * which is the one way to wait for a run that works on every platform the core client runs
+ * on: no stream is held open, so a Worker request or a browser tab can wait on it.
+ */
+class WorkflowRunRef {
+    constructor(workflowRunId, runs, parentWorkflowRunId, standaloneTaskName, defaultSignal) {
+        this.runs = runs;
+        this.workflowRunId = workflowRunId;
+        this.parentWorkflowRunId = parentWorkflowRunId;
+        this._standaloneTaskName = standaloneTaskName;
+        this.defaultSignal = defaultSignal;
+    }
+    get runId() {
+        return this.getWorkflowRunId();
+    }
+    getWorkflowRunId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.workflowRunId;
+        });
+    }
+    /** The run's result; the same as `result()` with no options. */
+    get output() {
+        return this.result();
+    }
+    /** The run's current state. */
+    details() {
+        return this.runs.getDetails(this.workflowRunId);
+    }
+    /**
+     * Waits for the run to finish and returns its output: the standalone task's output for a
+     * task, or the outputs keyed by task name for a workflow.
+     *
+     * The wait polls with backoff, starting at 250 ms and capped at 5 s with jitter. It is
+     * unbounded unless `timeoutMs` is set (rejects with a `HatchetError`) or `signal` fires
+     * (rejects with an `AbortError`). Both bound the poll in flight as well as the waits
+     * between polls, so a stalled `GetRunDetails` cannot hold the result past the deadline.
+     *
+     * A failed or cancelled run rejects the way the Node client's `result()` does: with the
+     * array of the tasks' error messages when any task reported one. When no task reported an
+     * error the run resolves with the tasks' outputs whatever its status, as it does on the
+     * Node client, since that is the shape an explicit cancellation leaves. A run with no
+     * tasks at all rejects with an `Error` naming the run's status.
+     */
+    result() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a;
+            const signal = (_a = options.signal) !== null && _a !== void 0 ? _a : this.defaultSignal;
+            const startedAt = Date.now();
+            const deadline = options.timeoutMs !== undefined ? startedAt + options.timeoutMs : undefined;
+            let interval = exports.INITIAL_POLL_INTERVAL_MS;
+            const abortError = () => (0, abort_error_1.createAbortError)(`waiting for run ${this.workflowRunId} was aborted`);
+            const timeoutError = () => new hatchet_error_1.default(`timed out after ${options.timeoutMs} ms waiting for run ${this.workflowRunId}`);
+            for (;;) {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw abortError();
+                }
+                const remaining = deadline !== undefined ? deadline - Date.now() : undefined;
+                if (remaining !== undefined && remaining <= 0) {
+                    throw timeoutError();
+                }
+                // Whatever the transport rejected with, an abort by the caller's signal surfaces as the
+                // AbortError the check above throws and one by the deadline as the same HatchetError;
+                // the deadline also goes to the call so the transport applies a Connect timeout.
+                const poll = pollSignal(signal, remaining);
+                let detail;
+                try {
+                    detail = yield this.runs.getDetails(this.workflowRunId, { signal: poll.signal, deadline });
+                }
+                catch (e) {
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                        throw abortError();
+                    }
+                    if (poll.timedOut() || (deadline !== undefined && Date.now() >= deadline)) {
+                        throw timeoutError();
+                    }
+                    throw e;
+                }
+                finally {
+                    poll.dispose();
+                }
+                if (detail.done) {
+                    return this.resolveResult(detail);
+                }
+                const now = Date.now();
+                if (deadline !== undefined && now >= deadline) {
+                    throw timeoutError();
+                }
+                // Jitter of up to 20% keeps many waiters from polling in lockstep; the cap holds for
+                // the jittered wait too.
+                let delay = Math.min(Math.round(interval * (1 + Math.random() * 0.2)), exports.MAX_POLL_INTERVAL_MS);
+                if (deadline !== undefined) {
+                    delay = Math.min(delay, Math.max(0, deadline - now));
+                }
+                yield wait(delay, signal);
+                interval = Math.min(interval * 2, exports.MAX_POLL_INTERVAL_MS);
+            }
+        });
+    }
+    resolveResult(detail) {
+        if (detail.status === data_contracts_1.V1TaskStatus.COMPLETED) {
+            return Promise.resolve(this.outputs(detail));
+        }
+        const tasks = Object.values(detail.taskRuns);
+        const errors = tasks
+            .map((task) => task.error)
+            .filter((error) => error !== undefined && error !== '');
+        if (errors.length > 0) {
+            return Promise.reject(errors);
+        }
+        // A task with no error under a terminal status is what an explicit cancellation
+        // (`ctx.cancel()` on a batch member, for one) leaves behind; the Node client resolves it
+        // with the task's output rather than failing the wait, and this keeps that contract.
+        if (tasks.length > 0) {
+            return Promise.resolve(this.outputs(detail));
+        }
+        const outcome = detail.status === data_contracts_1.V1TaskStatus.CANCELLED ? 'was cancelled' : 'failed';
+        return Promise.reject(new Error(`run ${this.workflowRunId} ${outcome}`));
+    }
+    /**
+     * The outputs keyed by task name, or the standalone task's own output, each read the way
+     * the Node client reads them; a task output that is not JSON throws its `SyntaxError`.
+     */
+    outputs(detail) {
+        const outputs = {};
+        for (const task of Object.values(detail.taskRuns)) {
+            outputs[task.readableId] = (0, run_detail_1.parseTaskOutput)(task);
+        }
+        if (this._standaloneTaskName) {
+            return outputs[this._standaloneTaskName];
+        }
+        return outputs;
+    }
+    toJSON() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify({ workflowRunId: this.workflowRunId });
+        });
+    }
+    cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runs.cancel({ ids: [this.workflowRunId] });
+        });
+    }
+    replay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runs.replay({ ids: [this.workflowRunId] });
+        });
+    }
+}
+exports.WorkflowRunRef = WorkflowRunRef;

package/core/types.d.ts

@@ -0,0 +1,182 @@
+/**
+ * The option and result types shared by the core client and the Node client. Everything in
+ * this module is edge-safe: it imports nothing from Node, so the Node client's types extend
+ * these where they need more.
+ */
+import type { Transport } from '@connectrpc/connect';
+import type { FetchTlsConfig } from '../clients/transport/fetch-transport';
+import type { Priority } from '../v1/declaration';
+import type { WorkerLabelComparator } from '../protoc/v1/shared/trigger';
+import type { RateLimitDuration } from '../protoc/workflows/workflows';
+import type { V1TaskStatus } from '../clients/rest/generated/data-contracts';
+import type { RetrierConfig } from '../util/retrier';
+import type { Logger, LogLevel } from '../util/logger/logger';
+import type { UnaryCallOptions } from '../clients/transport/ts-proto-client';
+/** Builds the logger a client component logs through. */
+export type LogConstructor = (context: string, logLevel?: LogLevel) => Logger;
+/**
+ * Per-call options for a unary RPC: `signal` aborts the call, `deadline` (a `Date` or epoch
+ * milliseconds) bounds it, `metadata` adds request headers. The same options the Node
+ * client's RPC clients take.
+ */
+export type CallOptions = UnaryCallOptions;
+/**
+ * The core client's configuration. It is explicit by design: nothing is read from the
+ * environment, a config file or the filesystem, so the same object works in a Worker, a
+ * browser bundle and Node.
+ */
+export interface CoreClientConfig {
+    /** The tenant API token. */
+    token: string;
+    /**
+     * The engine's base URL, for example `https://engine.example.com:7070`: an absolute
+     * `http://` or `https://` URL with no username, password, query string or fragment, whose
+     * scheme agrees with `tls` (`http://` needs `{ strategy: 'none' }`). When neither this nor
+     * `hostPort` is set, the address is read from the token's `grpc_broadcast_address` claim,
+     * so `{ token }` alone reaches the engine the token was issued for.
+     */
+    serverUrl?: string;
+    /** The engine's `host:port`, combined with `tls` into the base URL. */
+    hostPort?: string;
+    /**
+     * Defaults to `{ strategy: 'tls' }`. The token travels on every call, so plain HTTP has to
+     * be chosen explicitly with `{ strategy: 'none' }`.
+     */
+    tls?: FetchTlsConfig;
+    /**
+     * The prefix applied to workflow names and event keys, the same way the Node client applies
+     * `HATCHET_CLIENT_NAMESPACE`: it is lowercased and gets a trailing underscore when missing.
+     */
+    namespace?: string;
+    /**
+     * A ready transport, in place of the fetch transport the client builds from the fields
+     * above. It is used as is: the bearer token, the URL and TLS checks and the message size
+     * limits apply to the transport the client builds, so a supplied transport owns its own
+     * authentication and limits.
+     */
+    transport?: Transport;
+    /** The `fetch` the transport sends with. Defaults to the runtime's global `fetch`. */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * The largest response accepted, in bytes after HTTP decompression; a larger one rejects
+     * with a `ConnectError` of code `ResourceExhausted`. Defaults to 4 MiB, the Node client's
+     * `grpc_max_recv_message_length` default.
+     */
+    maxReceiveMessageBytes?: number;
+    /**
+     * The largest request sent, in bytes; a larger one rejects with a `ConnectError` of code
+     * `ResourceExhausted` before anything is sent. Defaults to 4 MiB, the Node client's
+     * `grpc_max_send_message_length` default.
+     */
+    maxSendMessageBytes?: number;
+    /** Retry settings for the unary calls, the same shape as the Node client's `retrier`. */
+    retrier?: RetrierConfig;
+    logger?: LogConstructor;
+    logLevel?: LogLevel;
+}
+export type DesiredWorkerLabelOpt = {
+    value: string | number;
+    required?: boolean;
+    weight?: number;
+    comparator?: WorkerLabelComparator;
+};
+/**
+ * The options a single `TriggerWorkflow` call accepts. The Node client's `admin.runWorkflow`
+ * takes exactly this type.
+ */
+export type TriggerRunOptions = {
+    parentId?: string | undefined;
+    /**
+     * (optional) the parent task run external id.
+     *
+     * This is the field understood by the workflows gRPC API (`parent_task_run_external_id`).
+     */
+    parentTaskRunExternalId?: string | undefined;
+    /**
+     * @deprecated Use `parentTaskRunExternalId` instead.
+     * Kept for backward compatibility; will be mapped to `parentTaskRunExternalId`.
+     */
+    parentStepRunId?: string | undefined;
+    childIndex?: number | undefined;
+    childKey?: string | undefined;
+    additionalMetadata?: Record<string, string> | undefined;
+    desiredWorkerId?: string | undefined;
+    priority?: Priority;
+    desiredWorkerLabels?: Record<string, DesiredWorkerLabelOpt>;
+    _standaloneTaskName?: string | undefined;
+};
+/** One entry of a bulk trigger. */
+export type TriggerRun<I = object> = {
+    workflowName: string;
+    input: I;
+    options?: TriggerRunOptions;
+};
+/** Options for pushing an event. */
+export interface PushEventOptions {
+    additionalMetadata?: Record<string, string>;
+    priority?: number;
+    scope?: string;
+}
+/** One event of a bulk push, with per-event overrides of the push options. */
+export interface EventWithMetadata<T> {
+    payload: T;
+    additionalMetadata?: Record<string, unknown>;
+    priority?: number;
+    scope?: string;
+}
+export type CreateRateLimitOpts = {
+    key: string;
+    limit: number;
+    duration?: RateLimitDuration;
+};
+/** The state of one task of a run, as `GetRunDetails` reports it. */
+export type TaskRunDetail = {
+    externalId: string;
+    readableId: string;
+    status: V1TaskStatus;
+    /** The output decoded as JSON; `null` when the task stored nothing, `null` or text that is not JSON. */
+    output: unknown;
+    /** The output text as the engine stored it; absent when the task stored nothing. */
+    rawOutput?: string;
+    error?: string;
+    isEvicted: boolean;
+};
+/** The state of a run, as `GetRunDetails` reports it. `taskRuns` is keyed by readable id. */
+export type RunDetail = {
+    status: V1TaskStatus;
+    done: boolean;
+    input: unknown;
+    additionalMetadata: unknown;
+    isEvicted: boolean;
+    taskRuns: Record<string, TaskRunDetail>;
+};
+/** The filter fields shared by the core and Node run filters. */
+export type RunFilterBase = {
+    /** Defaults to one hour ago. */
+    since?: Date;
+    until?: Date;
+    statuses?: V1TaskStatus[];
+    additionalMetadata?: Record<string, string>;
+};
+/**
+ * The core client's run filter. It takes workflow ids rather than names because resolving a
+ * name is a REST call, which the core client does not make.
+ */
+export type RunFilter = RunFilterBase & {
+    workflowIds?: string[];
+};
+export type CancelRunOpts = {
+    ids?: string[];
+    filters?: RunFilter;
+};
+export type ReplayRunOpts = {
+    ids?: string[];
+    filters?: RunFilter;
+};
+/** Options for waiting on a run's result. */
+export interface ResultOptions {
+    /** Rejects with a `HatchetError` once this many milliseconds have passed. No limit by default. */
+    timeoutMs?: number;
+    /** Rejects with an `AbortError` when the signal fires. */
+    signal?: AbortSignal;
+}

package/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/check-edge-entry.mjs

@@ -1,20 +1,39 @@
 #!/usr/bin/env node
 /* eslint-disable no-console */
-// Verifies the edge entry point (`@hatchet-dev/typescript-sdk/edge`) imports nothing
-// from Node. Bundles dist/edge/index.js for a workerd-like browser target and fails on
-// any `node:` specifier or Node builtin reached from it, transitively.
+// Verifies that an entry point imports nothing from Node. Bundles the entry for a
+// workerd-like browser target and fails on any `node:` specifier or Node builtin reached
+// from it, transitively, on any package named with `--forbid`, and on any SDK module in the
+// bundle that touches a Node-only global (which a bundler cannot see, since nothing imports
+// them): `process`, `Buffer`, `setImmediate`, a timer's `.unref()`, `AbortSignal.timeout`
+// and `AbortSignal.any`. A use the module feature-detects (`typeof setImmediate`,
+// `timer.unref?.()`, `globalThis.Buffer`) is allowed.
 //
-// Run after `pnpm run tsc:build` (the `check:edge` script does both). An alternative
-// entry can be given as the first argument to inspect another module, for example
-// `node scripts/check-edge-entry.mjs dist/index.js` to see what the root reaches.
+// Run after `pnpm run tsc:build`:
+//   node scripts/check-edge-entry.mjs                       # dist/edge/index.js
+//   node scripts/check-edge-entry.mjs dist/core/index.js --forbid axios,nice-grpc
+// The `check:edge` and `check:core` scripts build first and then run the two entries.
 import { builtinModules } from 'node:module';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
+import { build, transformSync } from 'esbuild';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const entry = resolve(root, process.argv[2] ?? 'dist/edge/index.js');
+
+const args = process.argv.slice(2);
+const forbidden = new Set();
+let entryArg = 'dist/edge/index.js';
+for (let i = 0; i < args.length; i += 1) {
+  if (args[i] === '--forbid') {
+    for (const pkg of (args[i + 1] ?? '').split(',')) if (pkg) forbidden.add(pkg);
+    i += 1;
+  } else {
+    entryArg = args[i];
+  }
+}
+
+const entry = resolve(root, entryArg);
+const label = entryArg.replace(/^dist\//, '').replace(/\/index\.js$/, '');
 
 if (!existsSync(entry)) {
   console.error(`entry not built: ${entry} is missing. Run \`pnpm run tsc:build\` first.`);
@@ -63,22 +82,61 @@ const result = await build({
 });
 
 const bundled = Object.keys(result.metafile.inputs);
-const sdkInputs = bundled.filter((f) => f.startsWith('dist/'));
+const sdkInputs = bundled.filter((f) => !f.includes('node_modules/'));
 const packageInputs = [...new Set(bundled.filter((f) => f.includes('node_modules/')).map((f) => {
   const m = f.match(/node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?((?:@[^/]+\/)?[^/]+)/);
   return m ? m[1] : f;
 }))].sort();
 
-console.log(`edge entry: bundled ${sdkInputs.length} SDK module(s) and ${packageInputs.length} package(s)`);
+console.log(`${label} entry: bundled ${sdkInputs.length} SDK module(s) and ${packageInputs.length} package(s)`);
 if (packageInputs.length) console.log(`packages: ${packageInputs.join(', ')}`);
 
+let failed = false;
+
 if (violations.size > 0) {
-  console.error('\nedge entry reaches Node builtins:');
+  failed = true;
+  console.error(`\n${label} entry reaches Node builtins:`);
   for (const [specifier, importers] of [...violations.entries()].sort()) {
     console.error(`  ${specifier}`);
     for (const importer of [...importers].sort()) console.error(`    from ${importer}`);
   }
-  process.exit(1);
 }
 
-console.log('edge entry is free of Node builtins');
+const forbiddenHits = packageInputs.filter((pkg) => forbidden.has(pkg));
+if (forbiddenHits.length > 0) {
+  failed = true;
+  console.error(`\n${label} entry bundles forbidden package(s): ${forbiddenHits.join(', ')}`);
+}
+
+// These are globals in Node that workerd and browsers lack, or that some runtimes the entry
+// targets lack (`AbortSignal.any`, `AbortSignal.timeout`); a module that reads them fails at
+// runtime without ever importing anything. A module that feature-detects one may use it: a
+// `globalThis.Buffer` access (which the generated bindings guard) and an optional
+// `.unref?.()` call are their own guards, and a `typeof` check of the global anywhere in the
+// module allows its use in that module.
+const nodeGlobals = [
+  { what: 'the process or Buffer globals', pattern: /(?<!globalThis\.)\b(?:process|Buffer)\s*\./ },
+  { what: 'setImmediate', pattern: /(?<![.\w$])setImmediate\s*\(/, guard: /typeof\s+setImmediate\b/ },
+  { what: "a timer's .unref()", pattern: /(?<!\?)\.unref\s*\(/ },
+  {
+    what: 'AbortSignal.timeout or AbortSignal.any',
+    pattern: /\bAbortSignal\s*\.\s*(?:timeout|any)\b/,
+    guard: /typeof\s+AbortSignal\s*\.\s*(?:timeout|any)\b/,
+  },
+];
+// Comments describe these globals without touching them, so they are stripped first. esbuild
+// drops them while leaving string literals alone, which a regex over `//` cannot promise.
+const stripComments = (source) => transformSync(source, { loader: 'js', legalComments: 'none' }).code;
+const sources = new Map(sdkInputs.map((f) => [f, stripComments(readFileSync(resolve(root, f), 'utf8'))]));
+for (const { what, pattern, guard } of nodeGlobals) {
+  const hits = sdkInputs.filter((f) => pattern.test(sources.get(f)) && !(guard && guard.test(sources.get(f))));
+  if (hits.length > 0) {
+    failed = true;
+    console.error(`\n${label} entry bundles SDK module(s) that use ${what}:`);
+    for (const f of hits) console.error(`  ${f}`);
+  }
+}
+
+if (failed) process.exit(1);
+
+console.log(`${label} entry is free of Node builtins${forbidden.size ? ' and forbidden packages' : ''}`);

package/dist/check-edge-entry.test.ts

@@ -0,0 +1,57 @@
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+const script = resolve(__dirname, 'check-edge-entry.mjs');
+
+/** Runs the checker on a module holding `source`, as if it were an SDK module in the bundle. */
+function check(source: string): { status: number | null; stderr: string } {
+  const dir = mkdtempSync(join(tmpdir(), 'check-edge-entry-'));
+  try {
+    const entry = join(dir, 'entry.js');
+    writeFileSync(entry, source);
+    const result = spawnSync(process.execPath, [script, entry], { encoding: 'utf8' });
+    return { status: result.status, stderr: result.stderr };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe('check-edge-entry', () => {
+  it('passes a module that uses none of the Node-only globals', () => {
+    const result = check(`
+      // setImmediate(() => {}) in a comment is fine, as is AbortSignal.any in prose.
+      /* process.exit() described here is fine too */
+      export const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+      export const url = 'https://example.com//path';
+    `);
+    expect(result.stderr).toBe('');
+    expect(result.status).toBe(0);
+  });
+
+  it.each([
+    ['setImmediate', 'export const tick = () => setImmediate(() => {});', /setImmediate/],
+    ['process.nextTick', 'export const tick = () => process.nextTick(() => {});', /process or Buffer/],
+    ['Buffer', "export const bytes = Buffer.from('x');", /process or Buffer/],
+    ['Buffer after // inside a string', "export const p = 'a//b'; export const bytes = Buffer.from('x');", /process or Buffer/],
+    ['.unref(', 'export const timer = setTimeout(() => {}, 1); timer.unref();', /\.unref\(\)/],
+    ['AbortSignal.timeout', 'export const signal = AbortSignal.timeout(5);', /AbortSignal\.timeout or AbortSignal\.any/],
+    ['AbortSignal.any', 'export const signal = AbortSignal.any([]);', /AbortSignal\.timeout or AbortSignal\.any/],
+  ])('fails a module that uses %s', (_name, source, message) => {
+    const result = check(source);
+    expect(result.status).toBe(1);
+    expect(result.stderr).toMatch(message);
+  });
+
+  it.each([
+    ['typeof setImmediate', "export const tick = typeof setImmediate === 'function' ? (f) => setImmediate(f) : (f) => setTimeout(f, 0);"],
+    ['an optional .unref?.()', 'export const timer = setTimeout(() => {}, 1); timer.unref?.();'],
+    ['typeof AbortSignal.any', "export const has = typeof AbortSignal.any === 'function';"],
+    ['globalThis.Buffer', "export const bytes = globalThis.Buffer ? globalThis.Buffer.from('x') : new Uint8Array();"],
+  ])('allows a feature-detected %s', (_name, source) => {
+    const result = check(source);
+    expect(result.stderr).toBe('');
+    expect(result.status).toBe(0);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.34.0-alpha.1",
+  "version": "1.34.0",
   "engines": {
     "node": ">=20"
   },
@@ -163,12 +163,14 @@
     "typedoc-plugin-markdown": "^4.10.0",
     "typedoc-plugin-no-inherit": "^1.6.1",
     "typescript": "^5.8.2",
-    "typescript-eslint": "^8.56.1"
+    "typescript-eslint": "^8.56.1",
+    "undici": "^7.29.1"
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.15.0",
     "@connectrpc/connect": "~2.1.2",
     "@connectrpc/connect-node": "~2.1.2",
+    "@connectrpc/connect-web": "~2.1.2",
     "@types/qs": "^6.15.0",
     "abort-controller-x": "^0.5.0",
     "axios": "^1.15.2",
@@ -236,6 +238,7 @@
     "tsc:build": "pnpm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
     "check:edge": "pnpm run tsc:build && node scripts/check-edge-entry.mjs",
+    "check:core": "pnpm run tsc:build && node scripts/check-edge-entry.mjs dist/core/index.js --forbid axios,nice-grpc,@grpc/grpc-js,@connectrpc/connect-node,long,protobufjs,yaml",
     "check:exports": "pnpm run tsc:build && node scripts/check-exports.mjs",
     "test:e2e": "jest --config jest.e2e.config.ts --silent --forceExit --runInBand",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",