@helmr/sdk 0.1.0-preview.g008b1d21.b36234405630

package/dist/client.d.ts

@@ -0,0 +1,164 @@
+import type { CursorPage, JsonValue, RunHandle, Run, RunStatus, Task, TaskInput, TaskOutput, RunOptions, TaskWait } from "./contract.js";
+import type { TokenCreateRequest, TokenCreateResult, TokenListItem, TokenListQuery, Token } from "./tokens.js";
+import type { WorkspaceRef } from "./workspace.js";
+import { type ClientWorkspacesApi } from "./client-workspace.js";
+import { type ClientSandboxesApi } from "./client-sandbox.js";
+import { type ClientActorsApi } from "./client-actor.js";
+import { type ClientSessionsApi } from "./client-session.js";
+import { type ClientDeploymentsApi } from "./client-deployment.js";
+import { type ClientSchedulesApi } from "./client-schedule.js";
+import { type ClientSecretsApi } from "./client-secret.js";
+import type { RequestOptions } from "./request.js";
+import type { LogAttributes, RunLogLevel } from "./logger.js";
+export interface HelmrClientOptions {
+    readonly url?: string;
+    readonly apiKey: string;
+    readonly fetch?: typeof fetch;
+}
+export interface TokenCompleteRequest {
+    readonly result: JsonValue;
+    readonly idempotencyKey?: string;
+}
+export interface TokenCancelRequest {
+    readonly idempotencyKey?: string;
+}
+export interface ClientTokensApi {
+    create(request?: TokenCreateRequest, options?: RequestOptions): Promise<TokenCreateResult>;
+    retrieve(id: string, options?: RequestOptions): Promise<Token>;
+    list(query?: TokenListQuery, options?: RequestOptions): Promise<CursorPage<TokenListItem>>;
+    complete(id: string, request: TokenCompleteRequest, options?: RequestOptions): Promise<Token>;
+    cancel(id: string, request?: TokenCancelRequest, options?: RequestOptions): Promise<Token>;
+}
+type ClientTaskRunRequest = RunOptions & Readonly<{
+    idempotencyKey?: string;
+    workspace: WorkspaceRef;
+}>;
+export type TaskStartRequest<TTask extends Task> = [
+    TaskInput<TTask>
+] extends [never] ? ClientTaskRunRequest & Readonly<{
+    payload?: never;
+}> : ClientTaskRunRequest & Readonly<{
+    payload: TaskInput<TTask>;
+}>;
+export interface ClientTasksApi {
+    retrieve(id: string, query?: TaskRetrieveQuery, options?: RequestOptions): Promise<TaskInfo>;
+    list(query?: TaskListQuery, options?: RequestOptions): Promise<TaskPage>;
+    start<TTask extends Task>(taskId: TTask["id"], request: TaskStartRequest<TTask>, options?: RequestOptions): Promise<RunHandle<TaskOutput<TTask>>>;
+}
+export interface TaskRetrieveQuery {
+    readonly deploymentId?: string;
+}
+export interface TaskListQuery extends TaskRetrieveQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface TaskListItem {
+    readonly id: string;
+}
+export interface TaskInfo extends TaskListItem {
+    readonly deploymentId: string;
+}
+export interface TaskPage extends CursorPage<TaskListItem> {
+    readonly deploymentId: string;
+}
+export interface RunListQuery {
+    readonly status?: RunStatus | readonly RunStatus[];
+    readonly kind?: RunEntrypointKind | readonly RunEntrypointKind[];
+    readonly sessionId?: string;
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export type RunEntrypointKind = "task" | "actor";
+export interface RunListItem {
+    readonly id: string;
+    readonly status: RunStatus;
+    readonly entrypoint: Readonly<{
+        kind: RunEntrypointKind;
+        id: string;
+    }>;
+    readonly workspaceId: string;
+    readonly sessionId?: string;
+    readonly currentAttemptNumber: number;
+    readonly createdAt: string;
+    readonly startedAt?: string;
+    readonly terminalAt?: string;
+}
+export interface RunLogQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly level?: RunLogLevel | readonly RunLogLevel[];
+}
+export interface RunEventQuery {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly severity?: RunLogLevel | readonly RunLogLevel[];
+}
+export interface StructuredRunLogRecord {
+    readonly id: string;
+    readonly kind: "structured";
+    readonly runId: string;
+    readonly attemptNumber: number;
+    readonly level: RunLogLevel;
+    readonly message: string;
+    readonly attributes: LogAttributes;
+    readonly at: string;
+}
+export interface StreamRunLogRecord {
+    readonly id: string;
+    readonly kind: "stdout" | "stderr";
+    readonly runId: string;
+    readonly attemptNumber: number;
+    readonly observedSequence: number;
+    readonly contentBase64: string;
+    readonly bytes: number;
+    readonly at: string;
+}
+export type RunLogRecord = StructuredRunLogRecord | StreamRunLogRecord;
+export interface RunEventRecord {
+    readonly id: string;
+    readonly runId: string;
+    readonly attemptNumber?: number;
+    readonly category: string;
+    readonly severity: RunLogLevel;
+    readonly source: string;
+    readonly kind: string;
+    readonly message: string;
+    readonly attributes: JsonValue;
+    readonly occurredAt: string;
+    readonly at: string;
+}
+export interface ActorRunCancellationReceipt {
+    readonly id: string;
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly holdId: string;
+    readonly status: "accepted";
+}
+export interface RunCancelRequest {
+    readonly idempotencyKey?: string;
+}
+export type RunCancellation = Run<JsonValue> | ActorRunCancellationReceipt;
+export interface ClientRunsApi {
+    retrieve<TOutput extends JsonValue>(run: RunHandle<TOutput>, options?: RequestOptions): Promise<Run<TOutput>>;
+    retrieve(runId: string, options?: RequestOptions): Promise<Run<JsonValue>>;
+    list(query?: RunListQuery, options?: RequestOptions): Promise<CursorPage<RunListItem>>;
+    cancel(runId: string, request?: RunCancelRequest, options?: RequestOptions): Promise<RunCancellation>;
+    wait<TOutput extends JsonValue>(run: RunHandle<TOutput>, options?: RequestOptions): TaskWait<TOutput>;
+    wait(runId: string, options?: RequestOptions): TaskWait<JsonValue>;
+    logs(runId: string, query?: RunLogQuery, options?: RequestOptions): Promise<CursorPage<RunLogRecord>>;
+    events(runId: string, query?: RunEventQuery, options?: RequestOptions): Promise<CursorPage<RunEventRecord>>;
+}
+export declare class HelmrClient {
+    readonly tasks: ClientTasksApi;
+    readonly actors: ClientActorsApi;
+    readonly sessions: ClientSessionsApi;
+    readonly sandboxes: ClientSandboxesApi;
+    readonly deployments: ClientDeploymentsApi;
+    readonly schedules: ClientSchedulesApi;
+    readonly secrets: ClientSecretsApi;
+    readonly runs: ClientRunsApi;
+    readonly tokens: ClientTokensApi;
+    readonly workspaces: ClientWorkspacesApi;
+    constructor(options: HelmrClientOptions);
+}
+export {};

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+import { type Builder } from "./builder.js";
+export interface HelmrBuildInput {
+    readonly builder?: Builder;
+    readonly installCommand?: string;
+    readonly secrets?: readonly string[];
+}
+export interface HelmrConfigInput {
+    readonly dirs?: readonly string[];
+    readonly ignorePatterns?: readonly string[];
+    readonly build?: HelmrBuildInput;
+}
+export interface HelmrBuildConfig {
+    readonly builder: Builder;
+    readonly installCommand: string | undefined;
+    readonly secrets: readonly string[];
+}
+export interface HelmrConfig {
+    readonly dirs: readonly string[];
+    readonly ignorePatterns: readonly string[];
+    readonly build: HelmrBuildConfig;
+}
+export declare function defineConfig(input: HelmrConfigInput): HelmrConfig;
+export declare function inspectConfig(value: unknown): HelmrConfig;
+export declare function matchesIgnorePattern(pattern: string, path: string): boolean;

