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

package/core/features/rate-limits.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitsClient = void 0;
+const retrier_1 = require("../../util/retrier");
+/** Tenant-wide rate limits that tasks declare against by key. */
+class RateLimitsClient {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Creates or updates a rate limit.
+     * @returns the rate limit's key
+     */
+    put(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, retrier_1.retrier)(() => this.deps.rpc.putRateLimit({ key: opts.key, limit: opts.limit, duration: opts.duration }), this.deps.logger, this.deps.retrier);
+            return opts.key;
+        });
+    }
+}
+exports.RateLimitsClient = RateLimitsClient;

package/core/features/runs.d.ts

@@ -0,0 +1,33 @@
+import type { AdminServiceClient } from '../../protoc/v1/workflows';
+import { WorkflowRunRef } from '../run-ref';
+import type { CallOptions, CancelRunOpts, ReplayRunOpts, RunDetail } from '../types';
+/**
+ * Task and workflow runs, over the v1 `AdminService`. Everything here is a unary call, so
+ * it works from any runtime the client runs on; listing runs is a REST feature of the Node
+ * client and is not available here.
+ */
+export declare class RunsClient {
+    private readonly rpc;
+    constructor(rpc: AdminServiceClient);
+    /**
+     * Gets a run's state: its status, whether it is done, its input and metadata, and each of
+     * its tasks with their status, output and error.
+     * @param run - The run id or a reference to the run.
+     * @param options - A signal or deadline for the call.
+     */
+    get<T = unknown>(run: string | WorkflowRunRef<T>, options?: CallOptions): Promise<RunDetail>;
+    /** @alias get */
+    getDetails<T = unknown>(run: string | WorkflowRunRef<T>, options?: CallOptions): Promise<RunDetail>;
+    /**
+     * Cancels runs by id, or every run matching the filter when no ids are given.
+     * @returns the ids of the cancelled tasks
+     */
+    cancel(opts: CancelRunOpts): Promise<import("../../protoc/v1/workflows").CancelTasksResponse>;
+    /**
+     * Replays runs by id, or every run matching the filter when no ids are given.
+     * @returns the ids of the replayed tasks
+     */
+    replay(opts: ReplayRunOpts): Promise<import("../../protoc/v1/workflows").ReplayTasksResponse>;
+    /** A reference to an existing run, to wait on, cancel or replay it. */
+    runRef<T = unknown>(id: string): WorkflowRunRef<T>;
+}

package/core/features/runs.js

@@ -0,0 +1,84 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunsClient = void 0;
+const run_detail_1 = require("../run-detail");
+const run_ref_1 = require("../run-ref");
+/**
+ * Task and workflow runs, over the v1 `AdminService`. Everything here is a unary call, so
+ * it works from any runtime the client runs on; listing runs is a REST feature of the Node
+ * client and is not available here.
+ */
+class RunsClient {
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /**
+     * Gets a run's state: its status, whether it is done, its input and metadata, and each of
+     * its tasks with their status, output and error.
+     * @param run - The run id or a reference to the run.
+     * @param options - A signal or deadline for the call.
+     */
+    get(run, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getDetails(run, options);
+        });
+    }
+    /** @alias get */
+    getDetails(run, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalId = typeof run === 'string' ? run : yield run.getWorkflowRunId();
+            return (0, run_detail_1.toRunDetail)(yield this.rpc.getRunDetails({ externalId }, options));
+        });
+    }
+    /**
+     * Cancels runs by id, or every run matching the filter when no ids are given.
+     * @returns the ids of the cancelled tasks
+     */
+    cancel(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return this.rpc.cancelTasks({
+                externalIds: (_a = opts.ids) !== null && _a !== void 0 ? _a : [],
+                filter: opts.ids ? undefined : prepareFilter((_b = opts.filters) !== null && _b !== void 0 ? _b : {}),
+            });
+        });
+    }
+    /**
+     * Replays runs by id, or every run matching the filter when no ids are given.
+     * @returns the ids of the replayed tasks
+     */
+    replay(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return this.rpc.replayTasks({
+                externalIds: (_a = opts.ids) !== null && _a !== void 0 ? _a : [],
+                filter: opts.ids ? undefined : prepareFilter((_b = opts.filters) !== null && _b !== void 0 ? _b : {}),
+            });
+        });
+    }
+    /** A reference to an existing run, to wait on, cancel or replay it. */
+    runRef(id) {
+        return new run_ref_1.WorkflowRunRef(id, this);
+    }
+}
+exports.RunsClient = RunsClient;
+/** Builds the proto filter; `since` defaults to one hour ago, as the Node client's does. */
+function prepareFilter(filter) {
+    var _a, _b, _c, _d;
+    return {
+        since: (_a = filter.since) !== null && _a !== void 0 ? _a : new Date(Date.now() - 60 * 60 * 1000),
+        until: filter.until,
+        statuses: (_b = filter.statuses) !== null && _b !== void 0 ? _b : [],
+        workflowIds: (_c = filter.workflowIds) !== null && _c !== void 0 ? _c : [],
+        additionalMetadata: Object.entries((_d = filter.additionalMetadata) !== null && _d !== void 0 ? _d : {}).map(([key, value]) => `${key}:${value}`),
+    };
+}

