@xmemory/temporal 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Configuration for the xmemory Temporal plugin.
+ *
+ * Nothing here carries secret material: {@link XmemoryConfig} holds the *name* of
+ * the env var supplying the API key, never the key. Workflow history is stored in
+ * the clear, so this stays safe to log and to persist.
+ */
+export declare const DEFAULT_API_KEY_ENV = "XMEM_API_KEY";
+export { DEFAULT_CLIENT_MARGIN_MS, DEFAULT_TIMEOUTS, clientTimeoutMs, type XmemoryTimeouts } from './defaults';
+export interface XmemoryConfig {
+    instanceId: string;
+    url?: string;
+    /** Name of the env var holding the key — never the key itself. */
+    apiKeyEnv?: string;
+    /**
+     * How far below its Temporal deadline each call's client timeout sits. The
+     * budgets themselves belong to the workflow (`xmemoryForWorkflow`).
+     */
+    clientMarginMs?: number;
+    defaultExtractionLogic?: 'fast' | 'deep';
+    /**
+     * Log the server's `error_detail` verbatim when a write fails.
+     *
+     * Off by default: the detail can echo memory text or internal endpoints. Off, the
+     * log names the failed write and the detail's size.
+     */
+    logServerErrorDetail?: boolean;
+}
+/**
+ * Read the API key from the environment.
+ *
+ * Throws at worker start rather than on the first activity, so a misconfigured
+ * worker fails visibly.
+ */
+export declare function resolveApiKey(config: XmemoryConfig, override?: string): string;
+/**
+ * Where the client points when nothing is configured. Mirrors its unexported
+ * `DEFAULT_BASE_URL`: omitting `url` would let the client read
+ * `process.env.XMEM_API_URL` itself, reopening what `resolveUrl` closes.
+ */
+export declare const DEFAULT_ENDPOINT = "https://api.xmemory.ai";
+/** The endpoint to hand the client: always a value, never left to its own fallback. */
+export declare function resolveEndpoint(config: XmemoryConfig): string;
+/** Validate the effective endpoint, or `undefined` when none was supplied. */
+export declare function resolveUrl(config: XmemoryConfig): string | undefined;
+/**
+ * Return `candidate` if the API key may safely be sent to it.
+ *
+ * The key is a bearer token, so plaintext is refused off-box and credentials in the
+ * URL are refused outright. What the endpoint otherwise looks like — path, query,
+ * port — is the client's business, not this plugin's.
+ */
+export declare function validateEndpoint(candidate: unknown, source: string): string;

