@superdurable/connector-asana 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,878 @@
+import {
+  AddCommentBranch,
+  AddCommentBranchAdded,
+  AddCommentBranchDefect,
+  AddCommentBranchNotFound,
+  AddCommentBranchProviderRejected,
+  AddCommentBranchUncertain,
+  AddCommentDefinition,
+  AddCommentInputSchema,
+  AddCommentMetadata,
+  AddCommentOutputSchema,
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  CreateTaskBranch,
+  CreateTaskBranchCreated,
+  CreateTaskBranchDefect,
+  CreateTaskBranchProviderRejected,
+  CreateTaskBranchUncertain,
+  CreateTaskDefinition,
+  CreateTaskInputSchema,
+  CreateTaskMetadata,
+  CreateTaskOutputSchema,
+  CustomFieldValueInputSchema,
+  CustomFieldValueSchema,
+  EnumOptionReferenceSchema,
+  GetTaskBranch,
+  GetTaskBranchDefect,
+  GetTaskBranchFound,
+  GetTaskBranchInvalidResponse,
+  GetTaskBranchNotFound,
+  GetTaskBranchProviderRejected,
+  GetTaskDefinition,
+  GetTaskInputSchema,
+  GetTaskMetadata,
+  ListTasksBranch,
+  ListTasksBranchDefect,
+  ListTasksBranchInvalidResponse,
+  ListTasksBranchListed,
+  ListTasksBranchNotFound,
+  ListTasksBranchProviderRejected,
+  ListTasksDefinition,
+  ListTasksInputSchema,
+  ListTasksMetadata,
+  ListTasksOutputSchema,
+  ProjectReferenceSchema,
+  ProviderID,
+  SectionReferenceSchema,
+  TaskMembershipSchema,
+  TaskReferenceSchema,
+  TaskSchema,
+  UpdateTaskBranch,
+  UpdateTaskBranchDefect,
+  UpdateTaskBranchInvalidResponse,
+  UpdateTaskBranchNotFound,
+  UpdateTaskBranchProviderRejected,
+  UpdateTaskBranchUpdated,
+  UpdateTaskDefinition,
+  UpdateTaskInputSchema,
+  UpdateTaskMetadata,
+  UpdateTaskOutputSchema,
+  UserReferenceSchema,
+  WorkspaceReferenceSchema,
+  newConnection,
+  newConnectionWithOperations
+} from "./chunk-BX7GRLMD.js";
+
+// src/generated/steps.ts
+import { goToBranch, newMutationStep, newQueryStep } from "@superdurable/connectors-sdk";
+function newListTasksStep(configuration) {
+  const { connection, connectionName, listed, notFound, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newQueryStep({ ...stepConfiguration, operation: connection.operations.listTasks(), connection: connection.reference, branches: [
+    goToBranch("listed", listed),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newGetTaskStep(configuration) {
+  const { connection, connectionName, found, notFound, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newQueryStep({ ...stepConfiguration, operation: connection.operations.getTask(), connection: connection.reference, branches: [
+    goToBranch("found", found),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newCreateTaskStep(configuration) {
+  const { connection, connectionName, created, providerRejected, uncertain, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newMutationStep({ ...stepConfiguration, operation: connection.operations.createTask(), connection: connection.reference, branches: [
+    goToBranch("created", created),
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...uncertain ? [goToBranch("uncertain", uncertain)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newUpdateTaskStep(configuration) {
+  const { connection, connectionName, updated, notFound, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newMutationStep({ ...stepConfiguration, operation: connection.operations.updateTask(), connection: connection.reference, branches: [
+    goToBranch("updated", updated),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newAddCommentStep(configuration) {
+  const { connection, connectionName, added, notFound, providerRejected, uncertain, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newMutationStep({ ...stepConfiguration, operation: connection.operations.addComment(), connection: connection.reference, branches: [
+    goToBranch("added", added),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...uncertain ? [goToBranch("uncertain", uncertain)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+
+// src/connection.ts
+import { SecretString as SecretString2 } from "@superdurable/connectors-sdk";
+import { z } from "zod";
+
+// src/client.ts
+import { SecretString } from "@superdurable/connectors-sdk";
+import { AddressRefusal, BodyTooLargeError, MaxErrorBodyBytes, ProviderTransportError, isHeaderSafeCredential, parseRetryAfter, sendProviderRequest, validateBaseURL } from "@superdurable/connectors-sdk/providerhttp";
+
+// src/operations.ts
+import { newMutationBranch, newMutationRetry, newMutationUncertain, newQueryBranch, newQueryRetry, zeroReceipt } from "@superdurable/connectors-sdk";
+import { newFence } from "@superdurable/connectors-sdk/singledispatch";
+
+// src/task.ts
+var taskSummaryFields = ["name", "resource_subtype", "completed", "completed_at", "assignee.name", "due_on", "due_at", "start_on", "memberships.project.name", "memberships.section.name", "parent.name", "permalink_url", "created_at", "modified_at"].join(",");
+var taskDetailFields = `${taskSummaryFields},workspace.name,notes,custom_fields.name,custom_fields.resource_subtype,custom_fields.display_value,custom_fields.text_value,custom_fields.number_value,custom_fields.enum_value.name,custom_fields.multi_enum_values.name`;
+var createdTaskFields = "gid,name,permalink_url,created_at";
+var createdStoryFields = "gid,created_at,created_by.gid,created_by.name,resource_subtype";
+var gidPattern = /^[0-9]{1,64}$/;
+function gid(value, field) {
+  const trimmed = value?.trim() ?? "";
+  if (!gidPattern.test(trimmed)) throw new TypeError(`${field} must be an Asana gid, a decimal string such as 1204567890123456`);
+  return trimmed;
+}
+function optionalGid(value, field) {
+  return value?.trim() ? gid(value, field) : "";
+}
+function dueDate(value, field) {
+  const trimmed = value.trim();
+  const date = /* @__PURE__ */ new Date(`${trimmed}T00:00:00Z`);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed) || Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== trimmed) throw new TypeError(`${field} must be a YYYY-MM-DD date such as 2026-10-15`);
+  return trimmed;
+}
+function assignee(value, field) {
+  const trimmed = value.trim();
+  if (trimmed === "me" || gidPattern.test(trimmed) || Buffer.byteLength(trimmed) <= 254 && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) return trimmed;
+  throw new TypeError(`${field} must be me, a user gid, or an email address`);
+}
+function plainText(value, field, required) {
+  if (required && !value.trim()) throw new TypeError(`${field} is required`);
+  if ([...value].length > 65536) throw new TypeError(`${field} cannot exceed 65536 characters`);
+  if ([...value].some((character) => {
+    const code = character.codePointAt(0);
+    return code < 32 && code !== 9 && code !== 10 && code !== 13 || code === 127;
+  })) throw new TypeError(`${field} cannot contain control characters`);
+  return value;
+}
+function taskName(value) {
+  const name = value.trim();
+  if (!name) throw new TypeError("name is required");
+  if ([...name].length > 1024) throw new TypeError("name cannot exceed 1024 characters");
+  if ([...name].some((character) => {
+    const code = character.codePointAt(0);
+    return code < 32 || code === 127;
+  })) throw new TypeError("name must be one line without control characters");
+  return name;
+}
+function customFieldValues(inputs) {
+  if (!inputs?.length) return void 0;
+  if (inputs.length > 20) throw new TypeError("customFields accepts at most 20 values");
+  const result = {};
+  for (const input of inputs) {
+    const fieldId = gid(input.customFieldId, "customFieldId");
+    if (fieldId in result) throw new TypeError(`custom field ${fieldId} is set twice`);
+    const selectors = [input.text !== void 0, input.number !== void 0, !!input.enumOptionId?.trim(), input.multiEnumOptionIds !== void 0];
+    if (selectors.filter(Boolean).length !== 1) throw new TypeError(`custom field ${fieldId}: set exactly one of text, number, enumOptionId, and multiEnumOptionIds`);
+    if (input.text !== void 0) result[fieldId] = plainText(input.text, "text", false);
+    else if (input.number !== void 0) {
+      if (!Number.isFinite(input.number)) throw new TypeError(`custom field ${fieldId}: number must be finite`);
+      result[fieldId] = input.number;
+    } else if (input.multiEnumOptionIds !== void 0) {
+      if (input.multiEnumOptionIds.length > 50) throw new TypeError(`custom field ${fieldId}: multiEnumOptionIds accepts at most 50 options`);
+      result[fieldId] = input.multiEnumOptionIds.map((value) => gid(value, "multiEnumOptionIds"));
+    } else result[fieldId] = gid(input.enumOptionId, "enumOptionId");
+  }
+  return result;
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function string(value) {
+  return typeof value === "string" ? value : "";
+}
+function named(value) {
+  const resource = record(value);
+  if (!gidPattern.test(string(resource.gid))) return void 0;
+  return { id: string(resource.gid), ...string(resource.name) ? { name: string(resource.name) } : {} };
+}
+function time(value) {
+  const text = string(value);
+  if (!text) return "0001-01-01T00:00:00Z";
+  const match = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/.exec(text);
+  if (!match) throw new TypeError("timestamp is not an ISO 8601 date-time");
+  const calendarDate = /* @__PURE__ */ new Date(0);
+  calendarDate.setUTCFullYear(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+  if (calendarDate.getUTCFullYear() !== Number(match[1]) || calendarDate.getUTCMonth() + 1 !== Number(match[2]) || calendarDate.getUTCDate() !== Number(match[3])) throw new TypeError("timestamp is not an ISO 8601 date-time");
+  const parsed = new Date(text);
+  if (Number.isNaN(parsed.getTime())) throw new TypeError("timestamp is not an ISO 8601 date-time");
+  return parsed.toISOString().replace(/\.000Z$/, "Z");
+}
+function optionalTime(value) {
+  return value ? time(value) : void 0;
+}
+function optionalDate(value) {
+  return value ? dueDate(string(value), "date") : void 0;
+}
+function decodeTask(value, detail) {
+  const resource = record(value);
+  const id = gid(string(resource.gid), "task gid");
+  const task = {
+    id,
+    name: string(resource.name),
+    isCompleted: resource.completed === true,
+    createdAt: time(resource.created_at),
+    modifiedAt: time(resource.modified_at)
+  };
+  if (string(resource.resource_subtype)) task.resourceSubtype = string(resource.resource_subtype);
+  if (optionalTime(resource.completed_at)) task.completedAt = optionalTime(resource.completed_at);
+  if (named(resource.assignee)) task.assignee = named(resource.assignee);
+  if (optionalDate(resource.due_on)) task.dueOn = optionalDate(resource.due_on);
+  if (optionalTime(resource.due_at)) task.dueAt = optionalTime(resource.due_at);
+  if (optionalDate(resource.start_on)) task.startOn = optionalDate(resource.start_on);
+  if (named(resource.parent)) task.parent = named(resource.parent);
+  if (string(resource.permalink_url)) task.permalinkUrl = string(resource.permalink_url);
+  const memberships = [];
+  for (const raw of Array.isArray(resource.memberships) ? resource.memberships : []) {
+    const item = record(raw);
+    const project = named(item.project);
+    if (!project || memberships.length === 20) continue;
+    const section = named(item.section);
+    memberships.push({ project, ...section ? { section } : {} });
+  }
+  if (memberships.length) task.memberships = memberships;
+  if (detail) {
+    if (named(resource.workspace)) task.workspace = named(resource.workspace);
+    const notes = string(resource.notes);
+    if (notes) {
+      task.notes = [...notes].slice(0, 65536).join("");
+      if ([...notes].length > 65536) task.isNotesTruncated = true;
+    }
+    const fields = [];
+    for (const raw of Array.isArray(resource.custom_fields) ? resource.custom_fields : []) {
+      const field = record(raw);
+      if (!gidPattern.test(string(field.gid)) || fields.length === 50) continue;
+      const view = { id: string(field.gid) };
+      if (string(field.name)) view.name = string(field.name);
+      if (string(field.resource_subtype)) view.type = string(field.resource_subtype);
+      if (typeof field.display_value === "string") view.displayValue = field.display_value;
+      if (typeof field.text_value === "string") view.textValue = field.text_value;
+      if (typeof field.number_value === "number") view.numberValue = field.number_value;
+      if (named(field.enum_value)) view.enumOption = named(field.enum_value);
+      const options = (Array.isArray(field.multi_enum_values) ? field.multi_enum_values : []).map((value2) => named(value2)).filter((value2) => value2 !== void 0);
+      if (options.length) view.multiEnumOptions = options;
+      fields.push(view);
+    }
+    if (fields.length) task.customFields = fields;
+  }
+  return task;
+}
+
+// src/operations.ts
+var zeroTime = "0001-01-01T00:00:00Z";
+var emptyTask = { id: "", name: "", isCompleted: false, createdAt: zeroTime, modifiedAt: zeroTime };
+var emptyList = { tasks: [] };
+var retryableStatus = (status) => status === 408 || status === 429 || status >= 500;
+var successStatus = (status) => status >= 200 && status < 300;
+var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var string2 = (value) => typeof value === "string" ? value : "";
+var parseTime = (value) => {
+  const raw = string2(value);
+  if (!raw) return void 0;
+  const date = new Date(raw);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString().replace(/\.000Z$/, "Z");
+};
+var queryForFields = (fields) => new URLSearchParams({ opt_fields: fields });
+function readOutcome(client, operation, subject, exchange) {
+  const delay = client.retryAfter(exchange);
+  if ("error" in exchange) {
+    if (exchange.error === "notBuilt") return { kind: "defect", error: failure(operation, "LOCAL_DEFECT", "Asana request could not be built"), delay };
+    return { kind: "retry", error: failure(operation, "TRANSPORT", `Asana ${subject} is temporarily unavailable`), delay };
+  }
+  const status = exchange.response.status;
+  if (status === 404) return { kind: "notFound", error: failure(operation, "NOT_FOUND", `Asana ${subject} was not found or is not visible to the connection`), delay };
+  if (status === 429) return { kind: "retry", error: failure(operation, "RATE_LIMIT", `Asana rate limited the ${subject}`), delay };
+  if (retryableStatus(status)) return { kind: "retry", error: failure(operation, "AVAILABILITY", `Asana ${subject} is temporarily unavailable`), delay };
+  if (status >= 400 && status < 500) return { kind: "providerRejected", error: rejection(operation, subject, status), delay };
+  if (!successStatus(status)) return { kind: "invalidResponse", error: failure(operation, "PROTOCOL", `Asana returned unexpected HTTP ${status} for the ${subject}`), delay };
+  if (exchange.isTooLarge) return { kind: "invalidResponse", error: failure(operation, "RESPONSE_TOO_LARGE", `Asana ${subject} response exceeds the configured size limit`), delay };
+  if (exchange.reflectsSecret) return { kind: "invalidResponse", error: failure(operation, "PROTOCOL", `Asana ${subject} response contains credential material`), delay };
+  return { kind: "success", delay };
+}
+function writeOutcome(client, operation, subject, exchange, repeatable) {
+  const delay = client.retryAfter(exchange);
+  if ("error" in exchange) {
+    if (exchange.error === "notBuilt") return { kind: "defect", error: failure(operation, "LOCAL_DEFECT", "Asana request could not be built"), delay };
+    if (exchange.error === "beforeSend" || repeatable) return { kind: "retry", error: failure(operation, "TRANSPORT", `Asana ${subject} outcome is unknown, so the update is sent again`), delay };
+    return { kind: "uncertain", error: failure(operation, "TRANSPORT", `Asana ${subject} outcome is unknown`), delay };
+  }
+  const status = exchange.response.status;
+  if (successStatus(status)) {
+    if (exchange.isTooLarge) return { kind: repeatable ? "invalidResponse" : "uncertain", error: failure(operation, "RESPONSE_TOO_LARGE", `Asana ${subject} response exceeds the configured size limit`), delay };
+    if (exchange.reflectsSecret) return { kind: repeatable ? "invalidResponse" : "uncertain", error: failure(operation, "PROTOCOL", `Asana ${subject} response contains credential material`), delay };
+    return { kind: "success", delay };
+  }
+  if (status === 429) return { kind: "retry", error: failure(operation, "RATE_LIMIT", `Asana rate limited the ${subject}`), delay };
+  if (status === 503 || repeatable && retryableStatus(status)) return { kind: "retry", error: failure(operation, "AVAILABILITY", `Asana ${subject} is temporarily unavailable`), delay };
+  if (status === 404) return { kind: "notFound", error: rejection(operation, subject, status), delay };
+  if (status >= 400 && status < 500 && status !== 408) return { kind: "providerRejected", error: rejection(operation, subject, status), delay };
+  if (repeatable) return { kind: "invalidResponse", error: failure(operation, "PROTOCOL", `Asana returned unexpected HTTP ${status} for the ${subject}`), delay };
+  return { kind: "uncertain", error: failure(operation, "AVAILABILITY", `Asana ${subject} outcome is unknown after HTTP ${status}`), delay };
+}
+var ListTasksOperation = class {
+  /** Bind a validated Asana client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the stable manifest definition. */
+  definition() {
+    return ListTasksDefinition;
+  }
+  /** Read one page and classify one provider attempt. */
+  async invoke(call, input) {
+    let query;
+    try {
+      query = listQuery(input);
+    } catch (error) {
+      return newQueryBranch("defect", emptyList, zeroReceipt(), failure("listTasks", "VALIDATION", String(error)));
+    }
+    const token = await this.client.token(call);
+    if (!token) return newQueryBranch("defect", emptyList, zeroReceipt(), failure("listTasks", "AUTHENTICATION", "Asana connection credentials are unavailable"));
+    const exchange = await this.client.exchange(call, token, "GET", "/tasks", query);
+    const classified = readOutcome(this.client, "listTasks", "task list", exchange);
+    if (classified.kind === "retry") return newQueryRetry(classified.error, classified.delay);
+    const receipt = this.client.receipt(call);
+    if (classified.kind !== "success") return newQueryBranch(classified.kind, emptyList, receipt, classified.error);
+    if (!("response" in exchange)) throw new TypeError("successful read requires a response");
+    try {
+      const page = JSON.parse(Buffer.from(exchange.response.body).toString("utf8"));
+      if (!Array.isArray(page.data) || page.data.length > 100) throw new TypeError("response has no data array");
+      const tasks = page.data.map((value) => decodeTask(value, false));
+      const nextOffset = string2(record2(page.next_page).offset);
+      if (nextOffset && !validOffset(nextOffset)) throw new TypeError("next page offset is invalid");
+      return newQueryBranch("listed", { tasks, ...nextOffset ? { nextOffset } : {} }, receipt);
+    } catch {
+      return newQueryBranch("invalidResponse", emptyList, receipt, failure("listTasks", "PROTOCOL", "Asana returned an invalid task page"));
+    }
+  }
+};
+var GetTaskOperation = class {
+  /** Bind a validated Asana client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the stable manifest definition. */
+  definition() {
+    return GetTaskDefinition;
+  }
+  /** Read one task and classify one provider attempt. */
+  async invoke(call, input) {
+    let taskId;
+    try {
+      taskId = gid(input.taskId, "taskId");
+    } catch (error) {
+      return newQueryBranch("defect", emptyTask, zeroReceipt(), failure("getTask", "VALIDATION", String(error)));
+    }
+    const token = await this.client.token(call);
+    if (!token) return newQueryBranch("defect", emptyTask, zeroReceipt(), failure("getTask", "AUTHENTICATION", "Asana connection credentials are unavailable"));
+    const exchange = await this.client.exchange(call, token, "GET", `/tasks/${taskId}`, queryForFields(taskDetailFields));
+    const classified = readOutcome(this.client, "getTask", "task", exchange);
+    if (classified.kind === "retry") return newQueryRetry(classified.error, classified.delay);
+    const receipt = this.client.receipt(call, taskId);
+    if (classified.kind !== "success") return newQueryBranch(classified.kind, emptyTask, receipt, classified.error);
+    try {
+      return newQueryBranch("found", decodeTask(dataObject(exchange), true), receipt);
+    } catch {
+      return newQueryBranch("invalidResponse", emptyTask, receipt, failure("getTask", "PROTOCOL", "Asana returned an invalid task"));
+    }
+  }
+};
+var CreateTaskOperation = class {
+  /** Bind a validated Asana client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the stable manifest definition. */
+  definition() {
+    return CreateTaskDefinition;
+  }
+  /** Use the Call ID in Dex receipts; Asana does not accept this key. */
+  idempotencyKey(callId) {
+    return callId;
+  }
+  /** Create or read back one task without repeating an ambiguous write. */
+  async invoke(call, input) {
+    const requested = { name: input.name?.trim() ?? "", ...input.projectId?.trim() ? { projectId: input.projectId.trim() } : {}, ...input.sectionId?.trim() ? { sectionId: input.sectionId.trim() } : {}, ...input.workspaceId?.trim() ? { workspaceId: input.workspaceId.trim() } : {} };
+    let fields;
+    try {
+      fields = createFields(input);
+    } catch (error) {
+      return newMutationBranch("defect", requested, zeroReceipt(), failure("createTask", "VALIDATION", String(error)));
+    }
+    const fence = newFence(call, 3e4);
+    const decision = fence.decide();
+    if (decision.kind === "failClosed") return newMutationUncertain(requested, failure("createTask", "LOCAL_DEFECT", "Asana task dispatch checkpoint is unavailable"), this.client.receipt(call));
+    const taskId = decision.marker?.providerId;
+    if (decision.kind === "readBackRequired" && !taskId) return newMutationUncertain(requested, failure("createTask", "TRANSPORT", "Asana task dispatch checkpoint does not permit another create"), this.client.receipt(call));
+    const token = await this.client.token(call);
+    if (!token) return taskId ? newMutationRetry(failure("createTask", "AUTHENTICATION", "Asana connection credentials are unavailable")) : newMutationBranch("defect", requested, zeroReceipt(), failure("createTask", "AUTHENTICATION", "Asana connection credentials are unavailable"));
+    if (taskId) return this.readBack(call, token, requested, taskId);
+    let exchange;
+    try {
+      exchange = await fence.dispatch((signal) => this.client.exchange(call, token, "POST", "/tasks", queryForFields(createdTaskFields), { data: fields }, signal));
+    } catch {
+      return newMutationRetry(failure("createTask", "AVAILABILITY", "Asana task dispatch checkpoint could not be recorded"));
+    }
+    const classified = writeOutcome(this.client, "createTask", "task", exchange, false);
+    const receipt = this.client.receipt(call);
+    if (classified.kind === "retry") {
+      try {
+        await fence.recordCanResend();
+      } catch {
+        return newMutationUncertain(requested, failure("createTask", "LOCAL_DEFECT", "Asana task retry checkpoint is unavailable"), receipt);
+      }
+      return newMutationRetry(classified.error, classified.delay);
+    }
+    if (classified.kind === "uncertain") return newMutationUncertain(requested, classified.error, receipt);
+    if (classified.kind !== "success") return newMutationBranch(classified.kind === "notFound" ? "providerRejected" : classified.kind, requested, receipt, classified.error);
+    let resource;
+    try {
+      resource = dataObject(exchange);
+      gid(string2(resource.gid), "task gid");
+    } catch {
+      return newMutationUncertain(requested, failure("createTask", "PROTOCOL", "Asana accepted the task but returned an unusable task reference"), receipt);
+    }
+    const createdId = string2(resource.gid);
+    try {
+      await fence.recordProviderId(createdId);
+    } catch {
+    }
+    return newMutationBranch("created", { ...requested, taskId: createdId, ...string2(resource.permalink_url) ? { permalinkUrl: string2(resource.permalink_url) } : {}, ...parseTime(resource.created_at) ? { createdAt: parseTime(resource.created_at) } : {} }, this.client.receipt(call, createdId));
+  }
+  async readBack(call, token, requested, taskId) {
+    const exchange = await this.client.exchange(call, token, "GET", `/tasks/${gid(taskId, "taskId")}`, queryForFields(createdTaskFields));
+    const classified = readOutcome(this.client, "createTask", "task", exchange);
+    if (classified.kind === "retry") return newMutationRetry(classified.error, classified.delay);
+    const receipt = this.client.receipt(call, taskId);
+    if (classified.kind !== "success") return newMutationUncertain(requested, failure("createTask", "PROTOCOL", "Asana task could not be confirmed by ID"), receipt);
+    try {
+      const resource = dataObject(exchange);
+      if (resource.gid !== taskId) throw new TypeError("task ID differs");
+      return newMutationBranch("created", { ...requested, taskId, ...string2(resource.permalink_url) ? { permalinkUrl: string2(resource.permalink_url) } : {}, ...parseTime(resource.created_at) ? { createdAt: parseTime(resource.created_at) } : {} }, receipt);
+    } catch {
+      return newMutationUncertain(requested, failure("createTask", "PROTOCOL", "Asana task read-back did not match the checkpointed ID"), receipt);
+    }
+  }
+};
+var UpdateTaskOperation = class {
+  /** Bind a validated Asana client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the stable manifest definition. */
+  definition() {
+    return UpdateTaskDefinition;
+  }
+  /** Use the stable Call ID in Dex receipts. */
+  idempotencyKey(callId) {
+    return callId;
+  }
+  /** Apply repeatable changes and read back the resulting task. */
+  async invoke(call, input) {
+    const output = { taskId: input.taskId?.trim() ?? "" };
+    let fields, taskId, sectionId;
+    try {
+      ({ fields, taskId, sectionId } = updateFields(input));
+    } catch (error) {
+      return newMutationBranch("defect", output, zeroReceipt(), failure("updateTask", "VALIDATION", String(error)));
+    }
+    const token = await this.client.token(call);
+    if (!token) return newMutationBranch("defect", output, zeroReceipt(), failure("updateTask", "AUTHENTICATION", "Asana connection credentials are unavailable"));
+    const receipt = this.client.receipt(call, taskId);
+    if (sectionId) {
+      const exchange2 = await this.client.exchange(call, token, "POST", `/sections/${sectionId}/addTask`, new URLSearchParams(), { data: { task: taskId } });
+      const classified2 = writeOutcome(this.client, "updateTask", "section move", exchange2, true);
+      const attempt = updateWriteAttempt(classified2, output, receipt);
+      if (attempt) return attempt;
+      output.isMovedToSection = true;
+    }
+    if (Object.keys(fields).length) {
+      const exchange2 = await this.client.exchange(call, token, "PUT", `/tasks/${taskId}`, queryForFields(taskDetailFields), { data: fields });
+      const classified2 = writeOutcome(this.client, "updateTask", "task update", exchange2, true);
+      const attempt = updateWriteAttempt(classified2, output, receipt);
+      if (attempt) return attempt;
+      try {
+        const task = decodeTask(dataObject(exchange2), true);
+        if (task.id !== taskId) throw new TypeError("task ID differs");
+        return newMutationBranch("updated", { ...output, task }, receipt);
+      } catch {
+        return newMutationBranch("invalidResponse", output, receipt, failure("updateTask", "PROTOCOL", "Asana returned an invalid task after the update"));
+      }
+    }
+    const exchange = await this.client.exchange(call, token, "GET", `/tasks/${taskId}`, queryForFields(taskDetailFields));
+    const classified = readOutcome(this.client, "updateTask", "task", exchange);
+    if (classified.kind === "retry") return newMutationRetry(classified.error, classified.delay);
+    if (classified.kind !== "success") return newMutationBranch(classified.kind, output, receipt, classified.error);
+    try {
+      return newMutationBranch("updated", { ...output, task: decodeTask(dataObject(exchange), true) }, receipt);
+    } catch {
+      return newMutationBranch("invalidResponse", output, receipt, failure("updateTask", "PROTOCOL", "Asana returned an invalid task"));
+    }
+  }
+};
+function updateWriteAttempt(classified, output, receipt) {
+  if (classified.kind === "success") return void 0;
+  if (classified.kind === "retry") return newMutationRetry(classified.error, classified.delay);
+  return newMutationBranch(classified.kind === "uncertain" ? "invalidResponse" : classified.kind, output, receipt, classified.error);
+}
+var AddCommentOperation = class {
+  /** Bind a validated Asana client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the stable manifest definition. */
+  definition() {
+    return AddCommentDefinition;
+  }
+  /** Use the Call ID in Dex receipts; Asana does not accept this key. */
+  idempotencyKey(callId) {
+    return callId;
+  }
+  /** Add or read back one story without repeating an ambiguous write. */
+  async invoke(call, input) {
+    const requested = { taskId: input.taskId?.trim() ?? "" };
+    let taskId;
+    try {
+      taskId = gid(input.taskId, "taskId");
+      plainText(input.text, "text", true);
+    } catch (error) {
+      return newMutationBranch("defect", requested, zeroReceipt(), failure("addComment", "VALIDATION", String(error)));
+    }
+    const fence = newFence(call, 3e4);
+    const decision = fence.decide();
+    if (decision.kind === "failClosed") return newMutationUncertain(requested, failure("addComment", "LOCAL_DEFECT", "Asana comment dispatch checkpoint is unavailable"), this.client.receipt(call));
+    const storyId = decision.marker?.providerId;
+    if (decision.kind === "readBackRequired" && !storyId) return newMutationUncertain(requested, failure("addComment", "TRANSPORT", "Asana comment dispatch checkpoint does not permit another comment"), this.client.receipt(call));
+    const token = await this.client.token(call);
+    if (!token) return storyId ? newMutationRetry(failure("addComment", "AUTHENTICATION", "Asana connection credentials are unavailable")) : newMutationBranch("defect", requested, zeroReceipt(), failure("addComment", "AUTHENTICATION", "Asana connection credentials are unavailable"));
+    if (storyId) return this.readBack(call, token, requested, storyId);
+    let exchange;
+    try {
+      exchange = await fence.dispatch((signal) => this.client.exchange(call, token, "POST", `/tasks/${taskId}/stories`, queryForFields(createdStoryFields), { data: { text: input.text } }, signal));
+    } catch {
+      return newMutationRetry(failure("addComment", "AVAILABILITY", "Asana comment dispatch checkpoint could not be recorded"));
+    }
+    const classified = writeOutcome(this.client, "addComment", "comment", exchange, false);
+    const receipt = this.client.receipt(call);
+    if (classified.kind === "retry") {
+      try {
+        await fence.recordCanResend();
+      } catch {
+        return newMutationUncertain(requested, failure("addComment", "LOCAL_DEFECT", "Asana comment retry checkpoint is unavailable"), receipt);
+      }
+      return newMutationRetry(classified.error, classified.delay);
+    }
+    if (classified.kind === "uncertain") return newMutationUncertain(requested, classified.error, receipt);
+    if (classified.kind !== "success") return newMutationBranch(classified.kind, requested, receipt, classified.error);
+    let resource;
+    try {
+      resource = dataObject(exchange);
+      gid(string2(resource.gid), "story gid");
+    } catch {
+      return newMutationUncertain(requested, failure("addComment", "PROTOCOL", "Asana accepted the comment but returned an unusable story reference"), receipt);
+    }
+    const createdId = string2(resource.gid);
+    try {
+      await fence.recordProviderId(createdId);
+    } catch {
+    }
+    return newMutationBranch("added", storyOutput(requested, resource), this.client.receipt(call, createdId));
+  }
+  async readBack(call, token, requested, storyId) {
+    const exchange = await this.client.exchange(call, token, "GET", `/stories/${gid(storyId, "storyId")}`, queryForFields(createdStoryFields));
+    const classified = readOutcome(this.client, "addComment", "comment", exchange);
+    if (classified.kind === "retry") return newMutationRetry(classified.error, classified.delay);
+    const receipt = this.client.receipt(call, storyId);
+    if (classified.kind !== "success") return newMutationUncertain(requested, failure("addComment", "PROTOCOL", "Asana comment could not be confirmed by ID"), receipt);
+    try {
+      const resource = dataObject(exchange);
+      if (resource.gid !== storyId) throw new TypeError("story ID differs");
+      return newMutationBranch("added", storyOutput(requested, resource), receipt);
+    } catch {
+      return newMutationUncertain(requested, failure("addComment", "PROTOCOL", "Asana comment read-back did not match the checkpointed ID"), receipt);
+    }
+  }
+};
+function storyOutput(requested, resource) {
+  const author = record2(resource.created_by);
+  return { ...requested, commentId: string2(resource.gid), .../^[0-9]{1,64}$/.test(string2(author.gid)) ? { author: { id: string2(author.gid), ...string2(author.name) ? { name: string2(author.name) } : {} } } : {}, ...parseTime(resource.created_at) ? { createdAt: parseTime(resource.created_at) } : {} };
+}
+function validOffset(value) {
+  return Buffer.byteLength(value) <= 4096 && /^[!-~]+$/.test(value);
+}
+function listQuery(input) {
+  const projectId = optionalGid(input.projectId, "projectId");
+  const sectionId = optionalGid(input.sectionId, "sectionId");
+  if (!!projectId === !!sectionId) throw new TypeError("set exactly one of projectId and sectionId");
+  const query = queryForFields(taskSummaryFields);
+  query.set(projectId ? "project" : "section", projectId || sectionId);
+  if (input.isIncompleteOnly && input.completedSince) throw new TypeError("set at most one of isIncompleteOnly and completedSince");
+  if (input.isIncompleteOnly) query.set("completed_since", "now");
+  else if (input.completedSince) query.set("completed_since", new Date(input.completedSince).toISOString().replace(/\.000Z$/, "Z"));
+  if (input.modifiedSince) query.set("modified_since", new Date(input.modifiedSince).toISOString().replace(/\.000Z$/, "Z"));
+  const size = input.pageSize || 50;
+  if (!Number.isSafeInteger(size) || size < 1 || size > 100) throw new TypeError("pageSize must be between 1 and 100");
+  query.set("limit", String(size));
+  const offset = input.offset?.trim() ?? "";
+  if (offset) {
+    if (!validOffset(offset)) throw new TypeError("offset must be the token from a previous task page");
+    query.set("offset", offset);
+  }
+  return query;
+}
+function createFields(input) {
+  const name = taskName(input.name);
+  const projectId = optionalGid(input.projectId, "projectId");
+  const sectionId = optionalGid(input.sectionId, "sectionId");
+  const workspaceId = optionalGid(input.workspaceId, "workspaceId");
+  if (!!projectId === !!workspaceId) throw new TypeError("set exactly one of projectId and workspaceId");
+  if (sectionId && !projectId) throw new TypeError("sectionId requires projectId");
+  const fields = { name };
+  if (input.notes && plainText(input.notes, "notes", false).trim()) fields.notes = input.notes;
+  if (sectionId) fields.memberships = [{ project: projectId, section: sectionId }];
+  else if (projectId) fields.projects = [projectId];
+  if (workspaceId) fields.workspace = workspaceId;
+  if (input.assigneeId?.trim()) fields.assignee = assignee(input.assigneeId, "assigneeId");
+  if (input.dueOn?.trim()) fields.due_on = dueDate(input.dueOn, "dueOn");
+  const custom = customFieldValues(input.customFields);
+  if (custom) fields.custom_fields = custom;
+  return fields;
+}
+function updateFields(input) {
+  const taskId = gid(input.taskId, "taskId");
+  const sectionId = optionalGid(input.sectionId, "sectionId");
+  const fields = {};
+  if (input.isCompleted !== void 0) fields.completed = input.isCompleted;
+  if (input.assigneeId !== void 0) fields.assignee = input.assigneeId.trim() ? assignee(input.assigneeId, "assigneeId") : null;
+  if (input.dueOn !== void 0) fields.due_on = input.dueOn.trim() ? dueDate(input.dueOn, "dueOn") : null;
+  const custom = customFieldValues(input.customFields);
+  if (custom) fields.custom_fields = custom;
+  if (!sectionId && !Object.keys(fields).length) throw new TypeError("set at least one of isCompleted, assigneeId, dueOn, customFields, and sectionId");
+  return { taskId, sectionId, fields };
+}
+
+// src/client.ts
+var publicEndpoint = "https://app.asana.com/api/1.0";
+var Client2 = class {
+  endpoint;
+  maxResponseBytes;
+  credentials;
+  send;
+  now;
+  /** Validate settings and own the credential source without resolving a secret. */
+  constructor(config, credentials, options = {}) {
+    if (!credentials) throw new TypeError("Asana credential provider is required");
+    this.endpoint = validateBaseURL(config.endpoint || publicEndpoint);
+    this.maxResponseBytes = config.maxResponseBytes || 4194304;
+    if (!Number.isSafeInteger(this.maxResponseBytes) || this.maxResponseBytes < 1) throw new TypeError("Asana maxResponseBytes must be positive");
+    this.credentials = credentials;
+    this.send = options.send ?? sendProviderRequest;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  /** Bind the task list query. */
+  listTasks() {
+    return new ListTasksOperation(this);
+  }
+  /** Bind the task detail query. */
+  getTask() {
+    return new GetTaskOperation(this);
+  }
+  /** Bind the task create mutation. */
+  createTask() {
+    return new CreateTaskOperation(this);
+  }
+  /** Bind the absolute task update mutation. */
+  updateTask() {
+    return new UpdateTaskOperation(this);
+  }
+  /** Bind the comment create mutation. */
+  addComment() {
+    return new AddCommentOperation(this);
+  }
+  /** Resolve the current personal token for exactly one operation attempt. */
+  async token(call) {
+    try {
+      const credentials = await this.credentials.resolve(call, call.context.cancellationSignal);
+      if (!(credentials.accessToken instanceof SecretString)) return void 0;
+      const token = credentials.accessToken.reveal();
+      return isHeaderSafeCredential(token) ? token : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Send one Asana JSON request while bounding response bytes and elapsed time. */
+  async exchange(call, token, method, path, query, payload, signal) {
+    const remaining = call.context.deadline ? call.context.deadline.getTime() - this.now().getTime() - 1e3 : 25e3;
+    if (remaining < 2500) return { error: "beforeSend" };
+    const sortedQuery = [...query.entries()].sort(([left], [right]) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    const search = new URLSearchParams(sortedQuery).toString();
+    const request = {
+      url: `${this.endpoint}${path}${search ? `?${search}` : ""}`,
+      method,
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json", ...payload === void 0 ? {} : { "Content-Type": "application/json" } },
+      ...payload === void 0 ? {} : { body: Buffer.from(JSON.stringify(payload), "utf8") },
+      maxResponseBytes: Math.max(this.maxResponseBytes, MaxErrorBodyBytes),
+      timeoutMs: Math.min(2e4, remaining),
+      addressPolicy: this.endpoint === publicEndpoint ? "publicHTTPS" : "privateNetworkHTTP",
+      signal: signal ?? call.context.cancellationSignal
+    };
+    try {
+      const response = await this.send(request);
+      const isTooLarge = response.status >= 200 && response.status < 300 && response.body.length > this.maxResponseBytes;
+      return { response: { ...response, body: isTooLarge ? new Uint8Array() : response.body }, isTooLarge, reflectsSecret: Buffer.from(response.body).includes(Buffer.from(token)) };
+    } catch (error) {
+      if (error instanceof BodyTooLargeError && error.status !== void 0) return { response: { status: error.status, headers: error.headers ?? {}, body: new Uint8Array() }, isTooLarge: true, reflectsSecret: false };
+      if (error instanceof AddressRefusal || error instanceof TypeError) return { error: "notBuilt" };
+      if (error instanceof ProviderTransportError) return { error: error.isProvablyNotSent ? "beforeSend" : "afterSend" };
+      return { error: "afterSend" };
+    }
+  }
+  /** Build a secret-free receipt, with no Asana request ID header. */
+  receipt(call, providerObjectId = "") {
+    return { callId: call.id, ...call.idempotencyKey ? { idempotencyKey: call.idempotencyKey } : {}, provider: "asana", ...providerObjectId ? { providerObjectId } : {}, observedAt: this.now().toISOString() };
+  }
+  /** Interpret Retry-After with the same bounded SDK parser as other connectors. */
+  retryAfter(exchange) {
+    if (!("response" in exchange)) return 0;
+    const value = exchange.response.headers["retry-after"];
+    return parseRetryAfter(typeof value === "string" ? value : "", this.now());
+  }
+};
+function failure(operation, kind, message) {
+  return { kind, provider: "asana", operation, message };
+}
+function rejection(operation, subject, status) {
+  const kind = status === 400 ? "VALIDATION" : status === 401 ? "AUTHENTICATION" : status === 402 || status === 403 ? "AUTHORIZATION" : status === 404 ? "NOT_FOUND" : status === 409 ? "CONFLICT" : "PROVIDER_REJECTION";
+  return failure(operation, kind, `Asana rejected the ${subject} with HTTP ${status}`);
+}
+function dataObject(exchange) {
+  if (!("response" in exchange)) throw new TypeError("Asana response is unavailable");
+  const parsed = JSON.parse(Buffer.from(exchange.response.body).toString("utf8"));
+  if (!parsed || typeof parsed !== "object" || !("data" in parsed) || !parsed.data || typeof parsed.data !== "object" || Array.isArray(parsed.data)) throw new TypeError("response has no data object");
+  return parsed.data;
+}
+
+// src/connection.ts
+function newProjectConnection(project, connectionName, options = {}) {
+  if (!project || !connectionName.trim()) throw new TypeError("Asana project connection is required");
+  const selected = project.configuration.connections.find((entry) => entry.connectorId === "asana" && entry.connectionName === connectionName);
+  if (!selected || selected.provider !== "asana") throw new TypeError("Asana project connection is not configured");
+  const settings = z.object({ endpoint: z.string().optional(), maxResponseBytes: z.number().int().optional() }).parse(selected.configuration);
+  const config = { ...settings.endpoint !== void 0 ? { endpoint: settings.endpoint } : {}, ...settings.maxResponseBytes !== void 0 ? { maxResponseBytes: settings.maxResponseBytes } : {} };
+  const credentials = {
+    async resolve(_call, signal) {
+      const fields = z.object({ access_token: z.string().min(1) }).parse(await project.resolveCredential("asana", connectionName, signal));
+      return { accessToken: new SecretString2(fields.access_token) };
+    }
+  };
+  return newConnection(new Client2(config, credentials, options), { provider: "asana", name: connectionName });
+}
+export {
+  AddCommentBranch,
+  AddCommentBranchAdded,
+  AddCommentBranchDefect,
+  AddCommentBranchNotFound,
+  AddCommentBranchProviderRejected,
+  AddCommentBranchUncertain,
+  AddCommentDefinition,
+  AddCommentInputSchema,
+  AddCommentMetadata,
+  AddCommentOperation,
+  AddCommentOutputSchema,
+  Client2 as Client,
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  CreateTaskBranch,
+  CreateTaskBranchCreated,
+  CreateTaskBranchDefect,
+  CreateTaskBranchProviderRejected,
+  CreateTaskBranchUncertain,
+  CreateTaskDefinition,
+  CreateTaskInputSchema,
+  CreateTaskMetadata,
+  CreateTaskOperation,
+  CreateTaskOutputSchema,
+  CustomFieldValueInputSchema,
+  CustomFieldValueSchema,
+  EnumOptionReferenceSchema,
+  GetTaskBranch,
+  GetTaskBranchDefect,
+  GetTaskBranchFound,
+  GetTaskBranchInvalidResponse,
+  GetTaskBranchNotFound,
+  GetTaskBranchProviderRejected,
+  GetTaskDefinition,
+  GetTaskInputSchema,
+  GetTaskMetadata,
+  GetTaskOperation,
+  ListTasksBranch,
+  ListTasksBranchDefect,
+  ListTasksBranchInvalidResponse,
+  ListTasksBranchListed,
+  ListTasksBranchNotFound,
+  ListTasksBranchProviderRejected,
+  ListTasksDefinition,
+  ListTasksInputSchema,
+  ListTasksMetadata,
+  ListTasksOperation,
+  ListTasksOutputSchema,
+  ProjectReferenceSchema,
+  ProviderID,
+  SectionReferenceSchema,
+  TaskMembershipSchema,
+  TaskReferenceSchema,
+  TaskSchema,
+  UpdateTaskBranch,
+  UpdateTaskBranchDefect,
+  UpdateTaskBranchInvalidResponse,
+  UpdateTaskBranchNotFound,
+  UpdateTaskBranchProviderRejected,
+  UpdateTaskBranchUpdated,
+  UpdateTaskDefinition,
+  UpdateTaskInputSchema,
+  UpdateTaskMetadata,
+  UpdateTaskOperation,
+  UpdateTaskOutputSchema,
+  UserReferenceSchema,
+  WorkspaceReferenceSchema,
+  dataObject,
+  failure,
+  newAddCommentStep,
+  newConnection,
+  newConnectionWithOperations,
+  newCreateTaskStep,
+  newGetTaskStep,
+  newListTasksStep,
+  newProjectConnection,
+  newUpdateTaskStep,
+  rejection
+};