package/core/features/streams.d.ts

@@ -0,0 +1,11 @@
+import type { EventsServiceClient, PutStreamEventResponse } from '../../protoc/events/events';
+/** Publishes stream chunks from a task run, the way `ctx.putStream` does from a worker. */
+export declare class StreamsClient {
+    private readonly rpc;
+    constructor(rpc: EventsServiceClient);
+    /**
+     * Publishes one chunk on a task run's stream. `index` orders chunks that are published
+     * concurrently. Resolves once the engine has the chunk.
+     */
+    put(taskRunExternalId: string, data: string | Uint8Array, index?: number): Promise<PutStreamEventResponse>;
+}

package/core/features/streams.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamsClient = void 0;
+/** Publishes stream chunks from a task run, the way `ctx.putStream` does from a worker. */
+class StreamsClient {
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /**
+     * Publishes one chunk on a task run's stream. `index` orders chunks that are published
+     * concurrently. Resolves once the engine has the chunk.
+     */
+    put(taskRunExternalId, data, index) {
+        const message = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        return this.rpc.putStreamEvent({
+            taskRunExternalId,
+            createdAt: new Date(),
+            message,
+            eventIndex: index,
+        });
+    }
+}
+exports.StreamsClient = StreamsClient;

package/core/features/workflows.d.ts

@@ -0,0 +1,22 @@
+import { type RetrierConfig } from '../../util/retrier';
+import type { Logger } from '../../util/logger/logger';
+import type { AdminServiceClient, CreateWorkflowVersionRequest, CreateWorkflowVersionResponse } from '../../protoc/v1/workflows';
+import type { BaseWorkflowDeclaration, WorkflowDefinition } from '../../v1/declaration';
+import type { InputType, OutputType } from '../../v1/types';
+export interface WorkflowsClientDeps {
+    rpc: AdminServiceClient;
+    logger: Logger;
+    namespace?: string;
+    retrier?: RetrierConfig;
+}
+/** Registers workflow definitions with the engine. */
+export declare class WorkflowsClient {
+    private readonly deps;
+    constructor(deps: WorkflowsClientDeps);
+    /**
+     * Creates or updates a workflow. A declaration from `/edge` (or its definition) is
+     * converted with the client's namespace the way a worker registers it; a
+     * `CreateWorkflowVersionRequest` is sent as given.
+     */
+    put<I extends InputType, O extends OutputType>(workflow: CreateWorkflowVersionRequest | WorkflowDefinition | BaseWorkflowDeclaration<I, O>): Promise<CreateWorkflowVersionResponse>;
+}

package/core/features/workflows.js

@@ -0,0 +1,46 @@
+"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.WorkflowsClient = void 0;
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const retrier_1 = require("../../util/retrier");
+const workflow_proto_1 = require("../../v1/client/worker/workflow-proto");
+/** Registers workflow definitions with the engine. */
+class WorkflowsClient {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Creates or updates a workflow. A declaration from `/edge` (or its definition) is
+     * converted with the client's namespace the way a worker registers it; a
+     * `CreateWorkflowVersionRequest` is sent as given.
+     */
+    put(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = isWireRequest(workflow)
+                ? workflow
+                : (0, workflow_proto_1.workflowToProto)(workflow, { namespace: this.deps.namespace });
+            try {
+                return yield (0, retrier_1.retrier)(() => this.deps.rpc.putWorkflow(request), this.deps.logger, this.deps.retrier);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e instanceof Error ? e.message : String(e));
+            }
+        });
+    }
+}
+exports.WorkflowsClient = WorkflowsClient;
+function isWireRequest(workflow) {
+    return 'tasks' in workflow && Array.isArray(workflow.tasks);
+}