package/dist/config.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Configuration for the xmemory Temporal plugin.
+ *
+ * Nothing here carries secret material: {@link XmemoryConfig} holds the *name* of
+ * the env var supplying the API key, never the key. Workflow history is stored in
+ * the clear, so this stays safe to log and to persist.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENDPOINT = exports.clientTimeoutMs = exports.DEFAULT_TIMEOUTS = exports.DEFAULT_CLIENT_MARGIN_MS = exports.DEFAULT_API_KEY_ENV = void 0;
+exports.resolveApiKey = resolveApiKey;
+exports.resolveEndpoint = resolveEndpoint;
+exports.resolveUrl = resolveUrl;
+exports.validateEndpoint = validateEndpoint;
+exports.DEFAULT_API_KEY_ENV = 'XMEM_API_KEY';
+// The client falls back to this when no url is passed, so it is an endpoint source
+// this plugin must validate too.
+const URL_ENV = 'XMEM_API_URL';
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+// Re-exported from the workflow-safe leaf, so callers have one import site.
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "DEFAULT_CLIENT_MARGIN_MS", { enumerable: true, get: function () { return defaults_1.DEFAULT_CLIENT_MARGIN_MS; } });
+Object.defineProperty(exports, "DEFAULT_TIMEOUTS", { enumerable: true, get: function () { return defaults_1.DEFAULT_TIMEOUTS; } });
+Object.defineProperty(exports, "clientTimeoutMs", { enumerable: true, get: function () { return defaults_1.clientTimeoutMs; } });
+/**
+ * Read the API key from the environment.
+ *
+ * Throws at worker start rather than on the first activity, so a misconfigured
+ * worker fails visibly.
+ */
+function resolveApiKey(config, override) {
+    // Passing a falsy key on is worse than failing: the client reads it as absent and
+    // falls back to XMEM_API_KEY, sending the ambient credential to this config's URL.
+    if (override !== undefined) {
+        if (typeof override !== 'string' || override === '') {
+            throw new Error(`xmemory apiKey was supplied but unusable (${override === '' ? 'empty' : typeof override}); ` +
+                'omit it to read the environment');
+        }
+        return override;
+    }
+    // Defaulted only when genuinely absent: `??` would treat an own `null` as one.
+    const configured = config.apiKeyEnv;
+    const varName = configured === undefined ? exports.DEFAULT_API_KEY_ENV : configured;
+    if (typeof varName !== 'string' || varName === '') {
+        throw new Error(`xmemory apiKeyEnv must be a non-empty string, got ${varName === null ? 'null' : typeof varName}`);
+    }
+    const key = process.env[varName];
+    if (typeof key !== 'string' || key === '') {
+        throw new Error(`xmemory API key not found: environment variable ${JSON.stringify(varName)} is unset or empty. ` +
+            `Set it on the worker process, or pass { apiKey } to XmemoryPlugin.`);
+    }
+    return key;
+}
+/**
+ * Where the client points when nothing is configured. Mirrors its unexported
+ * `DEFAULT_BASE_URL`: omitting `url` would let the client read
+ * `process.env.XMEM_API_URL` itself, reopening what `resolveUrl` closes.
+ */
+exports.DEFAULT_ENDPOINT = 'https://api.xmemory.ai';
+/** The endpoint to hand the client: always a value, never left to its own fallback. */
+function resolveEndpoint(config) {
+    return resolveUrl(config) ?? exports.DEFAULT_ENDPOINT;
+}
+/** Validate the effective endpoint, or `undefined` when none was supplied. */
+function resolveUrl(config) {
+    const configured = config.url;
+    if (configured !== undefined)
+        return validateEndpoint(configured, 'xmemory url');
+    // With `url` unset the client falls back to this variable, which would then reach
+    // the wire unchecked. Resolving it here makes this the only path to an endpoint.
+    const fromEnv = process.env[URL_ENV];
+    if (fromEnv === undefined)
+        return undefined;
+    return validateEndpoint(fromEnv, `$${URL_ENV}`);
+}
+/**
+ * Return `candidate` if the API key may safely be sent to it.
+ *
+ * The key is a bearer token, so plaintext is refused off-box and credentials in the
+ * URL are refused outright. What the endpoint otherwise looks like — path, query,
+ * port — is the client's business, not this plugin's.
+ */
+function validateEndpoint(candidate, source) {
+    if (typeof candidate !== 'string') {
+        throw new Error(`${source} must be a string, got ${candidate === null ? 'null' : typeof candidate}`);
+    }
+    // The trimmed value is what is returned: `new URL()` ignores surrounding
+    // whitespace, but the client concatenates this string with the request path.
+    const endpoint = candidate.trim();
+    if (endpoint === '') {
+        throw new Error(`${source} was supplied but empty; unset it to use the default endpoint`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(endpoint);
+    }
+    catch {
+        // Not echoed: it may hold a secret.
+        throw new Error(`${source} is not a valid URL`);
+    }
+    if (parsed.username !== '' || parsed.password !== '') {
+        // Node rejects these at request time anyway, and the config stops being safe to log.
+        throw new Error(`${source} must not embed credentials; the API key is passed separately`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new Error(`${source} must use https (got scheme ${JSON.stringify(parsed.protocol)})`);
+    }
+    if (parsed.protocol === 'http:' && !LOOPBACK_HOSTS.has(parsed.hostname)) {
+        // The host is left out: it can name internal infrastructure.
+        throw new Error(`${source} must use https; the API key is sent as a bearer token. ` +
+            'Plaintext http is accepted only for loopback hosts.');
+    }
+    return endpoint;
+}

package/dist/deadline.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A total wall-clock bound for a client call.
+ *
+ * The xmemory client's `timeoutMs` stops applying once response headers arrive, so
+ * a stalled body can outlive the Activity deadline. Racing a timer caps the total.
+ */
+export declare class DeadlineExceededError extends Error {
+    constructor(ms: number);
+}
+/** `ms` is a client budget, already positive and capped by `clientTimeoutMs`. */
+export declare function withDeadline<T>(promise: Promise<T>, ms: number): Promise<T>;
+export interface DeadlineInfo {
+    readonly startToCloseTimeoutMs: number;
+    readonly scheduleToCloseTimeoutMs: number;
+    readonly scheduledTimestampMs: number;
+}
+/**
+ * What is left of this Activity's deadline, or `null` if it has none. Zero or
+ * negative once spent.
+ *
+ * The smaller of the two bounds — a short schedule-to-close expires the attempt
+ * before a longer start-to-close would, and the larger figure would let a write
+ * commit after Temporal gave up. Schedule-to-close counts from the service's own
+ * `scheduledTimestampMs`; `Math.max(0, ...)` stops a lagging Worker clock, or a
+ * time-skipping test server, from *lengthening* the budget.
+ *
+ * `elapsedInAttemptMs` is for a caller running partway through the Activity, and
+ * applies to start-to-close only — schedule-to-close already contains that time.
+ * Time spent *before* the Activity function is not measurable without a
+ * Worker-wide interceptor, which this plugin does not install.
+ */
+export declare function activityBudgetMs(info: DeadlineInfo, elapsedInAttemptMs?: number): number | null;

package/dist/deadline.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeadlineExceededError = void 0;
+exports.withDeadline = withDeadline;
+exports.activityBudgetMs = activityBudgetMs;
+/**
+ * A total wall-clock bound for a client call.
+ *
+ * The xmemory client's `timeoutMs` stops applying once response headers arrive, so
+ * a stalled body can outlive the Activity deadline. Racing a timer caps the total.
+ */
+class DeadlineExceededError extends Error {
+    constructor(ms) {
+        super(`xmemory call exceeded its ${ms}ms client deadline`);
+        this.name = 'DeadlineExceededError';
+    }
+}
+exports.DeadlineExceededError = DeadlineExceededError;
+/** `ms` is a client budget, already positive and capped by `clientTimeoutMs`. */
+function withDeadline(promise, ms) {
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new DeadlineExceededError(ms)), ms);
+    });
+    return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+}
+/**
+ * What is left of this Activity's deadline, or `null` if it has none. Zero or
+ * negative once spent.
+ *
+ * The smaller of the two bounds — a short schedule-to-close expires the attempt
+ * before a longer start-to-close would, and the larger figure would let a write
+ * commit after Temporal gave up. Schedule-to-close counts from the service's own
+ * `scheduledTimestampMs`; `Math.max(0, ...)` stops a lagging Worker clock, or a
+ * time-skipping test server, from *lengthening* the budget.
+ *
+ * `elapsedInAttemptMs` is for a caller running partway through the Activity, and
+ * applies to start-to-close only — schedule-to-close already contains that time.
+ * Time spent *before* the Activity function is not measurable without a
+ * Worker-wide interceptor, which this plugin does not install.
+ */
+function activityBudgetMs(info, elapsedInAttemptMs = 0) {
+    const bounds = [];
+    if (info.startToCloseTimeoutMs > 0)
+        bounds.push(info.startToCloseTimeoutMs - elapsedInAttemptMs);
+    if (info.scheduleToCloseTimeoutMs > 0) {
+        bounds.push(info.scheduleToCloseTimeoutMs - Math.max(0, Date.now() - info.scheduledTimestampMs));
+    }
+    return bounds.length > 0 ? Math.min(...bounds) : null;
+}

