@hatchet-dev/typescript-sdk 1.34.0-alpha.0 → 1.34.0-alpha.2

package/scripts/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/scripts/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/util/batch.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.batch = batch;
+const utf8 = new TextEncoder();
 function batch(payloads, numElm, maxBytes) {
     const batches = [];
     let currentBatchPayloads = [];
@@ -8,7 +9,7 @@ function batch(payloads, numElm, maxBytes) {
     let currentBatchSize = 0;
     for (let i = 0; i < payloads.length; i += 1) {
         const request = payloads[i];
-        const requestSize = Buffer.byteLength(JSON.stringify(request), 'utf8');
+        const requestSize = utf8.encode(JSON.stringify(request)).byteLength;
         // Check if adding this request would exceed either the payload limit or batch size
         if (currentBatchPayloads.length > 0 &&
             (currentBatchSize + requestSize > maxBytes || currentBatchPayloads.length >= numElm)) {

package/util/config-loader/token.d.ts

@@ -1,4 +1,9 @@
 export declare function getTenantIdFromJWT(token: string): string;
+/**
+ * The engine address a token was issued with, or `undefined` when the claim is absent. The
+ * core client needs only this claim, so it must not fail on a token that lacks `server_url`.
+ */
+export declare function getGrpcBroadcastAddressFromJWT(token: string): string | undefined;
 export declare function getAddressesFromJWT(token: string): {
     serverUrl: string;
     grpcBroadcastAddress: string;

package/util/config-loader/token.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTenantIdFromJWT = getTenantIdFromJWT;
+exports.getGrpcBroadcastAddressFromJWT = getGrpcBroadcastAddressFromJWT;
 exports.getAddressesFromJWT = getAddressesFromJWT;
 const parse_1 = require("../parse");
 function getTenantIdFromJWT(token) {
@@ -10,6 +11,13 @@ function getTenantIdFromJWT(token) {
     }
     return claims.sub;
 }
+/**
+ * The engine address a token was issued with, or `undefined` when the claim is absent. The
+ * core client needs only this claim, so it must not fail on a token that lacks `server_url`.
+ */
+function getGrpcBroadcastAddressFromJWT(token) {
+    return extractClaimsFromJWT(token).grpc_broadcast_address || undefined;
+}
 function getAddressesFromJWT(token) {
     const claims = extractClaimsFromJWT(token);
     if (claims.server_url === undefined || claims.grpc_broadcast_address === undefined) {

package/util/errors/bulk-trigger-partial-error.d.ts

@@ -0,0 +1,17 @@
+import HatchetError from './hatchet-error';
+/**
+ * A bulk trigger that failed after at least one of its batches was accepted. The runs the
+ * accepted batches created exist and are running; a caller that retries the whole request
+ * would create them again, so `refs` carries their references, in input order, for the
+ * caller to keep or cancel. `cause` is the error the failed batch raised, which is a
+ * `BulkTriggerIdempotencyCollisionError` when that batch collided on an idempotency key.
+ */
+export declare class BulkTriggerPartialError<Ref = unknown> extends HatchetError {
+    /** The references of every run created before the failed batch, in input order. */
+    refs: Ref[];
+    /** The zero-based index of the batch that failed. */
+    failedBatchIndex: number;
+    /** The error the failed batch raised. */
+    cause: unknown;
+    constructor(refs: Ref[], failedBatchIndex: number, cause: unknown);
+}

package/util/errors/bulk-trigger-partial-error.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkTriggerPartialError = void 0;
+const hatchet_error_1 = __importStar(require("./hatchet-error"));
+/**
+ * A bulk trigger that failed after at least one of its batches was accepted. The runs the
+ * accepted batches created exist and are running; a caller that retries the whole request
+ * would create them again, so `refs` carries their references, in input order, for the
+ * caller to keep or cancel. `cause` is the error the failed batch raised, which is a
+ * `BulkTriggerIdempotencyCollisionError` when that batch collided on an idempotency key.
+ */
+class BulkTriggerPartialError extends hatchet_error_1.default {
+    constructor(refs, failedBatchIndex, cause) {
+        super(`bulk trigger failed at batch ${failedBatchIndex} after ${refs.length} runs were created: ${(0, hatchet_error_1.getErrorMessage)(cause)}`, { cause });
+        this.name = 'BulkTriggerPartialError';
+        this.refs = refs;
+        this.failedBatchIndex = failedBatchIndex;
+        this.cause = cause;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.BulkTriggerPartialError = BulkTriggerPartialError;

package/v1/client/admin.d.ts

@@ -1,18 +1,13 @@
 import { ClientConfig } from '../../clients/hatchet-client/client-config';
 import WorkflowRunRef from '../../util/workflow-run-ref';
-import { Priority, RateLimitDuration, RunsClient, WorkerLabelComparator } from './..';
+import { RateLimitDuration, RunsClient } from './..';
 import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
 import { Api } from '../../clients/rest/generated/Api';
 import { WorkflowServiceClient } from '../../protoc/workflows';
 import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
 import { type Transport } from '../../clients/transport';
+import type { TriggerRun, TriggerRunOptions } from '../../core/types';
 import { Logger } from '../../util/logger';
-type DesiredWorkerLabelOpt = {
-    value: string | number;
-    required?: boolean;
-    weight?: number;
-    comparator?: WorkerLabelComparator;
-};
 export type WorkflowRun<T = object> = {
     workflowName: string;
     input: T;
@@ -58,27 +53,7 @@ export declare class AdminClient {
      * @important This method is instrumented by HatchetInstrumentor._patchRunWorkflow.
      * Keep the signature in sync with the instrumentor wrapper.
      */
-    runWorkflow<Q = object, P = object>(workflowName: string, input: Q, options?: {
-        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;
-    }): Promise<WorkflowRunRef<P>>;
+    runWorkflow<Q = object, P = object>(workflowName: string, input: Q, options?: TriggerRunOptions): Promise<WorkflowRunRef<P>>;
     /**
      * Run multiple workflows runs with the given input and options. This will create new workflow runs and return their IDs.
      * Order is preserved in the response.
@@ -88,31 +63,6 @@ export declare class AdminClient {
      * @important This method is instrumented by HatchetInstrumentor._patchRunWorkflows.
      * Keep the signature in sync with the instrumentor wrapper.
      */
-    runWorkflows<Q = object, P = object>(workflowRuns: Array<{
-        workflowName: string;
-        input: Q;
-        options?: {
-            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;
-        };
-    }>, batchSize?: number): Promise<WorkflowRunRef<P>[]>;
+    runWorkflows<Q = object, P = object>(workflowRuns: Array<TriggerRun<Q>>, batchSize?: number): Promise<WorkflowRunRef<P>[]>;
     putRateLimit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
 }
-export {};

package/v1/client/admin.js

@@ -8,17 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -26,51 +15,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const idempotency_collision_error_1 = require("../../util/errors/idempotency-collision-error");
-const bulk_trigger_idempotency_collision_error_1 = require("../../util/errors/bulk-trigger-idempotency-collision-error");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
-const connect_1 = require("@connectrpc/connect");
-const workflows_pb_1 = require("../../protoc-es/v1/workflows_pb");
 const nice_grpc_1 = require("nice-grpc");
 const grpc_helpers_1 = require("../../util/grpc-helpers");
 const config_loader_1 = require("../../util/config-loader");
 const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
 const workflows_1 = require("../../protoc/workflows");
 const rpc_1 = require("../../clients/admin/rpc");
+const trigger_request_1 = require("../../clients/admin/trigger-request");
 const transport_1 = require("../../clients/transport");
 const retrier_1 = require("../../util/retrier");
 const batch_1 = require("../../util/batch");
-const apply_namespace_1 = require("../../util/apply-namespace");
-/**
- * The engine answers a trigger whose idempotency key is already taken with `ALREADY_EXISTS`
- * and attaches the collision details to the status. The Connect client decodes those details
- * from the trailer, so the error carries everything needed to build the SDK's collision errors.
- */
-function isAlreadyExists(e) {
-    return e instanceof connect_1.ConnectError && e.code === connect_1.Code.AlreadyExists;
-}
-function extractExistingRunId(e) {
-    var _a;
-    const [detail] = e.findDetails(workflows_pb_1.IdempotencyCollisionErrorSchema);
-    return (_a = detail === null || detail === void 0 ? void 0 : detail.existingRunExternalId) !== null && _a !== void 0 ? _a : '';
-}
-function extractBulkTriggerCollision(e) {
-    const [detail] = e.findDetails(workflows_pb_1.BulkTriggerIdempotencyCollisionErrorSchema);
-    if (!detail)
-        return null;
-    return new bulk_trigger_idempotency_collision_error_1.BulkTriggerIdempotencyCollisionError(detail.successfulWorkflowRunExternalIds, detail.collisions.map((c) => new idempotency_collision_error_1.IdempotencyCollisionError(c.existingRunExternalId)));
-}
-function convertDesiredWorkerLabels(labels) {
-    return Object.fromEntries(Object.entries(labels).map(([key, label]) => [
-        key,
-        {
-            strValue: typeof label.value === 'string' ? label.value : undefined,
-            intValue: typeof label.value === 'number' ? label.value : undefined,
-            required: label.required,
-            weight: label.weight,
-            comparator: label.comparator,
-        },
-    ]));
-}
 class AdminClient {
     constructor(config, api, runs, transport = (0, transport_1.createNodeTransport)(config)) {
         this.config = config;
@@ -111,24 +66,16 @@ class AdminClient {
     runWorkflow(workflowName, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace).toLowerCase();
-                const inputStr = JSON.stringify(input);
-                const opts = options !== null && options !== void 0 ? options : {};
-                const { additionalMetadata, parentStepRunId, parentTaskRunExternalId, desiredWorkerLabels } = opts, rest = __rest(opts, ["additionalMetadata", "parentStepRunId", "parentTaskRunExternalId", "desiredWorkerLabels"]);
-                const request = Object.assign(Object.assign({ name: computedName, input: inputStr }, rest), { 
-                    // API expects `parentTaskRunExternalId`; accept old names as aliases.
-                    parentTaskRunExternalId: parentTaskRunExternalId !== null && parentTaskRunExternalId !== void 0 ? parentTaskRunExternalId : parentStepRunId, additionalMetadata: additionalMetadata ? JSON.stringify(additionalMetadata) : undefined, priority: opts.priority, desiredWorkerLabels: desiredWorkerLabels
-                        ? convertDesiredWorkerLabels(desiredWorkerLabels)
-                        : {} });
-                const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.triggerWorkflow(request); }), this.logger, Object.assign(Object.assign({}, this.config.retrier), { shouldRetry: (e) => !isAlreadyExists(e) }));
+                const request = (0, trigger_request_1.buildTriggerWorkflowRequest)(workflowName, input, options, this.config.namespace);
+                const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.triggerWorkflow(request); }), this.logger, Object.assign(Object.assign({}, this.config.retrier), { shouldRetry: (e) => !(0, trigger_request_1.isAlreadyExists)(e) }));
                 const id = resp.workflowRunId;
                 const ref = new workflow_run_ref_1.default(id, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, options === null || options === void 0 ? void 0 : options._standaloneTaskName);
                 yield ref.getWorkflowRunId();
                 return ref;
             }
             catch (e) {
-                if (isAlreadyExists(e)) {
-                    throw new idempotency_collision_error_1.IdempotencyCollisionError(extractExistingRunId(e));
+                if ((0, trigger_request_1.isAlreadyExists)(e)) {
+                    throw new idempotency_collision_error_1.IdempotencyCollisionError((0, trigger_request_1.extractExistingRunId)(e));
                 }
                 throw new hatchet_error_1.default(e instanceof Error ? e.message : String(e));
             }
@@ -147,17 +94,7 @@ class AdminClient {
         return __awaiter(this, arguments, void 0, function* (workflowRuns, batchSize = 500) {
             var _a;
             // Prepare workflows to be triggered in bulk
-            const workflowRequests = workflowRuns.map(({ workflowName, input, options }) => {
-                const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace).toLowerCase();
-                const inputStr = JSON.stringify(input);
-                const opts = options !== null && options !== void 0 ? options : {};
-                const { additionalMetadata, parentStepRunId, parentTaskRunExternalId, desiredWorkerLabels } = opts, rest = __rest(opts, ["additionalMetadata", "parentStepRunId", "parentTaskRunExternalId", "desiredWorkerLabels"]);
-                return Object.assign(Object.assign({ name: computedName, input: inputStr }, rest), { 
-                    // API expects `parentTaskRunExternalId`; accept old names as aliases.
-                    parentTaskRunExternalId: parentTaskRunExternalId !== null && parentTaskRunExternalId !== void 0 ? parentTaskRunExternalId : parentStepRunId, additionalMetadata: additionalMetadata ? JSON.stringify(additionalMetadata) : undefined, desiredWorkerLabels: desiredWorkerLabels
-                        ? convertDesiredWorkerLabels(desiredWorkerLabels)
-                        : {} });
-            });
+            const workflowRequests = workflowRuns.map(({ workflowName, input, options }) => (0, trigger_request_1.buildTriggerWorkflowRequest)(workflowName, input, options, this.config.namespace));
             const batches = (0, batch_1.batch)(workflowRequests, batchSize, (_a = this.config.grpc_max_send_message_length) !== null && _a !== void 0 ? _a : 4 * 1024 * 1024);
             this.logger.debug(`batching ${batches.length} batches`);
             try {
@@ -168,7 +105,7 @@ class AdminClient {
                         workflows: payloads,
                     });
                     // Call the bulk trigger workflow method for this batch
-                    const bulkTriggerWorkflowResponse = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.bulkTriggerWorkflow(request); }), this.logger, Object.assign(Object.assign({}, this.config.retrier), { shouldRetry: (e) => !isAlreadyExists(e) }));
+                    const bulkTriggerWorkflowResponse = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.bulkTriggerWorkflow(request); }), this.logger, Object.assign(Object.assign({}, this.config.retrier), { shouldRetry: (e) => !(0, trigger_request_1.isAlreadyExists)(e) }));
                     this.logger.debug(`batch ${batchIndex + 1} of ${batches.length}`);
                     // Map the results back to their original indices
                     const batchResults = bulkTriggerWorkflowResponse.workflowRunIds.map((resp, index) => {
@@ -181,8 +118,8 @@ class AdminClient {
                 return results;
             }
             catch (e) {
-                if (isAlreadyExists(e)) {
-                    const collision = extractBulkTriggerCollision(e);
+                if ((0, trigger_request_1.isAlreadyExists)(e)) {
+                    const collision = (0, trigger_request_1.extractBulkTriggerCollision)(e);
                     if (collision)
                         throw collision;
                 }

package/v1/client/client.d.ts

@@ -13,6 +13,7 @@ import { DispatcherClient } from '../../clients/dispatcher/dispatcher-client';
 import { Logger } from '../../util/logger';
 import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
 import { DurableListenerClient } from '../../clients/listeners/durable-listener/durable-listener-client';
+import { type Transport } from '../../clients/transport';
 import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration, CreateDurableTaskWorkflowOpts, CreateBatchTaskWorkflowOpts } from '../declaration';
 import { BatchTaskFn } from '../task';
 import type { LegacyWorkflow } from '../../legacy/legacy-transformer';
@@ -241,6 +242,11 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @internal
      */
     get listener(): RunListenerClient;
+    /**
+     * The Connect transport the client's unary RPCs go through
+     * @internal
+     */
+    get transport(): Transport;
     /**
      * @deprecated use client.events instead
      * @hidden

package/v1/client/client.js

@@ -321,6 +321,13 @@ class HatchetClient {
     get listener() {
         return this._listener;
     }
+    /**
+     * The Connect transport the client's unary RPCs go through
+     * @internal
+     */
+    get transport() {
+        return this._transport;
+    }
     /**
      * @deprecated use client.events instead
      * @hidden

package/v1/client/features/runs.d.ts

@@ -1,32 +1,13 @@
 import WorkflowRunRef from '../../../util/workflow-run-ref';
-import { V1TaskStatus } from '../../../clients/rest/generated/data-contracts';
 import { RunListenerClient } from '../../../clients/listeners/run-listener/child-listener-client';
 import { WorkflowsClient } from './workflows';
 import { HatchetClient } from '../client';
-import { runStatusToJSON } from '../../../protoc/v1/workflows';
-export type RunDetail = {
-    status: V1TaskStatus;
-    done: boolean;
-    input: unknown;
-    additionalMetadata: unknown;
-    isEvicted: boolean;
-    taskRuns: Record<string, TaskRunDetail>;
-};
-export type TaskRunDetail = {
-    externalId: string;
-    readableId: string;
-    status: V1TaskStatus;
-    output: unknown;
-    error?: string;
-    isEvicted: boolean;
-};
+import { runStatusToJSON } from '../../../core/run-detail';
+import type { RunDetail, RunFilterBase, TaskRunDetail } from '../../../core/types';
+export type { RunDetail, TaskRunDetail };
 export { runStatusToJSON };
-export type RunFilter = {
-    since?: Date;
-    until?: Date;
-    statuses?: V1TaskStatus[];
+export type RunFilter = RunFilterBase & {
     workflowNames?: string[];
-    additionalMetadata?: Record<string, string>;
 };
 export type CancelRunOpts = {
     ids?: string[];
@@ -90,10 +71,11 @@ export declare class RunsClient {
     tenantId: string;
     workflows: WorkflowsClient;
     listener: RunListenerClient;
-    private _config;
-    private _adminGrpc;
+    private _transport;
+    private _adminRpc;
     constructor(client: HatchetClient);
-    private get adminGrpc();
+    /** The v1 admin RPCs on the client's Connect transport, the same path the core client uses. */
+    private get adminRpc();
     /**
      * Gets a task or workflow run by its ID.
      * @param run - The ID of the run to get.
@@ -105,7 +87,7 @@ export declare class RunsClient {
      * @param run - The ID of the run to get the status of.
      * @returns A promise that resolves to the status of the run.
      */
-    get_status<T = any>(run: string | WorkflowRunRef<T>): Promise<V1TaskStatus>;
+    get_status<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").V1TaskStatus>;
     /**
      * Gets run details
      * @param run - The workflow run ID (string) or a WorkflowRunRef.