@helmr/sdk 0.1.0-preview.g52eb0eef.b35190749915

package/dist/index.js

@@ -0,0 +1,3029 @@
+// sdk/typescript/src/schema/payload.ts
+var payloadSchemaValidationErrorBrand = Symbol.for("helmr.sdk.PayloadSchemaValidationError");
+
+class PayloadSchemaValidationError extends Error {
+  issues;
+  constructor(label, issues) {
+    super(formatPayloadSchemaValidationMessage(label, issues));
+    this.name = "PayloadSchemaValidationError";
+    this.issues = issues;
+    Object.defineProperty(this, payloadSchemaValidationErrorBrand, { value: true });
+  }
+  static [Symbol.hasInstance](value) {
+    return this === PayloadSchemaValidationError && typeof value === "object" && value !== null && payloadSchemaValidationErrorBrand in value;
+  }
+}
+function assertPayloadSchema(value, label = "payload") {
+  if (value === undefined) {
+    return;
+  }
+  assertStandardSchema(value, label);
+}
+function assertStandardSchema(value, label = "schema") {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    throw new Error(`${label} must implement the Standard Schema v1 interface`);
+  }
+  const standard = value["~standard"];
+  if (standard === null || typeof standard !== "object") {
+    throw new Error(`${label} must implement the Standard Schema v1 interface`);
+  }
+  const record = standard;
+  if (record["version"] !== 1 || typeof record["validate"] !== "function") {
+    throw new Error(`${label} must implement the Standard Schema v1 interface`);
+  }
+}
+async function parsePayloadWithSchema(schema, payload, label) {
+  assertStandardSchema(schema, label);
+  const result = await schema["~standard"].validate(payload);
+  if ("issues" in result && result.issues !== undefined) {
+    throw new PayloadSchemaValidationError(label, result.issues);
+  }
+  return result.value;
+}
+function formatPayloadSchemaValidationMessage(label, issues) {
+  if (issues.length === 0) {
+    return `${label} failed validation`;
+  }
+  const formattedIssues = issues.slice(0, 5).map(formatPayloadSchemaIssue);
+  const suffix = issues.length > formattedIssues.length ? `; and ${issues.length - formattedIssues.length} more` : "";
+  return `${label} failed validation: ${formattedIssues.join("; ")}${suffix}`;
+}
+function formatPayloadSchemaIssue(issue) {
+  const path = formatPayloadSchemaIssuePath(issue.path);
+  return path === "" ? issue.message : `${path}: ${issue.message}`;
+}
+function formatPayloadSchemaIssuePath(path) {
+  if (path === undefined || path.length === 0) {
+    return "";
+  }
+  let formatted = "payload";
+  for (const segment of path) {
+    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
+    if (typeof key === "string" && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
+      formatted += `.${key}`;
+    } else if (typeof key === "string" && isArrayIndexKey(key)) {
+      formatted += `[${key}]`;
+    } else if (typeof key === "number") {
+      formatted += `[${key}]`;
+    } else {
+      formatted += `[${JSON.stringify(String(key))}]`;
+    }
+  }
+  return formatted;
+}
+function isArrayIndexKey(value) {
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    return false;
+  }
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed);
+}
+
+// sdk/typescript/src/schema/task.ts
+var TASK_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$";
+var TASK_ID_MAX_LENGTH = 128;
+var QUEUE_NAME_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$";
+var QUEUE_NAME_MAX_LENGTH = 256;
+
+class TaskIdError extends Error {
+  name = "TaskIdError";
+  value;
+  constructor(value) {
+    super(`task id must match ${TASK_ID_PATTERN}: ${JSON.stringify(value)}`);
+    this.value = value;
+  }
+}
+function validateTaskId(value) {
+  if (!isValidTaskId(value)) {
+    throw new TaskIdError(value);
+  }
+}
+function isValidTaskId(value) {
+  if (value.length === 0 || value.length > TASK_ID_MAX_LENGTH) {
+    return false;
+  }
+  const first = value.charCodeAt(0);
+  if (!isAsciiAlnum(first)) {
+    return false;
+  }
+  for (let index = 1;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!(isAsciiAlnum(code) || code === 46 || code === 95 || code === 45)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+class TaskQueueNameError extends Error {
+  name = "TaskQueueNameError";
+  value;
+  constructor(value) {
+    super(`queue name must match ${QUEUE_NAME_PATTERN}: ${JSON.stringify(value)}`);
+    this.value = value;
+  }
+}
+
+class TaskQueueConcurrencyLimitError extends Error {
+  name = "TaskQueueConcurrencyLimitError";
+  value;
+  constructor(value) {
+    super("queue concurrencyLimit must be a positive integer");
+    this.value = value;
+  }
+}
+function validateQueueName(value) {
+  if (!isValidQueueName(value)) {
+    throw new TaskQueueNameError(value);
+  }
+}
+function isValidQueueName(value) {
+  if (value.length === 0 || value.length > QUEUE_NAME_MAX_LENGTH) {
+    return false;
+  }
+  const first = value.charCodeAt(0);
+  if (!isAsciiAlnum(first)) {
+    return false;
+  }
+  for (let index = 1;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!(isAsciiAlnum(code) || code === 46 || code === 95 || code === 45 || code === 47)) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateOptionalQueueConcurrencyLimit(value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) {
+    return;
+  }
+  throw new TaskQueueConcurrencyLimitError(value);
+}
+function isAsciiAlnum(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+
+// sdk/typescript/src/internal/runtime.ts
+var runtimeOperationsSymbol = Symbol.for("helmr.sdk.v0.runtime_operations");
+function currentRuntimeOperations() {
+  const operations = globalThis[runtimeOperationsSymbol];
+  if (operations === undefined) {
+    throw new Error("runtime operation is unavailable without the Helmr managed runtime");
+  }
+  return operations;
+}
+function runtimeOperationsInstalled() {
+  return globalThis[runtimeOperationsSymbol] !== undefined;
+}
+
+// sdk/typescript/src/internal/run-failure.ts
+function runFailureError(failure) {
+  const error = new Error(failure.message);
+  error.name = "RunFailure";
+  error.code = failure.code;
+  error.details = failure.details;
+  return error;
+}
+
+// sdk/typescript/src/internal/id.ts
+var uuidV7Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function resourceID(value, label) {
+  if (typeof value !== "string" || !uuidV7Pattern.test(value)) {
+    throw new Error(`${label} must be a canonical UUIDv7`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/session.ts
+function createRuntimeSessionRef(id) {
+  const sessionID = resourceID(id, "Session ID");
+  return Object.freeze({
+    id: sessionID,
+    input: Object.freeze({
+      send(input, request, options) {
+        return currentRuntimeOperations().actorInputSend(sessionID, input, request, options?.signal);
+      }
+    }),
+    output: Object.freeze({
+      list(query, options) {
+        return currentRuntimeOperations().sessionOutputPage(sessionID, query, options?.signal);
+      }
+    }),
+    retrieve(options = {}) {
+      return currentRuntimeOperations().sessionRetrieve(sessionID, options.signal);
+    },
+    close(request, options) {
+      return currentRuntimeOperations().sessionClose(sessionID, request, options?.signal);
+    }
+  });
+}
+var sessions = Object.freeze({
+  ref(id) {
+    return createRuntimeSessionRef(id);
+  }
+});
+
+// sdk/typescript/src/internal/run-handle.ts
+function createRunHandle(id) {
+  return Object.freeze({
+    id: resourceID(id, "Run ID")
+  });
+}
+function runHandleID(value) {
+  return resourceID(typeof value === "string" ? value : value.id, "Run ID");
+}
+
+// sdk/typescript/src/definitions.ts
+var privateDefinitionBrand = Symbol.for("helmr.sdk.v0.definition");
+var privateQueueBrand = Symbol.for("helmr.sdk.v0.queue");
+function inspectDefinition(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return;
+  }
+  if (!Object.hasOwn(value, privateDefinitionBrand))
+    return;
+  const definition = value[privateDefinitionBrand];
+  if (!isInternalDefinition(definition)) {
+    throw new Error("invalid private definition record");
+  }
+  return definition;
+}
+function isQueue(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!Object.hasOwn(value, privateQueueBrand))
+    return false;
+  if (value[privateQueueBrand] !== true) {
+    throw new Error("invalid private queue record");
+  }
+  const queue = value;
+  if (typeof queue.name !== "string") {
+    throw new Error("invalid private queue record");
+  }
+  validateQueueName(queue.name);
+  validateOptionalQueueConcurrencyLimit(queue.concurrencyLimit);
+  return true;
+}
+function isInternalDefinition(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const definition = value;
+  if (typeof definition.id !== "string")
+    return false;
+  validateTaskId(definition.id);
+  switch (definition.kind) {
+    case "task":
+      if (typeof definition.handler !== "function" || typeof definition.hasPayload !== "boolean") {
+        return false;
+      }
+      if (definition.hasPayload) {
+        assertPayloadSchema(definition.payloadSchema, `task ${JSON.stringify(definition.id)} payload`);
+      } else if (Object.hasOwn(definition, "payloadSchema")) {
+        return false;
+      }
+      return true;
+    case "actor":
+      return typeof definition.handler === "function";
+    default:
+      return false;
+  }
+}
+function queue(config) {
+  validateQueueName(config.name);
+  validateOptionalQueueConcurrencyLimit(config.concurrencyLimit);
+  return Object.freeze(Object.defineProperty({
+    name: config.name,
+    ...config.concurrencyLimit === undefined ? {} : { concurrencyLimit: config.concurrencyLimit }
+  }, privateQueueBrand, { value: true }));
+}
+function task(config) {
+  validateDefinitionDefaults(config, `task ${JSON.stringify(config.id)}`);
+  const hasPayload = "payload" in config;
+  if (hasPayload) {
+    assertPayloadSchema(config.payload, `task ${JSON.stringify(config.id)} payload`);
+  }
+  const internal = Object.freeze({
+    kind: "task",
+    id: config.id,
+    hasPayload,
+    handler: config.run,
+    ...hasPayload ? { payloadSchema: config.payload } : {},
+    ...copyDefinitionDefaults(config)
+  });
+  return createTaskDefinition(internal);
+}
+function actor(config) {
+  validateDefinitionDefaults(config, `actor ${JSON.stringify(config.id)}`);
+  if (typeof config.run !== "function") {
+    throw new Error(`actor ${JSON.stringify(config.id)} run must be a function`);
+  }
+  const internal = Object.freeze({
+    kind: "actor",
+    id: config.id,
+    handler: config.run,
+    ...copyDefinitionDefaults(config),
+    ...config.idleTimeout === undefined ? {} : { idleTimeout: config.idleTimeout }
+  });
+  const value = {
+    id: internal.id,
+    async start(options) {
+      const started = await currentRuntimeOperations().actorStart(internal.id, options);
+      return Object.freeze({
+        session: createRuntimeSessionRef(started.sessionId),
+        run: createRunHandle(started.runId)
+      });
+    }
+  };
+  return brandDefinition(value, internal);
+}
+function createScheduledTask(config) {
+  const base = task({
+    id: config.id,
+    payload: config.payload,
+    run: config.run,
+    ...config.queue === undefined ? {} : { queue: config.queue },
+    ...config.maxDuration === undefined ? {} : { maxDuration: config.maxDuration },
+    ...config.ttl === undefined ? {} : { ttl: config.ttl },
+    ...config.retry === undefined ? {} : { retry: config.retry }
+  });
+  const inspected = inspectDefinition(base);
+  if (inspected?.kind !== "task") {
+    throw new Error("scheduled task construction failed");
+  }
+  const internal = Object.freeze({
+    ...inspected,
+    schedule: config.schedule
+  });
+  return brandDefinition({
+    id: base.id,
+    hasPayload: true,
+    start: base.start.bind(base),
+    call: base.call.bind(base)
+  }, internal);
+}
+function createTaskDefinition(internal) {
+  if (internal.hasPayload) {
+    return brandDefinition({
+      id: internal.id,
+      hasPayload: true,
+      start(payload, options) {
+        return currentRuntimeOperations().taskStart(Object.freeze({ declaredId: internal.id, payloadPresent: true }), payload, options);
+      },
+      call(payload, options) {
+        return taskWait(currentRuntimeOperations().taskCall(Object.freeze({ declaredId: internal.id, payloadPresent: true }), payload, options));
+      }
+    }, internal);
+  }
+  return brandDefinition({
+    id: internal.id,
+    hasPayload: false,
+    start(options) {
+      return currentRuntimeOperations().taskStart(Object.freeze({ declaredId: internal.id, payloadPresent: false }), undefined, options);
+    },
+    call(options) {
+      return taskWait(currentRuntimeOperations().taskCall(Object.freeze({ declaredId: internal.id, payloadPresent: false }), undefined, options));
+    }
+  }, internal);
+}
+function brandDefinition(value, internal) {
+  Object.defineProperty(value, privateDefinitionBrand, {
+    value: internal,
+    enumerable: false
+  });
+  return Object.freeze(value);
+}
+function validateDefinitionDefaults(config, label) {
+  validateTaskId(config.id);
+  if (typeof config.run !== "function") {
+    throw new Error(`${label} run must be a function`);
+  }
+  if (config.maxDuration !== undefined && typeof config.maxDuration !== "string") {
+    throw new Error(`${label} maxDuration must be a duration string`);
+  }
+  if (typeof config.queue === "string") {
+    validateQueueName(config.queue);
+  } else if (config.queue !== undefined && !isQueue(config.queue)) {
+    throw new Error(`${label} queue must be a queue() definition or queue name`);
+  }
+  if (config.ttl !== undefined && typeof config.ttl !== "string") {
+    throw new Error(`${label} ttl must be a duration string`);
+  }
+}
+function copyDefinitionDefaults(config) {
+  return {
+    ...config.queue === undefined ? {} : { queue: config.queue },
+    ...config.maxDuration === undefined ? {} : { maxDuration: config.maxDuration },
+    ...config.ttl === undefined ? {} : { ttl: config.ttl },
+    ...config.retry === undefined ? {} : { retry: config.retry }
+  };
+}
+function taskWait(result) {
+  return Object.freeze({
+    then(onfulfilled, onrejected) {
+      return result.then(onfulfilled, onrejected);
+    },
+    async unwrap() {
+      const settled = await result;
+      if (!settled.ok)
+        throw runFailureError(settled.failure);
+      return settled.output;
+    }
+  });
+}
+// sdk/typescript/src/internal/abort.ts
+function abortableDelay(milliseconds, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(done, milliseconds);
+    function done() {
+      signal?.removeEventListener("abort", aborted);
+      resolve();
+    }
+    function aborted() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", aborted);
+      try {
+        signal?.throwIfAborted();
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      reject(new Error("Operation was aborted"));
+    }
+    signal?.addEventListener("abort", aborted, { once: true });
+  });
+}
+
+// sdk/typescript/src/internal/timestamp.ts
+var utcRFC3339 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/;
+function timestampString(value, label) {
+  const match = typeof value === "string" ? utcRFC3339.exec(value) : null;
+  if (match === null || !validDateTime(match)) {
+    throw new Error(`${label} must be a UTC RFC 3339 timestamp`);
+  }
+  return value;
+}
+function validDateTime(match) {
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  if (month < 1 || month > 12 || hour > 23 || minute > 59 || second > 59) {
+    return false;
+  }
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return day >= 1 && day <= days[month - 1];
+}
+
+// sdk/typescript/src/image.ts
+var imageBrand = Symbol.for("helmr.sdk.v0.image");
+var sourceFileBrand = Symbol.for("helmr.sdk.v0.source-file");
+var sourceDirectoryBrand = Symbol.for("helmr.sdk.v0.source-directory");
+
+class Image {
+  key;
+  steps;
+  constructor(key, steps = []) {
+    if (key.length === 0) {
+      throw new Error("image key must be non-empty");
+    }
+    this.key = key;
+    this.steps = Object.freeze([...steps]);
+    Object.defineProperty(this, imageBrand, { value: true });
+    Object.freeze(this);
+  }
+  from(ref, ...unexpected) {
+    if (unexpected.length !== 0) {
+      throw new Error("image.from() accepts only an image reference");
+    }
+    return new Image(this.key, [...this.steps, { kind: "from", ref }]);
+  }
+  run(argv, ...unexpected) {
+    if (unexpected.length !== 0) {
+      throw new Error("image.run() accepts only argv");
+    }
+    return new Image(this.key, [
+      ...this.steps,
+      {
+        kind: "run",
+        argv: Object.freeze([...argv])
+      }
+    ]);
+  }
+  copy(destination, source) {
+    if (isSourceFile(source)) {
+      return new Image(this.key, [
+        ...this.steps,
+        { kind: "copy_source_file", destination, source }
+      ]);
+    }
+    if (isSourceDirectory(source)) {
+      return new Image(this.key, [
+        ...this.steps,
+        { kind: "copy_source_directory", destination, source }
+      ]);
+    }
+    throw new Error("image.copy() requires source.file() or source.directory()");
+  }
+  copyFrom(destination, source, sourcePath) {
+    if (inspectImage(source) === undefined) {
+      throw new Error("image.copyFrom() requires an image() value");
+    }
+    return new Image(this.key, [
+      ...this.steps,
+      { kind: "copy_from_image", destination, source, sourcePath }
+    ]);
+  }
+  workdir(path) {
+    return new Image(this.key, [...this.steps, { kind: "workdir", path }]);
+  }
+  env(key, value) {
+    return new Image(this.key, [...this.steps, { kind: "env", key, value }]);
+  }
+  user(name) {
+    return new Image(this.key, [...this.steps, { kind: "user", name }]);
+  }
+}
+
+class SourceFileValue {
+  path;
+  constructor(path) {
+    this.path = path;
+    Object.defineProperty(this, sourceFileBrand, { value: true });
+    Object.freeze(this);
+  }
+}
+
+class SourceDirectoryValue {
+  path;
+  constructor(path) {
+    this.path = path;
+    Object.defineProperty(this, sourceDirectoryBrand, { value: true });
+    Object.freeze(this);
+  }
+}
+function image(key) {
+  return new Image(key);
+}
+var source = Object.freeze({
+  file(path) {
+    return new SourceFileValue(path);
+  },
+  directory(path) {
+    return new SourceDirectoryValue(path);
+  }
+});
+function inspectImage(value) {
+  if (typeof value !== "object" || value === null || value[imageBrand] !== true) {
+    return;
+  }
+  const imageValue = value;
+  return { key: imageValue.key, steps: imageValue.steps };
+}
+function isSourceFile(value) {
+  return typeof value === "object" && value !== null && value[sourceFileBrand] === true;
+}
+function isSourceDirectory(value) {
+  return typeof value === "object" && value !== null && value[sourceDirectoryBrand] === true;
+}
+
+// sdk/typescript/src/secret.ts
+var secretNamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+function validateSecretName(value) {
+  if (typeof value !== "string" || !secretNamePattern.test(value)) {
+    throw new Error("Secret name is invalid");
+  }
+}
+
+// sdk/typescript/src/internal/origin.ts
+function canonicalSecretOrigin(value) {
+  if (typeof value !== "string" || value.trim() !== value || !/^https:\/\//i.test(value)) {
+    throw new Error("Secret origin must be an exact HTTPS origin");
+  }
+  const authority = value.replace(/^https:\/\//i, "").replace(/\/$/, "");
+  if (!/^[A-Za-z0-9.-]+(?::[0-9]+)?$/.test(authority))
+    throw new Error("Secret origin must contain only a DNS hostname and optional port");
+  const [rawHost, port] = authority.split(":");
+  const host = rawHost.toLowerCase();
+  if (host.length > 253 || host === "localhost" || host.endsWith(".localhost") || /^[0-9.]+$/.test(host) || host.split(".").some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label))) {
+    throw new Error("Secret origin must use a DNS hostname without wildcards or IP addresses");
+  }
+  if (port !== undefined && (!/^[1-9][0-9]*$/.test(port) || Number(port) > 65535))
+    throw new Error("Secret origin port is invalid");
+  return `https://${host}${port === undefined || port === "443" ? "" : `:${port}`}`;
+}
+
+// sdk/typescript/src/workspace.ts
+var sandboxDefinitionBrand = Symbol.for("helmr.sdk.v0.sandbox");
+var workspaceAddressBrand = Symbol.for("helmr.sdk.v0.workspace-address");
+
+class Builder {
+  id;
+  constructor(id) {
+    validateTaskId(id);
+    this.id = id;
+    Object.freeze(this);
+  }
+  image(value) {
+    const inspected = inspectImage(value);
+    if (inspected === undefined) {
+      throw new Error("sandbox.image() requires an image() value");
+    }
+    return new ResourceBuilder(this.id, inspected);
+  }
+}
+
+class ResourceBuilder {
+  id;
+  imageValue;
+  constructor(id, imageValue) {
+    this.id = id;
+    this.imageValue = imageValue;
+    Object.freeze(this);
+  }
+  resources(value) {
+    assertResourceMembers(value);
+    return new Definition(this.id, this.imageValue, Object.freeze({ cpu: value.cpu, memory: value.memory }));
+  }
+}
+
+class Definition {
+  id;
+  internal;
+  constructor(id, imageValue, resources) {
+    this.id = id;
+    this.internal = Object.freeze({
+      kind: "sandbox",
+      id,
+      image: imageValue,
+      resources
+    });
+    Object.defineProperty(this, sandboxDefinitionBrand, { value: true });
+    Object.freeze(this);
+  }
+  createWorkspace(request, options) {
+    return currentRuntimeOperations().workspaceCreate(this.id, request, options?.signal).then(({ workspaceId }) => createWorkspaceRef(workspaceId));
+  }
+}
+function sandbox(config) {
+  return new Builder(config.id);
+}
+var workspaces = Object.freeze({
+  ref: createWorkspaceRef
+});
+function inspectWorkspaceAddress(value) {
+  if (typeof value !== "object" || value === null || value[workspaceAddressBrand] !== true) {
+    return;
+  }
+  const address = value;
+  if (address.id === undefined) {
+    throw new Error("private Workspace address is invalid");
+  }
+  return createWorkspaceAddress(address.id);
+}
+function workspaceRefID(value) {
+  const address = inspectWorkspaceAddress(value);
+  if (address === undefined || typeof address.id !== "string") {
+    throw new Error("Workspace requires a Workspace ref");
+  }
+  return address.id;
+}
+function encodeWorkspaceSecrets(inputs) {
+  if (inputs === undefined)
+    return Object.freeze([]);
+  if (!Array.isArray(inputs) || inputs.length > 64)
+    throw new Error("Workspace secrets must be an array of at most 64 bindings");
+  const envNames = new Set;
+  const files = [];
+  let originCount = 0;
+  const result = inputs.map((input) => {
+    const value = workspaceObject(input, "Workspace Secret");
+    validateSecretName(value["secret"]);
+    const hasEnv = value["env"] !== undefined;
+    const hasFile = value["file"] !== undefined;
+    if (hasEnv === hasFile)
+      throw new Error("Workspace Secret requires exactly one of env or file");
+    exactBindingKeys(value, ["secret", "env", "file"]);
+    if (hasEnv) {
+      const env = workspaceObject(value["env"], "Workspace Secret env");
+      const mode = env["mode"];
+      if (mode !== "raw" && mode !== "protected")
+        throw new Error("Workspace Secret env requires explicit raw or protected mode");
+      exactBindingKeys(env, ["name", "mode", "allowedOrigins"]);
+      if (mode === "raw" && env["allowedOrigins"] !== undefined)
+        throw new Error("Raw env cannot specify allowedOrigins");
+      const name = env["name"];
+      if (typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || name.startsWith("HELMR_") || name.startsWith("LD_") || ["NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA", "OPENSSL_CONF", "OPENSSL_MODULES", "OPENSSL_ENGINES", "GCONV_PATH", "LOCPATH"].includes(name) || ["SSL_CERT_FILE", "SSL_CERT_DIR", "NODE_EXTRA_CA_CERTS", "NODE_USE_SYSTEM_CA"].includes(name.toUpperCase()))
+        throw new Error("Invalid or reserved Secret env name");
+      if (envNames.has(name))
+        throw new Error(`Duplicate Secret env target ${name}`);
+      envNames.add(name);
+      if (mode === "raw")
+        return Object.freeze({ secret: input.secret, env: Object.freeze({ name, mode }) });
+      const origins = env["allowedOrigins"];
+      if (!Array.isArray(origins) || origins.length === 0 || origins.length > 16)
+        throw new Error("Protected env requires 1 to 16 exact HTTPS origins");
+      const allowed_origins = Object.freeze([...new Set(origins.map(canonicalSecretOrigin))].sort());
+      originCount += allowed_origins.length;
+      return Object.freeze({ secret: input.secret, env: Object.freeze({ name, mode, allowed_origins }) });
+    }
+    const file = workspaceObject(value["file"], "Workspace Secret file");
+    exactBindingKeys(file, ["path"]);
+    const path = file["path"];
+    if (typeof path !== "string" || path.length > 4096 || !path.startsWith("/") || path === "/" || path.includes("\x00") || path.split("/").slice(1).some((part) => part === "" || part === "." || part === "..") || ["/workspace", "/var/lib/helmr", "/dev", "/opt/helmr", "/proc", "/sys", "/.helmr-old-root", "/run/helmr"].some((root) => path === root || path.startsWith(root + "/")))
+      throw new Error("Invalid or reserved Secret file path");
+    files.push(path);
+    return Object.freeze({ secret: input.secret, file: Object.freeze({ path }) });
+  });
+  files.sort();
+  if (files.some((path, index) => index > 0 && (path === files[index - 1] || path.startsWith(files[index - 1] + "/"))))
+    throw new Error("Conflicting Secret file paths");
+  if (originCount > 256)
+    throw new Error("Workspace Secret origins exceed 256");
+  return Object.freeze(result);
+}
+function exactBindingKeys(value, allowed) {
+  const unknown = Object.keys(value).find((key) => !allowed.includes(key));
+  if (unknown !== undefined)
+    throw new Error(`Workspace Secret has unknown member ${JSON.stringify(unknown)}`);
+}
+function inspectSandboxDefinition(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  if (!Object.hasOwn(value, sandboxDefinitionBrand))
+    return;
+  if (value[sandboxDefinitionBrand] !== true) {
+    throw new Error("invalid private Sandbox record");
+  }
+  const internal = value.internal;
+  if (typeof internal !== "object" || internal === null || internal.kind !== "sandbox" || typeof internal.id !== "string" || typeof internal.image !== "object" || internal.image === null || typeof internal.resources !== "object" || internal.resources === null) {
+    throw new Error("invalid private Sandbox record");
+  }
+  validateTaskId(internal.id);
+  return internal;
+}
+function createWorkspaceRef(id) {
+  const workspaceID = resourceID(id, "Workspace ID");
+  const operations = {
+    retrieve(options) {
+      return currentRuntimeOperations().workspaceRetrieve(workspaceID, options?.signal);
+    },
+    exec(request, options) {
+      return currentRuntimeOperations().workspaceExec(workspaceID, request, options?.signal);
+    },
+    delete(request, options) {
+      return currentRuntimeOperations().workspaceDelete(workspaceID, request, options?.signal);
+    }
+  };
+  return brandWorkspaceAddress({ id: workspaceID, ...operations });
+}
+function createWorkspaceAddress(id) {
+  return brandWorkspaceAddress({ id: resourceID(id, "Workspace ID") });
+}
+function brandWorkspaceAddress(value) {
+  resourceID(value.id, "Workspace ID");
+  return freezeWorkspaceAddress(value);
+}
+function freezeWorkspaceAddress(value) {
+  Object.defineProperty(value, workspaceAddressBrand, { value: true });
+  return Object.freeze(value);
+}
+function parseWorkspace(value) {
+  const input = workspaceObject(value, "Workspace response");
+  const key = input["key"];
+  if (key !== undefined && typeof key !== "string") {
+    throw new Error("Workspace response.key must be a string");
+  }
+  const sandboxId = input["sandbox_id"];
+  if (typeof sandboxId !== "string") {
+    throw new Error("Workspace response.sandbox_id must be a string");
+  }
+  validateTaskId(sandboxId);
+  const status = input["status"];
+  if (status !== "available" && status !== "recovery_required" && status !== "deleting") {
+    throw new Error("Workspace response.status is invalid");
+  }
+  if (!Array.isArray(input["secrets"])) {
+    throw new Error("Workspace response.secrets must be an array");
+  }
+  const owner = parseWorkspaceOwner(input["owner"], "Workspace response.owner");
+  return Object.freeze({
+    id: resourceID(input["id"], "Workspace response.id"),
+    ...key === undefined ? {} : { key },
+    sandboxId,
+    deploymentId: resourceID(input["deployment_id"], "Workspace response.deployment_id"),
+    status,
+    ...owner === undefined ? {} : { owner },
+    secrets: Object.freeze(input["secrets"].map(parseWorkspaceSecret)),
+    lastActivityAt: workspaceTimestamp(input["last_activity_at"], "last_activity_at"),
+    createdAt: workspaceTimestamp(input["created_at"], "created_at"),
+    updatedAt: workspaceTimestamp(input["updated_at"], "updated_at")
+  });
+}
+function parseWorkspaceOwner(value, label) {
+  if (value === undefined)
+    return;
+  const input = workspaceObject(value, label);
+  const hasSession = input["session_id"] !== undefined;
+  const hasRun = input["run_id"] !== undefined;
+  if (hasSession === hasRun) {
+    throw new Error(`${label} must name exactly one of session_id or run_id`);
+  }
+  return Object.freeze(hasSession ? { sessionId: resourceID(input["session_id"], `${label}.session_id`) } : { runId: resourceID(input["run_id"], `${label}.run_id`) });
+}
+function parseWorkspaceSecret(value) {
+  const wire = workspaceObject(value, "Workspace Secret");
+  exactBindingKeys(wire, wire["env"] !== undefined ? ["secret", "env"] : ["secret", "file"]);
+  let binding;
+  if (wire["env"] !== undefined) {
+    const env = workspaceObject(wire["env"], "Workspace Secret env");
+    exactBindingKeys(env, ["name", "mode", "allowed_origins"]);
+    binding = { secret: wire["secret"], env: { name: env["name"], mode: env["mode"], ...env["allowed_origins"] === undefined ? {} : { allowedOrigins: env["allowed_origins"] } } };
+  } else {
+    binding = { secret: wire["secret"], file: wire["file"] };
+  }
+  const normalized = encodeWorkspaceSecrets([binding])[0];
+  return normalized.env !== undefined ? Object.freeze({ secret: normalized.secret, env: Object.freeze({ name: normalized.env.name, mode: normalized.env.mode, ...normalized.env.allowed_origins === undefined ? {} : { allowedOrigins: normalized.env.allowed_origins } }) }) : Object.freeze({ secret: normalized.secret, file: normalized.file });
+}
+function parseWorkspaceExecResult(value) {
+  const response = workspaceObject(value, "Workspace exec response");
+  const exitCode = response["exit_code"];
+  if (!Number.isSafeInteger(exitCode)) {
+    throw new Error("Workspace exec response.exit_code must be an integer");
+  }
+  return Object.freeze({
+    exitCode,
+    stdout: decodeWorkspaceBase64(response["stdout_base64"], "Workspace exec response.stdout_base64"),
+    stderr: decodeWorkspaceBase64(response["stderr_base64"], "Workspace exec response.stderr_base64")
+  });
+}
+function parseWorkspaceDeleteReceipt(value) {
+  const response = workspaceObject(value, "Workspace delete response");
+  return Object.freeze({
+    workspaceId: resourceID(response["workspace_id"], "Workspace delete response.workspace_id")
+  });
+}
+function workspaceObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function workspaceTimestamp(value, field) {
+  return timestampString(value, `Workspace response.${field}`);
+}
+function decodeWorkspaceBase64(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be canonical padded base64`);
+  }
+  let binary;
+  try {
+    binary = atob(value);
+  } catch {
+    throw new Error(`${label} must be canonical padded base64`);
+  }
+  if (btoa(binary) !== value) {
+    throw new Error(`${label} must be canonical padded base64`);
+  }
+  const output = new Uint8Array(binary.length);
+  for (let index = 0;index < binary.length; index++) {
+    output[index] = binary.charCodeAt(index);
+  }
+  return output;
+}
+function assertResourceMembers(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || !Object.hasOwn(value, "cpu") || !Object.hasOwn(value, "memory")) {
+    throw new Error("workspace resources require cpu and memory");
+  }
+  const members = Object.keys(value);
+  if (members.length !== 2 || !members.includes("cpu") || !members.includes("memory")) {
+    throw new Error("workspace resources support only cpu and memory");
+  }
+}
+
+// sdk/typescript/src/client-workspace.ts
+function createClientWorkspaces(transport) {
+  return Object.freeze({
+    async retrieve(id, options = {}) {
+      const workspaceID = resourceID(id, "Workspace ID");
+      return parseWorkspace(await transport.request("GET", `/v1/workspaces/${encodeURIComponent(workspaceID)}`, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async list(queryInput = {}, options = {}) {
+      const query = workspaceListQuery(queryInput);
+      const response = objectValue(await transport.request("GET", `/v1/workspaces${query}`, options.signal === undefined ? {} : { signal: options.signal }), "Workspace list response");
+      if (!Array.isArray(response["workspaces"])) {
+        throw new Error("Workspace list response.workspaces must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Workspace list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        items: Object.freeze(response["workspaces"].map(parseWorkspaceListItem)),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    },
+    ref(id) {
+      return createClientWorkspaceRef(resourceID(id, "Workspace ID"), transport);
+    }
+  });
+}
+function parseWorkspaceListItem(value) {
+  const input = objectValue(value, "Workspace list item");
+  const key = input["key"];
+  if (key !== undefined && typeof key !== "string") {
+    throw new Error("Workspace list item.key must be a string");
+  }
+  const sandboxId = input["sandbox_id"];
+  if (typeof sandboxId !== "string") {
+    throw new Error("Workspace list item.sandbox_id must be a string");
+  }
+  validateTaskId(sandboxId);
+  const status = input["status"];
+  if (status !== "available" && status !== "recovery_required" && status !== "deleting") {
+    throw new Error("Workspace list item.status is invalid");
+  }
+  const owner = parseWorkspaceOwner(input["owner"], "Workspace list item.owner");
+  return Object.freeze({
+    id: resourceID(input["id"], "Workspace list item.id"),
+    ...key === undefined ? {} : { key },
+    sandboxId,
+    deploymentId: resourceID(input["deployment_id"], "Workspace list item.deployment_id"),
+    status,
+    ...owner === undefined ? {} : { owner },
+    lastActivityAt: workspaceTimestamp2(input["last_activity_at"], "last_activity_at"),
+    createdAt: workspaceTimestamp2(input["created_at"], "created_at"),
+    updatedAt: workspaceTimestamp2(input["updated_at"], "updated_at")
+  });
+}
+function workspaceTimestamp2(value, field) {
+  return timestampString(value, `Workspace list item.${field}`);
+}
+function createClientWorkspaceRef(id, transport) {
+  const workspaceID = resourceID(id, "Workspace ID");
+  const path = `/v1/workspaces/${encodeURIComponent(workspaceID)}`;
+  const ref = {
+    id: workspaceID,
+    async retrieve(options = {}) {
+      return parseWorkspace(await transport.request("GET", path, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async exec(request, options = {}) {
+      let process = parseWorkspaceExecProcess(await transport.request("POST", `${path}/exec`, {
+        body: {
+          command: [...request.command],
+          ...request.cwd === undefined ? {} : { cwd: request.cwd },
+          ...request.env === undefined ? {} : { env: request.env },
+          ...request.stdin === undefined ? {} : { stdin_base64: encodeBase64(request.stdin) },
+          ...request.timeout === undefined ? {} : { timeout: request.timeout },
+          idempotency_key: request.idempotencyKey
+        },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }));
+      const admittedProcessId = process.processId;
+      while (process.status === "pending" || process.status === "running") {
+        await abortableDelay(1000, options.signal);
+        process = parseWorkspaceExecProcess(await transport.request("GET", `${path}/exec/${encodeURIComponent(admittedProcessId)}`, options.signal === undefined ? {} : { signal: options.signal }));
+        if (process.processId !== admittedProcessId) {
+          throw new Error("Workspace exec poll response changed process ID");
+        }
+      }
+      if (process.status === "failed")
+        throw workspaceExecFailure(process.terminalReasonCode);
+      if (process.status !== "exited") {
+        throw new Error("Workspace exec process response did not reach a terminal status");
+      }
+      return process.result;
+    },
+    async delete(request = {}, options = {}) {
+      return parseWorkspaceDeleteReceipt(await transport.request("DELETE", path, {
+        body: request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }));
+    }
+  };
+  return brandWorkspaceAddress(ref);
+}
+function parseWorkspaceExecProcess(value) {
+  const response = objectValue(value, "Workspace exec process response");
+  const processId = resourceID(response["process_id"], "Workspace exec process response.process_id");
+  switch (response["status"]) {
+    case "pending":
+    case "running":
+      return Object.freeze({ processId, status: response["status"] });
+    case "exited":
+      return Object.freeze({
+        processId,
+        status: "exited",
+        result: parseWorkspaceExecResult(response)
+      });
+    case "failed": {
+      const error = objectValue(response["error"], "Workspace exec process response.error");
+      const terminalReasonCode = error["terminal_reason_code"];
+      if (typeof terminalReasonCode !== "string" || ![
+        "workspace_exec_timed_out",
+        "workspace_exec_output_limit_exceeded",
+        "workspace_exec_placement_timed_out",
+        "workspace_exec_failed"
+      ].includes(terminalReasonCode)) {
+        throw new Error("Workspace exec process response.error.terminal_reason_code is invalid");
+      }
+      return Object.freeze({ processId, status: "failed", terminalReasonCode });
+    }
+    default:
+      throw new Error("Workspace exec process response.status is invalid");
+  }
+}
+function workspaceExecFailure(code) {
+  const message = code === "workspace_exec_timed_out" ? "workspace exec timed out" : code === "workspace_exec_output_limit_exceeded" ? "workspace exec output limit was exceeded" : code === "workspace_exec_placement_timed_out" ? "workspace exec placement timed out" : "workspace exec failed";
+  const error = new Error(message);
+  error.name = "HelmrError";
+  error.code = code;
+  return error;
+}
+function workspaceListQuery(queryInput) {
+  if (queryInput.key !== undefined && (queryInput.cursor !== undefined || queryInput.limit !== undefined)) {
+    throw new Error("Workspace exact key lookup does not accept cursor or limit");
+  }
+  const query = new URLSearchParams;
+  if (queryInput.key !== undefined) {
+    if (queryInput.key.length === 0)
+      throw new Error("Workspace key is required");
+    query.set("key", queryInput.key);
+  }
+  if (queryInput.cursor !== undefined) {
+    if (queryInput.cursor.length === 0)
+      throw new Error("Workspace cursor is required");
+    query.set("cursor", queryInput.cursor);
+  }
+  if (queryInput.limit !== undefined) {
+    if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+      throw new Error("Workspace limit must be an integer in [1,100]");
+    }
+    query.set("limit", queryInput.limit.toString());
+  }
+  return query.size === 0 ? "" : `?${query.toString()}`;
+}
+function encodeBase64(value) {
+  let binary = "";
+  for (const byte of value)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function objectValue(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/internal/definition-query.ts
+function definitionItemQuery(queryInput, label) {
+  if ("cursor" in queryInput || "limit" in queryInput) {
+    throw new Error(`${label} item query does not accept cursor or limit`);
+  }
+  const query = new URLSearchParams;
+  if (queryInput.deploymentId !== undefined) {
+    query.set("deployment_id", resourceID(queryInput.deploymentId, "Deployment ID"));
+  }
+  return query.size === 0 ? "" : `?${query.toString()}`;
+}
+function definitionListQuery(queryInput, label) {
+  const query = new URLSearchParams;
+  if (queryInput.deploymentId !== undefined) {
+    query.set("deployment_id", resourceID(queryInput.deploymentId, "Deployment ID"));
+  }
+  if (queryInput.cursor !== undefined) {
+    if (queryInput.cursor.length === 0)
+      throw new Error(`${label} cursor is required`);
+    query.set("cursor", queryInput.cursor);
+  }
+  if (queryInput.limit !== undefined) {
+    if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+      throw new Error(`${label} limit must be an integer in [1,100]`);
+    }
+    query.set("limit", queryInput.limit.toString());
+  }
+  return query.size === 0 ? "" : `?${query.toString()}`;
+}
+
+// sdk/typescript/src/client-sandbox.ts
+function createClientSandboxes(transport) {
+  return Object.freeze({
+    async retrieve(id, query = {}, options = {}) {
+      validateTaskId(id);
+      return parseSandboxInfo(await transport.request("GET", `/v1/sandboxes/${encodeURIComponent(id)}${definitionItemQuery(query, "Sandbox")}`, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async list(queryInput = {}, options = {}) {
+      const response = objectValue2(await transport.request("GET", `/v1/sandboxes${definitionListQuery(queryInput, "Sandbox")}`, options.signal === undefined ? {} : { signal: options.signal }), "Sandbox list response");
+      if (!Array.isArray(response["sandboxes"])) {
+        throw new Error("Sandbox list response.sandboxes must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Sandbox list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        deploymentId: resourceID(response["deployment_id"], "Sandbox list response.deployment_id"),
+        items: Object.freeze(response["sandboxes"].map(parseSandboxListItem)),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    },
+    async createWorkspace(id, request = {}, options = {}) {
+      validateTaskId(id);
+      const secrets = encodeWorkspaceSecrets(request.secrets);
+      const workspace = parseWorkspace(await transport.request("POST", `/v1/sandboxes/${encodeURIComponent(id)}/workspaces`, {
+        body: {
+          ...request.key === undefined ? {} : { key: request.key },
+          ...request.secrets === undefined ? {} : { secrets },
+          ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey }
+        },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }));
+      return createClientWorkspaceRef(workspace.id, transport);
+    }
+  });
+}
+function parseSandboxInfo(value) {
+  const input = objectValue2(value, "Sandbox response");
+  const id = input["id"];
+  if (typeof id !== "string")
+    throw new Error("Sandbox response.id must be a string");
+  validateTaskId(id);
+  return Object.freeze({
+    id,
+    deploymentId: resourceID(input["deployment_id"], "Sandbox response.deployment_id")
+  });
+}
+function parseSandboxListItem(value) {
+  const input = objectValue2(value, "Sandbox list item");
+  const id = input["id"];
+  if (typeof id !== "string")
+    throw new Error("Sandbox list item.id must be a string");
+  validateTaskId(id);
+  return Object.freeze({ id });
+}
+function objectValue2(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/internal/utf8.ts
+var encoder = new TextEncoder;
+var encode = TextEncoder.prototype.encode.call.bind(TextEncoder.prototype.encode);
+var charCodeAt = String.prototype.charCodeAt.call.bind(String.prototype.charCodeAt);
+function compareUTF8(left, right) {
+  const leftBytes = encode(encoder, left);
+  const rightBytes = encode(encoder, right);
+  const length = leftBytes.length < rightBytes.length ? leftBytes.length : rightBytes.length;
+  for (let index = 0;index < length; index++) {
+    const difference = leftBytes[index] - rightBytes[index];
+    if (difference !== 0)
+      return difference;
+  }
+  return leftBytes.length - rightBytes.length;
+}
+function hasOnlyUnicodeScalarValues(value) {
+  for (let index = 0;index < value.length; index++) {
+    const unit = charCodeAt(value, index);
+    if (unit >= 55296 && unit <= 56319) {
+      if (index + 1 === value.length)
+        return false;
+      const next = charCodeAt(value, index + 1);
+      if (next < 56320 || next > 57343)
+        return false;
+      index++;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function assertUnicodeString(value) {
+  if (!hasOnlyUnicodeScalarValues(value)) {
+    throw new Error("canonical JSON contains an unpaired surrogate");
+  }
+}
+
+// sdk/typescript/src/internal/jsoncanon.ts
+var textEncoder = new TextEncoder;
+function canonicalizeJsonValue(value) {
+  return textEncoder.encode(serialize(value, new Set));
+}
+function serialize(value, ancestors) {
+  if (value === null || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("canonical JSON numbers must be finite IEEE 754 doubles");
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    assertUnicodeString(value);
+    return JSON.stringify(value);
+  }
+  if (typeof value !== "object") {
+    throw new Error(`canonical JSON does not support ${typeof value}`);
+  }
+  if (ancestors.has(value)) {
+    throw new Error("canonical JSON does not support cyclic values");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      assertPlainArray(value);
+      const items = value.map((item) => serialize(item, ancestors));
+      return `[${items.join(",")}]`;
+    }
+    const objectValue3 = value;
+    assertPlainObject(objectValue3);
+    const entries = Object.keys(objectValue3).sort().map((key) => {
+      assertUnicodeString(key);
+      return `${JSON.stringify(key)}:${serialize(objectValue3[key], ancestors)}`;
+    });
+    return `{${entries.join(",")}}`;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function assertPlainArray(value) {
+  const keys = Reflect.ownKeys(value);
+  const expected = Array.from({ length: value.length }, (_, index) => String(index));
+  expected.push("length");
+  if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
+    throw new Error("canonical JSON arrays must be dense and have no extra properties");
+  }
+}
+function assertPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new Error("canonical JSON objects must have a plain or null prototype");
+  }
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") {
+      throw new Error("canonical JSON objects cannot have symbol properties");
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw new Error("canonical JSON object properties must be enumerable data properties");
+    }
+  }
+}
+
+// sdk/typescript/src/internal/session.ts
+function parseSession(value) {
+  const input = objectValue3(value, "Session response");
+  const status = sessionStatus(input["status"]);
+  const failure = input["failure"] === undefined ? undefined : parseSessionFailure(input["failure"]);
+  const terminalFailure = status === "cancelled" || status === "failed";
+  if (terminalFailure !== (failure !== undefined)) {
+    throw new Error("Session response has an inconsistent failure projection");
+  }
+  if (failure !== undefined && status === "cancelled" !== (failure.code === "cancelled")) {
+    throw new Error("Session response failure code is inconsistent with status");
+  }
+  const actorId = requiredString(input, "actor_id", "Session response");
+  validateTaskId(actorId);
+  return Object.freeze({
+    id: resourceID(input["id"], "Session response.id"),
+    actorId,
+    deploymentId: resourceID(input["deployment_id"], "Session response.deployment_id"),
+    workspaceId: resourceID(input["workspace_id"], "Session response.workspace_id"),
+    ...input["key"] === undefined ? {} : { key: requiredString(input, "key", "Session response") },
+    status,
+    createdAt: timestampString(input["created_at"], "Session response.created_at"),
+    updatedAt: timestampString(input["updated_at"], "Session response.updated_at"),
+    ...input["current_run_id"] === undefined ? {} : { currentRunId: resourceID(input["current_run_id"], "Session response.current_run_id") },
+    ...failure === undefined ? {} : { failure }
+  });
+}
+function parseSessionInputRecord(value) {
+  const input = objectValue3(value, "Session input response");
+  if (!Object.hasOwn(input, "data")) {
+    throw new Error("Session input response.data is required");
+  }
+  const data = input["data"];
+  canonicalizeJsonValue(data);
+  const source2 = objectValue3(input["source"], "Session input response.source");
+  const type = source2["type"];
+  if (type !== "external" && type !== "run") {
+    throw new Error("Session input response.source.type is invalid");
+  }
+  const parsedSource = type === "external" ? Object.freeze({ type }) : Object.freeze({
+    type,
+    runId: resourceID(source2["run_id"], "Session input response.source.run_id")
+  });
+  return Object.freeze({
+    id: resourceID(input["id"], "Session input response.id"),
+    sequence: safeSequence(input["sequence"], "Session input response.sequence"),
+    data,
+    source: parsedSource,
+    createdAt: timestampString(input["created_at"], "Session input response.created_at")
+  });
+}
+function parseSessionOutputRecord(value) {
+  const input = objectValue3(value, "Session output record");
+  if (!Object.hasOwn(input, "data")) {
+    throw new Error("Session output record.data is required");
+  }
+  const provenance = objectValue3(input["provenance"], "Session output provenance");
+  return Object.freeze({
+    id: resourceID(input["id"], "Session output record.id"),
+    sequence: safeSequence(input["sequence"], "Session output record.sequence"),
+    data: input["data"],
+    contentType: requiredString(input, "content_type", "Session output record"),
+    createdAt: timestampString(input["created_at"], "Session output record.created_at"),
+    provenance: Object.freeze({
+      runId: resourceID(provenance["run_id"], "Session output provenance.run_id"),
+      attemptNumber: safeSequence(provenance["attempt_number"], "Session output provenance.attempt_number"),
+      deploymentId: resourceID(provenance["deployment_id"], "Session output provenance.deployment_id")
+    })
+  });
+}
+function parseSessionFailure(value) {
+  const input = objectValue3(value, "Session failure");
+  const code = requiredString(input, "code", "Session failure");
+  const details = objectValue3(input["details"], "Session failure.details");
+  const runId = details["run_id"] === undefined ? undefined : resourceID(details["run_id"], "Session failure.details.run_id");
+  return Object.freeze({
+    code,
+    message: requiredString(input, "message", "Session failure"),
+    details: Object.freeze(runId === undefined ? {} : { runId })
+  });
+}
+function sessionStatus(value, label = "Session response.status") {
+  if (value !== "open" && value !== "closed" && value !== "cancelled" && value !== "failed") {
+    throw new Error(`${label} is invalid`);
+  }
+  return value;
+}
+function requiredString(value, field, label) {
+  const result = value[field];
+  if (typeof result !== "string" || result.length === 0) {
+    throw new Error(`${label}.${field} must be a non-empty string`);
+  }
+  return result;
+}
+function objectValue3(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function safeSequence(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/client-session.ts
+function createClientSessions(transport) {
+  return Object.freeze({
+    async retrieve(id, options = {}) {
+      const sessionID = resourceID(id, "Session ID");
+      return parseSession(await transport.request("GET", `/v1/sessions/${encodeURIComponent(sessionID)}`, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async list(queryInput = {}, options = {}) {
+      const query = sessionListQuery(queryInput);
+      const response = objectValue4(await transport.request("GET", `/v1/sessions${query}`, {
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }), "Session list response");
+      if (!Array.isArray(response["sessions"])) {
+        throw new Error("Session list response.sessions must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Session list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        items: Object.freeze(response["sessions"].map(parseSession)),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    },
+    ref(id) {
+      return createSessionRef(resourceID(id, "Session ID"), transport);
+    }
+  });
+}
+function createSessionRef(id, transport) {
+  const sessionID = resourceID(id, "Session ID");
+  const basePath = `/v1/sessions/${encodeURIComponent(sessionID)}`;
+  const readRecordPage = async (direction, label, parseRecord, queryInput, options) => {
+    const query = new URLSearchParams;
+    if (queryInput.after !== undefined) {
+      query.set("after", safeSequence2(queryInput.after, `${label} after`).toString());
+    }
+    if (queryInput.limit !== undefined) {
+      if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+        throw new Error(`${label} limit must be an integer in [1,100]`);
+      }
+      query.set("limit", queryInput.limit.toString());
+    }
+    const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+    const response = objectValue4(await transport.request("GET", `${basePath}/${direction}${suffix}`, options.signal === undefined ? {} : { signal: options.signal }), `${label} response`);
+    if (!Array.isArray(response["records"])) {
+      throw new Error(`${label} response.records must be an array`);
+    }
+    return Object.freeze({
+      records: Object.freeze(response["records"].map(parseRecord)),
+      nextAfter: safeSequence2(response["next_after"], `${label} next_after`),
+      hasMore: requiredBoolean(response, "has_more", `${label} response`)
+    });
+  };
+  const output = Object.freeze({
+    async list(query = {}, options = {}) {
+      return readRecordPage("outputs", "Session output", parseSessionOutputRecord, query, options);
+    }
+  });
+  return Object.freeze({
+    id: sessionID,
+    input: Object.freeze({
+      async list(query = {}, options = {}) {
+        return readRecordPage("inputs", "Session input", parseSessionInputRecord, query, options);
+      },
+      async send(input, request = {}, options = {}) {
+        return parseSessionInputRecord(await transport.request("POST", `${basePath}/inputs`, {
+          body: {
+            input,
+            ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey }
+          },
+          ...options.signal === undefined ? {} : { signal: options.signal }
+        }));
+      }
+    }),
+    output,
+    async retrieve(options = {}) {
+      return parseSession(await transport.request("GET", basePath, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async close(request = {}, options = {}) {
+      const response = objectValue4(await transport.request("POST", `${basePath}/close`, {
+        body: request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }), "Session close response");
+      return Object.freeze({
+        sessionId: resourceID(response["session_id"], "Session close response.session_id"),
+        acceptedAt: timestampString(response["accepted_at"], "Session close response.accepted_at")
+      });
+    }
+  });
+}
+function sessionListQuery(queryInput) {
+  const exact = queryInput.actorId !== undefined || queryInput.key !== undefined;
+  if (exact && (queryInput.actorId === undefined || queryInput.key === undefined)) {
+    throw new Error("Session exact key lookup requires actorId and key");
+  }
+  if (exact && (queryInput.status !== undefined || queryInput.cursor !== undefined || queryInput.limit !== undefined)) {
+    throw new Error("Session exact key lookup does not accept status, cursor or limit");
+  }
+  const query = new URLSearchParams;
+  const statuses = queryInput.status === undefined ? [] : Array.isArray(queryInput.status) ? queryInput.status : [queryInput.status];
+  for (const status of statuses) {
+    query.append("status", sessionStatus(status, "Session list status"));
+  }
+  if (queryInput.actorId !== undefined) {
+    validateTaskId(queryInput.actorId);
+    query.set("actor_id", queryInput.actorId);
+  }
+  if (queryInput.key !== undefined) {
+    if (queryInput.key.length === 0)
+      throw new Error("Session key is required");
+    query.set("key", queryInput.key);
+  }
+  if (queryInput.cursor !== undefined) {
+    if (queryInput.cursor.length === 0)
+      throw new Error("Session cursor is required");
+    query.set("cursor", queryInput.cursor);
+  }
+  if (queryInput.limit !== undefined) {
+    if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+      throw new Error("Session limit must be an integer in [1,100]");
+    }
+    query.set("limit", queryInput.limit.toString());
+  }
+  return query.size === 0 ? "" : `?${query.toString()}`;
+}
+function objectValue4(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function requiredBoolean(value, field, label) {
+  const result = value[field];
+  if (typeof result !== "boolean")
+    throw new Error(`${label}.${field} must be a boolean`);
+  return result;
+}
+function safeSequence2(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/client-actor.ts
+function createClientActors(transport) {
+  return Object.freeze({
+    async retrieve(id, query = {}, options = {}) {
+      validateTaskId(id);
+      return parseActorInfo(await transport.request("GET", `/v1/actors/${encodeURIComponent(id)}${definitionItemQuery(query, "Actor")}`, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async list(queryInput = {}, options = {}) {
+      const response = objectValue5(await transport.request("GET", `/v1/actors${definitionListQuery(queryInput, "Actor")}`, options.signal === undefined ? {} : { signal: options.signal }), "Actor list response");
+      if (!Array.isArray(response["actors"])) {
+        throw new Error("Actor list response.actors must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Actor list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        deploymentId: resourceID(response["deployment_id"], "Actor list response.deployment_id"),
+        items: Object.freeze(response["actors"].map(parseActorListItem)),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    },
+    async start(id, request, options = {}) {
+      validateTaskId(id);
+      const response = objectValue5(await transport.request("POST", `/v1/actors/${encodeURIComponent(id)}/start`, {
+        body: actorStartBody(request),
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }), "Actor start response");
+      const sessionID = resourceID(response["session_id"], "Actor start response.session_id");
+      const runID = resourceID(response["run_id"], "Actor start response.run_id");
+      return Object.freeze({
+        session: createSessionRef(sessionID, transport),
+        run: createRunHandle(runID)
+      });
+    }
+  });
+}
+function parseActorInfo(value) {
+  const input = objectValue5(value, "Actor response");
+  const id = requiredString2(input, "id", "Actor response");
+  validateTaskId(id);
+  return Object.freeze({
+    id,
+    deploymentId: resourceID(input["deployment_id"], "Actor response.deployment_id")
+  });
+}
+function parseActorListItem(value) {
+  const input = objectValue5(value, "Actor list item");
+  const id = requiredString2(input, "id", "Actor list item");
+  validateTaskId(id);
+  return Object.freeze({ id });
+}
+function actorStartBody(request) {
+  return {
+    ...request.key === undefined ? {} : { key: request.key },
+    ...request.input === undefined ? {} : { input: request.input },
+    ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey },
+    workspace: { id: workspaceRefID(request.workspace) },
+    ...request.run === undefined ? {} : { run: runOptionsBody(request.run) }
+  };
+}
+function runOptionsBody(run) {
+  return {
+    ...run.queue === undefined ? {} : { queue: run.queue },
+    ...run.concurrencyKey === undefined ? {} : { concurrency_key: run.concurrencyKey },
+    ...run.priority === undefined ? {} : { priority: run.priority },
+    ...run.ttl === undefined ? {} : { ttl: run.ttl },
+    ...run.retry === undefined ? {} : {
+      retry: run.retry.enabled === false ? { enabled: false } : {
+        ...run.retry.enabled === undefined ? {} : { enabled: run.retry.enabled },
+        max_attempts: run.retry.maxAttempts,
+        ...run.retry.backoff === undefined ? {} : {
+          backoff: {
+            ...run.retry.backoff.minDelay === undefined ? {} : { min_delay: run.retry.backoff.minDelay },
+            ...run.retry.backoff.maxDelay === undefined ? {} : { max_delay: run.retry.backoff.maxDelay },
+            ...run.retry.backoff.factor === undefined ? {} : { factor: run.retry.backoff.factor },
+            ...run.retry.backoff.jitter === undefined ? {} : { jitter: run.retry.backoff.jitter }
+          }
+        }
+      }
+    },
+    ...run.metadata === undefined ? {} : { metadata: run.metadata },
+    ...run.tags === undefined ? {} : { tags: [...run.tags] }
+  };
+}
+function objectValue5(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function requiredString2(value, field, label) {
+  const result = value[field];
+  if (typeof result !== "string" || result.length === 0) {
+    throw new Error(`${label}.${field} must be a non-empty string`);
+  }
+  return result;
+}
+
+// sdk/typescript/src/client-deployment.ts
+function createClientDeployments(transport) {
+  return Object.freeze({
+    async list(queryInput = {}, options = {}) {
+      const query = new URLSearchParams;
+      if (queryInput.cursor !== undefined) {
+        if (queryInput.cursor.length === 0)
+          throw new Error("Deployment cursor is required");
+        query.set("cursor", queryInput.cursor);
+      }
+      if (queryInput.limit !== undefined) {
+        if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+          throw new Error("Deployment limit must be an integer in [1,100]");
+        }
+        query.set("limit", String(queryInput.limit));
+      }
+      const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+      const response = deploymentObject(await transport.request("GET", `/v1/deployments${suffix}`, options.signal === undefined ? {} : { signal: options.signal }), "Deployment list response");
+      if (!Array.isArray(response["deployments"])) {
+        throw new Error("Deployment list response.deployments must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Deployment list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        items: Object.freeze(response["deployments"].map(parseDeploymentListItem)),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    },
+    async current(options = {}) {
+      try {
+        return parseDeployment(await transport.request("GET", "/v1/deployments/current", options.signal === undefined ? {} : { signal: options.signal }));
+      } catch (error) {
+        if (errorCode(error) === "no_current_deployment")
+          return null;
+        throw error;
+      }
+    },
+    async retrieve(deploymentId, options = {}) {
+      return parseDeployment(await transport.request("GET", `/v1/deployments/${encodeURIComponent(resourceID(deploymentId, "Deployment ID"))}`, options.signal === undefined ? {} : { signal: options.signal }));
+    }
+  });
+}
+function parseDeploymentListItem(value) {
+  const input = deploymentObject(value, "Deployment list item");
+  return Object.freeze({
+    id: resourceID(input["id"], "Deployment list item.id"),
+    version: requiredString3(input, "version", "Deployment list item"),
+    bundleDigest: requiredString3(input, "bundle_digest", "Deployment list item"),
+    createdAt: timestamp(input, "created_at", "Deployment list item")
+  });
+}
+function errorCode(value) {
+  if (value === null || typeof value !== "object")
+    return;
+  const code = value.code;
+  return typeof code === "string" ? code : undefined;
+}
+function parseDeployment(value) {
+  const input = deploymentObject(value, "Deployment response");
+  const deployment = {
+    id: resourceID(input["id"], "Deployment response.id"),
+    version: requiredString3(input, "version"),
+    bundleDigest: requiredString3(input, "bundle_digest"),
+    createdAt: timestamp(input, "created_at", "Deployment response")
+  };
+  return Object.freeze(deployment);
+}
+function deploymentObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function requiredString3(value, field, label = "Deployment response") {
+  const result = value[field];
+  if (typeof result !== "string" || result === "") {
+    throw new Error(`${label}.${field} must be a non-empty string`);
+  }
+  return result;
+}
+function timestamp(value, field, label) {
+  return timestampString(value[field], `${label}.${field}`);
+}
+
+// sdk/typescript/src/client-schedule.ts
+function createClientSchedules(transport) {
+  return Object.freeze({
+    async retrieve(scheduleId, options = {}) {
+      return parseSchedule(await transport.request("GET", `/v1/schedules/${encodeURIComponent(resourceID(scheduleId, "Schedule ID"))}`, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    async list(query = {}, options = {}) {
+      const values = new URLSearchParams;
+      if (query.taskId !== undefined) {
+        if (query.cursor !== undefined || query.limit !== undefined) {
+          throw new Error("Schedule exact task lookup does not accept cursor or limit");
+        }
+        validateTaskId(query.taskId);
+        values.set("task_id", query.taskId);
+      }
+      if (query.cursor !== undefined) {
+        if (query.cursor.length === 0)
+          throw new Error("Schedule cursor is required");
+        values.set("cursor", query.cursor);
+      }
+      if (query.limit !== undefined) {
+        if (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100) {
+          throw new Error("Schedule limit must be an integer in [1,100]");
+        }
+        values.set("limit", String(query.limit));
+      }
+      const suffix = values.size === 0 ? "" : `?${values}`;
+      const response = scheduleObject(await transport.request("GET", `/v1/schedules${suffix}`, options.signal === undefined ? {} : { signal: options.signal }), "Schedule list response");
+      if (!Array.isArray(response["schedules"])) {
+        throw new Error("Schedule list response.schedules must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Schedule list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        items: Object.freeze(response["schedules"].map(parseSchedule)),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    }
+  });
+}
+function parseSchedule(value) {
+  const input = scheduleObject(value, "Schedule response");
+  const cron = scheduleObject(input["cron"], "Schedule cron");
+  const status = input["status"];
+  if (status !== "active" && status !== "errored" && status !== "archived") {
+    throw new Error("Schedule response.status is invalid");
+  }
+  const lastFailure = input["last_failure"] === undefined ? undefined : parseScheduleFailure(input["last_failure"]);
+  if (status === "errored" && lastFailure === undefined) {
+    throw new Error("Errored Schedule response must contain last_failure");
+  }
+  return Object.freeze({
+    id: resourceID(input["id"], "Schedule response.id"),
+    taskId: requiredString4(input, "task_id", "Schedule response"),
+    generation: positiveInteger(input["generation"], "generation"),
+    effectiveFrom: timestamp2(input["effective_from"], "effective_from"),
+    cron: Object.freeze({
+      pattern: requiredString4(cron, "pattern", "Schedule cron"),
+      timezone: requiredString4(cron, "timezone", "Schedule cron")
+    }),
+    status,
+    ...lastFailure === undefined ? {} : { lastFailure },
+    ...input["next_fire_at"] === undefined ? {} : { nextFireAt: timestamp2(input["next_fire_at"], "next_fire_at") },
+    ...input["last_fire_at"] === undefined ? {} : { lastFireAt: timestamp2(input["last_fire_at"], "last_fire_at") },
+    createdAt: timestamp2(input["created_at"], "created_at"),
+    updatedAt: timestamp2(input["updated_at"], "updated_at")
+  });
+}
+function parseScheduleFailure(value) {
+  const input = scheduleObject(value, "Schedule failure");
+  const code = requiredString4(input, "code", "Schedule failure");
+  return Object.freeze({
+    code,
+    message: requiredString4(input, "message", "Schedule failure"),
+    details: Object.freeze({ ...scheduleObject(input["details"], "Schedule failure.details") })
+  });
+}
+function scheduleObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function requiredString4(value, field, label) {
+  const result = value[field];
+  if (typeof result !== "string" || result === "") {
+    throw new Error(`${label}.${field} must be a non-empty string`);
+  }
+  return result;
+}
+function timestamp2(value, field) {
+  return timestampString(value, `Schedule response.${field}`);
+}
+function positiveInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`Schedule response.${field} must be a positive integer`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/client-secret.ts
+function createClientSecrets(transport) {
+  return Object.freeze({
+    async create(request, options = {}) {
+      validateSecretName(request.name);
+      if (typeof request.value !== "string") {
+        throw new Error("Secret create request.value must be a string");
+      }
+      validateOptionalIdempotencyKey(request.idempotencyKey);
+      return parseSecret(await transport.request("POST", "/v1/secrets", {
+        body: {
+          name: request.name,
+          value: request.value,
+          ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey }
+        },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }));
+    },
+    async retrieve(id, options = {}) {
+      const secretID = resourceID(id, "Secret ID");
+      return parseSecret(await transport.request("GET", `/v1/secrets/${encodeURIComponent(secretID)}`, options.signal === undefined ? {} : { signal: options.signal }));
+    },
+    ref(id) {
+      return createSecretRef(id, transport);
+    },
+    async list(queryInput = {}, options = {}) {
+      const query = new URLSearchParams;
+      if (queryInput.name !== undefined) {
+        validateSecretName(queryInput.name);
+        if (queryInput.cursor !== undefined || queryInput.limit !== undefined) {
+          throw new Error("Secret exact name lookup does not accept cursor or limit");
+        }
+        query.set("name", queryInput.name);
+      }
+      if (queryInput.cursor !== undefined) {
+        if (queryInput.cursor.trim() === "") {
+          throw new Error("Secret list query.cursor must not be empty");
+        }
+        query.set("cursor", queryInput.cursor);
+      }
+      if (queryInput.limit !== undefined) {
+        if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+          throw new Error("Secret list query.limit must be an integer in [1,100]");
+        }
+        query.set("limit", String(queryInput.limit));
+      }
+      const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+      const response = objectValue6(await transport.request("GET", `/v1/secrets${suffix}`, {
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }), "Secret list response");
+      if (!Array.isArray(response["secrets"])) {
+        throw new Error("Secret list response.secrets must be an array");
+      }
+      const nextCursor = response["next_cursor"];
+      if (nextCursor !== undefined && typeof nextCursor !== "string") {
+        throw new Error("Secret list response.next_cursor must be a string");
+      }
+      return Object.freeze({
+        items: Object.freeze(response["secrets"].map((value) => parseSecret(value))),
+        ...nextCursor === undefined ? {} : { nextCursor }
+      });
+    }
+  });
+}
+function createSecretRef(id, transport) {
+  const secretID = resourceID(id, "Secret ID");
+  const path = `/v1/secrets/${encodeURIComponent(secretID)}`;
+  return Object.freeze({
+    id: secretID,
+    async rotate(request, options = {}) {
+      if (typeof request.value !== "string") {
+        throw new Error("Secret rotate request.value must be a string");
+      }
+      validateIdempotencyKey(request.idempotencyKey);
+      return parseSecret(await transport.request("POST", `${path}/rotate`, {
+        body: {
+          value: request.value,
+          idempotency_key: request.idempotencyKey
+        },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }));
+    },
+    async revoke(request, options = {}) {
+      validateIdempotencyKey(request.idempotencyKey);
+      return parseSecret(await transport.request("POST", `${path}/revoke`, {
+        body: { idempotency_key: request.idempotencyKey },
+        ...options.signal === undefined ? {} : { signal: options.signal }
+      }));
+    }
+  });
+}
+function parseSecret(value) {
+  const input = objectValue6(value, "Secret response");
+  const id = input["id"];
+  const name = input["name"];
+  const status = input["status"];
+  if (typeof id !== "string")
+    throw new Error("Secret response.id must be a string");
+  if (typeof name !== "string") {
+    throw new Error("Secret response.name must be a string");
+  }
+  if (status !== "active" && status !== "revoked") {
+    throw new Error("Secret response.status must be active or revoked");
+  }
+  const canonicalID = resourceID(id, "Secret response.id");
+  validateSecretName(name);
+  return Object.freeze({
+    id: canonicalID,
+    name,
+    status,
+    createdAt: dateValue(input["created_at"], "Secret response.created_at"),
+    ...optionalDate(input, "rotated_at", "rotatedAt"),
+    ...optionalDate(input, "revoked_at", "revokedAt")
+  });
+}
+function optionalDate(input, wireName, fieldName) {
+  const value = input[wireName];
+  return value === undefined ? {} : { [fieldName]: dateValue(value, `Secret response.${wireName}`) };
+}
+function dateValue(value, label) {
+  return timestampString(value, label);
+}
+function validateOptionalIdempotencyKey(value) {
+  if (value !== undefined)
+    validateIdempotencyKey(value);
+}
+function validateIdempotencyKey(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error("Secret idempotencyKey is required");
+  }
+}
+function objectValue6(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+
+// sdk/typescript/src/client.ts
+class HelmrClient {
+  tasks;
+  actors;
+  sessions;
+  sandboxes;
+  deployments;
+  schedules;
+  secrets;
+  runs;
+  tokens;
+  workspaces;
+  constructor(options) {
+    const transport = new ClientTransport(options);
+    this.tasks = Object.freeze(new ClientTasks(transport));
+    this.actors = createClientActors(transport);
+    this.sessions = createClientSessions(transport);
+    this.sandboxes = createClientSandboxes(transport);
+    this.deployments = createClientDeployments(transport);
+    this.schedules = createClientSchedules(transport);
+    this.secrets = createClientSecrets(transport);
+    this.runs = Object.freeze(new ClientRuns(transport));
+    this.tokens = Object.freeze(new ClientTokens(transport));
+    this.workspaces = createClientWorkspaces(transport);
+  }
+}
+
+class ClientTasks {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  async retrieve(id, query = {}, options = {}) {
+    validateTaskId(id);
+    return parseTask(await this.#transport.request("GET", `/v1/tasks/${encodeURIComponent(id)}${definitionItemQuery(query, "Task")}`, options.signal === undefined ? {} : { signal: options.signal }));
+  }
+  async list(query = {}, options = {}) {
+    const response = objectValue7(await this.#transport.request("GET", `/v1/tasks${definitionListQuery(query, "Task")}`, options.signal === undefined ? {} : { signal: options.signal }), "Task list response");
+    if (!Array.isArray(response["tasks"])) {
+      throw new Error("Task list response.tasks must be an array");
+    }
+    const nextCursor = response["next_cursor"];
+    if (nextCursor !== undefined && typeof nextCursor !== "string") {
+      throw new Error("Task list response.next_cursor must be a string");
+    }
+    return Object.freeze({
+      deploymentId: resourceID(response["deployment_id"], "Task list response.deployment_id"),
+      items: Object.freeze(response["tasks"].map(parseTaskListItem)),
+      ...nextCursor === undefined ? {} : { nextCursor }
+    });
+  }
+  async start(taskId, request, options = {}) {
+    validateTaskId(taskId);
+    const response = objectValue7(await this.#transport.request("POST", `/v1/tasks/${encodeURIComponent(taskId)}/start`, {
+      body: {
+        ..."payload" in request ? { payload: request.payload } : {},
+        ...taskStartRequest(request)
+      },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    }), "Task start response");
+    const runId = resourceID(response["run_id"], "Task start response.run_id");
+    return createRunHandle(runId);
+  }
+}
+function parseTask(value) {
+  const input = objectValue7(value, "Task response");
+  const id = requiredStringFrom(input, "id", "Task response");
+  validateTaskId(id);
+  return Object.freeze({
+    id,
+    deploymentId: resourceID(input["deployment_id"], "Task response.deployment_id")
+  });
+}
+function parseTaskListItem(value) {
+  const input = objectValue7(value, "Task list item");
+  const id = requiredStringFrom(input, "id", "Task list item");
+  validateTaskId(id);
+  return Object.freeze({ id });
+}
+
+class ClientRuns {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  async retrieve(run, options = {}) {
+    const runId = runHandleID(run);
+    return parseRun(await this.#transport.request("GET", `/v1/runs/${encodeURIComponent(runId)}`, options.signal === undefined ? {} : { signal: options.signal }));
+  }
+  async list(queryInput = {}, options = {}) {
+    const query = new URLSearchParams;
+    const statuses = queryInput.status === undefined ? [] : Array.isArray(queryInput.status) ? queryInput.status : [queryInput.status];
+    for (const status of statuses)
+      query.append("status", runStatus(status));
+    const kinds = queryInput.kind === undefined ? [] : Array.isArray(queryInput.kind) ? queryInput.kind : [queryInput.kind];
+    for (const kind of kinds) {
+      if (kind !== "task" && kind !== "actor") {
+        throw new Error("Run list kind is invalid");
+      }
+      query.append("kind", kind);
+    }
+    if (queryInput.sessionId !== undefined) {
+      query.set("session_id", resourceID(queryInput.sessionId, "Run list Session ID"));
+    }
+    if (queryInput.cursor !== undefined) {
+      if (queryInput.cursor.length === 0)
+        throw new Error("Run cursor is required");
+      query.set("cursor", queryInput.cursor);
+    }
+    if (queryInput.limit !== undefined) {
+      if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+        throw new Error("Run limit must be an integer in [1,100]");
+      }
+      query.set("limit", String(queryInput.limit));
+    }
+    const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+    const response = objectValue7(await this.#transport.request("GET", `/v1/runs${suffix}`, {
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    }), "Run list response");
+    if (!Array.isArray(response["runs"])) {
+      throw new Error("Run list response.runs must be an array");
+    }
+    const nextCursor = response["next_cursor"];
+    if (nextCursor !== undefined && typeof nextCursor !== "string") {
+      throw new Error("Run list response.next_cursor must be a string");
+    }
+    return Object.freeze({
+      items: Object.freeze(response["runs"].map(parseRunListItem)),
+      ...nextCursor === undefined ? {} : { nextCursor }
+    });
+  }
+  async cancel(runId, options = {}) {
+    return parseRun(await this.#transport.request("POST", `/v1/runs/${encodeURIComponent(resourceID(runId, "Run ID"))}/cancel`, options.signal === undefined ? {} : { signal: options.signal }));
+  }
+  async logs(runId, queryInput = {}, options = {}) {
+    const query = runTelemetryQuery(queryInput.cursor, queryInput.limit, "level", queryInput.level);
+    const response = objectValue7(await this.#transport.request("GET", `/v1/runs/${encodeURIComponent(resourceID(runId, "Run ID"))}/logs${query}`, options.signal === undefined ? {} : { signal: options.signal }), "Run log page");
+    if (!Array.isArray(response["logs"])) {
+      throw new Error("Run log page.logs must be an array");
+    }
+    return cursorPage(response["logs"].map(parseRunLogRecord), response["next_cursor"], "Run log page");
+  }
+  async events(runId, queryInput = {}, options = {}) {
+    const query = runTelemetryQuery(queryInput.cursor, queryInput.limit, "severity", queryInput.severity);
+    const response = objectValue7(await this.#transport.request("GET", `/v1/runs/${encodeURIComponent(resourceID(runId, "Run ID"))}/events${query}`, options.signal === undefined ? {} : { signal: options.signal }), "Run event page");
+    if (!Array.isArray(response["events"])) {
+      throw new Error("Run event page.events must be an array");
+    }
+    return cursorPage(response["events"].map(parseRunEventRecord), response["next_cursor"], "Run event page");
+  }
+  wait(run, options = {}) {
+    if (runtimeOperationsInstalled()) {
+      throw new Error("client.runs.wait() is unavailable inside an active Helmr Run; use task.call()");
+    }
+    const id = runHandleID(run);
+    const result = this.#waitForTerminal(id, options);
+    return Object.freeze({
+      then(onfulfilled, onrejected) {
+        return result.then(onfulfilled, onrejected);
+      },
+      async unwrap() {
+        const settled = await result;
+        if (!settled.ok)
+          throw runFailureError(settled.failure);
+        return settled.output;
+      }
+    });
+  }
+  async#waitForTerminal(runId, options) {
+    let delayMilliseconds = 250;
+    while (true) {
+      options.signal?.throwIfAborted();
+      const run = await this.retrieve(createRunHandle(runId), options);
+      if (run.status === "succeeded") {
+        if (run.output === undefined) {
+          throw new Error("Succeeded Run response must include output");
+        }
+        return Object.freeze({
+          ok: true,
+          output: run.output,
+          run: createRunHandle(run.id)
+        });
+      }
+      if (runStatusIsTerminal(run.status)) {
+        if (run.failure === undefined) {
+          throw new Error("Non-success terminal Run response must include failure");
+        }
+        return Object.freeze({
+          ok: false,
+          failure: run.failure,
+          run: createRunHandle(run.id)
+        });
+      }
+      await abortableDelay(delayMilliseconds, options.signal);
+      delayMilliseconds = Math.min(delayMilliseconds * 2, 2000);
+    }
+  }
+}
+function parseRunListItem(value) {
+  const run = objectValue7(value, "Run list item");
+  const status = runStatus(requiredStringFrom(run, "status", "Run list item"));
+  const entrypoint = objectValue7(run["entrypoint"], "Run list item.entrypoint");
+  const kind = requiredStringFrom(entrypoint, "kind", "Run list item.entrypoint");
+  if (kind !== "task" && kind !== "actor") {
+    throw new Error("Run list item.entrypoint.kind is invalid");
+  }
+  const item = {
+    id: resourceID(requiredStringFrom(run, "id", "Run list item"), "Run list item.id"),
+    status,
+    entrypoint: Object.freeze({
+      kind,
+      id: requiredStringFrom(entrypoint, "id", "Run list item.entrypoint")
+    }),
+    workspaceId: resourceID(requiredStringFrom(run, "workspace_id", "Run list item"), "Run list item.workspace_id"),
+    ...run["session_id"] === undefined ? {} : {
+      sessionId: resourceID(requiredStringFrom(run, "session_id", "Run list item"), "Run list item.session_id")
+    },
+    currentAttemptNumber: requiredPositiveInteger(run, "current_attempt_number", "Run list item"),
+    createdAt: requiredTimestamp(run, "created_at", "Run list item"),
+    ...run["started_at"] === undefined ? {} : { startedAt: requiredTimestamp(run, "started_at", "Run list item") },
+    ...run["terminal_at"] === undefined ? {} : { terminalAt: requiredTimestamp(run, "terminal_at", "Run list item") }
+  };
+  if (runStatusIsTerminal(status) !== (item.terminalAt !== undefined)) {
+    throw new Error("Run list item.terminal_at is inconsistent with status");
+  }
+  return Object.freeze(item);
+}
+
+class ClientTokens {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  async create(request = {}, options = {}) {
+    const response = await this.#transport.request("POST", "/v1/tokens", {
+      body: {
+        ...request.timeout === undefined ? {} : { timeout: request.timeout },
+        ...request.metadata === undefined ? {} : { metadata: request.metadata },
+        ...request.tags === undefined ? {} : { tags: [...request.tags] },
+        ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey }
+      },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
+    const token = parseToken(response, true);
+    if (token.status !== "pending") {
+      throw new Error("Token create response must be pending");
+    }
+    return token;
+  }
+  async retrieve(id, options = {}) {
+    return parseToken(await this.#transport.request("GET", `/v1/tokens/${encodeURIComponent(resourceID(id, "Token ID"))}`, options.signal === undefined ? {} : { signal: options.signal }), false);
+  }
+  async list(queryInput = {}, options = {}) {
+    const query = new URLSearchParams;
+    if (queryInput.status !== undefined)
+      query.set("status", tokenStatus(queryInput.status));
+    if (queryInput.cursor !== undefined) {
+      if (queryInput.cursor.length === 0)
+        throw new Error("Token cursor is required");
+      query.set("cursor", queryInput.cursor);
+    }
+    if (queryInput.limit !== undefined) {
+      if (!Number.isInteger(queryInput.limit) || queryInput.limit < 1 || queryInput.limit > 100) {
+        throw new Error("Token limit must be an integer in [1,100]");
+      }
+      query.set("limit", String(queryInput.limit));
+    }
+    const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+    const response = objectValue7(await this.#transport.request("GET", `/v1/tokens${suffix}`, {
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    }), "Token list response");
+    if (!Array.isArray(response["tokens"])) {
+      throw new Error("Token list response.tokens must be an array");
+    }
+    const nextCursor = response["next_cursor"];
+    if (nextCursor !== undefined && typeof nextCursor !== "string") {
+      throw new Error("Token list response.next_cursor must be a string");
+    }
+    return Object.freeze({
+      items: Object.freeze(response["tokens"].map(parseTokenListItem)),
+      ...nextCursor === undefined ? {} : { nextCursor }
+    });
+  }
+  async complete(id, request, options = {}) {
+    return parseToken(await this.#transport.request("POST", `/v1/tokens/${encodeURIComponent(resourceID(id, "Token ID"))}/complete`, {
+      body: {
+        result: request.result,
+        ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey }
+      },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    }), false);
+  }
+  async cancel(id, request = {}, options = {}) {
+    return parseToken(await this.#transport.request("POST", `/v1/tokens/${encodeURIComponent(resourceID(id, "Token ID"))}/cancel`, {
+      body: request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    }), false);
+  }
+}
+function taskStartRequest(request) {
+  return {
+    workspace: { id: workspaceRefID(request.workspace) },
+    ...request.idempotencyKey === undefined ? {} : { idempotency_key: request.idempotencyKey },
+    ...request.queue === undefined ? {} : { queue: request.queue },
+    ...request.concurrencyKey === undefined ? {} : { concurrency_key: request.concurrencyKey },
+    ...request.priority === undefined ? {} : { priority: request.priority },
+    ...request.ttl === undefined ? {} : { ttl: request.ttl },
+    ...request.retry === undefined ? {} : {
+      retry: request.retry.enabled === false ? { enabled: false } : {
+        ...request.retry.enabled === undefined ? {} : { enabled: request.retry.enabled },
+        max_attempts: request.retry.maxAttempts,
+        ...request.retry.backoff === undefined ? {} : {
+          backoff: {
+            ...request.retry.backoff.minDelay === undefined ? {} : { min_delay: request.retry.backoff.minDelay },
+            ...request.retry.backoff.maxDelay === undefined ? {} : { max_delay: request.retry.backoff.maxDelay },
+            ...request.retry.backoff.factor === undefined ? {} : { factor: request.retry.backoff.factor },
+            ...request.retry.backoff.jitter === undefined ? {} : { jitter: request.retry.backoff.jitter }
+          }
+        }
+      }
+    },
+    ...request.metadata === undefined ? {} : { metadata: request.metadata },
+    ...request.tags === undefined ? {} : { tags: [...request.tags] }
+  };
+}
+
+class ClientTransport {
+  #baseURL;
+  #apiKey;
+  #fetch;
+  constructor(options) {
+    this.#baseURL = clientBaseURL(options.url ?? "https://api.helmr.dev");
+    this.#apiKey = options.apiKey.trim();
+    if (this.#apiKey === "")
+      throw new Error("Helmr API key is required");
+    this.#fetch = options.fetch ?? globalThis.fetch;
+    if (typeof this.#fetch !== "function") {
+      throw new Error("fetch is unavailable");
+    }
+  }
+  async request(method, path, options = {}) {
+    const response = await this.#fetch(new URL(path, this.#baseURL), {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.#apiKey}`,
+        ...options.body === undefined ? {} : { "Content-Type": "application/json" }
+      },
+      ...options.body === undefined ? {} : { body: JSON.stringify(options.body) },
+      ...options.signal === undefined ? {} : { signal: options.signal }
+    });
+    const value = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw clientRequestError(response, value);
+    }
+    return value;
+  }
+}
+function clientRequestError(response, value) {
+  const body = value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const payload = body["error"] !== null && typeof body["error"] === "object" && !Array.isArray(body["error"]) ? body["error"] : {};
+  const message = typeof payload["message"] === "string" && payload["message"] !== "" ? payload["message"] : `Helmr request failed with status ${response.status}`;
+  const code = typeof payload["code"] === "string" && payload["code"] !== "" ? payload["code"] : responseStatusCode(response.status);
+  const details = payload["details"] !== null && typeof payload["details"] === "object" && !Array.isArray(payload["details"]) ? payload["details"] : undefined;
+  const requestId = response.headers.get("X-Request-ID")?.trim() || undefined;
+  const error = new Error(message);
+  error.name = "HelmrError";
+  error.code = code;
+  if (details !== undefined)
+    error.details = details;
+  if (requestId !== undefined)
+    error.requestId = requestId;
+  return error;
+}
+function responseStatusCode(status) {
+  switch (status) {
+    case 400:
+      return "bad_request";
+    case 401:
+      return "unauthorized";
+    case 403:
+      return "forbidden";
+    case 404:
+      return "not_found";
+    case 405:
+      return "method_not_allowed";
+    case 409:
+      return "conflict";
+    case 410:
+      return "gone";
+    case 413:
+      return "request_too_large";
+    case 422:
+      return "unprocessable_entity";
+    case 429:
+      return "rate_limited";
+    case 501:
+      return "not_implemented";
+    case 502:
+      return "bad_gateway";
+    case 503:
+      return "service_unavailable";
+    default:
+      return status >= 500 ? "internal_error" : "request_failed";
+  }
+}
+function clientBaseURL(raw) {
+  const url = new URL(raw);
+  if (url.username !== "" || url.password !== "" || url.pathname !== "" && url.pathname !== "/" || url.search !== "" || url.hash !== "") {
+    throw new Error("Helmr API URL must be an origin without credentials, path, query, or fragment");
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]"))) {
+    throw new Error("Helmr API URL must use HTTPS except on loopback");
+  }
+  url.pathname = "/";
+  return url;
+}
+function runStatus(value) {
+  switch (value) {
+    case "queued":
+    case "running":
+    case "waiting":
+    case "retry_delayed":
+    case "cancel_requested":
+    case "succeeded":
+    case "failed":
+    case "cancelled":
+    case "expired":
+    case "system_failed":
+      return value;
+    default:
+      throw new Error(`Run status ${JSON.stringify(value)} is invalid`);
+  }
+}
+function runStatusIsTerminal(status) {
+  return status === "succeeded" || status === "failed" || status === "cancelled" || status === "expired" || status === "system_failed";
+}
+function parseRun(value) {
+  const run = objectValue7(value, "Run response");
+  const status = runStatus(requiredStringFrom(run, "status", "Run response"));
+  const entrypoint = objectValue7(run["entrypoint"], "Run response.entrypoint");
+  const entrypointKind = requiredStringFrom(entrypoint, "kind", "Run response.entrypoint");
+  if (entrypointKind !== "task" && entrypointKind !== "actor") {
+    throw new Error("Run response.entrypoint.kind is invalid");
+  }
+  const deployment = objectValue7(run["deployment"], "Run response.deployment");
+  const metadata = objectValue7(run["metadata"], "Run response.metadata");
+  const tags = run["tags"];
+  if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string")) {
+    throw new Error("Run response.tags must be an array of strings");
+  }
+  const cause = parseRunCause(run["cause"]);
+  const runResource = {
+    ...createRunHandle(resourceID(requiredStringFrom(run, "id", "Run response"), "Run response.id")),
+    status,
+    entrypoint: Object.freeze({
+      kind: entrypointKind,
+      id: requiredStringFrom(entrypoint, "id", "Run response.entrypoint")
+    }),
+    deployment: Object.freeze({
+      id: resourceID(requiredStringFrom(deployment, "id", "Run response.deployment"), "Run response.deployment.id"),
+      version: requiredStringFrom(deployment, "version", "Run response.deployment")
+    }),
+    workspaceId: resourceID(requiredStringFrom(run, "workspace_id", "Run response"), "Run response.workspace_id"),
+    ...run["session_id"] === undefined ? {} : {
+      sessionId: resourceID(requiredStringFrom(run, "session_id", "Run response"), "Run response.session_id")
+    },
+    ...run["parent_run_id"] === undefined ? {} : {
+      parentRunId: resourceID(requiredStringFrom(run, "parent_run_id", "Run response"), "Run response.parent_run_id")
+    },
+    currentAttemptNumber: requiredPositiveInteger(run, "current_attempt_number", "Run response"),
+    cause,
+    metadata: Object.freeze({ ...metadata }),
+    tags: Object.freeze([...tags]),
+    ...run["output"] === undefined ? {} : { output: run["output"] },
+    ...run["failure"] === undefined ? {} : { failure: parseRunFailure(run["failure"]) },
+    createdAt: requiredTimestamp(run, "created_at", "Run response"),
+    ...run["started_at"] === undefined ? {} : { startedAt: requiredTimestamp(run, "started_at", "Run response") },
+    ...run["terminal_at"] === undefined ? {} : { terminalAt: requiredTimestamp(run, "terminal_at", "Run response") }
+  };
+  if (status === "succeeded") {
+    if (runResource.failure !== undefined || runResource.terminalAt === undefined) {
+      throw new Error("Succeeded Run response has an invalid terminal projection");
+    }
+  } else if (runStatusIsTerminal(status)) {
+    if (runResource.output !== undefined || runResource.failure === undefined || runResource.terminalAt === undefined) {
+      throw new Error("Terminal Run response has an invalid failure projection");
+    }
+  } else if (runResource.output !== undefined || runResource.failure !== undefined || runResource.terminalAt !== undefined) {
+    throw new Error("Active Run response has terminal fields");
+  }
+  return Object.freeze(runResource);
+}
+function parseRunCause(value) {
+  const cause = objectValue7(value, "Run response.cause");
+  const type = requiredStringFrom(cause, "type", "Run response.cause");
+  switch (type) {
+    case "api":
+    case "manual":
+    case "actor_start":
+    case "continuation":
+      return Object.freeze({ type });
+    case "child":
+      return Object.freeze({
+        type,
+        parentRunId: resourceID(requiredStringFrom(cause, "parent_run_id", "Run response.cause"), "Run response.cause.parent_run_id")
+      });
+    case "schedule":
+      return Object.freeze({
+        type,
+        scheduleId: resourceID(requiredStringFrom(cause, "schedule_id", "Run response.cause"), "Run response.cause.schedule_id"),
+        scheduledAt: requiredTimestamp(cause, "scheduled_at", "Run response.cause"),
+        ...cause["last_scheduled_at"] === undefined ? {} : {
+          lastScheduledAt: requiredTimestamp(cause, "last_scheduled_at", "Run response.cause")
+        },
+        timezone: requiredStringFrom(cause, "timezone", "Run response.cause")
+      });
+    default:
+      throw new Error("Run response.cause.type is invalid");
+  }
+}
+function parseRunFailure(value) {
+  const source2 = objectValue7(value, "Run response.failure");
+  const details = objectValue7(source2["details"], "Run response.failure.details");
+  return Object.freeze({
+    code: requiredStringFrom(source2, "code", "Run response.failure"),
+    message: requiredStringFrom(source2, "message", "Run response.failure"),
+    details: Object.freeze({ ...details })
+  });
+}
+function runTelemetryQuery(cursor, limit, filterName, filter) {
+  const query = new URLSearchParams;
+  if (cursor !== undefined) {
+    if (cursor.length === 0)
+      throw new Error("Run telemetry cursor is required");
+    query.set("cursor", cursor);
+  }
+  if (limit !== undefined) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200) {
+      throw new Error("Run telemetry limit must be an integer in [1,200]");
+    }
+    query.set("limit", String(limit));
+  }
+  const values = filter === undefined ? [] : Array.isArray(filter) ? filter : [filter];
+  for (const value of values)
+    query.append(filterName, runLogLevel(value));
+  return query.size === 0 ? "" : `?${query.toString()}`;
+}
+function parseRunLogRecord(value) {
+  const record = objectValue7(value, "Run log record");
+  const kind = requiredStringFrom(record, "kind", "Run log record");
+  const common = {
+    id: requiredStringFrom(record, "id", "Run log record"),
+    runId: resourceID(requiredStringFrom(record, "run_id", "Run log record"), "Run log record.run_id"),
+    attemptNumber: requiredPositiveInteger(record, "attempt_number", "Run log record"),
+    at: requiredTimestamp(record, "at", "Run log record")
+  };
+  if (kind === "structured") {
+    const attributes = objectValue7(record["attributes"], "Run log record.attributes");
+    return Object.freeze({
+      ...common,
+      kind,
+      level: runLogLevel(record["level"]),
+      message: stringValue(record, "message", "Run log record"),
+      attributes: Object.freeze({ ...attributes })
+    });
+  }
+  if (kind !== "stdout" && kind !== "stderr") {
+    throw new Error("Run log record.kind is invalid");
+  }
+  const contentBase64 = stringValue(record, "content_base64", "Run log record");
+  if (!validBase64(contentBase64)) {
+    throw new Error("Run log record.content_base64 must be canonical base64");
+  }
+  return Object.freeze({
+    ...common,
+    kind,
+    observedSequence: requiredPositiveInteger(record, "observed_sequence", "Run log record"),
+    contentBase64,
+    bytes: requiredNonnegativeInteger(record, "bytes", "Run log record")
+  });
+}
+function parseRunEventRecord(value) {
+  const event = objectValue7(value, "Run event record");
+  return Object.freeze({
+    id: requiredStringFrom(event, "id", "Run event record"),
+    runId: resourceID(requiredStringFrom(event, "run_id", "Run event record"), "Run event record.run_id"),
+    ...event["attempt_number"] === undefined ? {} : {
+      attemptNumber: requiredPositiveInteger(event, "attempt_number", "Run event record")
+    },
+    category: requiredStringFrom(event, "category", "Run event record"),
+    severity: runLogLevel(event["severity"]),
+    source: requiredStringFrom(event, "source", "Run event record"),
+    kind: requiredStringFrom(event, "kind", "Run event record"),
+    message: stringValue(event, "message", "Run event record"),
+    attributes: event["attributes"],
+    occurredAt: requiredTimestamp(event, "occurred_at", "Run event record"),
+    at: requiredTimestamp(event, "at", "Run event record")
+  });
+}
+function cursorPage(items, nextCursor, label) {
+  if (nextCursor !== undefined && typeof nextCursor !== "string") {
+    throw new Error(`${label}.next_cursor must be a string`);
+  }
+  return Object.freeze({
+    items: Object.freeze(items),
+    ...nextCursor === undefined ? {} : { nextCursor }
+  });
+}
+function runLogLevel(value) {
+  if (value !== "debug" && value !== "info" && value !== "warn" && value !== "error") {
+    throw new Error("Run log level must be debug, info, warn, or error");
+  }
+  return value;
+}
+function validBase64(value) {
+  return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
+}
+function parseToken(value, credentials) {
+  const input = objectValue7(value, "Token response");
+  const status = tokenStatus(input["status"]);
+  const metadata = objectValue7(input["metadata"], "Token response.metadata");
+  const tags = input["tags"];
+  if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string")) {
+    throw new Error("Token response.tags must be an array of strings");
+  }
+  const token = {
+    id: resourceID(requiredString5(input, "id"), "Token response.id"),
+    status,
+    ...input["result"] === undefined ? {} : { result: input["result"] },
+    metadata,
+    tags: Object.freeze([...tags]),
+    timeoutAt: requiredTimestamp(input, "timeout_at", "Token response"),
+    ...input["completed_at"] === undefined ? {} : { completedAt: requiredTimestamp(input, "completed_at", "Token response") },
+    createdAt: requiredTimestamp(input, "created_at", "Token response"),
+    updatedAt: requiredTimestamp(input, "updated_at", "Token response")
+  };
+  if (!credentials)
+    return Object.freeze(token);
+  return Object.freeze({
+    ...token,
+    callbackUrl: requiredString5(input, "callback_url"),
+    publicAccessToken: requiredString5(input, "public_access_token")
+  });
+}
+function parseTokenListItem(value) {
+  const token = objectValue7(value, "Token list item");
+  const tags = token["tags"];
+  if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string")) {
+    throw new Error("Token list item.tags must be an array of strings");
+  }
+  return Object.freeze({
+    id: resourceID(requiredStringFrom(token, "id", "Token list item"), "Token list item.id"),
+    status: tokenStatus(token["status"]),
+    tags: Object.freeze([...tags]),
+    timeoutAt: requiredTimestamp(token, "timeout_at", "Token list item"),
+    ...token["completed_at"] === undefined ? {} : { completedAt: requiredTimestamp(token, "completed_at", "Token list item") },
+    createdAt: requiredTimestamp(token, "created_at", "Token list item"),
+    updatedAt: requiredTimestamp(token, "updated_at", "Token list item")
+  });
+}
+function tokenStatus(value) {
+  if (value !== "pending" && value !== "completed" && value !== "cancelled" && value !== "expired") {
+    throw new Error("Token status is invalid");
+  }
+  return value;
+}
+function objectValue7(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function requiredString5(value, field) {
+  return requiredStringFrom(value, field, "Token response");
+}
+function requiredStringFrom(value, field, label) {
+  const result = value[field];
+  if (typeof result !== "string" || result === "") {
+    throw new Error(`${label}.${field} must be a non-empty string`);
+  }
+  return result;
+}
+function stringValue(value, field, label) {
+  const result = value[field];
+  if (typeof result !== "string") {
+    throw new Error(`${label}.${field} must be a string`);
+  }
+  return result;
+}
+function requiredPositiveInteger(value, field, label) {
+  const result = value[field];
+  if (!Number.isSafeInteger(result) || result < 1) {
+    throw new Error(`${label}.${field} must be a positive safe integer`);
+  }
+  return result;
+}
+function requiredNonnegativeInteger(value, field, label) {
+  const result = value[field];
+  if (!Number.isSafeInteger(result) || result < 0) {
+    throw new Error(`${label}.${field} must be a nonnegative safe integer`);
+  }
+  return result;
+}
+function requiredTimestamp(value, field, label) {
+  return timestampString(value[field], `${label}.${field}`);
+}
+// sdk/typescript/src/logger.ts
+function write(level, message, attributes = {}) {
+  return currentRuntimeOperations().structuredLog(level, message, attributes);
+}
+var logger = Object.freeze({
+  debug(message, attributes) {
+    return write("debug", message, attributes);
+  },
+  info(message, attributes) {
+    return write("info", message, attributes);
+  },
+  warn(message, attributes) {
+    return write("warn", message, attributes);
+  },
+  error(message, attributes) {
+    return write("error", message, attributes);
+  }
+});
+// sdk/typescript/src/metadata.ts
+var metadata = Object.freeze({
+  set(key, value) {
+    return currentRuntimeOperations().metadataSet(key, value);
+  },
+  patch(values) {
+    return currentRuntimeOperations().metadataPatch(values);
+  },
+  increment(key, amount = 1) {
+    return currentRuntimeOperations().metadataIncrement(key, amount);
+  }
+});
+// sdk/typescript/src/config.ts
+var arrayIsArray = Array.isArray;
+var arrayPrototype = Array.prototype;
+var defineProperty = Object.defineProperty;
+var objectPrototype = Object.prototype;
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+var getPrototypeOf = Object.getPrototypeOf;
+var hasOwn = Object.hasOwn;
+var freeze = Object.freeze;
+var ownKeys = Reflect.ownKeys;
+var startsWith = String.prototype.startsWith.call.bind(String.prototype.startsWith);
+var endsWith = String.prototype.endsWith.call.bind(String.prototype.endsWith);
+var includes = String.prototype.includes.call.bind(String.prototype.includes);
+var split = String.prototype.split.call.bind(String.prototype.split);
+var slice = String.prototype.slice.call.bind(String.prototype.slice);
+var charCodeAt2 = String.prototype.charCodeAt.call.bind(String.prototype.charCodeAt);
+var regexpTest = RegExp.prototype.test.call.bind(RegExp.prototype.test);
+function defineConfig(input) {
+  return normalizeConfig(input);
+}
+function validateDirectory(value) {
+  if (typeof value !== "string" || value === "" || !hasOnlyUnicodeScalarValues(value) || startsWith(value, "/") || includes(value, "\\") || hasControl(value)) {
+    throw new Error("config dirs entries must be non-empty root-relative POSIX paths");
+  }
+  const normalized = startsWith(value, "./") ? slice(value, 2) : value;
+  const segments = split(normalized, "/");
+  let invalidSegment = normalized === "";
+  for (let index = 0;index < segments.length; index++) {
+    const segment = segments[index];
+    if (segment === "" || segment === "." || segment === "..") {
+      invalidSegment = true;
+      break;
+    }
+  }
+  if (invalidSegment) {
+    throw new Error("config dirs entries must be normalized root-relative paths");
+  }
+  return normalized;
+}
+function validateIgnorePattern(value) {
+  if (typeof value !== "string" || value === "" || !hasOnlyUnicodeScalarValues(value) || startsWith(value, "./") || startsWith(value, "/") || endsWith(value, "/") || includes(value, "//") || includes(value, "\\") || hasControl(value) || startsWith(value, "!") || regexpTest(/[[\]{}]/, value) || regexpTest(/[?*+@!]\(/, value)) {
+    throw new Error(`unsupported ignorePattern ${JSON.stringify(value)}`);
+  }
+  const segments = split(value, "/");
+  for (let index = 0;index < segments.length; index++) {
+    const segment = segments[index];
+    if (segment === ".." || includes(segment, "**") && segment !== "**") {
+      throw new Error(`unsupported ignorePattern ${JSON.stringify(value)}`);
+    }
+  }
+  return value;
+}
+function hasControl(value) {
+  for (let index = 0;index < value.length; index++) {
+    const code = charCodeAt2(value, index);
+    if (code <= 31 || code >= 127 && code <= 159)
+      return true;
+  }
+  return false;
+}
+function normalizeConfig(value) {
+  if (arrayIsArray(value) || getPrototypeOf(value) !== objectPrototype) {
+    throw new Error("config must be an ordinary object");
+  }
+  const descriptors = getOwnPropertyDescriptors(value);
+  const keys = ownKeys(value);
+  let invalidKey = false;
+  for (let index = 0;index < keys.length; index++) {
+    const key = keys[index];
+    if (typeof key !== "string" || key !== "dirs" && key !== "ignorePatterns") {
+      invalidKey = true;
+      break;
+    }
+  }
+  if (invalidKey) {
+    throw new Error("config accepts only dirs and ignorePatterns");
+  }
+  for (let index = 0;index < keys.length; index++) {
+    const key = keys[index];
+    if (typeof key !== "string") {
+      throw new Error("config accepts only dirs and ignorePatterns");
+    }
+    const descriptor = descriptors[key];
+    if (descriptor === undefined || !descriptor.enumerable || !hasOwn(descriptor, "value")) {
+      throw new Error("config properties must be enumerable data properties");
+    }
+  }
+  const dirs = normalizeStringSet(hasOwn(descriptors, "dirs") ? descriptors["dirs"]?.value : ["tasks"], "config dirs", validateDirectory, true);
+  const ignorePatterns = normalizeStringSet(hasOwn(descriptors, "ignorePatterns") ? descriptors["ignorePatterns"]?.value : [], "config ignorePatterns", validateIgnorePattern, false);
+  return freeze({
+    dirs: freeze(dirs),
+    ignorePatterns: freeze(ignorePatterns)
+  });
+}
+function normalizeStringSet(value, name, normalize, nonempty) {
+  if (!arrayIsArray(value) || getPrototypeOf(value) !== arrayPrototype) {
+    throw new Error(`${name} must be an array`);
+  }
+  const keys = ownKeys(value);
+  const lengthDescriptor = getOwnPropertyDescriptor(value, "length");
+  const length = lengthDescriptor?.value;
+  if (typeof length !== "number" || keys.length !== length + 1 || keys[length] !== "length") {
+    throw new Error(`${name} must be a dense ordinary array`);
+  }
+  const normalized = [];
+  for (let index = 0;index < length; index++) {
+    const key = `${index}`;
+    if (keys[index] !== key) {
+      throw new Error(`${name} must be a dense ordinary array`);
+    }
+    const descriptor = getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined || !descriptor.enumerable || !hasOwn(descriptor, "value")) {
+      throw new Error(`${name} entries must be enumerable data properties`);
+    }
+    const current = normalize(descriptor.value);
+    let insertion = normalized.length;
+    while (insertion > 0 && compareUTF8(current, normalized[insertion - 1]) < 0) {
+      setArrayIndex(normalized, insertion, normalized[insertion - 1]);
+      insertion--;
+    }
+    setArrayIndex(normalized, insertion, current);
+  }
+  if (nonempty && length === 0) {
+    throw new Error(`${name} must be non-empty`);
+  }
+  for (let index = 1;index < normalized.length; index++) {
+    if (normalized[index] === normalized[index - 1]) {
+      throw new Error(`${name} contains a duplicate entry`);
+    }
+  }
+  return normalized;
+}
+function setArrayIndex(array, index, value) {
+  defineProperty(array, `${index}`, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+// sdk/typescript/src/schedules.ts
+function scheduledTask(config) {
+  validateScheduleMembers(config);
+  validateCron(config.cron);
+  if (typeof config.workspace !== "object" || config.workspace === null || Array.isArray(config.workspace)) {
+    throw new Error("schedule workspace must be an object");
+  }
+  const unknownWorkspaceMember = Object.keys(config.workspace).find((key) => key !== "sandbox" && key !== "secrets");
+  if (unknownWorkspaceMember !== undefined) {
+    throw new Error(`schedule workspace has unknown member ${JSON.stringify(unknownWorkspaceMember)}`);
+  }
+  const sandbox2 = config.workspace.sandbox;
+  if (inspectSandboxDefinition(sandbox2) === undefined) {
+    throw new Error("schedule workspace requires a Sandbox definition");
+  }
+  const secrets = encodeWorkspaceSecrets(config.workspace.secrets);
+  return createScheduledTask({
+    id: config.id,
+    payload: scheduledTaskSchema,
+    run: config.run,
+    ...config.queue === undefined ? {} : { queue: config.queue },
+    ...config.maxDuration === undefined ? {} : { maxDuration: config.maxDuration },
+    ...config.ttl === undefined ? {} : { ttl: config.ttl },
+    ...config.retry === undefined ? {} : { retry: config.retry },
+    schedule: {
+      cron: config.cron.pattern,
+      timezone: config.cron.timezone,
+      workspace: {
+        sandbox: sandbox2,
+        secrets
+      }
+    }
+  });
+}
+function validateScheduleMembers(value) {
+  const allowed = new Set([
+    "id",
+    "cron",
+    "workspace",
+    "run",
+    "queue",
+    "maxDuration",
+    "ttl",
+    "retry"
+  ]);
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown !== undefined) {
+    throw new Error(`schedule has unknown member ${JSON.stringify(unknown)}`);
+  }
+}
+var schedules = Object.freeze({
+  task: scheduledTask
+});
+var scheduledTaskSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "helmr",
+    validate(value) {
+      if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return { issues: [{ message: "expected scheduled task input object" }] };
+      }
+      const input = value;
+      const allowed = new Set([
+        "scheduledAt",
+        "lastScheduledAt",
+        "timezone",
+        "scheduleId",
+        "upcoming"
+      ]);
+      if (Object.keys(input).some((key) => !allowed.has(key))) {
+        return { issues: [{ message: "scheduled task input has unknown members" }] };
+      }
+      const scheduledAt = parseDate(input["scheduledAt"]);
+      const lastScheduledAt = input["lastScheduledAt"] === undefined ? undefined : parseDate(input["lastScheduledAt"]);
+      const upcoming = input["upcoming"];
+      if (scheduledAt === undefined || input["lastScheduledAt"] !== undefined && lastScheduledAt === undefined || typeof input["timezone"] !== "string" || typeof input["scheduleId"] !== "string" || !Array.isArray(upcoming)) {
+        return { issues: [{ message: "invalid scheduled task input" }] };
+      }
+      const parsedUpcoming = upcoming.map(parseDate);
+      if (parsedUpcoming.some((date) => date === undefined)) {
+        return { issues: [{ message: "invalid upcoming timestamp" }] };
+      }
+      let scheduleId;
+      try {
+        scheduleId = resourceID(input["scheduleId"], "Scheduled task input.scheduleId");
+      } catch {
+        return { issues: [{ message: "invalid scheduled task input" }] };
+      }
+      return {
+        value: {
+          scheduledAt,
+          ...lastScheduledAt === undefined ? {} : { lastScheduledAt },
+          timezone: input["timezone"],
+          scheduleId,
+          upcoming: parsedUpcoming
+        }
+      };
+    }
+  }
+};
+function parseDate(value) {
+  try {
+    return new Date(timestampString(value, "Scheduled task timestamp"));
+  } catch {
+    return;
+  }
+}
+function validateCron(cron) {
+  if (cron === null || typeof cron !== "object" || Array.isArray(cron) || Object.keys(cron).length !== 2 || !Object.hasOwn(cron, "pattern") || !Object.hasOwn(cron, "timezone") || typeof cron.pattern !== "string" || typeof cron.timezone !== "string") {
+    throw new Error("cron must contain exactly pattern and timezone");
+  }
+  if (new TextEncoder().encode(cron.pattern).length === 0 || new TextEncoder().encode(cron.pattern).length > 1024 || new TextEncoder().encode(cron.timezone).length === 0 || new TextEncoder().encode(cron.timezone).length > 255) {
+    throw new Error("cron pattern and timezone must be non-empty bounded strings");
+  }
+}
+// sdk/typescript/src/timers.ts
+var timers = Object.freeze({
+  waitFor(duration) {
+    return currentRuntimeOperations().waitFor(duration);
+  },
+  waitUntil(date) {
+    return currentRuntimeOperations().waitUntil(date);
+  }
+});
+// sdk/typescript/src/tokens.ts
+var tokens = Object.freeze({
+  async create(request = {}) {
+    const token = await currentRuntimeOperations().tokenCreate(request);
+    return Object.freeze({
+      ...token,
+      wait: tokenWait(token.id)
+    });
+  },
+  ref(id) {
+    const normalized = resourceID(id, "Token ID");
+    return Object.freeze({
+      id: normalized,
+      wait: tokenWait(normalized)
+    });
+  }
+});
+function tokenWait(tokenId) {
+  const wait = (waitOptions = {}) => {
+    const pending = currentRuntimeOperations().tokenWait(tokenId, waitOptions).then(async (value) => {
+      const parsed = waitOptions.schema === undefined ? value : await parsePayloadWithSchema(waitOptions.schema, value, "Token completion result");
+      return Object.freeze({
+        ok: true,
+        data: parsed,
+        unwrap: () => parsed
+      });
+    }).catch((error) => Object.freeze({
+      ok: false,
+      error: tokenWaitError(error),
+      unwrap() {
+        throw this.error;
+      }
+    }));
+    return Object.freeze({
+      then(onfulfilled, onrejected) {
+        return pending.then(onfulfilled, onrejected);
+      },
+      async unwrap() {
+        const result = await pending;
+        if (!result.ok)
+          throw result.error;
+        return result.data;
+      }
+    });
+  };
+  return wait;
+}
+function tokenWaitError(value) {
+  if (value instanceof Error && "code" in value && (value.code === "wait_timeout" || value.code === "token_cancelled" || value.code === "token_expired")) {
+    return value;
+  }
+  throw value;
+}
+export {
+  workspaces,
+  tokens,
+  timers,
+  task,
+  source,
+  sessions,
+  schedules,
+  sandbox,
+  queue,
+  metadata,
+  logger,
+  image,
+  defineConfig,
+  actor,
+  HelmrClient
+};