package/dist/defaults.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Default activity budgets and the client-margin rule.
+ *
+ * A dependency-free leaf on purpose: workflow code imports these defaults, so
+ * this module must never reach for `process.env` or the xmemory client the way
+ * `config.ts` does.
+ */
+/** Default `startToClose` budgets, in milliseconds. */
+export interface XmemoryTimeouts {
+    readMs: number;
+    writeMs: number;
+    writeStartMs: number;
+    writeStatusMs: number;
+}
+/**
+ * The defaults `xmemoryForWorkflow()` applies when a workflow does not pass its
+ * own. The workflow owns the real budget: whatever it sets is what Temporal
+ * enforces, and what each activity derives its client timeout from.
+ */
+export declare const DEFAULT_TIMEOUTS: XmemoryTimeouts;
+/**
+ * How far below its Temporal deadline each call's client timeout sits. Inverted,
+ * Temporal could abandon an enqueue that still succeeds server-side, and a later
+ * durable-write retry would queue it twice.
+ */
+export declare const DEFAULT_CLIENT_MARGIN_MS = 5000;
+/**
+ * The longest a Node timer can hold (24.8 days).
+ *
+ * `setTimeout` silently turns anything larger into 1ms. Client budgets are capped
+ * at it, and `writeDurable` refuses loop options past it before its enqueue.
+ */
+export declare const MAX_DURATION_MS = 2147483647;
+/**
+ * Client budget for an activity whose Temporal deadline is `activityMs`.
+ *
+ * Always strictly below it, so the client gives up first and the failure is an
+ * attributable xmemory error rather than an opaque activity timeout. A budget at
+ * or under the margin gets a proportional one instead; there is no floor, which
+ * would hand back more time than Temporal is giving.
+ *
+ * Only meaningful above timer resolution: a 1ms deadline yields 0.8ms, which
+ * `setTimeout` rounds back to 1ms — the same instant Temporal uses.
+ *
+ * Capped at `MAX_DURATION_MS`, because the client arms a `setTimeout` with this
+ * value and Node fires anything larger after 1ms. The cap only applies to a deadline
+ * longer than that, so the client still gives up first.
+ */
+export declare function clientTimeoutMs(activityMs: number, marginMs?: number): number;