package/core/index.d.ts

@@ -1,9 +1,47 @@
 /**
- * The core entry point: the application client for runtimes without gRPC, built on the
- * Connect transport seam. The entry resolves today so that `@hatchet-dev/typescript-sdk/core`
- * is a stable import path; the client it exports is added on top.
+ * The core entry point: the application client for runtimes without gRPC. It triggers runs,
+ * pushes events, waits for results by polling and manages workflows over unary Connect calls
+ * on a fetch transport, and it is configured from an explicit object only.
  *
+ * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this module
+ * for a browser-like target and fails the build if a Node builtin, `axios` or a gRPC package
+ * sneaks in.
+ *
+ * ```typescript
+ * import { Hatchet } from './';
+ *
+ * const hatchet = new Hatchet({ token: env.HATCHET_CLIENT_TOKEN });
+ * const ref = await hatchet.runNoWait('greet', { name: 'world' });
+ * const output = await ref.result({ timeoutMs: 30_000 });
+ * ```
  * @module Core
  */
 /** Bumped whenever the surface exported from this entry changes incompatibly. */
-export declare const CORE_ENTRY_VERSION = 0;
+export declare const CORE_ENTRY_VERSION = 1;
+export { HatchetCore, HatchetCore as Hatchet } from './client';
+export type { ResolvedCoreConfig, WorkflowRef } from './client';
+export { WorkflowRunRef, INITIAL_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS } from './run-ref';
+export type { RunRefClient } from './run-ref';
+export { toRunDetail, parseTaskOutput, runStatusToJSON } from './run-detail';
+export { ConsoleLogger, consoleLogger } from './logger';
+export type { CallOptions, CancelRunOpts, CoreClientConfig, CreateRateLimitOpts, DesiredWorkerLabelOpt, EventWithMetadata, LogConstructor, PushEventOptions, ReplayRunOpts, ResultOptions, RunDetail, RunFilter, RunFilterBase, TaskRunDetail, TriggerRun, TriggerRunOptions, } from './types';
+export { EventsClient } from './features/events';
+export { RunsClient } from './features/runs';
+export { WorkflowsClient } from './features/workflows';
+export { RateLimitsClient } from './features/rate-limits';
+export { LogsClient, MAX_LOG_LINE_CHARS } from './features/logs';
+export type { PutLogOptions } from './features/logs';
+export { StreamsClient } from './features/streams';
+export { createFetchTransport, limitMessageSizes, resolveServerUrl, type FetchTlsConfig, type FetchTransportOptions, type MessageSizeLimits, } from '../clients/transport/fetch-transport';
+export { createAuthInterceptor, DEFAULT_MAX_MESSAGE_BYTES, type Transport, } from '../clients/transport/transport';
+export { LogLevel } from '../clients/event/rpc';
+export { Priority } from '../v1/declaration';
+export type { RunManyOpt, RunOpts } from '../v1/declaration';
+export { RateLimitDuration } from '../protoc/workflows/workflows';
+export { WorkerLabelComparator } from '../protoc/v1/shared/trigger';
+export { V1TaskStatus } from '../clients/rest/generated/data-contracts';
+export { default as HatchetError, getErrorMessage, toHatchetError, } from '../util/errors/hatchet-error';
+export { IdempotencyCollisionError } from '../util/errors/idempotency-collision-error';
+export { BulkTriggerIdempotencyCollisionError } from '../util/errors/bulk-trigger-idempotency-collision-error';
+export { BulkTriggerPartialError } from '../util/errors/bulk-trigger-partial-error';
+export { AbortError, isAbortError } from '../util/abort-error';

package/core/index.js