package/dist/contract.d.ts

@@ -0,0 +1,408 @@
+import type { PayloadSchema } from "./schema/payload.js";
+import type { RequestOptions } from "./request.js";
+import type { WorkspaceRef } from "./workspace.js";
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export type Serializable = JsonValue;
+export type Metadata = Readonly<Record<string, JsonValue>>;
+export type MaybePromise<T> = T | Promise<T>;
+export type { PayloadSchema };
+export interface CursorPage<T> {
+    readonly items: readonly T[];
+    readonly nextCursor?: string;
+}
+export type Duration = string;
+export type RetryPolicy = Readonly<{
+    enabled?: true;
+    maxAttempts: number;
+    backoff?: Readonly<{
+        minDelay?: Duration;
+        maxDelay?: Duration;
+        factor?: number;
+        jitter?: "none" | "full";
+    }>;
+}> | Readonly<{
+    enabled: false;
+}>;
+declare const queueTypeBrand: unique symbol;
+export interface QueueConfig {
+    readonly name: string;
+    readonly concurrencyLimit?: number | null;
+}
+export interface Queue extends QueueConfig {
+    readonly [queueTypeBrand]: true;
+}
+export interface RunOptions {
+    readonly queue?: string;
+    readonly concurrencyKey?: string;
+    readonly priority?: number;
+    readonly ttl?: Duration;
+    readonly retry?: RetryPolicy;
+    readonly metadata?: Metadata;
+    readonly tags?: readonly string[];
+}
+export interface RunDefaults {
+    readonly queue?: Queue | string;
+    readonly maxDuration?: Duration;
+    readonly ttl?: Duration;
+    readonly retry?: RetryPolicy;
+}
+declare const workspaceAddressTypeBrand: unique symbol;
+export interface WorkspaceAddress {
+    readonly [workspaceAddressTypeBrand]: true;
+    readonly id: string;
+}
+export type RunCause = Readonly<{
+    type: "api" | "manual";
+}> | Readonly<{
+    type: "child";
+    parentRunId: string;
+}> | Readonly<{
+    type: "schedule";
+    scheduleId: string;
+    scheduledAt: string;
+    lastScheduledAt?: string;
+    timezone: string;
+}> | Readonly<{
+    type: "actor_start" | "continuation";
+}>;
+interface RunContext {
+    readonly signal: AbortSignal;
+    readonly run: Readonly<{
+        id: string;
+        attemptNumber: number;
+        cause: RunCause;
+    }>;
+    readonly deployment: Readonly<{
+        id: string;
+        version: string;
+    }>;
+    readonly workspace: WorkspaceRef;
+}
+export interface TaskContext extends RunContext {
+    readonly task: Readonly<{
+        id: string;
+    }>;
+    readonly actor?: never;
+}
+export interface ActorContext extends RunContext {
+    readonly task?: never;
+    readonly actor: Readonly<{
+        id: string;
+    }>;
+}
+export interface HelmrError extends Error {
+    readonly code: string;
+    readonly requestId?: string;
+}
+export interface APIError extends HelmrError {
+    readonly details?: Readonly<Record<string, JsonValue>>;
+}
+export type RunStatus = "queued" | "running" | "waiting" | "retry_delayed" | "cancel_requested" | "succeeded" | "failed" | "cancelled" | "expired" | "system_failed";
+declare const runHandleOutputBrand: unique symbol;
+export interface RunHandle<TOutput extends JsonValue = JsonValue> {
+    readonly id: string;
+    readonly [runHandleOutputBrand]: TOutput;
+}
+export interface RunFailure {
+    readonly code: string;
+    readonly message: string;
+    readonly details: Readonly<Record<string, JsonValue>>;
+}
+export interface Run<TOutput extends JsonValue = JsonValue> extends RunHandle<TOutput> {
+    readonly status: RunStatus;
+    readonly entrypoint: Readonly<{
+        kind: "task" | "actor";
+        id: string;
+    }>;
+    readonly deployment: Readonly<{
+        id: string;
+        version: string;
+    }>;
+    readonly workspaceId: string;
+    readonly sessionId?: string;
+    readonly parentRunId?: string;
+    readonly currentAttemptNumber: number;
+    readonly cause: RunCause;
+    readonly metadata: Metadata;
+    readonly tags: readonly string[];
+    readonly output?: TOutput;
+    readonly failure?: RunFailure;
+    readonly createdAt: string;
+    readonly startedAt?: string;
+    readonly terminalAt?: string;
+}
+export type TaskResult<T extends JsonValue> = Readonly<{
+    ok: true;
+    output: T;
+    run: RunHandle<T>;
+}> | Readonly<{
+    ok: false;
+    failure: RunFailure;
+    run: RunHandle<T>;
+}>;
+export interface TaskWait<T extends JsonValue> extends PromiseLike<TaskResult<T>> {
+    unwrap(): Promise<T>;
+}
+export interface TaskStartOptions extends RunOptions {
+    readonly idempotencyKey?: string;
+    readonly workspace: WorkspaceRef;
+    readonly signal?: AbortSignal;
+}
+export interface TaskCallOptions extends RunOptions {
+    readonly idempotencyKey: string;
+    readonly workspace: WorkspaceRef;
+    readonly signal?: AbortSignal;
+}
+declare const taskBrand: unique symbol;
+interface TaskTypeInfo<TIdentifier extends string, TInput extends JsonValue, TOutput extends JsonValue> {
+    readonly identifier: TIdentifier;
+    readonly input: TInput;
+    readonly output: TOutput;
+}
+export interface Task<TIdentifier extends string = string, TInput extends JsonValue = JsonValue, TOutput extends JsonValue = JsonValue> {
+    readonly [taskBrand]: TaskTypeInfo<TIdentifier, TInput, TOutput>;
+    readonly id: TIdentifier;
+    readonly hasPayload: boolean;
+    start(...args: [TInput] extends [never] ? [options: TaskStartOptions] : [payload: TInput, options: TaskStartOptions]): Promise<RunHandle<TOutput>>;
+    call(...args: [TInput] extends [never] ? [options: TaskCallOptions] : [payload: TInput, options: TaskCallOptions]): TaskWait<TOutput>;
+}
+export type TaskInput<TTask extends Task> = TTask[typeof taskBrand]["input"];
+export type TaskOutput<TTask extends Task> = TTask[typeof taskBrand]["output"];
+export type TaskConfigWithPayload<TIdentifier extends string, TInput extends JsonValue, TPayload, TOutput extends JsonValue> = RunDefaults & Readonly<{
+    id: TIdentifier;
+    payload: PayloadSchema<TInput, TPayload>;
+    run(payload: TPayload, ctx: TaskContext): MaybePromise<TOutput>;
+}>;
+export type TaskConfigWithoutPayload<TIdentifier extends string, TOutput extends JsonValue> = RunDefaults & Readonly<{
+    id: TIdentifier;
+    payload?: never;
+    run(ctx: TaskContext): MaybePromise<TOutput>;
+}>;
+export type TaskConfig<TIdentifier extends string = string, TInput extends JsonValue = never, TPayload = never, TOutput extends JsonValue = JsonValue> = TaskConfigWithPayload<TIdentifier, TInput, TPayload, TOutput> | TaskConfigWithoutPayload<TIdentifier, TOutput>;
+export type TurnSource = Readonly<{
+    type: "external";
+}> | Readonly<{
+    type: "run";
+    runId: string;
+}>;
+export interface WaitTimeoutError extends HelmrError {
+    readonly code: "wait_timeout";
+}
+export interface ActorSessionReceiveOptions {
+    readonly timeout?: Duration;
+    /** Hot managed-wait duration before suspension is eligible; not a response deadline or billing cap. */
+    readonly idleTimeout?: Duration;
+    readonly metadata?: Metadata;
+    readonly tags?: readonly string[];
+}
+export interface SessionOperationOptions {
+    readonly idempotencyKey?: string;
+}
+export interface OutputReceipt {
+    readonly id: string;
+    readonly sequence: number;
+    readonly sessionId: string;
+    readonly turnId: string | null;
+    readonly runId: string;
+    readonly attemptNumber: number;
+    readonly runGeneration: number;
+}
+export interface RecordWriter<TValue = JsonValue> {
+    write(value: TValue, options?: SessionOperationOptions): Promise<OutputReceipt>;
+    pipe(source: AsyncIterable<TValue> | Iterable<TValue>): Promise<void>;
+}
+export interface Message<TData = JsonValue> {
+    readonly id: string;
+    readonly data: TData;
+}
+export interface Turn {
+    readonly id: string;
+    readonly sequence: number;
+    readonly input: JsonValue;
+    readonly source: TurnSource;
+    readonly createdAt: string;
+    readonly signal: AbortSignal;
+    readonly output: RecordWriter;
+    onMessage(handler: (message: Message) => MaybePromise<void>): Promise<void>;
+    /** Commit the Turn result without checkpointing the Computer. */
+    complete(result?: JsonValue): Promise<void>;
+    fail(error: unknown): Promise<void>;
+}
+export interface ActorSession {
+    readonly id: string;
+    readonly key?: string;
+    readonly output: RecordWriter;
+    receive(options?: ActorSessionReceiveOptions): Promise<Turn | null>;
+}
+export interface ActorConfig extends RunDefaults {
+    readonly id: string;
+    /** Hot managed-wait duration before suspension is eligible; not a response deadline or billing cap. */
+    readonly idleTimeout?: Duration;
+    readonly run: (session: ActorSession, ctx: ActorContext) => MaybePromise<void>;
+}
+export interface ActorStartOptions {
+    readonly key?: string;
+    readonly idempotencyKey?: string;
+    readonly workspace: WorkspaceRef;
+    readonly run?: RunOptions;
+    readonly signal?: AbortSignal;
+}
+export type SessionStatus = "open" | "closing" | "closed" | "failed";
+export type SessionFailureCode = string;
+export interface SessionFailure {
+    readonly code: SessionFailureCode;
+    readonly message: string;
+    readonly details: Readonly<{
+        runId?: string;
+    }>;
+}
+export type SessionDispatch = Readonly<{
+    state: "ready";
+}> | Readonly<{
+    state: "held";
+    holdId: string;
+    reason: "interrupt_requested" | "interrupted" | "recovery_required";
+}>;
+export interface Session {
+    readonly cancelRequestedAt?: string;
+    readonly id: string;
+    readonly actorId: string;
+    readonly deploymentId: string;
+    readonly workspaceId: string;
+    readonly key?: string;
+    readonly status: SessionStatus;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly currentRunId: string | null;
+    readonly activeTurnId: string | null;
+    readonly dispatch: SessionDispatch;
+    readonly failure?: SessionFailure;
+}
+export type TurnStatus = "queued" | "running" | "completed" | "failed" | "interrupted" | "cancelled";
+export interface TurnState {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly sequence: number;
+    readonly input: JsonValue;
+    readonly source: TurnSource;
+    readonly status: TurnStatus;
+    readonly createdAt: string;
+    readonly interruptRequested: boolean;
+    readonly acceptsMessages: boolean;
+    readonly terminalEventId?: string;
+    readonly workspaceVersionId?: string;
+    readonly result?: JsonValue;
+    readonly error?: JsonValue;
+}
+export interface SessionCloseReceipt {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly status: "accepted";
+}
+export interface SessionCancelReceipt {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly status: "accepted";
+}
+export interface TurnInterruptReceipt {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly holdId: string;
+    readonly status: "accepted";
+}
+export interface SessionResumeReceipt {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly holdId: string;
+    readonly status: "accepted";
+}
+export interface SessionResumeRequest extends SessionOperationOptions {
+    readonly holdId: string;
+}
+export type SessionAdmissionReceipt = Readonly<{
+    id: string;
+    kind: "enqueued";
+    turnId: string;
+}> | Readonly<{
+    id: string;
+    kind: "messaged";
+    turnId: string;
+    messageId: string;
+}>;
+export interface SessionMessageReceipt {
+    readonly id: string;
+    readonly turnId: string;
+    readonly messageId: string;
+    readonly status: "accepted";
+}
+export interface MessageReceipt {
+    readonly id: string;
+    readonly status: "accepted";
+}
+export type SessionEventKind = "output" | "turn.enqueued" | "turn.started" | "turn.interrupt_requested" | "turn.completed" | "turn.failed" | "turn.interrupted" | "message.accepted" | "message.handled" | "message.rejected" | "message.unknown" | "session.closing" | "session.closed" | "session.cancel_requested" | "turn.cancelled" | "session.failed" | "session.held" | "session.resumed" | "session.execution_lost";
+export interface SessionEvent {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly turnId: string | null;
+    readonly sequence: number;
+    readonly createdAt: string;
+    readonly kind: SessionEventKind;
+    readonly data: JsonValue;
+    readonly provenance: Readonly<{
+        runId: string;
+        attemptNumber: number;
+        runGeneration: number;
+        deploymentId: string;
+    }> | null;
+}
+export interface SessionEventQuery {
+    readonly after?: number;
+    readonly limit?: number;
+}
+export interface SessionEventPage {
+    readonly records: readonly SessionEvent[];
+    readonly nextAfter: number;
+    readonly hasMore: boolean;
+    readonly retainedAfter: number;
+}
+export interface TurnRef {
+    readonly id: string;
+    readonly sessionId: string;
+    send(data: JsonValue, request?: SessionOperationOptions, options?: RequestOptions): Promise<MessageReceipt>;
+    retrieve(options?: RequestOptions): Promise<TurnState>;
+    interrupt(request?: SessionOperationOptions, options?: RequestOptions): Promise<TurnInterruptReceipt>;
+}
+export type SessionSendResult = Readonly<{
+    kind: "enqueued";
+    turn: TurnRef;
+}> | Readonly<{
+    kind: "messaged";
+    turn: TurnRef;
+    message: MessageReceipt;
+}>;
+export interface SessionRef {
+    readonly id: string;
+    send(data: JsonValue, request?: SessionOperationOptions, options?: RequestOptions): Promise<SessionSendResult>;
+    enqueue(input: JsonValue, request?: SessionOperationOptions, options?: RequestOptions): Promise<TurnRef>;
+    turn(id: string): TurnRef;
+    readonly events: Readonly<{
+        list(query?: SessionEventQuery, options?: RequestOptions): Promise<SessionEventPage>;
+    }>;
+    retrieve(options?: RequestOptions): Promise<Session>;
+    close(request?: SessionOperationOptions, options?: RequestOptions): Promise<SessionCloseReceipt>;
+    cancel(request?: SessionOperationOptions, options?: RequestOptions): Promise<SessionCancelReceipt>;
+    resume(request: SessionResumeRequest, options?: RequestOptions): Promise<SessionResumeReceipt>;
+}
+declare const actorTypeBrand: unique symbol;
+export interface ActorStartResult {
+    readonly session: SessionRef;
+    readonly run: RunHandle<null>;
+}
+export interface Actor {
+    readonly [actorTypeBrand]: true;
+    readonly id: string;
+    start(options: ActorStartOptions): Promise<ActorStartResult>;
+}