package/dist/defaults.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Default activity budgets and the client-margin rule.
+ *
+ * A dependency-free leaf on purpose: workflow code imports these defaults, so
+ * this module must never reach for `process.env` or the xmemory client the way
+ * `config.ts` does.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DURATION_MS = exports.DEFAULT_CLIENT_MARGIN_MS = exports.DEFAULT_TIMEOUTS = void 0;
+exports.clientTimeoutMs = clientTimeoutMs;
+/**
+ * The defaults `xmemoryForWorkflow()` applies when a workflow does not pass its
+ * own. The workflow owns the real budget: whatever it sets is what Temporal
+ * enforces, and what each activity derives its client timeout from.
+ */
+exports.DEFAULT_TIMEOUTS = {
+    readMs: 120_000,
+    writeMs: 180_000,
+    writeStartMs: 30_000,
+    writeStatusMs: 30_000,
+};
+/**
+ * How far below its Temporal deadline each call's client timeout sits. Inverted,
+ * Temporal could abandon an enqueue that still succeeds server-side, and a later
+ * durable-write retry would queue it twice.
+ */
+exports.DEFAULT_CLIENT_MARGIN_MS = 5_000;
+/**
+ * The longest a Node timer can hold (24.8 days).
+ *
+ * `setTimeout` silently turns anything larger into 1ms. Client budgets are capped
+ * at it, and `writeDurable` refuses loop options past it before its enqueue.
+ */
+exports.MAX_DURATION_MS = 2_147_483_647;
+/**
+ * Client budget for an activity whose Temporal deadline is `activityMs`.
+ *
+ * Always strictly below it, so the client gives up first and the failure is an
+ * attributable xmemory error rather than an opaque activity timeout. A budget at
+ * or under the margin gets a proportional one instead; there is no floor, which
+ * would hand back more time than Temporal is giving.
+ *
+ * Only meaningful above timer resolution: a 1ms deadline yields 0.8ms, which
+ * `setTimeout` rounds back to 1ms — the same instant Temporal uses.
+ *
+ * Capped at `MAX_DURATION_MS`, because the client arms a `setTimeout` with this
+ * value and Node fires anything larger after 1ms. The cap only applies to a deadline
+ * longer than that, so the client still gives up first.
+ */
+function clientTimeoutMs(activityMs, marginMs = exports.DEFAULT_CLIENT_MARGIN_MS) {
+    if (!Number.isFinite(activityMs) || activityMs <= 0) {
+        throw new RangeError(`activityMs must be a positive, finite number, got ${activityMs}`);
+    }
+    const margin = Number.isFinite(marginMs) && marginMs > 0 ? marginMs : 0;
+    const budgetMs = margin === 0 || activityMs <= margin ? activityMs * 0.8 : activityMs - margin;
+    return Math.min(budgetMs, exports.MAX_DURATION_MS);
+}