@@ -1,12 +1,86 @@
 "use strict";
 /**
- * The core entry point: the application client for runtimes without gRPC, built on the
- * Connect transport seam. The entry resolves today so that `@hatchet-dev/typescript-sdk/core`
- * is a stable import path; the client it exports is added on top.
+ * The core entry point: the application client for runtimes without gRPC. It triggers runs,
+ * pushes events, waits for results by polling and manages workflows over unary Connect calls
+ * on a fetch transport, and it is configured from an explicit object only.
  *
+ * Nothing exported here imports from Node. `scripts/check-edge-entry.mjs` bundles this module
+ * for a browser-like target and fails the build if a Node builtin, `axios` or a gRPC package
+ * sneaks in.
+ *
+ * ```typescript
+ * import { Hatchet } from './index.js';
+ *
+ * const hatchet = new Hatchet({ token: env.HATCHET_CLIENT_TOKEN });
+ * const ref = await hatchet.runNoWait('greet', { name: 'world' });
+ * const output = await ref.result({ timeoutMs: 30_000 });
+ * ```
  * @module Core
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CORE_ENTRY_VERSION = void 0;
+exports.isAbortError = exports.AbortError = exports.BulkTriggerPartialError = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.toHatchetError = exports.getErrorMessage = exports.HatchetError = exports.V1TaskStatus = exports.WorkerLabelComparator = exports.RateLimitDuration = exports.Priority = exports.LogLevel = exports.DEFAULT_MAX_MESSAGE_BYTES = exports.createAuthInterceptor = exports.resolveServerUrl = exports.limitMessageSizes = exports.createFetchTransport = exports.StreamsClient = exports.MAX_LOG_LINE_CHARS = exports.LogsClient = exports.RateLimitsClient = exports.WorkflowsClient = exports.RunsClient = exports.EventsClient = exports.consoleLogger = exports.ConsoleLogger = exports.runStatusToJSON = exports.parseTaskOutput = exports.toRunDetail = exports.MAX_POLL_INTERVAL_MS = exports.INITIAL_POLL_INTERVAL_MS = exports.WorkflowRunRef = exports.Hatchet = exports.HatchetCore = exports.CORE_ENTRY_VERSION = void 0;
 /** Bumped whenever the surface exported from this entry changes incompatibly. */