package/dist/definitions.d.ts

@@ -0,0 +1,42 @@
+import { type ActorConfig, type Actor, type JsonValue, type Queue, type QueueConfig, type Task, type TaskConfigWithPayload, type TaskConfigWithoutPayload } from "./contract.js";
+import { type PayloadSchema } from "./schema/payload.js";
+export type InternalTaskDefinition = Readonly<{
+    kind: "task";
+    id: string;
+    hasPayload: boolean;
+    handler: (...args: readonly unknown[]) => unknown;
+    payloadSchema?: PayloadSchema;
+    queue?: Queue | string;
+    maxDuration?: import("./contract.js").Duration;
+    ttl?: import("./contract.js").Duration;
+    retry?: ActorConfig["retry"];
+    schedule?: Readonly<{
+        cron: string;
+        timezone: string;
+        workspace: Readonly<{
+            sandbox: import("./workspace.js").Sandbox;
+            secrets: readonly import("./workspace.js").EncodedWorkspaceSecret[];
+        }>;
+    }>;
+}>;
+export type InternalActorDefinition = Readonly<{
+    kind: "actor";
+    id: string;
+    handler: (...args: readonly unknown[]) => unknown;
+    queue?: Queue | string;
+    maxDuration?: import("./contract.js").Duration;
+    ttl?: import("./contract.js").Duration;
+    retry?: ActorConfig["retry"];
+    idleTimeout?: ActorConfig["idleTimeout"];
+}>;
+export type InternalDefinition = InternalTaskDefinition | InternalActorDefinition;
+export declare function inspectDefinition(value: unknown): InternalDefinition | undefined;
+export declare function isQueue(value: unknown): value is Queue;
+export declare function queue(config: QueueConfig): Queue;
+export declare function task<TIdentifier extends string, TInput extends JsonValue, TPayload, TOutput extends JsonValue>(config: TaskConfigWithPayload<TIdentifier, TInput, TPayload, TOutput>): Task<TIdentifier, TInput, TOutput>;
+export declare function task<TIdentifier extends string, TOutput extends JsonValue>(config: TaskConfigWithoutPayload<TIdentifier, TOutput>): Task<TIdentifier, never, TOutput>;
+export declare function actor(config: ActorConfig): Actor;
+export declare function createScheduledTask<TIdentifier extends string, TInput extends JsonValue, TPayload, TOutput extends JsonValue>(config: Omit<TaskConfigWithPayload<TIdentifier, TInput, TPayload, TOutput>, "payload"> & {
+    readonly payload: PayloadSchema<TInput, TPayload>;
+    readonly schedule: NonNullable<InternalTaskDefinition["schedule"]>;
+}): Task<TIdentifier, TInput, TOutput>;

package/dist/fuzzy.d.ts

@@ -0,0 +1 @@
+export declare function levenshteinDistance(left: string, right: string): number;

package/dist/fuzzy.js

@@ -0,0 +1,29 @@
+// sdk/typescript/src/fuzzy.ts
+function levenshteinDistance(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return right.length;
+  }
+  if (right.length === 0) {
+    return left.length;
+  }
+  const previous = new Array(right.length + 1);
+  const current = new Array(right.length + 1);
+  for (let column = 0;column <= right.length; column += 1) {
+    previous[column] = column;
+  }
+  for (let row = 1;row <= left.length; row += 1) {
+    current[0] = row;
+    for (let column = 1;column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + cost);
+    }
+    previous.splice(0, previous.length, ...current);
+  }
+  return previous[right.length] ?? right.length;
+}
+export {
+  levenshteinDistance
+};