package/dist/dto.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Activity input and output types.
+ *
+ * The `*Input` / `*Output` shapes are ours: activity payloads are persisted
+ * verbatim into workflow history, so they are a compatibility contract for every
+ * workflow that has ever run, and owning them lets a result field be added or
+ * renamed upstream without breaking replay. What we send through untransformed —
+ * mutations, read modes, scopes — is the client's own type.
+ */
+import type { AsyncWriteResult, ReadMode, ReadResult, ReadScope, WriteMutation, WriteResult, WriteStatusResult } from 'xmemory';
+export type { ObjectMutationBody, ReadMode, ReadScope, RelationEndpoint, RelationMutationBody, RelationsScope, ScopeObject, WriteMutation, } from 'xmemory';
+export interface ReadInput {
+    query: string;
+    readMode?: ReadMode;
+    scope?: ReadScope;
+}
+export interface SubAnswer {
+    subQuery: string;
+    readerResult: unknown;
+    error: string | null;
+}
+export interface ReadOutput {
+    readerResult: unknown;
+    subAnswers: SubAnswer[];
+    traceId: string | null;
+}
+/** Either free `text` for the extractor, or explicit `structuredMutations`. */
+export interface WriteInput {
+    text: string;
+    extractionLogic?: string;
+    diffEngine?: boolean;
+    structuredMutations?: readonly WriteMutation[];
+}
+export interface WriteOutput {
+    writeId: string;
+    traceId: string | null;
+    changes: unknown;
+}
+export interface WriteStartOutput {
+    writeId: string;
+}
+export interface WriteStatusInput {
+    writeId: string;
+}
+export interface WriteStatusOutput {
+    writeId: string;
+    writeStatus: string;
+    completedAt: string | null;
+    changes: unknown;
+}
+export declare function projectRead(result: ReadResult): ReadOutput;
+export declare function projectWrite(result: WriteResult): WriteOutput;
+export declare function projectWriteStart(result: AsyncWriteResult): WriteStartOutput;
+export declare function projectWriteStatus(result: WriteStatusResult): WriteStatusOutput;