-exports.CORE_ENTRY_VERSION = 0;
+exports.CORE_ENTRY_VERSION = 1;
+var client_1 = require("./client");
+Object.defineProperty(exports, "HatchetCore", { enumerable: true, get: function () { return client_1.HatchetCore; } });
+Object.defineProperty(exports, "Hatchet", { enumerable: true, get: function () { return client_1.HatchetCore; } });
+var run_ref_1 = require("./run-ref");
+Object.defineProperty(exports, "WorkflowRunRef", { enumerable: true, get: function () { return run_ref_1.WorkflowRunRef; } });
+Object.defineProperty(exports, "INITIAL_POLL_INTERVAL_MS", { enumerable: true, get: function () { return run_ref_1.INITIAL_POLL_INTERVAL_MS; } });
+Object.defineProperty(exports, "MAX_POLL_INTERVAL_MS", { enumerable: true, get: function () { return run_ref_1.MAX_POLL_INTERVAL_MS; } });
+var run_detail_1 = require("./run-detail");
+Object.defineProperty(exports, "toRunDetail", { enumerable: true, get: function () { return run_detail_1.toRunDetail; } });
+Object.defineProperty(exports, "parseTaskOutput", { enumerable: true, get: function () { return run_detail_1.parseTaskOutput; } });
+Object.defineProperty(exports, "runStatusToJSON", { enumerable: true, get: function () { return run_detail_1.runStatusToJSON; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logger_1.ConsoleLogger; } });
+Object.defineProperty(exports, "consoleLogger", { enumerable: true, get: function () { return logger_1.consoleLogger; } });
+// Feature clients
+var events_1 = require("./features/events");
+Object.defineProperty(exports, "EventsClient", { enumerable: true, get: function () { return events_1.EventsClient; } });
+var runs_1 = require("./features/runs");
+Object.defineProperty(exports, "RunsClient", { enumerable: true, get: function () { return runs_1.RunsClient; } });
+var workflows_1 = require("./features/workflows");
+Object.defineProperty(exports, "WorkflowsClient", { enumerable: true, get: function () { return workflows_1.WorkflowsClient; } });
+var rate_limits_1 = require("./features/rate-limits");
+Object.defineProperty(exports, "RateLimitsClient", { enumerable: true, get: function () { return rate_limits_1.RateLimitsClient; } });
+var logs_1 = require("./features/logs");
+Object.defineProperty(exports, "LogsClient", { enumerable: true, get: function () { return logs_1.LogsClient; } });
+Object.defineProperty(exports, "MAX_LOG_LINE_CHARS", { enumerable: true, get: function () { return logs_1.MAX_LOG_LINE_CHARS; } });
+var streams_1 = require("./features/streams");
+Object.defineProperty(exports, "StreamsClient", { enumerable: true, get: function () { return streams_1.StreamsClient; } });
+// Transport
+var fetch_transport_1 = require("../clients/transport/fetch-transport");
+Object.defineProperty(exports, "createFetchTransport", { enumerable: true, get: function () { return fetch_transport_1.createFetchTransport; } });
+Object.defineProperty(exports, "limitMessageSizes", { enumerable: true, get: function () { return fetch_transport_1.limitMessageSizes; } });
+Object.defineProperty(exports, "resolveServerUrl", { enumerable: true, get: function () { return fetch_transport_1.resolveServerUrl; } });
+var transport_1 = require("../clients/transport/transport");
+Object.defineProperty(exports, "createAuthInterceptor", { enumerable: true, get: function () { return transport_1.createAuthInterceptor; } });
+Object.defineProperty(exports, "DEFAULT_MAX_MESSAGE_BYTES", { enumerable: true, get: function () { return transport_1.DEFAULT_MAX_MESSAGE_BYTES; } });
+// Wire enums and errors callers switch on
+var rpc_1 = require("../clients/event/rpc");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return rpc_1.LogLevel; } });
+var declaration_1 = require("../v1/declaration");
+Object.defineProperty(exports, "Priority", { enumerable: true, get: function () { return declaration_1.Priority; } });
+var workflows_2 = require("../protoc/workflows/workflows");
+Object.defineProperty(exports, "RateLimitDuration", { enumerable: true, get: function () { return workflows_2.RateLimitDuration; } });
+var trigger_1 = require("../protoc/v1/shared/trigger");
+Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return trigger_1.WorkerLabelComparator; } });
+var data_contracts_1 = require("../clients/rest/generated/data-contracts");
+Object.defineProperty(exports, "V1TaskStatus", { enumerable: true, get: function () { return data_contracts_1.V1TaskStatus; } });
+var hatchet_error_1 = require("../util/errors/hatchet-error");
+Object.defineProperty(exports, "HatchetError", { enumerable: true, get: function () { return __importDefault(hatchet_error_1).default; } });
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return hatchet_error_1.getErrorMessage; } });
+Object.defineProperty(exports, "toHatchetError", { enumerable: true, get: function () { return hatchet_error_1.toHatchetError; } });
+var idempotency_collision_error_1 = require("../util/errors/idempotency-collision-error");
+Object.defineProperty(exports, "IdempotencyCollisionError", { enumerable: true, get: function () { return idempotency_collision_error_1.IdempotencyCollisionError; } });
+var bulk_trigger_idempotency_collision_error_1 = require("../util/errors/bulk-trigger-idempotency-collision-error");
+Object.defineProperty(exports, "BulkTriggerIdempotencyCollisionError", { enumerable: true, get: function () { return bulk_trigger_idempotency_collision_error_1.BulkTriggerIdempotencyCollisionError; } });
+var bulk_trigger_partial_error_1 = require("../util/errors/bulk-trigger-partial-error");
+Object.defineProperty(exports, "BulkTriggerPartialError", { enumerable: true, get: function () { return bulk_trigger_partial_error_1.BulkTriggerPartialError; } });
+var abort_error_1 = require("../util/abort-error");
+Object.defineProperty(exports, "AbortError", { enumerable: true, get: function () { return abort_error_1.AbortError; } });
+Object.defineProperty(exports, "isAbortError", { enumerable: true, get: function () { return abort_error_1.isAbortError; } });

package/core/logger.d.ts