package/dist/dto.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Activity input and output types.
+ *
+ * The `*Input` / `*Output` shapes are ours: activity payloads are persisted
+ * verbatim into workflow history, so they are a compatibility contract for every
+ * workflow that has ever run, and owning them lets a result field be added or
+ * renamed upstream without breaking replay. What we send through untransformed —
+ * mutations, read modes, scopes — is the client's own type.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRead = projectRead;
+exports.projectWrite = projectWrite;
+exports.projectWriteStart = projectWriteStart;
+exports.projectWriteStatus = projectWriteStatus;
+// --- Projections from the client's result shapes ---------------------------
+//
+// Required fields are checked rather than defaulted, so a malformed response fails
+// as a transport error instead of reading as an empty answer or an unknown status.
+function ownField(result, field) {
+    return typeof result === 'object' && result !== null && Object.hasOwn(result, field)
+        ? result[field]
+        : undefined;
+}
+function requiredString(result, field) {
+    const value = ownField(result, field);
+    // Non-empty: an empty id passes every type check and names no write.
+    if (typeof value !== 'string' || value === '') {
+        throw new Error(`xmemory response has no usable ${field}`);
+    }
+    return value;
+}
+function optionalString(result, field) {
+    const value = ownField(result, field);
+    return typeof value === 'string' ? value : null;
+}
+/** Present, whatever its type. `reader_result` may legitimately be null. */
+function requiredField(result, field) {
+    if (typeof result !== 'object' || result === null || !Object.hasOwn(result, field)) {
+        throw new Error(`xmemory response has no ${field}`);
+    }
+    return result[field];
+}
+function projectRead(result) {
+    // Required, not defaulted: turning a missing answer into `undefined` hands the
+    // workflow a confident empty one. The client normalizes `reader_results` to an
+    // array, so a non-array here did not come from a client that did.
+    const readerResult = requiredField(result, 'reader_result');
+    const subAnswers = requiredField(result, 'reader_results');
+    if (!Array.isArray(subAnswers)) {
+        throw new Error('xmemory response has a malformed reader_results');
+    }
+    return {
+        readerResult,
+        subAnswers: subAnswers.map((r) => ({
+            subQuery: requiredString(r, 'sub_query'),
+            readerResult: requiredField(r, 'reader_result'),
+            error: optionalString(r, 'error'),
+        })),
+        traceId: optionalString(result, 'trace_id'),
+    };
+}
+function projectWrite(result) {
+    return {
+        writeId: requiredString(result, 'write_id'),
+        traceId: optionalString(result, 'trace_id'),
+        changes: ownField(result, 'changes') ?? null,
+    };
+}
+function projectWriteStart(result) {
+    return { writeId: requiredString(result, 'write_id') };
+}
+function projectWriteStatus(result) {
+    return {
+        writeId: requiredString(result, 'write_id'),
+        // Required: the durable loop decides a write is done by this value.
+        writeStatus: requiredString(result, 'write_status'),
+        completedAt: optionalString(result, 'completed_at'),
+        // Not surfaced by the client yet; populates itself if a later release adds it.
+        // `null`, never absent: an omitted field vanishes in JSON.
+        changes: ownField(result, 'changes') ?? ownField(result, 'result') ?? null,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Translate xmemory API errors into Temporal failures.
+ *
+ * Temporal owns retries, so this is the one place an `XmemoryAPIError` becomes an
+ * `ApplicationFailure` with a retryability verdict.
+ *
+ * Rules: branch on `.code`, not the HTTP status; an unrecognized code never raises
+ * and keeps its own type, so a newer server cannot break this client mid-deploy,
+ * while whether to retry it comes from the status — a 401 or 404 is terminal
+ * whatever the code says; never echo the raw exception string, which can embed
+ * internal hostnames.
+ */
+import { ApplicationFailure } from '@temporalio/common';
+import { TYPE_AUTH_FAILED, TYPE_BAD_OPTIONS, TYPE_BAD_REQUEST, TYPE_DAILY_QUOTA_EXCEEDED, TYPE_DEADLINE_EXPIRED, TYPE_MONTHLY_QUOTA_EXCEEDED, TYPE_NOT_BOUND, TYPE_NOT_FOUND, TYPE_NO_DEADLINE, TYPE_QUOTA_EXCEEDED, TYPE_RATE_LIMITED, TYPE_SCHEMA_REJECTED, TYPE_SERVER_ERROR, TYPE_UNAVAILABLE, TYPE_UNKNOWN, TYPE_WRITE_FAILED, TYPE_WRITE_NOT_FOUND, TYPE_WRITE_TIMEOUT } from './names';
+export { TYPE_AUTH_FAILED, TYPE_BAD_OPTIONS, TYPE_BAD_REQUEST, TYPE_DAILY_QUOTA_EXCEEDED, TYPE_DEADLINE_EXPIRED, TYPE_MONTHLY_QUOTA_EXCEEDED, TYPE_NOT_BOUND, TYPE_NOT_FOUND, TYPE_NO_DEADLINE, TYPE_QUOTA_EXCEEDED, TYPE_RATE_LIMITED, TYPE_SCHEMA_REJECTED, TYPE_SERVER_ERROR, TYPE_UNAVAILABLE, TYPE_UNKNOWN, TYPE_WRITE_FAILED, TYPE_WRITE_NOT_FOUND, TYPE_WRITE_TIMEOUT, };
+export declare const NON_RETRYABLE_TYPES: readonly string[];
+/** Map any client-raised error onto a Temporal `ApplicationFailure`. */
+export declare function toApplicationFailure(err: unknown): ApplicationFailure;