@@ -0,0 +1,19 @@
+import { Logger, LogLevel } from '../util/logger/logger';
+/**
+ * The logger the core client uses when none is configured: level-filtered `console` output
+ * with the context in brackets. It reads nothing from the process, so it runs anywhere the
+ * client does.
+ */
+export declare class ConsoleLogger implements Logger {
+    private readonly context;
+    /** The lowest level written; `OFF` sets it above every level, so nothing is. */
+    private readonly threshold;
+    constructor(context: string, logLevel?: LogLevel);
+    private log;
+    debug(message: string): void;
+    info(message: string): void;
+    green(message: string): void;
+    warn(message: string, error?: Error): void;
+    error(message: string, error?: Error): void;
+}
+export declare const consoleLogger: (context: string, logLevel?: LogLevel) => Logger;

package/core/logger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleLogger = exports.ConsoleLogger = void 0;
+const logger_1 = require("../util/logger/logger");
+/**
+ * The logger the core client uses when none is configured: level-filtered `console` output
+ * with the context in brackets. It reads nothing from the process, so it runs anywhere the
+ * client does.
+ */
+class ConsoleLogger {
+    constructor(context, logLevel = 'INFO') {
+        this.context = context;
+        this.threshold = logLevel === 'OFF' ? Number.POSITIVE_INFINITY : logger_1.LogLevelEnum[logLevel];
+    }
+    log(level, message, error) {
+        if (logger_1.LogLevelEnum[level] < this.threshold)
+            return;
+        const write = level === 'ERROR'
+            ? console.error
+            : level === 'WARN'
+                ? console.warn
+                : level === 'DEBUG'
+                    ? console.debug
+                    : console.info;
+        write(`[${level}/${this.context}] ${error ? `${message} ${error}` : message}`);
+    }
+    debug(message) {
+        this.log('DEBUG', message);
+    }
+    info(message) {
+        this.log('INFO', message);
+    }
+    green(message) {
+        this.log('INFO', message);
+    }
+    warn(message, error) {
+        this.log('WARN', message, error);
+    }
+    error(message, error) {
+        this.log('ERROR', message, error);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+const consoleLogger = (context, logLevel) => new ConsoleLogger(context, logLevel);
+exports.consoleLogger = consoleLogger;

package/core/run-detail.d.ts

@@ -0,0 +1,14 @@
+import { GetRunDetailsResponse, runStatusToJSON } from '../protoc/v1/workflows';
+import type { RunDetail, TaskRunDetail } from './types';
+/**
+ * A task's output the way the Node client's `result()` reads it (`JSON.parse(output || '{}')`):
+ * nothing stored is `{}`, a stored `null` is `null`, and stored text that is not JSON throws
+ * the `SyntaxError`, so a corrupt output is never mistaken for an empty one.
+ */
+export declare function parseTaskOutput(task: TaskRunDetail): unknown;
+/**
+ * Converts a `GetRunDetails` response into the `RunDetail` both clients return: statuses
+ * become `V1TaskStatus` values and the JSON payloads are decoded.
+ */
+export declare function toRunDetail(raw: GetRunDetailsResponse): RunDetail;
+export { runStatusToJSON };

package/core/run-detail.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStatusToJSON = void 0;
+exports.parseTaskOutput = parseTaskOutput;
+exports.toRunDetail = toRunDetail;
+const data_contracts_1 = require("../clients/rest/generated/data-contracts");
+const workflows_1 = require("../protoc/v1/workflows");
+Object.defineProperty(exports, "runStatusToJSON", { enumerable: true, get: function () { return workflows_1.runStatusToJSON; } });
+// EVICTED is not in V1TaskStatus; treat as RUNNING per the proto comment.
+const PROTO_STATUS_MAP = {
+    [workflows_1.RunStatus.QUEUED]: data_contracts_1.V1TaskStatus.QUEUED,
+    [workflows_1.RunStatus.RUNNING]: data_contracts_1.V1TaskStatus.RUNNING,
+    [workflows_1.RunStatus.COMPLETED]: data_contracts_1.V1TaskStatus.COMPLETED,
+    [workflows_1.RunStatus.FAILED]: data_contracts_1.V1TaskStatus.FAILED,
+    [workflows_1.RunStatus.CANCELLED]: data_contracts_1.V1TaskStatus.CANCELLED,
+    [workflows_1.RunStatus.EVICTED]: data_contracts_1.V1TaskStatus.RUNNING,
+    [workflows_1.RunStatus.UNRECOGNIZED]: data_contracts_1.V1TaskStatus.RUNNING,
+};
+function decodeText(b) {
+    return (b === null || b === void 0 ? void 0 : b.length) ? new TextDecoder().decode(b) : undefined;
+}
+/**
+ * The forgiving decode `getDetails` shapes payloads with: absent, `null` and malformed JSON
+ * all read as `null`, so inspecting a run never throws.
+ */
+function decodeJson(text) {
+    if (text === undefined)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * A task's output the way the Node client's `result()` reads it (`JSON.parse(output || '{}')`):
+ * nothing stored is `{}`, a stored `null` is `null`, and stored text that is not JSON throws
+ * the `SyntaxError`, so a corrupt output is never mistaken for an empty one.
+ */
+function parseTaskOutput(task) {
+    var _a;
+    if (task.rawOutput === undefined) {
+        return (_a = task.output) !== null && _a !== void 0 ? _a : {};
+    }
+    // The forgiving decode already parsed valid JSON; only a `null` result needs the strict
+    // parse to tell a stored `null` from text that failed to parse.
+    return task.output !== null ? task.output : JSON.parse(task.rawOutput);
+}
+/**
+ * Converts a `GetRunDetails` response into the `RunDetail` both clients return: statuses
+ * become `V1TaskStatus` values and the JSON payloads are decoded.
+ */
+function toRunDetail(raw) {
+    var _a;
+    return {
+        status: (_a = PROTO_STATUS_MAP[raw.status]) !== null && _a !== void 0 ? _a : data_contracts_1.V1TaskStatus.RUNNING,
+        done: raw.done,
+        input: decodeJson(decodeText(raw.input)),
+        additionalMetadata: decodeJson(decodeText(raw.additionalMetadata)),
+        isEvicted: raw.isEvicted,
+        taskRuns: Object.fromEntries(Object.entries(raw.taskRuns).map(([id, tr]) => {
+            var _a;
+            const rawOutput = decodeText(tr.output);
+            return [
+                id,
+                {
+                    externalId: tr.externalId,
+                    readableId: tr.readableId,
+                    status: (_a = PROTO_STATUS_MAP[tr.status]) !== null && _a !== void 0 ? _a : data_contracts_1.V1TaskStatus.RUNNING,
+                    output: decodeJson(rawOutput),
+                    rawOutput,
+                    error: tr.error,
+                    isEvicted: tr.isEvicted,
+                },
+            ];
+        })),
+    };
+}

package/core/run-ref.d.ts

@@ -0,0 +1,63 @@
+import type { CallOptions, ResultOptions, RunDetail } from './types';
+/** What a run reference needs from the client that created it. */
+export interface RunRefClient {
+    getDetails(runId: string, options?: CallOptions): Promise<RunDetail>;
+    cancel(opts: {
+        ids: string[];
+    }): Promise<unknown>;
+    replay(opts: {
+        ids: string[];
+    }): Promise<unknown>;
+}
+/** The first wait between two `GetRunDetails` polls. */
+export declare const INITIAL_POLL_INTERVAL_MS = 250;
+/** The longest wait between two polls; the interval doubles until it gets here. */
+export declare const MAX_POLL_INTERVAL_MS = 5000;
+/**
+ * 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.
+ */
+export declare class WorkflowRunRef<T> {
+    private readonly runs;
+    readonly workflowRunId: string;
+    parentWorkflowRunId?: string;
+    _standaloneTaskName?: string;
+    /**
+     * The signal `result()` waits with when none is passed, so a run spawned from inside a task
+     * stops being awaited when the task is cancelled.
+     */
+    defaultSignal?: AbortSignal;
+    constructor(workflowRunId: string, runs: RunRefClient, parentWorkflowRunId?: string, standaloneTaskName?: string, defaultSignal?: AbortSignal);
+    get runId(): Promise<string>;
+    getWorkflowRunId(): Promise<string>;
+    /** The run's result; the same as `result()` with no options. */
+    get output(): Promise<T>;
+    /** The run's current state. */
+    details(): Promise<RunDetail>;
+    /**
+     * 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(options?: ResultOptions): Promise<T>;
+    private resolveResult;
+    /**
+     * 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`.
+     */
+    private outputs;
+    toJSON(): Promise<string>;
+    cancel(): Promise<void>;
+    replay(): Promise<void>;
+}