agenttwin 0.3.7 → 0.3.9

package/dist/world-host.js

@@ -14,7 +14,7 @@ function operationMatrix(spec) {
       name: s.name,
       adapter: s.adapter ?? "json-collection",
       version: CONTRACTS[s.adapter ?? "json-collection"].version,
-      operations: s.adapter === "slack" ? CONTRACTS.slack.operations : s.adapter === "stripe" ? CONTRACTS.stripe.operations : s.collections.flatMap((c) => CONTRACTS["json-collection"].operations.map((op) => ({ ...op, endpoint: c.path })))
+      operations: s.adapter === "slack" ? CONTRACTS.slack.operations : s.adapter === "stripe" ? CONTRACTS.stripe.operations : s.adapter && s.adapter !== "json-collection" ? CONTRACTS[s.adapter].operations : s.collections.flatMap((c) => CONTRACTS["json-collection"].operations.map((op) => ({ ...op, endpoint: c.path })))
     })) ?? []
   };
 }
@@ -53,6 +53,187 @@ var init_contracts = __esm({
           { method: "GET|POST", endpoint: "/api/conversations.list", effect: "read /channels", parameters: [], errors: [] }
         ],
         limitations: ["JSON and form bodies only", "No OAuth, scopes, pagination, threads, edits, deletes, attachments or webhooks", "Errors channel_not_found/no_text use HTTP 200 with ok:false", "Unmodeled parameters and operations return HTTP 501 and make coverage incomplete"]
+      },
+      github: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; GitHub-style Authorization header",
+        operations: [
+          { method: "GET", endpoint: "/repos", effect: "list repositories", parameters: [], errors: [] },
+          { method: "GET", endpoint: "/repos/<repo>", effect: "retrieve repository by name or full_name", parameters: [], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/repos/<repo>/issues", effect: "list issues", parameters: ["state", "page", "per_page"], errors: ["404 Not Found", "422 validation"] },
+          { method: "POST", endpoint: "/repos/<repo>/issues", effect: "create issue", parameters: ["title", "body", "labels"], errors: ["404 Not Found", "422 validation"] },
+          { method: "GET", endpoint: "/repos/<repo>/issues/<number>", effect: "retrieve issue", parameters: [], errors: ["404 Not Found"] },
+          { method: "PATCH", endpoint: "/repos/<repo>/issues/<number>", effect: "update title/body or close", parameters: ["state", "title", "body"], errors: ["404 Not Found", "422 validation"] },
+          { method: "POST", endpoint: "/repos/<repo>/issues/<number>/comments", effect: "create comment", parameters: ["body"], errors: ["404 Not Found", "422 validation"] },
+          { method: "GET", endpoint: "/repos/<repo>/issues/<number>/comments", effect: "list comments", parameters: [], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/repos/<repo>/pulls", effect: "list pull requests", parameters: ["state"], errors: ["404 Not Found", "422 validation"] },
+          { method: "GET", endpoint: "/repos/<repo>/pulls/<number>", effect: "retrieve pull request", parameters: [], errors: ["404 Not Found"] },
+          { method: "PUT", endpoint: "/repos/<repo>/pulls/<number>/merge", effect: "merge pull request", parameters: ["merge_method"], errors: ["404 Not Found", "405 not mergeable/already merged", "422 validation"] },
+          { method: "POST", endpoint: "/repos/<repo>/check-runs", effect: "create check run", parameters: ["name", "head_sha", "status", "conclusion"], errors: ["404 Not Found", "422 validation"] }
+        ],
+        limitations: ["Bounded REST v3-shaped subset; minimal object fields only", "Ids, numbers and timestamps are deterministic synthetic values", "No auth beyond the run token, no reactions, labels mutation, reviews, branches, contents, releases or webhooks", "Unknown query parameters and operations return 501 and make coverage incomplete"]
+      },
+      linear: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; GraphQL endpoint shape",
+        operations: [
+          { method: "POST", endpoint: "/graphql query viewer", effect: "read first seeded user as viewer", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/graphql query issues", effect: "list issues", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/graphql query issue(id:)", effect: "retrieve issue", parameters: ["id"], errors: ["data:null with Entity not found error"] },
+          { method: "POST", endpoint: "/graphql query projects", effect: "list projects", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/graphql query project(id:)", effect: "retrieve project", parameters: ["id"], errors: ["data:null with Entity not found error"] },
+          { method: "POST", endpoint: "/graphql mutation issueCreate", effect: "create issue", parameters: ["input:title,description,state,assigneeId,projectId,priority"], errors: ["Issue title required"] },
+          { method: "POST", endpoint: "/graphql mutation issueUpdate", effect: "update issue", parameters: ["id", "input:title,description,state,assigneeId,projectId,priority"], errors: ["data:null with Entity not found error"] },
+          { method: "POST", endpoint: "/graphql mutation commentCreate", effect: "create issue comment", parameters: ["input:issueId,body"], errors: ["data:null with Entity not found error", "Comment body required"] }
+        ],
+        limitations: ["GraphQL-shaped approximation of Linear\u2019s API, not the real schema: a bounded root-field whitelist over the same POST /graphql surface", "Structured inputs must be sent as GraphQL variables; inline object arguments are rejected", "Responses use full bounded node shapes regardless of selection set; no pagination, filters, teams, workflows, attachments or subscriptions", "Known failures (missing entity, validation) use HTTP 200 GraphQL errors; unsupported root fields return 501 and make coverage incomplete"]
+      },
+      notion: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; requires Notion-Version header",
+        operations: [
+          { method: "GET", endpoint: "/v1/pages/<id>", effect: "retrieve page", parameters: [], errors: ["404 object_not_found"] },
+          { method: "POST", endpoint: "/v1/pages", effect: "create page in a seeded database", parameters: ["parent.database_id", "properties"], errors: ["400 validation_error", "404 object_not_found"] },
+          { method: "PATCH", endpoint: "/v1/pages/<id>", effect: "update properties or archive", parameters: ["properties", "archived"], errors: ["404 object_not_found", "400 validation_error"] },
+          { method: "GET", endpoint: "/v1/databases/<id>", effect: "retrieve database", parameters: [], errors: ["404 object_not_found"] },
+          { method: "POST", endpoint: "/v1/databases/<id>/query", effect: "query pages in database", parameters: ["filter(property + equals on title/rich_text/number/select/status/checkbox)", "page_size"], errors: ["404 object_not_found", "400 validation_error"] },
+          { method: "PATCH", endpoint: "/v1/blocks/<id>/children", effect: "append child blocks", parameters: ["children (1-100)"], errors: ["404 object_not_found", "400 validation_error"] }
+        ],
+        limitations: ["Bounded envelope subset: pages must use a seeded database parent", "Ids are deterministic synthetic UUIDs; no url, users, comments, searches or nested rich text parsing", "Databases and blocks are returned as created; schema changes and page_size cursoring are not modeled", "Unsupported filters and operations return 501 and make coverage incomplete"]
+      },
+      hubspot: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; HubSpot-style Bearer private token",
+        operations: [
+          { method: "GET", endpoint: "/crm/v3/objects/<contacts|companies|deals|tickets>", effect: "list objects", parameters: ["limit", "after"], errors: ["400 validation"] },
+          { method: "POST", endpoint: "/crm/v3/objects/<contacts|companies|deals|tickets>", effect: "create object", parameters: ["properties"], errors: ["400 validation"] },
+          { method: "GET", endpoint: "/crm/v3/objects/<object>/<id>", effect: "retrieve object", parameters: [], errors: ["404 OBJECT_NOT_FOUND"] },
+          { method: "PATCH", endpoint: "/crm/v3/objects/<object>/<id>", effect: "update properties", parameters: ["properties"], errors: ["404 OBJECT_NOT_FOUND", "400 validation"] },
+          { method: "POST", endpoint: "/crm/v3/objects/<object>/search", effect: "search objects", parameters: ["query", "filterGroups(EQ only, max 3 filters)", "limit", "after"], errors: ["400 validation"] }
+        ],
+        limitations: ["Bounded CRM v3 subset: scalar properties only, no associations, batches, pipelines, owners or dedupe", "Ids and timestamps are deterministic synthetic values", "properties/sorts query parameters and filter operators beyond EQ are unsupported", "Unknown objects, parameters and operations return 501 and make coverage incomplete"]
+      },
+      shopify: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; also accepts X-Shopify-Access-Token",
+        operations: [
+          { method: "GET", endpoint: "/admin/api/2024-01/products.json", effect: "list products", parameters: ["limit", "since_id"], errors: ["400 validation"] },
+          { method: "POST", endpoint: "/admin/api/2024-01/products.json", effect: "create product", parameters: ["product:title,body_html,vendor,product_type,status,tags,variants,options"], errors: ["422 title blank"] },
+          { method: "GET|PUT", endpoint: "/admin/api/2024-01/products/<id>.json", effect: "retrieve or update product", parameters: ["product"], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/admin/api/2024-01/orders.json", effect: "list orders", parameters: ["limit", "since_id"], errors: ["400 validation"] },
+          { method: "POST", endpoint: "/admin/api/2024-01/orders.json", effect: "create order with line_items", parameters: ["order:email,phone,line_items,financial_status,fulfillment_status,note,total_price,currency"], errors: ["422 line_items blank"] },
+          { method: "GET|PUT", endpoint: "/admin/api/2024-01/orders/<id>.json", effect: "retrieve or update order", parameters: ["order"], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/admin/api/2024-01/customers.json", effect: "list customers", parameters: ["limit", "since_id"], errors: ["400 validation"] },
+          { method: "POST", endpoint: "/admin/api/2024-01/customers.json", effect: "create customer", parameters: ["customer:first_name,last_name,email,phone,note,tags"], errors: [] },
+          { method: "GET|PUT", endpoint: "/admin/api/2024-01/customers/<id>.json", effect: "retrieve or update customer", parameters: ["customer"], errors: ["404 Not Found"] }
+        ],
+        limitations: ["REST Admin API pinned to version 2024-01; .json endpoints only", "No metafields, variants mutation, fulfillment, transactions, webhooks, GraphQL or counts endpoints", "Ids and timestamps are deterministic synthetic values", "Unknown parameters and operations return 501 and make coverage incomplete"]
+      },
+      datadog: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; also accepts DD-API-KEY and DD-APPLICATION-KEY headers",
+        operations: [
+          { method: "GET", endpoint: "/api/v1/monitors", effect: "list monitors", parameters: ["name"], errors: [] },
+          { method: "POST", endpoint: "/api/v1/monitors", effect: "create monitor", parameters: ["name", "type", "query", "message", "tags", "options", "priority"], errors: ["400 invalid name/type/query"] },
+          { method: "GET", endpoint: "/api/v1/monitor/<id>", effect: "retrieve monitor", parameters: [], errors: ["404 Monitor not found"] },
+          { method: "POST", endpoint: "/api/v1/monitor/<id>/mute", effect: "mute monitor", parameters: ["scope", "end"], errors: ["404 Monitor not found"] },
+          { method: "POST", endpoint: "/api/v1/events", effect: "post event", parameters: ["title", "text", "tags", "priority", "alert_type", "source"], errors: ["400 invalid title/text"] },
+          { method: "GET", endpoint: "/api/v1/events", effect: "list events in window", parameters: ["start", "end", "priority", "tags"], errors: ["400 start/end required"] },
+          { method: "GET", endpoint: "/api/v1/query", effect: "query seeded metric series", parameters: ["from", "to", "query (avg/min/max/sum:metric{scope})"], errors: ["400 malformed query"] }
+        ],
+        limitations: ["Bounded v1 subset: no dashboards, logs, SLOs, downtimes, unmute or v2 endpoints", "Overall state is always OK; monitor unmute and event deletion are unsupported", "Metric queries return seeded /metrics points clipped to the window; unknown metrics return empty series", "Unknown parameters and operations return 501 and make coverage incomplete"]
+      },
+      gmail: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; Google-style OAuth2 Bearer header",
+        operations: [
+          { method: "POST", endpoint: "/gmail/v1/users/me/messages/send", effect: "append a sent message", parameters: ["text", "raw", "to", "subject", "threadId"], errors: ["400 body required", "400 invalid field type"] },
+          { method: "GET", endpoint: "/gmail/v1/users/me/messages", effect: "list message ids with a snippet q filter", parameters: ["q"], errors: ["400 validation"] },
+          { method: "GET", endpoint: "/gmail/v1/users/me/messages/<id>", effect: "retrieve message", parameters: [], errors: ["404 NOT_FOUND"] },
+          { method: "GET", endpoint: "/gmail/v1/users/me/labels", effect: "list seeded labels", parameters: [], errors: [] }
+        ],
+        limitations: ["Bounded Gmail v1 subset: send, list, get and labels only", "Sent messages carry a bounded Message envelope; MIME bodies are not parsed and attachments are not modeled", "No drafts, threads, history, modify, trash or watch endpoints", "Unknown fields and operations return 501 and make coverage incomplete"]
+      },
+      "google-calendar": {
+        version: "1.1.0",
+        authentication: "Bearer run-scoped test token; Google-style OAuth2 Bearer header",
+        operations: [
+          { method: "GET", endpoint: "/calendar/v3/users/me/calendarList", effect: "list seeded calendars", parameters: [], errors: [] },
+          { method: "GET", endpoint: "/calendar/v3/calendars/primary/events", effect: "filter and paginate nonrecurring timed primary-calendar events", parameters: ["timeMin", "timeMax", "maxResults", "pageToken", "singleEvents", "orderBy=startTime", "conferenceDataVersion=1"], errors: ["400 invalid range, page size, ordering or stale page token"] },
+          { method: "POST", endpoint: "/calendar/v3/calendars/primary/events", effect: "create event", parameters: ["summary", "description", "location", "start", "end", "attendees", "status"], errors: ["400 summary required", "400 invalid field type", "404 unknown calendar"] },
+          { method: "GET", endpoint: "/calendar/v3/calendars/primary/events/<id>", effect: "retrieve event", parameters: [], errors: ["404 NOT_FOUND"] },
+          { method: "PATCH", endpoint: "/calendar/v3/calendars/primary/events/<id>", effect: "update event fields", parameters: ["summary", "description", "location", "start", "end", "attendees", "status"], errors: ["404 NOT_FOUND", "400 invalid field type"] },
+          { method: "DELETE", endpoint: "/calendar/v3/calendars/primary/events/<id>", effect: "delete event (responds 200 with an empty object; production returns 204)", parameters: [], errors: ["404 NOT_FOUND"] }
+        ],
+        limitations: ["Bounded Calendar v3 subset: events on the primary seeded calendar only; requests to any other calendar id return 404", "Recurring-event expansion, all-day timezone filtering, reminders, conference data and sendUpdates are not modeled; these queries return 501", "Pagination tokens are synthetic and expire when query or event state changes; calendar queries follow documented end > timeMin and start < timeMax semantics", "Unknown fields and operations return 501 and make coverage incomplete"]
+      },
+      gitlab: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; GitLab-style Bearer/OAuth token",
+        operations: [
+          { method: "GET", endpoint: "/api/v4/projects", effect: "list projects", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/api/v4/projects", effect: "create project", parameters: ["name", "description", "visibility"], errors: ["400 name missing"] },
+          { method: "GET", endpoint: "/api/v4/projects/<id>", effect: "retrieve project", parameters: [], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/api/v4/issues", effect: "list issues", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/api/v4/issues", effect: "create issue in a seeded project", parameters: ["title", "project_id", "description", "labels", "assignee_ids"], errors: ["400 missing title/project_id", "404 Project Not Found"] },
+          { method: "GET", endpoint: "/api/v4/issues/<id>", effect: "retrieve issue", parameters: [], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/api/v4/merge_requests", effect: "list merge requests", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/api/v4/merge_requests", effect: "create merge request in a seeded project", parameters: ["title", "project_id", "source_branch", "target_branch", "description"], errors: ["400 missing fields", "404 Project Not Found"] },
+          { method: "GET", endpoint: "/api/v4/merge_requests/<iid>", effect: "retrieve merge request", parameters: [], errors: ["404 Not Found"] },
+          { method: "GET", endpoint: "/api/v4/merge_requests/<iid>/notes", effect: "list merge request notes", parameters: [], errors: ["404 Merge Request Not Found"] },
+          { method: "POST", endpoint: "/api/v4/merge_requests/<iid>/notes", effect: "create merge request note", parameters: ["body"], errors: ["404 Merge Request Not Found", "400 body required"] }
+        ],
+        limitations: ["Bounded v4 subset: groups, branches, pipelines, environments, tags workflows and uploads are not modeled", "Ids, iids and timestamps are deterministic synthetic values", "List endpoints take no query parameters; unsupported filters return 501", "Unknown operations return 501 and make coverage incomplete"]
+      },
+      jira: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; Atlassian PAT Bearer header",
+        operations: [
+          { method: "POST", endpoint: "/rest/api/3/issue", effect: "create issue", parameters: ["fields:project.key,issuetype.name,summary,description,priority,labels,assignee"], errors: ["400 missing fields", "400 unknown project"] },
+          { method: "GET", endpoint: "/rest/api/3/issue/<keyOrId>", effect: "retrieve issue", parameters: [], errors: ["404 Issue does not exist"] },
+          { method: "POST", endpoint: "/rest/api/3/search", effect: "search issues with bounded JQL (project = KEY only)", parameters: ["jql", "maxResults", "fields"], errors: ["400 jql required", "501 JQL clauses beyond project ="] },
+          { method: "POST", endpoint: "/rest/api/3/issue/<key>/comment", effect: "create issue comment (ADF doc or plain string)", parameters: ["body"], errors: ["404 Issue does not exist", "400 body format"] },
+          { method: "POST", endpoint: "/rest/api/3/issue/<key>/transitions", effect: "apply a bounded transition (11 To Do, 21 In Progress, 31 Done)", parameters: ["transition.id"], errors: ["404 Issue does not exist", "400 unknown transition id"] },
+          { method: "GET", endpoint: "/rest/api/3/project", effect: "list seeded projects", parameters: [], errors: [] },
+          { method: "GET", endpoint: "/rest/api/3/project/<key>", effect: "retrieve project", parameters: [], errors: ["404 No project could be found"] }
+        ],
+        limitations: ["Bounded /rest/api/3 subset", "JQL supports only the project = KEY clause; unsupported clauses return 501", "Transitions are the fixed ids 11/21/31 and respond 200 with an empty object", "Comment bodies accept ADF doc objects or plain strings; no rich-text validation", "No attachments, watchers, boards, bulk operations or user endpoints", "Unknown fields and operations return 501 and make coverage incomplete"]
+      },
+      discord: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; also accepts the Discord-idiomatic Authorization: Bot header",
+        operations: [
+          { method: "GET", endpoint: "/api/channels/<id>", effect: "retrieve seeded channel", parameters: [], errors: ["404 Unknown Channel"] },
+          { method: "GET", endpoint: "/api/channels/<id>/messages", effect: "list channel messages (newest first)", parameters: [], errors: ["404 Unknown Channel"] },
+          { method: "POST", endpoint: "/api/channels/<id>/messages", effect: "create channel message", parameters: ["content", "tts"], errors: ["404 Unknown Channel", "400 content empty", "400 invalid field type"] },
+          { method: "GET", endpoint: "/api/guilds/<id>", effect: "retrieve seeded guild", parameters: [], errors: ["404 Unknown Guild"] },
+          { method: "GET", endpoint: "/api/guilds/<id>/members", effect: "list guild members", parameters: ["limit"], errors: ["404 Unknown Guild", "400 invalid limit"] }
+        ],
+        limitations: ["Bounded subset: channels and guilds exist only as seeded reference state", "Message edit/delete, reactions, roles, threads and guild creation are unsupported", "Member results are seeded records; no gateway presence or intents"]
+      },
+      twilio: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; production Twilio HTTP Basic auth is not required by this twin",
+        operations: [
+          { method: "POST", endpoint: "/2010-04-01/Accounts/<sid>/Messages.json", effect: "create outbound message (status queued)", parameters: ["To", "From", "Body"], errors: ["400 missing parameters"] },
+          { method: "GET", endpoint: "/2010-04-01/Accounts/<sid>/Messages.json", effect: "list messages", parameters: ["To", "From"], errors: ["400 validation"] },
+          { method: "POST", endpoint: "/2010-04-01/Accounts/<sid>/Calls.json", effect: "create outbound call (status queued)", parameters: ["To", "From", "Url"], errors: ["400 missing parameters"] },
+          { method: "GET", endpoint: "/2010-04-01/Accounts/<sid>/Calls.json", effect: "list calls", parameters: ["To", "From"], errors: ["400 validation"] }
+        ],
+        limitations: ["JSON bodies accepted in place of Twilio\u2019s form encoding; the .json suffix is optional", "Messages and Calls only; statuses stay queued and never progress in-flight", "No call updates, lookups, queues, recordings, SMS status callbacks or rate limits", "Deterministic synthetic sids; any account sid is accepted", "Unknown parameters and operations return 501 and make coverage incomplete"]
+      },
+      zendesk: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; production Zendesk Basic auth is not required by this twin",
+        operations: [
+          { method: "GET", endpoint: "/api/v2/tickets.json", effect: "list tickets", parameters: [], errors: [] },
+          { method: "POST", endpoint: "/api/v2/tickets.json", effect: "create ticket", parameters: ["ticket:subject,comment.body,requester,status,priority,tags,description,type"], errors: ["400 RecordInvalid subject/comment required", "400 InvalidStatus"] },
+          { method: "GET", endpoint: "/api/v2/tickets/<id>.json", effect: "retrieve ticket", parameters: [], errors: ["404 RecordNotFound"] },
+          { method: "PUT", endpoint: "/api/v2/tickets/<id>.json", effect: "update ticket fields", parameters: ["ticket:subject,status,priority,tags"], errors: ["404 RecordNotFound", "400 InvalidStatus"] },
+          { method: "GET", endpoint: "/api/v2/users.json", effect: "list seeded users", parameters: [], errors: [] },
+          { method: "GET", endpoint: "/api/v2/organizations.json", effect: "list seeded organizations", parameters: [], errors: [] }
+        ],
+        limitations: ["Bounded Support API v2 subset: ticket create/list/get/update plus users and organizations lists", "No macros, views, triggers, audits, attachments, bulk updates or deletes", "Users and organizations are seed-only records; their updates are unsupported", "Unknown fields and operations return 501 and make coverage incomplete"]
       }
     };
   }
@@ -76,8 +257,8 @@ async function captureGit(cwd, previousHead) {
       }
     }
     return { head, branch: branch || "detached HEAD", totalCommits: Number(total), dirty: !!status, capturedAt: (/* @__PURE__ */ new Date()).toISOString(), commits: history ? history.split("\n").map((line) => {
-      const [sha, date] = line.split(" ");
-      return { sha, date };
+      const [sha2, date] = line.split(" ");
+      return { sha: sha2, date };
     }) : [], changedFiles: [...new Set(changed.split("\n").filter(Boolean))].slice(0, 1e3), ...previousHead ? { previousHead } : {} };
   } catch {
     return void 0;
@@ -91,16 +272,15 @@ var init_git = __esm({
 
 // src/runtime/world-session.ts
 import { createServer as createServer2 } from "http";
-import { randomBytes as randomBytes3, randomUUID as randomUUID2, createHash as createHash3 } from "crypto";
-import { mkdir as mkdir4, mkdtemp as mkdtemp3, readFile as readFile6, readdir as readdir2, rename, rm as rm4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, join as join7, resolve as resolve3, relative as relative2, sep as sep2 } from "path";
+import { randomBytes as randomBytes3, randomUUID as randomUUID2, createHash as createHash6 } from "crypto";
+import { mkdir as mkdir5, mkdtemp as mkdtemp3, readFile as readFile7, readdir as readdir2, rename, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname2, join as join8, resolve as resolve4, relative as relative3, sep as sep2 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawn as spawn2 } from "child_process";
 
 // src/runtime/http-world.ts
 import { createServer } from "http";
-import { randomBytes } from "crypto";
 import { isDeepStrictEqual } from "util";
 import { AsyncLocalStorage } from "async_hooks";
 
@@ -141,20 +321,20 @@ function stripeOperation(method, path, params, data, sequence) {
   const error = (status, code, message, param) => ({ status, body: { error: { type: "invalid_request_error", code, message, ...param ? { param } : {} } } });
   const match = /^\/v1\/(customers|payment_intents)(?:\/([^/]+))?(?:\/(confirm))?$/.exec(path);
   if (!match || !["GET", "POST"].includes(method)) return void 0;
-  const [, resource, id, action] = match, collection = `/v1/${resource}`, rows = data[collection];
+  const [, resource, id, action] = match, collection = `/v1/${resource}`, rows2 = data[collection];
   const allowed = method === "GET" ? id ? [] : ["limit", "starting_after"] : resource === "customers" && !id ? ["email", "name", "description"] : resource === "payment_intents" && !id ? ["amount", "currency", "customer", "payment_method", "confirm"] : action === "confirm" ? ["payment_method"] : void 0;
   if (!allowed || resource === "customers" && action || resource === "payment_intents" && method === "GET" && !id) return void 0;
   if (Object.keys(params).some((k) => !allowed.includes(k))) return void 0;
   if (method === "GET" && !id) {
     const limit = params.limit === void 0 ? 10 : Number(params.limit);
     if (!Number.isInteger(limit) || limit < 1 || limit > 100) return { ...error(400, "parameter_invalid_integer", "limit must be 1\u2013100", "limit"), collection };
-    const ordered = [...rows].reverse();
+    const ordered = [...rows2].reverse();
     const index = params.starting_after === void 0 ? -1 : ordered.findIndex((r) => r.id === params.starting_after);
     if (params.starting_after !== void 0 && index === -1) return { ...error(400, "resource_missing", "No such starting_after customer", "starting_after"), collection };
     const page = ordered.slice(index + 1, index + 1 + limit);
     return { status: 200, body: { object: "list", data: page, has_more: ordered.length > index + 1 + limit, url: collection }, collection, operation: "read" };
   }
-  const row = id ? rows.find((r) => r.id === id) : void 0;
+  const row = id ? rows2.find((r) => r.id === id) : void 0;
   if (id && !row) return { ...error(404, "resource_missing", `No such ${resource}: '${id}'`), collection };
   if (method === "GET") return { status: 200, body: row, collection, operation: "read" };
   if (action === "confirm") {
@@ -168,11 +348,11 @@ function stripeOperation(method, path, params, data, sequence) {
   }
   const prefix = resource === "customers" ? "cus" : "pi";
   let suffix = sequence;
-  while (rows.some((r) => r.id === `${prefix}_at_${suffix}`)) suffix++;
-  const created = { id: `${prefix}_at_${suffix}`, object: resource === "customers" ? "customer" : "payment_intent", created: 17e8, livemode: false };
+  while (rows2.some((r) => r.id === `${prefix}_at_${suffix}`)) suffix++;
+  const created2 = { id: `${prefix}_at_${suffix}`, object: resource === "customers" ? "customer" : "payment_intent", created: 17e8, livemode: false };
   if (resource === "customers") {
     if (params.email !== void 0 && typeof params.email !== "string") return { ...error(400, "parameter_invalid", "email must be a string", "email"), collection };
-    Object.assign(created, { email: null, name: null, description: null, ...params });
+    Object.assign(created2, { email: null, name: null, description: null, ...params });
   } else {
     const amount = Number(params.amount);
     if (!Number.isSafeInteger(amount) || amount < 1) return { ...error(400, "parameter_invalid_integer", "amount must be a positive integer", "amount"), collection };
@@ -182,27 +362,975 @@ function stripeOperation(method, path, params, data, sequence) {
     if (params.confirm !== void 0 && !["true", "false", true, false].includes(params.confirm)) return { ...error(400, "parameter_invalid", "confirm must be boolean", "confirm"), collection };
     const confirm = params.confirm === "true" || params.confirm === true;
     if (confirm && !params.payment_method) return { ...error(400, "parameter_missing", "Missing payment_method", "payment_method"), collection };
-    Object.assign(created, { amount, currency: params.currency, customer: params.customer ?? null, payment_method: params.payment_method ?? null, status: confirm && params.payment_method === "pm_card_visa" ? "succeeded" : !confirm && params.payment_method ? "requires_confirmation" : "requires_payment_method", last_payment_error: confirm && params.payment_method === "pm_card_chargeDeclined" ? { code: "card_declined", message: "Your card was declined." } : null });
+    Object.assign(created2, { amount, currency: params.currency, customer: params.customer ?? null, payment_method: params.payment_method ?? null, status: confirm && params.payment_method === "pm_card_visa" ? "succeeded" : !confirm && params.payment_method ? "requires_confirmation" : "requires_payment_method", last_payment_error: confirm && params.payment_method === "pm_card_chargeDeclined" ? { code: "card_declined", message: "Your card was declined." } : null });
   }
-  if (rows.length >= 1e4) return { ...error(429, "world_capacity", "World record capacity reached"), collection };
-  rows.push(created);
+  if (rows2.length >= 1e4) return { ...error(429, "world_capacity", "World record capacity reached"), collection };
+  rows2.push(created2);
   const declined = resource === "payment_intents" && (params.confirm === "true" || params.confirm === true) && params.payment_method === "pm_card_chargeDeclined";
-  return { status: declined ? 402 : 200, body: declined ? { error: { type: "card_error", code: "card_declined", decline_code: "generic_decline", message: "Your card was declined.", payment_intent: structuredClone(created) } } : created, collection, record: structuredClone(created), operation: "write" };
+  return { status: declined ? 402 : 200, body: declined ? { error: { type: "card_error", code: "card_declined", decline_code: "generic_decline", message: "Your card was declined.", payment_intent: structuredClone(created2) } } : created2, collection, record: structuredClone(created2), operation: "write" };
+}
+
+// src/runtime/rest-adapters.ts
+import { createHash } from "crypto";
+var EPOCH = 17e8;
+var iso = (epoch = EPOCH) => new Date(epoch * 1e3).toISOString();
+var sha = (value) => createHash("sha256").update(value).digest("hex");
+var detUuid = (seed) => {
+  const hex = sha(seed).slice(0, 32).split("");
+  hex[12] = "4";
+  hex[16] = "8";
+  const s = hex.join("");
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
+};
+var rows = (data, collection) => data[collection];
+var notFound = (collection, body) => ({ status: 404, body, collection });
+var badRequest = (collection, body) => ({ status: 400, body, collection });
+var ok = (collection, body, operation = "read") => ({ status: 200, body, collection, operation });
+var created = (collection, body, record) => ({ status: 201, body, collection, record: structuredClone(record), operation: "write" });
+var write = (status, collection, body, record) => ({ status, body, collection, record: structuredClone(record), operation: "write" });
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? v : void 0;
+var pagination = (params, limitDefault, limitMax) => {
+  if (params.limit !== void 0 && (!Number.isInteger(Number(params.limit)) || Number(params.limit) < 1 || Number(params.limit) > limitMax)) return void 0;
+  const limit = params.limit === void 0 ? limitDefault : Number(params.limit);
+  return { limit };
+};
+var uniqueId = (existing, base, key = "id") => {
+  let candidate = base;
+  while (existing.some((r) => r[key] === String(candidate))) candidate++;
+  return String(candidate);
+};
+var boundedInt = (value, min, max) => {
+  if (value === void 0) return void 0;
+  const n = typeof value === "number" ? value : typeof value === "string" && /^-?\d+$/.test(value) ? Number(value) : NaN;
+  return Number.isInteger(n) && n >= min && n <= max ? n : null;
+};
+function githubOperation(method, path, params, _headers, data, sequence) {
+  const errors = (status, message, extra) => ({ status, body: { message, documentation_url: "https://docs.github.com/rest", ...extra ?? {} }, collection: "/repos" });
+  if (path === "/repos") return method === "GET" ? ok("/repos", rows(data, "/repos").map((row) => structuredClone(row))) : void 0;
+  const match = /^\/repos\/([^/]+)\/([^/]+)(?:\/(issues|pulls|check-runs)(?:\/(\d+))?(?:\/(comments|merge))?)?$/.exec(path);
+  if (!match) return void 0;
+  const [, owner, name, resource, id, sub] = match;
+  const repo = `${owner}/${name}`;
+  if (!rows(data, "/repos").some((r) => r.name === repo || r.full_name === repo)) return notFound("/repos", { message: "Not Found", documentation_url: "https://docs.github.com/rest" });
+  if (!resource) {
+    if (method !== "GET") return void 0;
+    const repository = rows(data, "/repos").find((r) => r.name === repo || r.full_name === repo);
+    return ok("/repos", structuredClone(repository));
+  }
+  if (resource === "check-runs") {
+    if (method !== "POST" || id) return void 0;
+    if (typeof params.name !== "string" || !params.name || typeof params.head_sha !== "string" || !params.head_sha) return errors(422, "Validation Failed", { errors: [{ resource: "CheckRun", field: "name", code: "missing_field" }] });
+    const allowed = ["name", "head_sha", "status", "conclusion"];
+    if (Object.keys(params).some((k) => !allowed.includes(k))) return void 0;
+    if (params.status !== void 0 && !["queued", "in_progress", "completed"].includes(String(params.status))) return errors(422, "Validation Failed", { errors: [{ resource: "CheckRun", field: "status", code: "invalid" }] });
+    if (params.conclusion !== void 0 && !["success", "failure", "neutral", "cancelled", "skipped", "timed_out"].includes(String(params.conclusion))) return errors(422, "Validation Failed", { errors: [{ resource: "CheckRun", field: "conclusion", code: "invalid" }] });
+    const run = { id: `github_at_${sequence}`, name: params.name, head_sha: params.head_sha, status: str(params.status) ?? (params.conclusion !== void 0 ? "completed" : "queued"), conclusion: params.conclusion === void 0 ? null : params.conclusion, repo, html_url: null, started_at: iso(), completed_at: params.conclusion === void 0 ? null : iso() };
+    rows(data, "/check-runs").push(run);
+    return created("/check-runs", structuredClone(run), run);
+  }
+  if (resource === "issues") {
+    const inRepo = rows(data, "/issues").filter((r) => r.repo === repo);
+    if (method === "GET" && !id && !sub) {
+      if (Object.keys(params).some((k) => !["state", "page", "per_page"].includes(k))) return void 0;
+      const page = pagination(params, 30, 100);
+      if (!page) return errors(422, "Validation Failed", { errors: [{ resource: "Issue", field: "per_page", code: "invalid" }] });
+      const state = str(params.state) ?? "open";
+      if (!["open", "closed", "all"].includes(state)) return errors(422, "Validation Failed", { errors: [{ resource: "Issue", field: "state", code: "invalid" }] });
+      const filtered = inRepo.filter((r) => state === "all" || r.state === state);
+      const pageNumber = params.page === void 0 ? 1 : Number(params.page);
+      if (!Number.isInteger(pageNumber) || pageNumber < 1) return errors(422, "Validation Failed", { errors: [{ resource: "Issue", field: "page", code: "invalid" }] });
+      return ok("/issues", filtered.slice((pageNumber - 1) * page.limit, pageNumber * page.limit).map((row) => structuredClone(row)));
+    }
+    if (method === "POST" && !id && !sub) {
+      if (Object.keys(params).some((k) => !["title", "body", "labels"].includes(k))) return void 0;
+      if (typeof params.title !== "string" || !params.title) return errors(422, "Validation Failed", { errors: [{ resource: "Issue", field: "title", code: "missing_field" }] });
+      if (params.labels !== void 0 && (!Array.isArray(params.labels) || !params.labels.every((l) => typeof l === "string"))) return errors(422, "Validation Failed", { errors: [{ resource: "Issue", field: "labels", code: "invalid" }] });
+      const issue2 = { id: `github_at_${sequence}`, number: inRepo.reduce((max, r) => Math.max(max, Number(r.number) || 0), 0) + 1, repo, title: params.title, body: str(params.body) ?? null, state: "open", user: { login: "agenttwin-test" }, labels: Array.isArray(params.labels) ? structuredClone(params.labels) : [], comments: 0, created_at: iso(), updated_at: iso(), closed_at: null };
+      rows(data, "/issues").push(issue2);
+      return created("/issues", structuredClone(issue2), issue2);
+    }
+    const issue = id ? inRepo.find((r) => String(r.number) === id) : void 0;
+    if (!issue) return notFound("/issues", { message: "Not Found", documentation_url: "https://docs.github.com/rest" });
+    if (method === "GET" && !sub) return ok("/issues", structuredClone(issue));
+    if (method === "PATCH" && !sub) {
+      const allowed = ["state", "title", "body"];
+      if (Object.keys(params).some((k) => !allowed.includes(k))) return void 0;
+      if (params.state !== void 0 && !["open", "closed"].includes(String(params.state))) return errors(422, "Validation Failed", { errors: [{ resource: "Issue", field: "state", code: "invalid" }] });
+      if (params.title !== void 0 && typeof params.title !== "string") return void 0;
+      if (params.body !== void 0 && typeof params.body !== "string") return void 0;
+      if (params.title !== void 0) issue.title = params.title;
+      if (params.body !== void 0) issue.body = params.body;
+      if (params.state !== void 0) {
+        issue.state = params.state;
+        issue.closed_at = params.state === "closed" ? iso() : null;
+      }
+      issue.updated_at = iso();
+      return write(200, "/issues", structuredClone(issue), issue);
+    }
+    if (method === "POST" && sub === "comments") {
+      if (typeof params.body !== "string" || !params.body) return errors(422, "Validation Failed", { errors: [{ resource: "IssueComment", field: "body", code: "missing_field" }] });
+      if (Object.keys(params).some((k) => k !== "body")) return void 0;
+      const comment = { id: `github_at_${sequence}`, repo, issue_number: issue.number, body: params.body, user: { login: "agenttwin-test" }, created_at: iso(), updated_at: iso() };
+      rows(data, "/comments").push(comment);
+      return created("/comments", structuredClone(comment), comment);
+    }
+    if (method === "GET" && sub === "comments") return ok("/comments", rows(data, "/comments").filter((c) => c.repo === repo && c.issue_number === issue.number).map((row) => structuredClone(row)));
+    return void 0;
+  }
+  if (resource === "pulls") {
+    const inRepo = rows(data, "/pulls").filter((r) => r.repo === repo);
+    const pull = id ? inRepo.find((r) => String(r.number) === id) : void 0;
+    if (method === "GET" && !id && !sub) {
+      if (Object.keys(params).some((k) => k !== "state")) return void 0;
+      const state = str(params.state) ?? "open";
+      if (!["open", "closed", "all"].includes(state)) return errors(422, "Validation Failed", { errors: [{ resource: "PullRequest", field: "state", code: "invalid" }] });
+      return ok("/pulls", inRepo.filter((r) => state === "all" || r.state === state).map((row) => structuredClone(row)));
+    }
+    if (!pull) return id ? notFound("/pulls", { message: "Not Found", documentation_url: "https://docs.github.com/rest" }) : void 0;
+    if (method === "GET" && id && !sub) return ok("/pulls", structuredClone(pull));
+    if (method === "PUT" && sub === "merge") {
+      if (Object.keys(params).some((k) => k !== "merge_method")) return void 0;
+      if (params.merge_method !== void 0 && !["merge", "squash", "rebase"].includes(String(params.merge_method))) return errors(422, "Validation Failed", { errors: [{ resource: "PullRequest", field: "merge_method", code: "invalid" }] });
+      if (pull.merged) return errors(405, "Pull Request was already merged");
+      if (pull.state !== "open") return errors(405, "Pull Request is not mergeable");
+      pull.merged = true;
+      pull.merged_at = iso();
+      pull.state = "closed";
+      pull.merge_commit_sha = sha(`${repo}:${pull.number}:${sequence}`).slice(0, 40);
+      return write(200, "/pulls", { sha: pull.merge_commit_sha, merged: true, message: "Pull Request successfully merged" }, pull);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function linearOperation(method, path, params, _headers, data, sequence) {
+  const notFoundNode = (name) => ({ status: 200, body: { data: null, errors: [{ message: `Entity not found: ${name}` }] }, collection: "/issues", operation: "read" });
+  if (method !== "POST" || path !== "/graphql") return void 0;
+  const query = str(params.query);
+  if (!query) return void 0;
+  if (!/^\s*(query|mutation)\b/m.test(query)) return void 0;
+  const isMutation = /\bmutation\b/.test(query.slice(0, query.indexOf("{") + 1));
+  const root = new RegExp(isMutation ? "\\bmutation\\b[^{]*\\{\\s*(\\w+)" : "\\bquery\\b[^{]*\\{\\s*(\\w+)").exec(query);
+  if (!root) return void 0;
+  const variables = isObject(params.variables) ? params.variables : {};
+  const arg = (name) => variables[name] ?? (new RegExp(`\\b${name}\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(query)?.[1] !== void 0 ? JSON.parse(`"${new RegExp(`\\b${name}\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(query)[1]}"`) : void 0);
+  const input = variables.input ?? void 0;
+  if (!isMutation) {
+    if (root[1] === "viewer") {
+      if (Object.keys(variables).length) return void 0;
+      return ok("/users", { data: { viewer: rows(data, "/users")[0] ?? { id: "linear_at_viewer", name: "Test User", email: "user@example.test", displayName: "Test User" } } });
+    }
+    if (root[1] === "issues") {
+      if (Object.keys(variables).length) return void 0;
+      return ok("/issues", { data: { issues: { nodes: rows(data, "/issues").map((row) => structuredClone(row)) } } });
+    }
+    if (root[1] === "projects") {
+      if (Object.keys(variables).length) return void 0;
+      return ok("/projects", { data: { projects: { nodes: rows(data, "/projects").map((row) => structuredClone(row)) } } });
+    }
+    if (root[1] === "issue") {
+      const issue = rows(data, "/issues").find((r) => r.id === arg("id"));
+      if (Object.keys(variables).some((k) => k !== "id") || arg("id") === void 0) return void 0;
+      return issue ? ok("/issues", { data: { issue: structuredClone(issue) } }) : notFoundNode("Issue");
+    }
+    if (root[1] === "project") {
+      const project = rows(data, "/projects").find((r) => r.id === arg("id"));
+      if (Object.keys(variables).some((k) => k !== "id") || arg("id") === void 0) return void 0;
+      return project ? ok("/projects", { data: { project: structuredClone(project) } }) : notFoundNode("Project");
+    }
+    return void 0;
+  }
+  if (root[1] === "issueCreate") {
+    if (!isObject(input) || Object.keys(variables).some((k) => k !== "input")) return void 0;
+    if (Object.keys(input).some((k) => !["title", "description", "state", "assigneeId", "projectId", "priority"].includes(k))) return void 0;
+    if (typeof input.title !== "string" || !input.title) return { status: 200, body: { data: null, errors: [{ message: "Issue title required" }] }, collection: "/issues" };
+    const issue = { id: `linear_at_${sequence}`, title: input.title, description: str(input.description) ?? null, state: str(input.state) ?? "todo", assigneeId: str(input.assigneeId) ?? null, projectId: str(input.projectId) ?? null, priority: input.priority === void 0 ? 0 : input.priority, createdAt: iso(), updatedAt: iso() };
+    rows(data, "/issues").push(issue);
+    return write(200, "/issues", { data: { issueCreate: { success: true, issue: structuredClone(issue) } } }, issue);
+  }
+  if (root[1] === "issueUpdate") {
+    if (!isObject(input) || arg("id") === void 0 || Object.keys(variables).some((k) => !["id", "input"].includes(k))) return void 0;
+    const issue = rows(data, "/issues").find((r) => r.id === arg("id"));
+    if (!issue) return notFoundNode("Issue");
+    if (Object.keys(input).some((k) => !["title", "description", "state", "assigneeId", "projectId", "priority"].includes(k))) return void 0;
+    for (const [k, v] of Object.entries(input)) if (["title", "description", "state", "assigneeId", "projectId", "priority"].includes(k)) issue[k] = v;
+    issue.updatedAt = iso();
+    return write(200, "/issues", { data: { issueUpdate: { success: true, issue: structuredClone(issue) } } }, issue);
+  }
+  if (root[1] === "commentCreate") {
+    if (!isObject(input) || Object.keys(variables).some((k) => k !== "input")) return void 0;
+    if (Object.keys(input).some((k) => !["issueId", "body"].includes(k))) return void 0;
+    const issue = rows(data, "/issues").find((r) => r.id === input.issueId);
+    if (!issue) return notFoundNode("Issue");
+    if (typeof input.body !== "string" || !input.body) return { status: 200, body: { data: null, errors: [{ message: "Comment body required" }] }, collection: "/comments" };
+    const comment = { id: `linear_at_${sequence}`, issueId: input.issueId, body: input.body, userId: rows(data, "/users")[0]?.id ?? "linear_at_viewer", createdAt: iso() };
+    rows(data, "/comments").push(comment);
+    return write(200, "/comments", { data: { commentCreate: { success: true, comment: structuredClone(comment) } } }, comment);
+  }
+  return void 0;
+}
+var notionPropValue = (property) => {
+  if (!isObject(property)) return property;
+  if (property.title !== void 0) return Array.isArray(property.title) ? property.title.map((t) => t?.plain_text ?? t?.text?.content ?? "").join("") : property.title;
+  if (property.rich_text !== void 0) return Array.isArray(property.rich_text) ? property.rich_text.map((t) => t?.plain_text ?? t?.text?.content ?? "").join("") : property.rich_text;
+  if (property.select !== void 0) return isObject(property.select) ? property.select.name : property.select;
+  if (property.status !== void 0) return isObject(property.status) ? property.status.name : property.status;
+  return property.number ?? property.checkbox ?? property.url ?? property.email ?? property.phone_number ?? null;
+};
+var notionPage = (id, parent, properties, archived = false) => ({ object: "page", id, created_time: iso(), last_edited_time: iso(), created_by: null, last_edited_by: null, cover: null, icon: null, parent, archived, properties, url: null });
+var notionError = (collection, status, code, message) => ({ status, body: { object: "error", status, code, message }, collection });
+function notionOperation(method, path, params, headers, data, sequence) {
+  if (!/^\/v1\/(pages|databases|blocks)/.test(path)) return void 0;
+  const version = headers["notion-version"];
+  if (typeof version !== "string" || !version) return notionError("/pages", 400, "invalid_request", "Notion-Version header failed validation: Notion-Version header should be defined, instead was `undefined`.");
+  if (path === "/v1/pages") {
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => !["parent", "properties"].includes(k))) return void 0;
+    const parent = isObject(params.parent) ? params.parent : void 0;
+    if (!parent || str(parent.database_id) === void 0 || Object.keys(parent).some((k) => k !== "database_id")) return notionError("/pages", 400, "validation_error", "Bounded Notion twin supports database parents only: provide parent.database_id.");
+    const database = rows(data, "/databases").find((d) => d.id === parent.database_id);
+    if (!database) return notionError("/pages", 404, "object_not_found", "Could not find database with ID.");
+    if (!isObject(params.properties)) return notionError("/pages", 400, "validation_error", "properties should be defined.");
+    const page = notionPage(detUuid(`page:${sequence}`), { type: "database_id", database_id: database.id }, structuredClone(params.properties));
+    rows(data, "/pages").push(page);
+    return { status: 200, body: structuredClone(page), collection: "/pages", record: structuredClone(page), operation: "write" };
+  }
+  const pageMatch = /^\/v1\/pages\/([^/]+)$/.exec(path);
+  if (pageMatch) {
+    const page = rows(data, "/pages").find((p) => p.id === pageMatch[1]);
+    if (!page) return notionError("/pages", 404, "object_not_found", "Could not find page with ID.");
+    if (method === "GET") return ok("/pages", structuredClone(page));
+    if (method === "PATCH") {
+      if (Object.keys(params).some((k) => !["properties", "archived", "in_trash"].includes(k))) return void 0;
+      if (params.properties !== void 0) {
+        if (!isObject(params.properties)) return notionError("/pages", 400, "validation_error", "properties should be an object.");
+        Object.assign(page.properties, structuredClone(params.properties));
+      }
+      if (params.archived !== void 0) {
+        if (typeof params.archived !== "boolean") return notionError("/pages", 400, "validation_error", "archived should be a boolean.");
+        page.archived = params.archived;
+      }
+      page.last_edited_time = iso();
+      return write(200, "/pages", structuredClone(page), page);
+    }
+    return void 0;
+  }
+  const databaseMatch = /^\/v1\/databases\/([^/]+)(?:\/(query))?$/.exec(path);
+  if (databaseMatch) {
+    const database = rows(data, "/databases").find((d) => d.id === databaseMatch[1]);
+    if (!database) return notionError("/databases", 404, "object_not_found", "Could not find database with ID.");
+    if (!databaseMatch[2]) {
+      if (method !== "GET") return void 0;
+      return ok("/databases", structuredClone(database));
+    }
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => !["filter", "page_size", "start_cursor", "sorts"].includes(k))) return void 0;
+    if (params.sorts !== void 0 || params.start_cursor !== void 0) return void 0;
+    let limit = 100;
+    if (params.page_size !== void 0) {
+      if (!Number.isInteger(params.page_size) || Number(params.page_size) < 1 || Number(params.page_size) > 100) return notionError("/databases", 400, "validation_error", "page_size must be an integer between 1 and 100.");
+      limit = Number(params.page_size);
+    }
+    const pages = rows(data, "/pages").filter((p) => p.parent && p.parent.database_id === database.id);
+    if (params.filter !== void 0) {
+      const filter = params.filter;
+      if (!isObject(filter) || Object.keys(filter).length !== 2 || typeof filter.property !== "string") return void 0;
+      const [condition] = Object.keys(filter).filter((k) => k !== "property");
+      if (!["title", "rich_text", "number", "select", "status", "checkbox"].includes(condition)) return void 0;
+      const expected = isObject(filter[condition]) ? filter[condition].equals : void 0;
+      if (expected === void 0 || Object.keys(filter[condition]).length !== 1) return void 0;
+      const property = filter.property;
+      const results = pages.filter((p) => notionPropValue(p.properties[property]) === expected);
+      return ok("/pages", { object: "list", results: results.slice(0, limit).map((row) => structuredClone(row)), has_more: false, next_cursor: null, type: "page_or_database", page_or_database: {} });
+    }
+    return ok("/pages", { object: "list", results: pages.slice(0, limit).map((row) => structuredClone(row)), has_more: false, next_cursor: null, type: "page_or_database", page_or_database: {} });
+  }
+  const blockMatch = /^\/v1\/blocks\/([^/]+)\/(children)$/.exec(path);
+  if (blockMatch) {
+    if (method !== "PATCH" || blockMatch[2] !== "children") return void 0;
+    if (Object.keys(params).some((k) => k !== "children")) return void 0;
+    if (!Array.isArray(params.children) || !params.children.length || params.children.length > 100) return notionError("/blocks", 400, "validation_error", "children should be an array of 1\u2013100 block objects.");
+    if (!params.children.every(isObject)) return notionError("/blocks", 400, "validation_error", "children should be block objects.");
+    if (params.children.some((c) => typeof c.type !== "string" || !c.type)) return notionError("/blocks", 400, "validation_error", "Each child block requires a type.");
+    const page = rows(data, "/pages").find((p) => p.id === blockMatch[1]);
+    const block = rows(data, "/blocks").find((b) => b.id === blockMatch[1]);
+    if (!page && !block) return notionError("/blocks", 404, "object_not_found", "Could not find block with ID.");
+    const parent = page ? { type: "page_id", page_id: page.id } : { type: "block_id", block_id: block.id };
+    const createdBlocks = params.children.map((child, index) => {
+      const record = { object: "block", id: detUuid(`block:${sequence}:${index}`), parent, type: child.type, created_time: iso(), last_edited_time: iso(), has_children: false, archived: false, block: structuredClone(child) };
+      rows(data, "/blocks").push(record);
+      return record;
+    });
+    return write(200, "/blocks", { object: "list", results: structuredClone(createdBlocks), has_more: false, next_cursor: null, type: "block", block: {} }, createdBlocks[createdBlocks.length - 1]);
+  }
+  return void 0;
+}
+var hubspotEnvelope = (record) => ({ id: record.id, properties: structuredClone(record.properties), createdAt: record.createdAt, updatedAt: record.updatedAt, archived: false });
+function hubspotOperation(method, path, params, _headers, data, sequence) {
+  const match = /^\/crm\/v3\/objects\/(contacts|companies|deals|tickets)(?:\/(search)|\/([^/]+))?$/.exec(path);
+  if (!match) return void 0;
+  const [, object3, search, id] = match;
+  const collection = `/crm/v3/objects/${object3}`;
+  const properties = isObject(params.properties) ? params.properties : void 0;
+  const validProperties = (value) => Object.values(value).every((v) => ["string", "number", "boolean", "object"].includes(v === null ? "object" : typeof v));
+  if (search) {
+    if (method !== "POST" || id) return void 0;
+    if (Object.keys(params).some((k) => !["query", "filterGroups", "limit", "after", "properties", "sorts"].includes(k))) return void 0;
+    if (params.properties !== void 0 || params.sorts !== void 0) return void 0;
+    const searchLimit = boundedInt(params.limit, 1, 100);
+    if (searchLimit === null) return badRequest(collection, { status: "error", message: "Unable to process: limit must be between 1 and 100", category: "VALIDATION_ERROR" });
+    const searchAfter = boundedInt(params.after, 0, Number.MAX_SAFE_INTEGER);
+    if (searchAfter === null) return badRequest(collection, { status: "error", message: "Unable to process: after must be a nonnegative integer offset", category: "VALIDATION_ERROR" });
+    const limit = searchLimit ?? 10, after = searchAfter ?? 0;
+    let filtered = rows(data, collection);
+    if (params.query !== void 0) {
+      if (typeof params.query !== "string") return void 0;
+      const needle = params.query.toLowerCase();
+      filtered = filtered.filter((r) => Object.values(r.properties).some((v) => typeof v === "string" && v.toLowerCase().includes(needle)));
+    }
+    if (params.filterGroups !== void 0) {
+      if (!Array.isArray(params.filterGroups) || params.filterGroups.length !== 1) return void 0;
+      const group = params.filterGroups[0];
+      if (!isObject(group) || Object.keys(group).some((k) => k !== "filters") || !Array.isArray(group.filters) || !group.filters.length || group.filters.length > 3) return void 0;
+      for (const filter of group.filters) {
+        if (!isObject(filter) || Object.keys(filter).some((k) => !["propertyName", "operator", "value"].includes(k)) || typeof filter.propertyName !== "string" || filter.operator !== "EQ" || filter.value === void 0) return void 0;
+        const propertyName = filter.propertyName;
+        filtered = filtered.filter((r) => r.properties[propertyName] === filter.value);
+      }
+    }
+    const page = filtered.slice(after, after + limit);
+    return ok(collection, { total: filtered.length, results: page.map((r) => hubspotEnvelope(r)) });
+  }
+  if (!id) {
+    if (method === "GET") {
+      if (Object.keys(params).some((k) => !["limit", "after"].includes(k))) return void 0;
+      const listLimit = boundedInt(params.limit, 1, 100);
+      if (listLimit === null) return badRequest(collection, { status: "error", message: "Unable to process: limit must be between 1 and 100", category: "VALIDATION_ERROR" });
+      const listAfter = boundedInt(params.after, 0, Number.MAX_SAFE_INTEGER);
+      if (listAfter === null) return badRequest(collection, { status: "error", message: "Unable to process: after must be a nonnegative integer offset", category: "VALIDATION_ERROR" });
+      const page = rows(data, collection).slice(listAfter ?? 0, (listAfter ?? 0) + (listLimit ?? 10));
+      return ok(collection, { total: rows(data, collection).length, results: page.map((r) => hubspotEnvelope(r)) });
+    }
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => k !== "properties") || !properties || !validProperties(properties)) return badRequest(collection, { status: "error", message: `Invalid input JSON on line 1: Unable to process JSON: properties required for ${object3}`, category: "VALIDATION_ERROR" });
+    const record2 = { id: uniqueId(rows(data, collection), 501 + sequence), properties: structuredClone(properties), createdAt: iso(), updatedAt: iso() };
+    rows(data, collection).push(record2);
+    return created(collection, hubspotEnvelope(record2), record2);
+  }
+  const record = rows(data, collection).find((r) => r.id === id);
+  if (!record) return { status: 404, body: { status: "error", message: `Object not found: ${object3} with id ${id}`, category: "OBJECT_NOT_FOUND" }, collection };
+  if (method === "GET") return ok(collection, hubspotEnvelope(record));
+  if (method === "PATCH") {
+    if (Object.keys(params).some((k) => k !== "properties") || !properties || !validProperties(properties)) return badRequest(collection, { status: "error", message: "Unable to process JSON: properties object required", category: "VALIDATION_ERROR" });
+    Object.assign(record.properties, structuredClone(properties));
+    record.updatedAt = iso();
+    return write(200, collection, hubspotEnvelope(record), record);
+  }
+  return void 0;
+}
+var SHOPIFY_VERSION = "2024-01";
+var shopifySlug = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function shopifyOperation(method, path, params, _headers, data, sequence) {
+  const match = new RegExp(`^/admin/api/${SHOPIFY_VERSION}/(products|orders|customers)(?:/(\\d+))?\\.json$`).exec(path);
+  if (!match) return void 0;
+  const [, resource, id] = match;
+  const collection = `/admin/${resource}`;
+  const wrap = resource === "products" ? "product" : resource === "orders" ? "order" : "customer";
+  const rowsIn2 = rows(data, collection);
+  const notFoundShopify = () => notFound(collection, { errors: "Not Found" });
+  const enriched = (record2) => ({ ...structuredClone(record2), created_at: record2.created_at ?? iso(), updated_at: iso() });
+  if (!id) {
+    if (method === "GET") {
+      if (Object.keys(params).some((k) => !["limit", "since_id"].includes(k))) return void 0;
+      const page = pagination(params, 50, 250);
+      if (!page) return badRequest(collection, { errors: "limit must be between 1 and 250" });
+      let filtered = rowsIn2;
+      if (params.since_id !== void 0) {
+        if (!Number.isInteger(Number(params.since_id)) || Number(params.since_id) < 0) return badRequest(collection, { errors: "since_id must be a nonnegative integer" });
+        filtered = filtered.filter((r) => Number(r.id) > Number(params.since_id));
+      }
+      return ok(collection, { [`${resource}`]: filtered.slice(0, page.limit).map(enriched) });
+    }
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => k !== wrap) || !isObject(params[wrap])) return badRequest(collection, { errors: { [wrap]: ["expected a root object"] } });
+    const body = params[wrap];
+    if (resource === "products" && (typeof body.title !== "string" || !body.title)) return { status: 422, body: { errors: { title: ["can't be blank"] } }, collection };
+    if (resource === "orders") {
+      if (!Array.isArray(body.line_items) || !body.line_items.length || !body.line_items.every(isObject)) return { status: 422, body: { errors: { line_items: ["can't be blank"] } }, collection };
+      if (body.line_items.some((item) => Object.keys(item).some((k) => !["title", "quantity", "price", "sku"].includes(k)))) return void 0;
+    }
+    const allowed = { products: ["title", "body_html", "vendor", "product_type", "status", "tags", "variants", "options"], orders: ["email", "phone", "line_items", "financial_status", "fulfillment_status", "note", "total_price", "currency"], customers: ["first_name", "last_name", "email", "phone", "note", "tags"] }[resource];
+    if (Object.keys(body).some((k) => !allowed.includes(k))) return void 0;
+    const record2 = { id: uniqueId(rowsIn2, { products: 632910392, orders: 450789469, customers: 207119551 }[resource] + sequence), created_at: iso(), updated_at: iso() };
+    if (resource === "products") Object.assign(record2, { title: body.title, body_html: body.body_html ?? null, vendor: body.vendor ?? null, product_type: body.product_type ?? null, handle: shopifySlug(String(body.title)), status: str(body.status) ?? "active", tags: body.tags ?? "", variants: Array.isArray(body.variants) ? structuredClone(body.variants) : [], options: Array.isArray(body.options) ? structuredClone(body.options) : [], image: null, images: [] });
+    if (resource === "orders") Object.assign(record2, { email: body.email ?? null, phone: body.phone ?? null, note: body.note ?? null, line_items: structuredClone(body.line_items), total_price: typeof body.total_price === "string" ? body.total_price : Number(Array.isArray(body.line_items) ? body.line_items.reduce((sum, item) => sum + Number(item.price ?? 0) * Number(item.quantity ?? 1), 0) : 0).toFixed(2), currency: str(body.currency) ?? "USD", financial_status: str(body.financial_status) ?? "pending", fulfillment_status: body.fulfillment_status ?? null });
+    if (resource === "customers") Object.assign(record2, { first_name: body.first_name ?? null, last_name: body.last_name ?? null, email: body.email ?? null, phone: body.phone ?? null, note: body.note ?? null, tags: body.tags ?? "", state: "enabled", verified_email: true, accepts_marketing: false });
+    rowsIn2.push(record2);
+    return created(collection, { [wrap]: enriched(record2) }, record2);
+  }
+  const record = rowsIn2.find((r) => String(r.id) === id);
+  if (!record) return notFoundShopify();
+  if (method === "GET") return ok(collection, { [wrap]: enriched(record) });
+  if (method === "PUT") {
+    if (Object.keys(params).some((k) => k !== wrap) || !isObject(params[wrap])) return badRequest(collection, { errors: { [wrap]: ["expected a root object"] } });
+    const body = params[wrap];
+    const allowed = { products: ["title", "body_html", "vendor", "product_type", "status", "tags"], orders: ["email", "phone", "note", "financial_status", "fulfillment_status"], customers: ["first_name", "last_name", "email", "phone", "note", "tags"] }[resource];
+    if (Object.keys(body).some((k) => !allowed.includes(k))) return void 0;
+    for (const [k, v] of Object.entries(body)) record[k] = v;
+    if (resource === "products" && body.title !== void 0) record.handle = shopifySlug(String(body.title));
+    record.updated_at = iso();
+    return write(200, collection, { [wrap]: enriched(record) }, record);
+  }
+  return void 0;
+}
+function datadogOperation(method, path, params, _headers, data, sequence) {
+  const monitorMatch = /^\/api\/v1\/monitors?\/?(\d+)?(?:\/(mute))?$/.exec(path);
+  if (monitorMatch) {
+    const [, id, mute] = monitorMatch;
+    if (!id) {
+      if (method === "GET") {
+        if (Object.keys(params).some((k) => k !== "name")) return void 0;
+        const filtered = params.name === void 0 ? rows(data, "/monitors") : rows(data, "/monitors").filter((m) => typeof params.name === "string" && String(m.name).includes(params.name));
+        return ok("/monitors", filtered.map((row) => structuredClone(row)));
+      }
+      if (method !== "POST") return void 0;
+      if (Object.keys(params).some((k) => !["name", "type", "query", "message", "tags", "options", "priority"].includes(k))) return void 0;
+      if (typeof params.name !== "string" || !params.name || typeof params.type !== "string" || !params.type || typeof params.query !== "string" || !params.query) return badRequest("/monitors", { errors: ["The value provided for parameter 'name', 'type' or 'query' is invalid"] });
+      const monitor2 = { id: sequence, name: params.name, type: params.type, query: params.query, message: str(params.message) ?? "", tags: Array.isArray(params.tags) ? structuredClone(params.tags) : [], options: isObject(params.options) ? structuredClone(params.options) : {}, priority: params.priority === void 0 ? null : params.priority, overall_state: "OK", creator: { name: "agenttwin@example.test", handle: "agenttwin@example.test" }, created: iso(), modified: iso() };
+      rows(data, "/monitors").push(monitor2);
+      return { status: 200, body: structuredClone(monitor2), collection: "/monitors", record: structuredClone(monitor2), operation: "write" };
+    }
+    const monitor = rows(data, "/monitors").find((m) => String(m.id) === id);
+    if (!monitor) return notFound("/monitors", { errors: ["Monitor not found"] });
+    if (method === "GET" && !mute) return ok("/monitors", structuredClone(monitor));
+    if (method === "POST" && mute === "mute") {
+      if (Object.keys(params).some((k) => !["scope", "end"].includes(k))) return void 0;
+      const options = isObject(monitor.options) ? monitor.options : {};
+      monitor.options = { ...options, muted: true };
+      monitor.modified = iso();
+      return write(200, "/monitors", structuredClone(monitor), monitor);
+    }
+    return void 0;
+  }
+  if (path === "/api/v1/events") {
+    if (method === "POST") {
+      if (Object.keys(params).some((k) => !["title", "text", "tags", "priority", "alert_type", "source"].includes(k))) return void 0;
+      if (typeof params.title !== "string" || !params.title || typeof params.text !== "string" || !params.text) return badRequest("/events", { errors: ["The value provided for parameter 'title' or 'text' is invalid"] });
+      const event = { id: sequence, title: params.title, text: params.text, tags: Array.isArray(params.tags) ? structuredClone(params.tags) : [], priority: params.priority === void 0 ? "normal" : params.priority, alert_type: str(params.alert_type) ?? "info", source: str(params.source) ?? "agenttwin", date_happened: EPOCH, device_name: null, host: null, resource: `/api/v1/events/${sequence}`, url: null, status: "ok" };
+      rows(data, "/events").push(event);
+      return { status: 200, body: { status: "ok", event: structuredClone(event) }, collection: "/events", record: structuredClone(event), operation: "write" };
+    }
+    if (method === "GET") {
+      if (Object.keys(params).some((k) => !["start", "end", "priority", "tags", "sources"].includes(k))) return void 0;
+      if (params.start === void 0 || params.end === void 0) return badRequest("/events", { errors: ["start and end parameters are required"] });
+      if (!Number.isInteger(Number(params.start)) || !Number.isInteger(Number(params.end))) return badRequest("/events", { errors: ["start and end parameters must be integers"] });
+      let filtered = rows(data, "/events").filter((e) => Number(e.date_happened) >= Number(params.start) && Number(e.date_happened) <= Number(params.end));
+      if (params.priority !== void 0) filtered = filtered.filter((e) => e.priority === params.priority);
+      if (params.tags !== void 0) {
+        if (typeof params.tags !== "string") return void 0;
+        const tags = params.tags.split(",").filter(Boolean);
+        filtered = filtered.filter((e) => tags.every((tag) => Array.isArray(e.tags) && e.tags.includes(tag)));
+      }
+      return ok("/events", { events: filtered.slice(0, 100).map((row) => structuredClone(row)) });
+    }
+    return void 0;
+  }
+  if (path === "/api/v1/query") {
+    if (method !== "GET") return void 0;
+    if (Object.keys(params).some((k) => !["from", "to", "query"].includes(k))) return void 0;
+    if (params.from === void 0 || params.to === void 0 || typeof params.query !== "string" || !params.query) return badRequest("/api/v1/query", { errors: ["from, to and query parameters are required"] });
+    if (!Number.isInteger(Number(params.from)) || !Number.isInteger(Number(params.to))) return badRequest("/api/v1/query", { errors: ["from and to must be epoch seconds"] });
+    const from = Number(params.from), to = Number(params.to);
+    if (to <= from) return badRequest("/api/v1/query", { errors: ["to must be after from"] });
+    const parsed = /^(?:avg|min|max|sum):([a-zA-Z0-9_.]+)\{[^}]*\}$/.exec(params.query);
+    if (!parsed) return badRequest("/api/v1/query", { errors: ["query must look like avg:metric.name{scope}"] });
+    const metric = rows(data, "/metrics").find((m) => m.metric === parsed[1]);
+    const pointlist = metric ? metric.points.filter(([ts]) => ts >= from && ts <= to) : [];
+    return ok("/metrics", { status: "ok", from_date: from * 1e3, to_date: to * 1e3, query: params.query, series: [{ metric: parsed[1], display_name: parsed[1].split(".").pop(), unit: null, pointlist: pointlist.map(([ts, value]) => [ts * 1e3, value]), scope: null, expression: params.query }] });
+  }
+  return void 0;
+}
+var googleError = (collection, status, message) => ({ status, body: { error: { code: status, message, status: status === 404 ? "NOT_FOUND" : "INVALID_ARGUMENT" } }, collection });
+var rowsIn = (data, collection) => data[collection];
+function gmailOperation(method, path, params, _headers, data, sequence) {
+  const MESSAGES = "/gmail/v1/users/me/messages", LABELS = "/gmail/v1/users/me/labels";
+  const fail = (status, message) => googleError(MESSAGES, status, message);
+  if (path === `${MESSAGES}/send`) {
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => !["raw", "to", "subject", "text", "threadId"].includes(k))) return void 0;
+    const text = str(params.text), raw = str(params.raw);
+    if (!text && !raw) return fail(400, "Message body is required: provide `text` or a `raw` MIME string.");
+    if (params.text !== void 0 && text === "") return fail(400, "Message text must not be empty.");
+    if (params.to !== void 0 && str(params.to) === void 0) return fail(400, "to must be a string.");
+    if (params.subject !== void 0 && str(params.subject) === void 0) return fail(400, "subject must be a string.");
+    if (params.threadId !== void 0 && str(params.threadId) === void 0) return fail(400, "threadId must be a string.");
+    const body = text ?? raw ?? "";
+    const message = { id: `gmail_at_${sequence}`, threadId: str(params.threadId) ?? `gmail_at_${sequence}`, labelIds: ["SENT"], snippet: body.slice(0, 100), payload: { mimeType: "text/plain", headers: [{ name: "To", value: str(params.to) ?? "" }, { name: "Subject", value: str(params.subject) ?? "" }], body: { data: body } }, sizeEstimate: body.length, internalDate: "1700000000000", historyId: String(17e8 + sequence) };
+    rowsIn(data, MESSAGES).push(message);
+    return write(200, MESSAGES, structuredClone(message), message);
+  }
+  if (path === MESSAGES) {
+    if (method !== "GET") return void 0;
+    if (Object.keys(params).some((k) => k !== "q")) return void 0;
+    let filtered = rowsIn(data, MESSAGES);
+    if (params.q !== void 0) {
+      if (typeof params.q !== "string") return fail(400, "q must be a string.");
+      filtered = filtered.filter((m) => typeof m.snippet === "string" && m.snippet.includes(params.q));
+    }
+    return ok(MESSAGES, { messages: filtered.map((m) => ({ id: m.id, threadId: m.threadId })), resultSizeEstimate: filtered.length });
+  }
+  const messageMatch = /^\/gmail\/v1\/users\/me\/messages\/([^/]+)$/.exec(path);
+  if (messageMatch) {
+    if (method !== "GET") return void 0;
+    const message = rowsIn(data, MESSAGES).find((m) => m.id === messageMatch[1]);
+    if (!message) return fail(404, `Message not found: ${messageMatch[1]}`);
+    return ok(MESSAGES, structuredClone(message));
+  }
+  if (path === LABELS) {
+    if (method !== "GET") return void 0;
+    if (Object.keys(params).length) return void 0;
+    return ok(LABELS, { labels: rowsIn(data, LABELS).map((row) => structuredClone(row)) });
+  }
+  return void 0;
+}
+function googleCalendarOperation(method, path, params, _headers, data, sequence) {
+  const CALENDAR_LIST = "/calendar/v3/users/me/calendarList", EVENTS = "/calendar/v3/calendars/primary/events";
+  const fail = (status, message) => googleError(EVENTS, status, message);
+  if (path === CALENDAR_LIST) {
+    if (method !== "GET") return void 0;
+    if (Object.keys(params).length) return void 0;
+    return ok(CALENDAR_LIST, { items: rowsIn(data, CALENDAR_LIST).map((row) => structuredClone(row)) });
+  }
+  const match = /^\/calendar\/v3\/calendars\/([^/]+)\/events(?:\/([^/]+))?$/.exec(path);
+  if (!match) return void 0;
+  const [, calendar, eventId] = match;
+  if (calendar !== "primary") return googleError(EVENTS, 404, `Not Found: no twin state for calendar ${calendar}`);
+  const scalar = (value) => ["summary", "description", "location"].filter((k) => params[k] !== void 0 && str(params[k]) === void 0);
+  const meetingField = (value) => value !== void 0 && !Array.isArray(value) && !isObject(value);
+  if (!eventId) {
+    if (method === "GET") {
+      const allowed = ["timeMin", "timeMax", "maxResults", "pageToken", "singleEvents", "orderBy", "conferenceDataVersion"];
+      if (Object.keys(params).some((k) => !allowed.includes(k))) return void 0;
+      if (params.singleEvents !== void 0 && !["true", "false", true, false].includes(params.singleEvents)) return fail(400, "Invalid singleEvents.");
+      if (params.orderBy !== void 0 && params.orderBy !== "startTime") return void 0;
+      if (params.orderBy === "startTime" && String(params.singleEvents) !== "true") return fail(400, "startTime ordering requires singleEvents=true.");
+      if (params.conferenceDataVersion !== void 0 && String(params.conferenceDataVersion) !== "1") return void 0;
+      const timestamp = (v) => {
+        if (typeof v !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(v)) return NaN;
+        return Math.floor(Date.parse(v) / 1e3) * 1e3;
+      };
+      const lower = params.timeMin === void 0 ? -Infinity : timestamp(params.timeMin);
+      const upper = params.timeMax === void 0 ? Infinity : timestamp(params.timeMax);
+      if (Number.isNaN(lower) || Number.isNaN(upper) || lower >= upper) return fail(400, "Invalid time range.");
+      const limit = params.maxResults === void 0 ? 250 : boundedInt(params.maxResults, 1, 2500);
+      if (limit === null) return fail(400, "Invalid maxResults.");
+      let events = rowsIn(data, EVENTS).filter((row) => row.status !== "cancelled");
+      if (events.some((row) => row.recurrence || row.recurringEventId || row.conferenceData)) return void 0;
+      const timed = params.timeMin !== void 0 || params.timeMax !== void 0 || params.orderBy !== void 0;
+      if (timed && events.some((row) => !isObject(row.start) || !isObject(row.end) || !Number.isFinite(timestamp(row.start.dateTime)) || !Number.isFinite(timestamp(row.end.dateTime)))) return void 0;
+      if (timed) events = events.filter((row) => timestamp(row.end.dateTime) > lower && timestamp(row.start.dateTime) < upper);
+      if (params.orderBy === "startTime") events = [...events].sort((a, b) => timestamp(a.start.dateTime) - timestamp(b.start.dateTime));
+      const query = Object.fromEntries(Object.entries(params).filter(([key]) => key !== "pageToken").sort(([a], [b]) => a.localeCompare(b)));
+      const fingerprint = sha(JSON.stringify({ query, events })).slice(0, 20);
+      let offset = 0;
+      if (params.pageToken !== void 0) {
+        if (typeof params.pageToken !== "string") return fail(400, "Invalid page token.");
+        const token = /^at_([a-f0-9]{20})_(\d+)$/.exec(params.pageToken);
+        if (!token || token[1] !== fingerprint || !Number.isSafeInteger(Number(token[2])) || Number(token[2]) < 1 || Number(token[2]) >= events.length) return fail(400, "Invalid or stale page token.");
+        offset = Number(token[2]);
+      }
+      const next = offset + (limit ?? 250);
+      return ok(EVENTS, { items: structuredClone(events.slice(offset, next)), ...next < events.length ? { nextPageToken: `at_${fingerprint}_${next}` } : {} });
+    }
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => !["summary", "description", "location", "start", "end", "attendees", "status"].includes(k))) return void 0;
+    if (typeof params.summary !== "string" || !params.summary) return fail(400, "Event summary is required.");
+    if (["start", "end", "attendees"].some((k) => meetingField(params[k]))) return fail(400, "start, end and attendees must be objects.");
+    const scalarBad = scalar(params);
+    if (scalarBad.length) return fail(400, `${scalarBad.join(", ")} must be strings.`);
+    const event2 = { id: detUuid(`gcal:${sequence}`), summary: params.summary, description: str(params.description) ?? null, location: str(params.location) ?? null, start: isObject(params.start) ? structuredClone(params.start) : { dateTime: iso() }, end: isObject(params.end) ? structuredClone(params.end) : { dateTime: iso() }, attendees: Array.isArray(params.attendees) ? structuredClone(params.attendees) : [], status: str(params.status) ?? "confirmed", htmlLink: null, creator: { email: "agenttwin@example.test", self: true }, created: iso(), updated: iso() };
+    rowsIn(data, EVENTS).push(event2);
+    return write(200, EVENTS, structuredClone(event2), event2);
+  }
+  const event = rowsIn(data, EVENTS).find((e) => e.id === eventId);
+  if (!event) return fail(404, `Not Found: event ${eventId}`);
+  if (method === "GET") return ok(EVENTS, structuredClone(event));
+  if (method === "PATCH") {
+    if (Object.keys(params).some((k) => !["summary", "description", "location", "start", "end", "attendees", "status"].includes(k))) return void 0;
+    if (["start", "end", "attendees"].some((k) => meetingField(params[k]))) return fail(400, "start, end and attendees must be objects.");
+    const scalarBad = scalar(params);
+    if (scalarBad.length) return fail(400, `${scalarBad.join(", ")} must be strings.`);
+    for (const [k, v] of Object.entries(params)) if (["summary", "description", "location", "start", "end", "attendees", "status"].includes(k)) event[k] = structuredClone(v);
+    event.updated = iso();
+    return write(200, EVENTS, structuredClone(event), event);
+  }
+  if (method === "DELETE") {
+    rowsIn(data, EVENTS).splice(rowsIn(data, EVENTS).findIndex((e) => e.id === eventId), 1);
+    return write(200, EVENTS, {}, structuredClone(event));
+  }
+  return void 0;
+}
+function gitlabOperation(method, path, params, _headers, data, sequence) {
+  const match = /^\/api\/v4\/(projects|issues|merge_requests)(?:\/(\d+))?(?:\/(notes)(?:\/(\d+))?)?$/.exec(path);
+  if (!match) return void 0;
+  const [, resource, id, sub] = match;
+  const collection = sub === "notes" ? "/api/v4/merge_requests/notes" : `/api/v4/${resource}`;
+  const records = rowsIn(data, collection);
+  const author = { id: 42, username: "agenttwin-test", name: "AgentTwin Test" };
+  if (sub === "notes") {
+    if (!id || !resource) return void 0;
+    const mr = rowsIn(data, "/api/v4/merge_requests").find((r) => String(r.iid) === id || String(r.id) === id);
+    if (!mr) return notFound(collection, { message: "404 Merge Request Not Found" });
+    if (method === "GET") return ok(collection, records.filter((n) => n.noteable_iid === mr.iid).map((row) => structuredClone(row)));
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => k !== "body")) return void 0;
+    if (typeof params.body !== "string" || !params.body) return badRequest(collection, { message: "body is required" });
+    const note = { id: uniqueId(records, 101 + sequence), body: params.body, author, created_at: iso(), updated_at: iso(), noteable_id: mr.id, noteable_iid: mr.iid, noteable_type: "MergeRequest" };
+    records.push(note);
+    return created(collection, structuredClone(note), note);
+  }
+  if (method === "GET" && !id) {
+    if (Object.keys(params).length) return void 0;
+    return ok(collection, records.map((row) => structuredClone(row)));
+  }
+  if (method === "POST" && !id) {
+    if (resource === "projects") {
+      if (Object.keys(params).some((k) => !["name", "description", "visibility"].includes(k))) return void 0;
+      if (typeof params.name !== "string" || !params.name) return badRequest(collection, { message: "name is missing" });
+      if (params.description !== void 0 && str(params.description) === void 0) return void 0;
+      const project = { id: uniqueId(records, 1 + sequence), name: params.name, description: str(params.description) ?? "", visibility: str(params.visibility) ?? "private", creator_id: 42, created_at: iso() };
+      records.push(project);
+      return created(collection, structuredClone(project), project);
+    }
+    if (resource === "issues") {
+      if (Object.keys(params).some((k) => !["title", "description", "project_id", "labels", "assignee_ids"].includes(k))) return void 0;
+      const projectId2 = Number(params.project_id);
+      if (typeof params.title !== "string" || !params.title || !Number.isInteger(projectId2)) return badRequest(collection, { message: "title and project_id are required" });
+      if (!rowsIn(data, "/api/v4/projects").some((p) => String(p.id) === String(projectId2))) return notFound(collection, { message: "404 Project Not Found" });
+      if (params.labels !== void 0 && (!Array.isArray(params.labels) || !params.labels.every((l) => typeof l === "string"))) return badRequest(collection, { message: "labels must be an array of strings" });
+      const inProject2 = records.filter((r) => r.project_id === projectId2);
+      const issue = { id: uniqueId(records, 101 + sequence), iid: inProject2.reduce((max, r) => Math.max(max, Number(r.iid) || 0), 0) + 1, project_id: projectId2, title: params.title, description: str(params.description) ?? null, state: "opened", labels: Array.isArray(params.labels) ? structuredClone(params.labels) : [], author, web_url: null, created_at: iso(), updated_at: iso() };
+      records.push(issue);
+      return created(collection, structuredClone(issue), issue);
+    }
+    if (Object.keys(params).some((k) => !["project_id", "source_branch", "target_branch", "title", "description"].includes(k))) return void 0;
+    const projectId = Number(params.project_id);
+    if (typeof params.title !== "string" || !params.title || !Number.isInteger(projectId) || typeof params.source_branch !== "string" || !params.source_branch || typeof params.target_branch !== "string" || !params.target_branch) return badRequest(collection, { message: "title, project_id, source_branch and target_branch are required" });
+    if (!rowsIn(data, "/api/v4/projects").some((p) => String(p.id) === String(projectId))) return notFound(collection, { message: "404 Project Not Found" });
+    const inProject = records.filter((r) => r.project_id === projectId);
+    const mergeRequest = { id: uniqueId(records, 201 + sequence), iid: inProject.reduce((max, r) => Math.max(max, Number(r.iid) || 0), 0) + 1, project_id: projectId, source_branch: params.source_branch, target_branch: params.target_branch, title: params.title, description: str(params.description) ?? null, state: "opened", author, web_url: null, created_at: iso(), updated_at: iso() };
+    records.push(mergeRequest);
+    return created(collection, structuredClone(mergeRequest), mergeRequest);
+  }
+  const primary = id ? rowsIn(data, `/api/v4/${resource}`).find((r) => String(r.id) === id || String(r.iid) === id) : void 0;
+  if (!primary) return id ? notFound(collection, { message: `404 ${resource === "merge_requests" ? "Merge Request" : resource.slice(0, -1)} Not Found` }) : void 0;
+  if (method === "GET") return ok(collection, structuredClone(primary));
+  return void 0;
+}
+var JIRA_TRANSITIONS = { "11": "To Do", "21": "In Progress", "31": "Done" };
+function jiraOperation(method, path, params, _headers, data, sequence) {
+  const ISSUE = "/rest/api/3/issue", PROJECT = "/rest/api/3/project";
+  const jiraFail = (collection, errorMessages, errors) => ({ status: 400, body: { errorMessages, errors }, collection });
+  if (path === "/rest/api/3/search") {
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => !["jql", "maxResults", "fields", "startAt"].includes(k))) return void 0;
+    const jql = str(params.jql);
+    if (!jql) return jiraFail("/rest/api/3/search", ["The 'jql' parameter is required."], {});
+    const parsed = /^\s*project\s*=\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*$/.exec(jql);
+    if (params.fields !== void 0 && (!Array.isArray(params.fields) || !params.fields.every((f) => typeof f === "string"))) return void 0;
+    if (!parsed) return void 0;
+    const project = parsed[1] ?? parsed[2] ?? parsed[3];
+    const maxResults = boundedInt(params.maxResults, 1, 100);
+    if (params.maxResults !== void 0 && maxResults === null) return jiraFail("/rest/api/3/search", ["'maxResults' must be an integer between 1 and 100."], {});
+    const issueRows = rowsIn(data, ISSUE).filter((r) => r.projectKey === project);
+    return ok(ISSUE, { expand: [], startAt: 0, maxResults: maxResults ?? 50, total: issueRows.length, issues: issueRows.slice(0, maxResults ?? 50).map((row) => structuredClone(row)) });
+  }
+  if (path === ISSUE) {
+    if (method !== "POST") return void 0;
+    if (Object.keys(params).some((k) => k !== "fields") || !isObject(params.fields)) return jiraFail(ISSUE, [], { fields: "fields is required" });
+    const fields = params.fields;
+    if (Object.keys(fields).some((k) => !["project", "issuetype", "summary", "description", "priority", "labels", "assignee"].includes(k))) return void 0;
+    const projectKey = isObject(fields.project) ? str(fields.project.key) : void 0;
+    const issuetype = isObject(fields.issuetype) ? str(fields.issuetype.name) : void 0;
+    if (!projectKey || !issuetype || typeof fields.summary !== "string" || !fields.summary) return jiraFail(ISSUE, [], { summary: projectKey && issuetype ? "Summary is required." : `${!projectKey ? "project key" : "issuetype name"} and summary are required.` });
+    if (!rowsIn(data, PROJECT).some((p) => p.key === projectKey)) return jiraFail(ISSUE, [`Project '${projectKey}' does not exist.`], {});
+    const issueRows = rowsIn(data, ISSUE);
+    const number = issueRows.filter((r) => r.projectKey === projectKey).reduce((max, r) => Math.max(max, Number(r.number) || 0), 0) + 1;
+    const issue = { id: uniqueId(issueRows, 1e4 + sequence), key: `${projectKey}-${number}`, projectKey, number, fields: { project: structuredClone(fields.project), issuetype: structuredClone(fields.issuetype), summary: fields.summary, description: fields.description ?? null, labels: Array.isArray(fields.labels) ? structuredClone(fields.labels) : [], status: { name: "Open" }, assignee: null, created: iso() } };
+    issueRows.push(issue);
+    return created(ISSUE, { id: issue.id, key: issue.key, self: null }, issue);
+  }
+  const issueMatch = /^\/rest\/api\/3\/issue\/([^/]+)(?:\/(comment|transitions))?$/.exec(path);
+  if (issueMatch) {
+    const issue = rowsIn(data, ISSUE).find((r) => r.key === issueMatch[1] || String(r.id) === issueMatch[1]);
+    if (!issue) return notFound(ISSUE, { errorMessages: ["Issue does not exist or you do not have permission to see it."], errors: {} });
+    if (method === "GET" && !issueMatch[2]) return ok(ISSUE, structuredClone(issue));
+    if (method === "POST" && issueMatch[2] === "comment") {
+      if (Object.keys(params).some((k) => k !== "body")) return void 0;
+      if (typeof params.body !== "string" && !isObject(params.body)) return jiraFail(ISSUE, [], { body: "body is required" });
+      if (isObject(params.body) && params.body.type !== "doc") return jiraFail(ISSUE, [], { body: "Comment bodies must be Atlassian Document Format objects with type 'doc', or plain strings." });
+      const commentRows = rowsIn(data, "/rest/api/3/issue/comments");
+      const comment = { id: uniqueId(commentRows, 101 + sequence), issueKey: issue.key, author: { accountId: "agenttwin-test-account", displayName: "AgentTwin Test" }, created: iso(), updated: iso(), body: structuredClone(params.body) };
+      commentRows.push(comment);
+      return created("/rest/api/3/issue/comments", structuredClone(comment), comment);
+    }
+    if (method === "POST" && issueMatch[2] === "transitions") {
+      if (Object.keys(params).some((k) => !["transition", "fields"].includes(k)) || !isObject(params.transition) || Object.keys(params.transition).some((k) => k !== "id")) return void 0;
+      const transitionId = str(params.transition.id);
+      if (!transitionId) return void 0;
+      if (!JIRA_TRANSITIONS[transitionId]) return jiraFail(ISSUE, [], { transition: "Transition id must be one of 11, 21, 31" });
+      issue.fields.status = { name: JIRA_TRANSITIONS[transitionId] };
+      return write(200, ISSUE, {}, structuredClone(issue));
+    }
+    return void 0;
+  }
+  if (path === PROJECT) {
+    if (method !== "GET") return void 0;
+    if (Object.keys(params).length) return void 0;
+    return ok(PROJECT, rowsIn(data, PROJECT).map((row) => structuredClone(row)));
+  }
+  const projectMatch = /^\/rest\/api\/3\/project\/([^/]+)$/.exec(path);
+  if (projectMatch) {
+    if (method !== "GET") return void 0;
+    const project = rowsIn(data, PROJECT).find((p) => p.key === projectMatch[1] || String(p.id) === projectMatch[1]);
+    if (!project) return notFound(PROJECT, { errorMessages: [`No project could be found with key '${projectMatch[1]}'`], errors: {} });
+    return ok(PROJECT, structuredClone(project));
+  }
+  return void 0;
+}
+var discordError = (collection, code, message) => ({ status: code === 10003 || code === 10004 ? 404 : 400, body: { message, code }, collection });
+function discordOperation(method, path, params, _headers, data, sequence) {
+  const CHANNELS = "/api/channels", MESSAGES = "/api/channels/messages", GUILDS = "/api/guilds", MEMBERS = "/api/guilds/members";
+  const channelMatch = /^\/api\/channels\/([^/]+)(?:\/(messages)(?:\/([^/]+))?)?$/.exec(path);
+  if (channelMatch) {
+    const [, channelId, messages, messageId] = channelMatch;
+    const channel = rowsIn(data, CHANNELS).find((c) => c.id === channelId);
+    if (!channel) return discordError(MESSAGES, 10003, "Unknown Channel");
+    if (!messages) {
+      if (method !== "GET") return void 0;
+      return ok(CHANNELS, structuredClone(channel));
+    }
+    if (messageId || method !== "GET" && method !== "POST") return void 0;
+    if (method === "GET") {
+      if (Object.keys(params).length) return void 0;
+      return ok(MESSAGES, rowsIn(data, MESSAGES).filter((m) => m.channel_id === channelId).map((row) => structuredClone(row)).reverse());
+    }
+    if (Object.keys(params).some((k) => !["content", "tts"].includes(k))) return void 0;
+    if (typeof params.content !== "string" || !params.content) return discordError(MESSAGES, 50035, "Invalid Form Body: content cannot be empty.");
+    if (params.tts !== void 0 && typeof params.tts !== "boolean") return void 0;
+    const records = rowsIn(data, MESSAGES);
+    const message = { id: String(uniqueId(records, 11e14 + sequence)), channel_id: channelId, content: params.content, author: { id: "discord_at_agenttwin", username: "agenttwin-test", avatar: null }, timestamp: iso(), tts: params.tts === true, embeds: [], pinned: false, type: 0 };
+    records.push(message);
+    return created(MESSAGES, structuredClone(message), message);
+  }
+  const guildMatch = /^\/api\/guilds\/([^/]+)(?:\/(members))?$/.exec(path);
+  if (guildMatch) {
+    const [, guildId, members] = guildMatch;
+    const guild = rowsIn(data, GUILDS).find((g) => g.id === guildId);
+    if (!guild) return discordError(MEMBERS, 10004, "Unknown Guild");
+    if (!members) {
+      if (method !== "GET") return void 0;
+      return ok(GUILDS, structuredClone(guild));
+    }
+    if (method !== "GET") return void 0;
+    if (Object.keys(params).some((k) => k !== "limit")) return void 0;
+    const limit = boundedInt(params.limit, 1, 1e3);
+    if (params.limit !== void 0 && limit === null) return discordError(MEMBERS, 50035, "Invalid Form Body: limit must be between 1 and 1000.");
+    return ok(MEMBERS, rowsIn(data, MEMBERS).filter((m) => m.guild_id === guildId).slice(0, limit ?? 1e3).map((row) => structuredClone(row)));
+  }
+  return void 0;
+}
+function twilioOperation(method, path, params, _headers, data, sequence) {
+  const match = /^\/2010-04-01\/Accounts\/([^/]+)\/(Messages|Calls)(?:\.json)?$/.exec(path);
+  if (!match) return void 0;
+  const [, accountSid, resource] = match;
+  const collection = `/2010-04-01/${resource}`;
+  const records = rowsIn(data, collection);
+  const fail = (status, code, message) => ({ status, body: { status, code, message, more_info: "" }, collection });
+  const stamp = () => {
+    const [date, time] = iso().split("T");
+    return `${date} ${time.slice(0, 8)}`;
+  };
+  if (method === "POST") {
+    const allowed = resource === "Messages" ? ["To", "From", "Body"] : ["To", "From", "Url"];
+    if (!accountSid || Object.keys(params).some((k) => !allowed.includes(k))) return void 0;
+    const missing = allowed.filter((k) => typeof params[k] !== "string" || !params[k]);
+    if (missing.length) return fail(400, missing.length === allowed.length ? "21211" : "21606", `No parameter provided for ${allowed.filter((k) => missing.includes(k)).join(", ")}`);
+    const prefix = resource === "Messages" ? "SM" : "CA";
+    const sid = `${prefix}${sha(`${prefix.toLowerCase()}:${sequence}:${accountSid}`).slice(0, 32)}`;
+    const record = resource === "Messages" ? { account_sid: accountSid, api_version: "2010-04-01", sid, messaging_service_sid: null, status: "queued", to: params.To, from: params.From, body: params.Body, num_segments: "1", num_media: "0", direction: "outbound-api", error_code: null, error_message: null, date_created: stamp(), date_updated: stamp(), date_sent: null, price: null, price_unit: null, uri: `/2010-04-01/Accounts/${accountSid}/Messages/${sid}.json` } : { account_sid: accountSid, api_version: "2010-04-01", sid, status: "queued", to: params.To, from: params.From, url: params.Url, direction: "outbound-api", error_code: null, error_message: null, date_created: stamp(), date_updated: stamp(), start_time: null, duration: null, price: null, price_unit: null, uri: `/2010-04-01/Accounts/${accountSid}/Calls/${sid}.json` };
+    records.push(record);
+    return created(collection, structuredClone(record), record);
+  }
+  if (method === "GET") {
+    if (Object.keys(params).some((k) => !["To", "From"].includes(k))) return void 0;
+    let filtered = records;
+    if (params.To !== void 0) {
+      if (typeof params.To !== "string") return fail(400, "20001", "To must be a string");
+      filtered = filtered.filter((r) => r.to === params.To);
+    }
+    if (params.From !== void 0) {
+      if (typeof params.From !== "string") return fail(400, "20001", "From must be a string");
+      filtered = filtered.filter((r) => r.from === params.From);
+    }
+    return ok(collection, { page: 0, page_size: filtered.length, start: 0, end: Math.max(filtered.length - 1, 0), next_page_uri: null, [resource.toLowerCase()]: filtered.map((row) => structuredClone(row)) });
+  }
+  return void 0;
+}
+var ZENDESK_STATUSES = ["new", "open", "pending", "solved", "closed"];
+function zendeskOperation(method, path, params, _headers, data, sequence) {
+  const match = /^\/api\/v2\/(tickets|users|organizations)(?:\/(\d+))?\.json$/.exec(path);
+  if (!match) return void 0;
+  const [, resource, id] = match;
+  const collection = `/api/v2/${resource}`;
+  const records = rowsIn(data, collection);
+  const envelope = (items) => ({ [resource]: items, next_page: null, previous_page: null, count: items.length });
+  if (method === "POST" && !id) {
+    if (resource !== "tickets") return void 0;
+    if (Object.keys(params).some((k) => k !== "ticket") || !isObject(params.ticket)) return badRequest(collection, { error: "RecordInvalid", description: "Ticket is not valid: ticket is required" });
+    const ticketParams = params.ticket;
+    if (Object.keys(ticketParams).some((k) => !["subject", "comment", "requester", "status", "priority", "tags", "description", "type"].includes(k))) return void 0;
+    if (typeof ticketParams.subject !== "string" || !ticketParams.subject) return badRequest(collection, { error: "RecordInvalid", description: "Ticket is not valid: Subject can't be blank" });
+    if (!isObject(ticketParams.comment) || Object.keys(ticketParams.comment).some((k) => k !== "body") || typeof ticketParams.comment.body !== "string" || !ticketParams.comment.body) return badRequest(collection, { error: "RecordInvalid", description: "Ticket is not valid: comment body is required" });
+    if (ticketParams.status !== void 0 && !ZENDESK_STATUSES.includes(String(ticketParams.status))) return badRequest(collection, { error: "InvalidStatus", description: "Status must be new, open, pending, solved or closed" });
+    const ticket = { id: uniqueId(records, 1 + sequence), subject: ticketParams.subject, description: str(ticketParams.description) ?? ticketParams.comment.body, status: str(ticketParams.status) ?? "new", priority: str(ticketParams.priority) ?? "normal", tags: Array.isArray(ticketParams.tags) ? structuredClone(ticketParams.tags) : [], requester: isObject(ticketParams.requester) ? structuredClone(ticketParams.requester) : null, created_at: iso(), updated_at: iso() };
+    records.push(ticket);
+    return created(collection, { ticket: structuredClone(ticket), audit: null }, ticket);
+  }
+  if (method === "GET" && !id) {
+    if (Object.keys(params).length) return void 0;
+    return ok(collection, envelope(records));
+  }
+  if (method === "GET" && id && resource === "tickets") {
+    const ticket = records.find((r) => String(r.id) === id);
+    if (!ticket) return notFound(collection, { error: "RecordNotFound", description: `Not found: ${id}` });
+    return ok(collection, { ticket: structuredClone(ticket) });
+  }
+  if (method === "PUT" && id && resource === "tickets") {
+    const ticket = typeof id === "string" ? records.find((r) => String(r.id) === id) : void 0;
+    if (!ticket) return notFound(collection, { error: "RecordNotFound", description: `Not found: ${id}` });
+    if (Object.keys(params).some((k) => k !== "ticket") || !isObject(params.ticket)) return badRequest(collection, { error: "RecordInvalid", description: "Ticket is not valid: ticket is required" });
+    const ticketParams = params.ticket;
+    if (Object.keys(ticketParams).some((k) => !["subject", "status", "priority", "tags"].includes(k))) return void 0;
+    if (ticketParams.status !== void 0 && !ZENDESK_STATUSES.includes(String(ticketParams.status))) return badRequest(collection, { error: "InvalidStatus", description: "Status must be new, open, pending, solved or closed" });
+    if (ticketParams.subject !== void 0 && (typeof ticketParams.subject !== "string" || !ticketParams.subject)) return badRequest(collection, { error: "RecordInvalid", description: "Ticket is not valid: Subject can't be blank" });
+    for (const [k, v] of Object.entries(ticketParams)) if (["subject", "status", "priority", "tags"].includes(k)) ticket[k] = structuredClone(v);
+    ticket.updated_at = iso();
+    return write(200, collection, { ticket: structuredClone(ticket), audit: null }, ticket);
+  }
+  return void 0;
+}
+var UNSUPPORTED_BODIES = {
+  github: { message: "Outside the verified AgentTwin GitHub twin subset", documentation_url: "https://docs.github.com/rest", forwardedToProduction: false },
+  linear: { errors: [{ message: "Outside the verified AgentTwin Linear twin subset" }], data: null, forwardedToProduction: false },
+  notion: { object: "error", status: 501, code: "unsupported_operation", message: "Outside the verified AgentTwin Notion twin subset", forwardedToProduction: false },
+  hubspot: { status: "error", category: "UNSUPPORTED_OPERATION", message: "Outside the verified AgentTwin HubSpot twin subset", forwardedToProduction: false },
+  shopify: { errors: "Outside the verified AgentTwin Shopify twin subset", forwardedToProduction: false },
+  datadog: { errors: ["Outside the verified AgentTwin Datadog twin subset"], forwardedToProduction: false },
+  gmail: { error: { code: 501, status: "UNIMPLEMENTED", message: "Outside the verified AgentTwin Gmail twin subset" }, forwardedToProduction: false },
+  "google-calendar": { error: { code: 501, status: "UNIMPLEMENTED", message: "Outside the verified AgentTwin Google Calendar twin subset" }, forwardedToProduction: false },
+  gitlab: { message: "Outside the verified AgentTwin GitLab twin subset", forwardedToProduction: false },
+  jira: { errorMessages: ["Outside the verified AgentTwin Jira twin subset"], errors: {}, forwardedToProduction: false },
+  discord: { message: "Outside the verified AgentTwin Discord twin subset", code: 50101, forwardedToProduction: false },
+  twilio: { status: 501, code: "50101", message: "Outside the verified AgentTwin Twilio twin subset", more_info: "", forwardedToProduction: false },
+  zendesk: { error: "UnsupportedOperation", description: "Outside the verified AgentTwin Zendesk twin subset", forwardedToProduction: false }
+};
+var REST_ADAPTERS = {
+  github: githubOperation,
+  linear: linearOperation,
+  notion: notionOperation,
+  hubspot: hubspotOperation,
+  shopify: shopifyOperation,
+  datadog: datadogOperation,
+  gmail: gmailOperation,
+  "google-calendar": googleCalendarOperation,
+  gitlab: gitlabOperation,
+  jira: jiraOperation,
+  discord: discordOperation,
+  twilio: twilioOperation,
+  zendesk: zendeskOperation
+};
+function restUnsupportedBody(adapter) {
+  return UNSUPPORTED_BODIES[adapter];
+}
+var REST_ADAPTER_NAMES = Object.keys(REST_ADAPTERS);
+
+// src/runtime/seed.ts
+import { createHash as createHash2, randomBytes } from "crypto";
+var SEED_PATTERN = /^[a-f0-9]{32}$/;
+var normalizeHex = (value) => value.trim().toLowerCase();
+function normalizeSeed(seed) {
+  if (seed === void 0 || seed.trim() === "") return randomBytes(16).toString("hex");
+  const text = normalizeHex(seed);
+  if (!/^[a-f0-9]+$/.test(text) || text.length > 256) throw new Error(`Seed must be up to 256 hex characters or empty to generate; got ${seed.slice(0, 40)}`);
+  if (text.length === 32) return text;
+  return createHash2("sha256").update(text).digest("hex").slice(0, 32);
+}
+var SeedStream = class {
+  constructor(seed, purpose) {
+    this.seed = seed;
+    this.purpose = purpose;
+    if (!SEED_PATTERN.test(seed)) throw new Error(`Invalid seed for stream: ${seed}`);
+    if (!purpose) throw new Error("Seed stream purpose must be nonempty");
+  }
+  seed;
+  purpose;
+  counter = 0;
+  draw() {
+    const value = createHash2("sha256").update(`agenttwin-stream|${this.seed}|${this.purpose}|${this.counter}`).digest("hex");
+    this.counter++;
+    return value;
+  }
+  /** Uniform float in [0, 1). */
+  next() {
+    return parseInt(this.draw().slice(0, 13), 16) / 2 ** 52;
+  }
+  /** Uniform integer in [0, max). */
+  nextInt(max) {
+    if (!Number.isInteger(max) || max < 1) throw new Error("nextInt needs a positive integer max");
+    const limit = Math.floor(2 ** 32 / max) * max;
+    let next;
+    do {
+      next = parseInt(this.draw().slice(0, 8), 16);
+    } while (next >= limit);
+    return next % max;
+  }
+  nextHex(bytes) {
+    if (!Number.isInteger(bytes) || bytes < 1 || bytes > 64) throw new Error("nextHex needs 1\u201364 bytes");
+    return this.draw().slice(0, bytes * 2);
+  }
+};
+var FAULT_SCHEDULE_WINDOW = 32;
+function faultOrdinals(selection, seed) {
+  const count = selection.type === "timeout-after-write" ? 1 : selection.count ?? 1;
+  const stream = new SeedStream(seed, `fault:${selection.type}:${selection.service}:${selection.path}`);
+  const all = Array.from({ length: FAULT_SCHEDULE_WINDOW }, (_, i) => i);
+  for (let i = all.length - 1; i > 0; i--) {
+    const j = stream.nextInt(i + 1);
+    [all[i], all[j]] = [all[j], all[i]];
+  }
+  return all.slice(0, count).sort((a, b) => a - b);
 }
 
 // src/runtime/http-world.ts
 var HttpWorld = class {
-  constructor(spec) {
+  constructor(spec, seed) {
     this.spec = spec;
+    this.seed = normalizeSeed(seed);
   }
   spec;
   events = [];
   state = /* @__PURE__ */ Object.create(null);
   credentials = /* @__PURE__ */ Object.create(null);
   unsupported = [];
+  /** The run seed that governed every seeded twin-side decision in this world instance. */
+  seed;
   servers = [];
   timers = /* @__PURE__ */ new Set();
   fired = false;
+  faultActions = 0;
+  candidateCounts = /* @__PURE__ */ new Map();
   epoch = 0;
   replayKeys = /* @__PURE__ */ new Map();
   sourceContext = new AsyncLocalStorage();
@@ -215,15 +1343,29 @@ var HttpWorld = class {
     this.unsupported.push(`${service}: ${method} ${path}: ${detail}`);
     this.record(service, "unsupported", path, detail);
   }
+  /** Seeded fault scheduling: the k-th matched request of the fault's scope is faulted iff the seeded draw picked ordinal k. */
+  candidateIndex(key) {
+    const next = this.candidateCounts.get(key) ?? 0;
+    this.candidateCounts.set(key, next + 1);
+    return next;
+  }
   async start() {
     if (this.servers.length) throw new Error("World is already started");
+    const fault = this.spec.fault;
     for (const service of this.spec.services) {
-      const token = `at_world_${randomBytes(24).toString("hex")}`;
+      const token = `at_world_${new SeedStream(this.seed, `credential:${service.name}`).nextHex(24)}`;
+      const faultOrdinalsFor = fault && fault.service === service.name ? faultOrdinals(fault, this.seed) : null;
+      const faultKey = `${fault?.type ?? ""}\0${service.name}\0${fault?.path ?? ""}`;
+      const adapterService = service.adapter === "stripe" || service.adapter && REST_ADAPTER_NAMES.includes(service.adapter);
+      const restAdapter = service.adapter && REST_ADAPTER_NAMES.includes(service.adapter) ? REST_ADAPTERS[service.adapter] : void 0;
+      const altAuth = (headers) => service.adapter === "shopify" ? headers["x-shopify-access-token"] === token : service.adapter === "datadog" ? headers["dd-api-key"] === token && headers["dd-application-key"] === token : service.adapter === "discord" ? headers.authorization === `Bot ${token}` : false;
       const data = /* @__PURE__ */ Object.create(null);
       this.state[service.name] = data;
       for (const c of service.collections) data[c.path] = structuredClone(c.seed);
       const keys = /* @__PURE__ */ new Map();
       this.replayKeys.set(service.name, keys);
+      const latency = this.spec.latency && (this.spec.latency.maxMs > this.spec.latency.minMs || this.spec.latency.minMs > 0) ? new SeedStream(this.seed, `latency:${service.name}`) : null;
+      const latencyMs = () => latency && this.spec.latency ? this.spec.latency.minMs + latency.nextInt(this.spec.latency.maxMs - this.spec.latency.minMs + 1) : 0;
       const server = createServer((req, res) => this.sourceContext.run(parseRequestSource(req.headers["x-agenttwin-source"], this.spec), async () => {
         const epoch = this.epoch;
         const send = (code, body) => {
@@ -232,14 +1374,68 @@ var HttpWorld = class {
             res.end(JSON.stringify(body));
           }
         };
+        const respond = (code, body) => {
+          const ms = latencyMs();
+          if (ms <= 0) {
+            send(code, body);
+            return;
+          }
+          const timer = setTimeout(() => {
+            this.timers.delete(timer);
+            if (epoch === this.epoch) send(code, body);
+          }, ms);
+          this.timers.add(timer);
+        };
+        const normalPath = (url, method) => {
+          const parsed = new URL(url, "http://localhost");
+          if (service.adapter === "slack") {
+            const m = parsed.pathname.replace(/^\/api\//, "");
+            if (m === "chat.postMessage" && method === "POST") return "/messages";
+            if (m === "conversations.history" && ["GET", "POST"].includes(method ?? "")) return "/messages";
+            if (m === "conversations.list" && ["GET", "POST"].includes(method ?? "")) return "/channels";
+            return parsed.pathname;
+          }
+          return parsed.pathname;
+        };
+        const matchesFault = (target) => adapterService ? target === fault.path || target.startsWith(`${fault.path}/`) || target.endsWith(fault.path) : target === fault.path;
+        const darkFault = () => {
+          if (!fault || !faultOrdinalsFor || fault.type !== "blackhole" && fault.type !== "server-error") return "none";
+          const target = normalPath(req.url ?? "/", req.method);
+          if (!matchesFault(target)) return "none";
+          const ordinal = this.candidateIndex(faultKey);
+          if (!faultOrdinalsFor.includes(ordinal)) return "none";
+          this.faultActions++;
+          return fault.type;
+        };
         try {
-          if (req.headers.authorization !== `Bearer ${token}`) {
+          if (req.headers.authorization !== `Bearer ${token}` && !altAuth(req.headers)) {
             this.record(service.name, "auth-denied", req.url ?? "", "invalid test credential");
-            send(401, { error: "invalid_test_credential" });
+            respond(401, { error: "invalid_test_credential" });
             return;
           }
           if (this.events.length >= 5e4 || this.unsupported.length >= 1e3) {
-            send(429, { error: "world_capacity" });
+            respond(429, { error: "world_capacity" });
+            return;
+          }
+          const darkness = darkFault();
+          if (darkness === "blackhole") {
+            this.record(service.name, "fault", fault.path, `blackhole: request dropped (matched ordinal ${this.candidateCounts.get(faultKey) - 1} of the seeded schedule); nothing committed`);
+            return;
+          }
+          if (darkness === "server-error") {
+            const windowMs = fault.windowMs ?? 0;
+            const delay = windowMs <= 0 ? 0 : new SeedStream(this.seed, `server-error:${service.name}:${fault.path}`).nextInt(windowMs + 1);
+            this.record(service.name, "fault", fault.path, `server-error fault: responding 500 after ${delay}ms; nothing committed`);
+            const respond500 = () => respond(500, { error: { type: "api_error", message: "server_error fault" } });
+            if (delay <= 0) {
+              respond500();
+              return;
+            }
+            const timer = setTimeout(() => {
+              this.timers.delete(timer);
+              if (epoch === this.epoch) respond500();
+            }, delay);
+            this.timers.add(timer);
             return;
           }
           const url = new URL(req.url ?? "/", "http://localhost");
@@ -247,13 +1443,13 @@ var HttpWorld = class {
           const slack = service.adapter === "slack";
           const slackMethod = path.replace(/^\/api\//, "");
           let payload;
-          if (req.method === "POST") {
+          if (["POST", "PUT", "PATCH"].includes(req.method ?? "")) {
             const chunks = [];
             let bytes = 0;
             for await (const chunk of req) {
               bytes += chunk.length;
               if (bytes > 1024 * 1024) {
-                send(413, { error: "body_too_large" });
+                respond(413, { error: "body_too_large" });
                 return;
               }
               chunks.push(Buffer.from(chunk));
@@ -263,20 +1459,20 @@ var HttpWorld = class {
             try {
               parsed = (slack || service.adapter === "stripe") && req.headers["content-type"]?.startsWith("application/x-www-form-urlencoded") ? Object.fromEntries(new URLSearchParams(text)) : JSON.parse(text);
             } catch {
-              send(400, { error: "expected_json_object" });
+              respond(400, { error: "expected_json_object" });
               return;
             }
             if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-              send(400, { error: "expected_json_object" });
+              respond(400, { error: "expected_json_object" });
               return;
             }
             payload = parsed;
           }
           if (epoch !== this.epoch) {
-            send(409, { error: "world_reset" });
+            respond(409, { error: "world_reset" });
             return;
           }
-          if (service.adapter === "stripe") {
+          if (service.adapter === "stripe" || restAdapter) {
             const params = payload ?? Object.fromEntries(url.searchParams);
             const keyHeader2 = req.headers["idempotency-key"];
             const key2 = req.method === "POST" && typeof keyHeader2 === "string" ? `${path}:${keyHeader2}` : void 0;
@@ -284,31 +1480,45 @@ var HttpWorld = class {
             const previous2 = key2 ? keys.get(key2) : void 0;
             if (previous2) {
               if (previous2.body !== signature2) {
-                send(400, { error: { type: "idempotency_error", message: "Keys for idempotent requests can only be used with the same parameters" } });
+                respond(400, { error: { type: "idempotency_error", message: "Keys for idempotent requests can only be used with the same parameters" } });
                 return;
               }
               this.record(service.name, "replay", path, "same-key response replay", previous2.record);
-              send(200, previous2.record);
+              respond(previous2.status ?? 200, previous2.record);
               return;
             }
-            const result = stripeOperation(req.method ?? "", path, params, data, this.events.length + 1);
+            const result = restAdapter ? restAdapter(req.method ?? "", path, params, req.headers, data, this.events.length + 1) : stripeOperation(req.method ?? "", path, params, data, this.events.length + 1);
             if (!result) {
-              this.rejectUnsupported(service.name, req.method ?? "", path, "unsupported Stripe operation or parameters");
-              send(501, { error: { type: "invalid_request_error", code: "unsupported_operation", message: "Outside the verified AgentTwin Stripe subset" }, forwardedToProduction: false });
+              this.rejectUnsupported(service.name, req.method ?? "", path, `unsupported ${service.adapter} operation or parameters`);
+              respond(501, restAdapter ? restUnsupportedBody(service.adapter) : { error: { type: "invalid_request_error", code: "unsupported_operation", message: "Outside the verified AgentTwin Stripe subset" }, forwardedToProduction: false });
               return;
             }
             if (result.operation) this.record(service.name, result.operation, result.collection, path, "record" in result ? result.record : result.body);
-            if (key2 && result.status === 200) keys.set(key2, { body: signature2, record: structuredClone(result.body) });
-            const fault2 = this.spec.fault;
-            if (!this.fired && result.operation === "write" && fault2?.service === service.name && fault2.path === result.collection) {
+            if (key2 && (result.status === 200 || result.status === 201)) keys.set(key2, { body: signature2, record: structuredClone(result.body), status: result.status });
+            const faultWritesMatch = fault?.type === "duplicate-write" && fault.service === service.name && result.operation === "write" && !key2 && matchesFault(result.collection);
+            const duplicate2 = faultWritesMatch && faultOrdinalsFor !== null && faultOrdinalsFor.includes(this.candidateIndex(faultKey));
+            if (duplicate2) {
+              const second = restAdapter ? restAdapter(req.method ?? "", path, params, req.headers, data, this.events.length + 1) : stripeOperation(req.method ?? "", path, params, data, this.events.length + 1);
+              if (second?.operation === "write") {
+                this.record(service.name, second.operation, second.collection, path, "record" in second ? second.record : second.body);
+                this.faultActions++;
+                this.record(service.name, "fault", fault.path, `duplicate-write: a single write was delivered twice (${result.collection})`);
+              } else if (second) {
+                this.record(service.name, "fault", fault.path, `duplicate-write: second delivery replaced by ${second.operation ?? "failure"}`);
+                respond(second.status, second.body);
+                return;
+              }
+            }
+            if (!this.fired && result.operation === "write" && fault?.type === "timeout-after-write" && fault.service === service.name && fault.path === result.collection) {
               this.fired = true;
-              this.record(service.name, "fault", result.collection, `write committed; response delayed ${fault2.delayMs}ms`);
+              this.faultActions++;
+              this.record(service.name, "fault", result.collection, `write committed; response delayed ${fault.delayMs}ms`);
               const timer = setTimeout(() => {
                 this.timers.delete(timer);
-                send(result.status, result.body);
-              }, fault2.delayMs);
+                respond(result.status, result.body);
+              }, fault.delayMs);
               this.timers.add(timer);
-            } else send(result.status, result.body);
+            } else respond(result.status, result.body);
             return;
           }
           if (slack) {
@@ -316,7 +1526,7 @@ var HttpWorld = class {
             const allowed = slackMethod === "chat.postMessage" ? ["channel", "text"] : slackMethod === "conversations.history" ? ["channel"] : [];
             if (Object.keys(params).some((k) => !allowed.includes(k))) {
               this.rejectUnsupported(service.name, req.method ?? "", url.pathname, `unsupported parameters for ${slackMethod}`);
-              send(501, { ok: false, error: "unsupported_parameters", forwardedToProduction: false });
+              respond(501, { ok: false, error: "unsupported_parameters", forwardedToProduction: false });
               return;
             }
             if (slackMethod === "chat.postMessage" && req.method === "POST") path = "/messages";
@@ -324,39 +1534,39 @@ var HttpWorld = class {
             else if (slackMethod === "conversations.list" && ["GET", "POST"].includes(req.method ?? "")) path = "/channels";
             else {
               this.rejectUnsupported(service.name, req.method ?? "", url.pathname, "unsupported operation");
-              send(501, { ok: false, error: "unsupported_operation", forwardedToProduction: false });
+              respond(501, { ok: false, error: "unsupported_operation", forwardedToProduction: false });
               return;
             }
           }
           if (!Object.hasOwn(data, path) || !["GET", "POST"].includes(req.method ?? "")) {
             this.rejectUnsupported(service.name, req.method ?? "", path, "unsupported operation");
-            send(501, { error: "unsupported_operation", forwardedToProduction: false });
+            respond(501, { error: "unsupported_operation", forwardedToProduction: false });
             return;
           }
           if (req.method === "GET" || slack && slackMethod !== "chat.postMessage") {
             this.record(service.name, "read", path, `${data[path].length} records`);
-            if (slack && path === "/channels") send(200, { ok: true, channels: data[path], response_metadata: { next_cursor: "" } });
+            if (slack && path === "/channels") respond(200, { ok: true, channels: data[path], response_metadata: { next_cursor: "" } });
             else if (slack) {
               const channel = payload?.channel ?? url.searchParams.get("channel");
-              if (!data["/channels"].some((c) => c.id === channel)) send(200, { ok: false, error: "channel_not_found" });
-              else send(200, { ok: true, messages: data[path].filter((m) => m.channel === channel), has_more: false });
-            } else send(200, { data: data[path] });
+              if (!data["/channels"].some((c) => c.id === channel)) respond(200, { ok: false, error: "channel_not_found" });
+              else respond(200, { ok: true, messages: data[path].filter((m) => m.channel === channel), has_more: false });
+            } else respond(200, { data: data[path] });
             return;
           }
           const body = payload;
           if (slack) {
             const message = body;
             if (!data["/channels"].some((c) => c.id === message.channel)) {
-              send(200, { ok: false, error: "channel_not_found" });
+              respond(200, { ok: false, error: "channel_not_found" });
               return;
             }
             if (typeof message.text !== "string" || !message.text) {
-              send(200, { ok: false, error: "no_text" });
+              respond(200, { ok: false, error: "no_text" });
               return;
             }
           }
           if (data[path].length >= 1e4 || this.events.length >= 5e4) {
-            send(429, { error: "world_capacity" });
+            respond(429, { error: "world_capacity" });
             return;
           }
           const keyHeader = slack ? void 0 : req.headers["idempotency-key"];
@@ -365,13 +1575,15 @@ var HttpWorld = class {
           const previous = key ? keys.get(key) : void 0;
           if (previous) {
             if (previous.body !== signature) {
-              send(409, { error: "idempotency_conflict" });
+              respond(409, { error: "idempotency_conflict" });
               return;
             }
             this.record(service.name, "replay", path, "same-key response replay", previous.record);
-            send(200, previous.record);
+            respond(200, previous.record);
             return;
           }
+          const duplicate = fault?.type === "duplicate-write" && fault.service === service.name && fault.path === path && !key && faultOrdinalsFor !== null && faultOrdinalsFor.includes(this.candidateIndex(faultKey));
+          if (duplicate) this.faultActions++;
           let index = data[path].length + 1;
           while (data[path].some((r) => r.id === `${service.name}_${index}`)) index++;
           const row = { ...body, id: `${service.name}_${index}` };
@@ -380,24 +1592,34 @@ var HttpWorld = class {
           data[path].push(row);
           if (key) keys.set(key, { body: signature, record: row });
           this.record(service.name, "write", path, String(row.id), row);
-          const fault = this.spec.fault;
-          if (!this.fired && fault?.service === service.name && fault.path === path) {
+          if (duplicate) {
+            index++;
+            while (data[path].some((r) => r.id === `${service.name}_${index}`)) index++;
+            const second = { ...body, id: `${service.name}_${index}` };
+            if (slack) second.ts = `${index}.000001`;
+            data[path].push(second);
+            this.record(service.name, "write", path, String(second.id), second);
+            this.record(service.name, "fault", fault.path, `duplicate-write: one write committed as two records (${row.id}, ${second.id})`);
+          }
+          const faultResponse = slack ? 200 : 201;
+          if (!this.fired && fault?.type === "timeout-after-write" && fault.service === service.name && fault.path === path) {
             this.fired = true;
+            this.faultActions++;
             this.record(service.name, "fault", path, `write committed; response delayed ${fault.delayMs}ms`);
             const timer = setTimeout(() => {
               this.timers.delete(timer);
-              send(slack ? 200 : 201, reply);
+              respond(faultResponse, reply);
             }, fault.delayMs);
             this.timers.add(timer);
-          } else send(slack ? 200 : 201, reply);
+          } else respond(faultResponse, reply);
         } catch {
-          send(500, { error: "world_request_error" });
+          respond(500, { error: "world_request_error" });
         }
       }));
       server.requestTimeout = 1e4;
-      await new Promise((resolve4, reject) => {
+      await new Promise((resolve5, reject) => {
         server.once("error", reject);
-        server.listen(0, "127.0.0.1", resolve4);
+        server.listen(0, "127.0.0.1", resolve5);
       });
       this.servers.push(server);
       this.credentials[service.name] = { endpoint: `http://127.0.0.1:${server.address().port}`, token };
@@ -406,12 +1628,12 @@ var HttpWorld = class {
   }
   assertions() {
     return this.spec.assertions.map((a) => {
-      const rows = this.state[a.service][a.path].filter((row) => !a.where || Object.entries(a.where).every(([k, v]) => isDeepStrictEqual(row[k], v)));
-      return { ...a, actual: rows.length, passed: rows.length === a.count };
+      const rows2 = this.state[a.service][a.path].filter((row) => !a.where || Object.entries(a.where).every(([k, v]) => isDeepStrictEqual(row[k], v)));
+      return { ...a, actual: rows2.length, passed: rows2.length === a.count };
     });
   }
   get faultTriggered() {
-    return this.fired;
+    return this.faultActions > 0;
   }
   snapshot() {
     return structuredClone(this.state);
@@ -431,14 +1653,16 @@ var HttpWorld = class {
     this.events.length = 0;
     this.unsupported.length = 0;
     this.fired = false;
+    this.faultActions = 0;
+    this.candidateCounts.clear();
     return this.snapshot();
   }
   async close() {
     this.epoch++;
     for (const timer of this.timers) clearTimeout(timer);
     this.timers.clear();
-    await Promise.all(this.servers.map((server) => new Promise((resolve4) => {
-      server.close(() => resolve4());
+    await Promise.all(this.servers.map((server) => new Promise((resolve5) => {
+      server.close(() => resolve5());
       server.closeAllConnections();
     })));
     this.servers.length = 0;
@@ -578,18 +1802,73 @@ function evaluateState(spec, initial, final, events) {
       evidence: { initial: `/initialState/${escape(policy.service)}/${escape(policy.path)}`, final: `/finalState/${escape(policy.service)}/${escape(policy.path)}` }
     };
   });
+  const properties = (spec.properties ?? []).map((policy) => evaluateProperty(policy, final, events));
   const taskPassed = checks.every((c) => c.passed);
-  const safe = [...forbidden, ...preserved].every((c) => c.passed);
-  return { schema: "agenttwin/evaluation-v1", outcome: !safe ? "unsafe" : taskPassed ? "passed" : "failed", taskPassed, safe, checks: [...checks, ...forbidden, ...preserved] };
+  const safe = [...forbidden, ...preserved, ...properties].every((c) => c.passed);
+  return { schema: "agenttwin/evaluation-v1", outcome: !safe ? "unsafe" : taskPassed ? "passed" : "failed", taskPassed, safe, checks: [...checks, ...forbidden, ...preserved, ...properties] };
+}
+var canonical = (value) => Array.isArray(value) ? value.map(canonical) : typeof value === "object" && value !== null ? Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])])) : value;
+var short = (value, limit = 120) => value.length <= limit ? value : `${value.slice(0, limit)}\u2026`;
+function evaluateProperty(policy, final, events) {
+  const base = { id: policy.id, kind: "property", propertyKind: policy.kind, service: policy.service, path: policy.path, passed: false };
+  const rows2 = final[policy.service]?.[policy.path];
+  if (!rows2) return { ...base, expected: "intact", actual: "missing collection", evidence: { evidenceGap: `final state has no collection "${policy.path}" in "${policy.service}"` } };
+  const eventsFor = (operation2, where2) => events.filter((e) => e.service === policy.service && e.path === policy.path && e.operation === operation2 && (!where2 || e.record !== void 0 && matches(e.record, where2)));
+  if (policy.kind === "unique-per-act") {
+    const field = String(policy.params?.field);
+    const keyed = /* @__PURE__ */ new Map();
+    for (const row of rows2) {
+      if (row[field] === void 0) continue;
+      const key = JSON.stringify(canonical(row[field]));
+      keyed.set(key, [...keyed.get(key) ?? [], row.id ?? row]);
+    }
+    const duplicates = [...keyed.entries()].filter(([, list]) => list.length > 1);
+    return {
+      ...base,
+      passed: duplicates.length === 0,
+      expected: 0,
+      actual: duplicates.length,
+      evidence: { field, duplicates: duplicates.map(([key, ids]) => ({ value: short(key), ids: ids.map(String) })), eventSequences: eventsFor("write").filter((e) => e.record !== void 0 && e.record[field] !== void 0 && duplicates.some(([key]) => key === JSON.stringify(canonical(e.record[field])))).map((e) => e.sequence) }
+    };
+  }
+  if (policy.kind === "no-loss") {
+    const writes = eventsFor("write", policy.params?.where);
+    const lost = writes.filter((e) => {
+      if (!e.record) return false;
+      const record = e.record;
+      if (typeof record.id === "string" && record.id) return !rows2.some((row) => row.id === record.id);
+      return !rows2.some((row) => isDeepStrictEqual3(row, record));
+    });
+    const unknown2 = writes.some((e) => !e.record);
+    return {
+      ...base,
+      passed: lost.length === 0 && !unknown2,
+      expected: 0,
+      actual: unknown2 ? "unknown" : lost.length,
+      evidence: { evidenceGap: unknown2, eventSequences: lost.map((e) => e.sequence), lost: lost.map((e) => String(e.detail)) }
+    };
+  }
+  const count = Number(policy.params?.count);
+  const operation = String(policy.params?.operation ?? "write");
+  const where = policy.params?.where;
+  const hits = eventsFor(operation, where);
+  const unknown = where !== void 0 && hits.length > 0 && hits.some((e) => !e.record);
+  return {
+    ...base,
+    expected: count,
+    actual: unknown ? "unknown" : hits.length,
+    passed: hits.length === count && !unknown,
+    evidence: { operation, eventSequences: hits.map((e) => e.sequence), evidenceGap: unknown }
+  };
 }
 var escape = (value) => value.replace(/~/g, "~0").replace(/\//g, "~1");
 
 // src/runtime/local.ts
 init_contracts();
-async function executeLocal(app, spec, signal, existingWorld) {
+async function executeLocal(app, spec, signal, existingWorld, seed) {
   if (spec.postgres || spec.redis) throw new Error("This world needs PostgreSQL or Redis. Use --runtime hosted or --runtime e2b, or prepare a workflow using HTTP twins only. No local containers are started.");
   signal?.throwIfAborted();
-  const world = existingWorld ?? new HttpWorld(spec), started = Date.now();
+  const world = existingWorld ?? new HttpWorld(spec, seed), started = Date.now();
   try {
     const credentials = existingWorld ? world.credentials : await world.start();
     const initialState = world.snapshot();
@@ -626,9 +1905,9 @@ async function executeLocal(app, spec, signal, existingWorld) {
       executionAbort.abort();
       kill();
     }, spec.timeoutSeconds * 1e3);
-    const completion = new Promise((resolve4, reject) => {
+    const completion = new Promise((resolve5, reject) => {
       child.once("error", reject);
-      child.once("close", resolve4);
+      child.once("close", resolve5);
     });
     let browser, background, executionError;
     let exitCode;
@@ -666,7 +1945,7 @@ async function executeLocal(app, spec, signal, existingWorld) {
     const assertions = world.assertions();
     const evaluation = evaluateState(spec, initialState, world.state, world.events);
     const status = world.unsupported.length || spec.fault && !world.faultTriggered ? "incomplete" : timedOut || exitCode !== 0 ? "error" : background?.passed === false || browser?.passed === false ? "failed" : evaluation.outcome === "passed" ? "passed" : "failed";
-    return { schema: "agenttwin/run-v1", name: spec.name, workflowId: spec.workflowId, status, browser, background, executionError, application: { command: spec.command, exitCode, timedOut, stdout, stderr }, assertions, evaluation, contracts: operationMatrix(spec), scenario: spec.scenario, infrastructureAssertions: [], fault: spec.fault ? { ...spec.fault, triggered: world.faultTriggered } : null, initialState, finalState: world.snapshot(), events: structuredClone(world.events), unsupported: [...world.unsupported], durationMs: Date.now() - started, coverage: "CLI Node execution with fresh in-process HTTP collections and advertised provider subsets. Optional Chromium browser steps and bounded collection-state background completion. Not a VM or network/filesystem isolation boundary. No production environment variables inherited; reviewed code can still access the host filesystem and network.", isolation: { kind: "process", productionCredentialsInherited: false, network: "host network; not isolated", rootFilesystem: "host-accessible; explicit files staged in temporary directory" } };
+    return { schema: "agenttwin/run-v1", name: spec.name, workflowId: spec.workflowId, status, browser, background, executionError, application: { command: spec.command, exitCode, timedOut, stdout, stderr }, assertions, evaluation, contracts: operationMatrix(spec), scenario: spec.scenario, infrastructureAssertions: [], fault: spec.fault ? { ...spec.fault, triggered: world.faultTriggered } : null, seed: world.seed, reproducibility: "Seed " + world.seed + " deterministically drives twin-side fault scheduling, latency jitter and test credentials. The seed does not control the application's own randomness, wall-clock behavior or threading; compare runs only over twin events and final state.", initialState, finalState: world.snapshot(), events: structuredClone(world.events), unsupported: [...world.unsupported], durationMs: Date.now() - started, coverage: "CLI Node execution with fresh in-process HTTP collections and advertised provider subsets. Optional Chromium browser steps and bounded collection-state background completion. Not a VM or network/filesystem isolation boundary. No production environment variables inherited; reviewed code can still access the host filesystem and network.", isolation: { kind: "process", productionCredentialsInherited: false, network: "host network; not isolated", rootFilesystem: "host-accessible; explicit files staged in temporary directory" } };
   } finally {
     if (existingWorld) world.quiesce();
     else await world.close();
@@ -674,8 +1953,28 @@ async function executeLocal(app, spec, signal, existingWorld) {
 }
 
 // src/runtime/spec.ts
+var ADAPTER_COLLECTIONS = {
+  slack: ["/messages", "/channels"],
+  stripe: ["/v1/customers", "/v1/payment_intents"],
+  github: ["/repos", "/issues", "/comments", "/pulls", "/check-runs"],
+  linear: ["/issues", "/projects", "/users", "/comments"],
+  notion: ["/pages", "/databases", "/blocks"],
+  hubspot: ["/crm/v3/objects/contacts", "/crm/v3/objects/companies", "/crm/v3/objects/deals", "/crm/v3/objects/tickets"],
+  shopify: ["/admin/products", "/admin/orders", "/admin/customers"],
+  datadog: ["/monitors", "/events", "/metrics"],
+  gmail: ["/gmail/v1/users/me/messages", "/gmail/v1/users/me/labels"],
+  "google-calendar": ["/calendar/v3/users/me/calendarList", "/calendar/v3/calendars/primary/events"],
+  gitlab: ["/api/v4/projects", "/api/v4/issues", "/api/v4/merge_requests", "/api/v4/merge_requests/notes"],
+  jira: ["/rest/api/3/issue", "/rest/api/3/issue/comments", "/rest/api/3/project"],
+  discord: ["/api/channels", "/api/channels/messages", "/api/guilds", "/api/guilds/members"],
+  twilio: ["/2010-04-01/Messages", "/2010-04-01/Calls"],
+  zendesk: ["/api/v2/tickets", "/api/v2/users", "/api/v2/organizations"]
+};
+var FAULT_TYPES = ["timeout-after-write", "blackhole", "server-error", "duplicate-write"];
+var PROPERTY_KINDS = ["unique-per-act", "no-loss", "effect-count"];
 var object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var namePattern = /^[a-z][a-z0-9_]{0,39}$/;
+var inRangeInt = (x, min, max) => Number.isInteger(x) && Number(x) >= min && Number(x) <= max;
 function parseWorld(value) {
   const invalid = (message) => {
     throw new Error(`Invalid world: ${message}`);
@@ -694,7 +1993,7 @@ function parseWorld(value) {
     if (!object(service) || typeof service.name !== "string" || !namePattern.test(service.name) || services.has(service.name)) invalid("service names must be unique lowercase identifiers");
     const item = service;
     if (!Array.isArray(item.collections) || !item.collections.length || item.collections.length > 20) invalid("each service needs 1\u201320 collections");
-    if (item.adapter !== void 0 && !["json-collection", "slack", "stripe"].includes(String(item.adapter))) invalid("unsupported service adapter");
+    if (item.adapter !== void 0 && !["json-collection", "slack", "stripe", "github", "linear", "notion", "hubspot", "shopify", "datadog", "gmail", "google-calendar", "gitlab", "jira", "discord", "twilio", "zendesk"].includes(String(item.adapter))) invalid("unsupported service adapter");
     const paths = /* @__PURE__ */ new Set();
     for (const entry of item.collections) {
       if (!object(entry) || typeof entry.path !== "string" || !/^\/[a-zA-Z0-9_/-]+$/.test(entry.path) || entry.path.includes("//") || paths.has(entry.path)) invalid("collection paths must be unique absolute HTTP paths");
@@ -702,8 +2001,8 @@ function parseWorld(value) {
       if (!Array.isArray(collection.seed) || collection.seed.length > 1e3 || !collection.seed.every(object)) invalid("seed must be an array of up to 1000 JSON records");
       paths.add(collection.path);
     }
-    if (item.adapter === "slack" && (!paths.has("/messages") || !paths.has("/channels") || paths.size !== 2)) invalid("slack adapter requires /messages and /channels collections");
-    if (item.adapter === "stripe" && (!paths.has("/v1/customers") || !paths.has("/v1/payment_intents") || paths.size !== 2)) invalid("stripe adapter requires /v1/customers and /v1/payment_intents collections");
+    const required = ADAPTER_COLLECTIONS[item.adapter];
+    if (required && (paths.size !== required.length || !required.every((p) => paths.has(p)))) invalid(`${item.adapter} adapter requires exactly ${required.join(", ")} collections`);
     services.set(item.name, paths);
   }
   const known = (entry) => typeof entry.service === "string" && typeof entry.path === "string" && services.get(entry.service)?.has(entry.path);
@@ -736,7 +2035,64 @@ function parseWorld(value) {
       if (!object(a) || typeof a.key !== "string" || !a.key || a.equals !== null && typeof a.equals !== "string") invalid("redis assertions require key and string/null equals");
     }
   }
-  if (v.fault !== void 0 && (!object(v.fault) || !known(v.fault) || v.fault.type !== "timeout-after-write" || !Number.isInteger(v.fault.delayMs) || Number(v.fault.delayMs) < 1 || Number(v.fault.delayMs) > 1e4)) invalid("fault requires an existing service/path and delayMs 1\u201310000");
+  if (v.faults !== void 0) {
+    if (!object(v.faults) || Object.keys(v.faults).length > 16) invalid("faults must contain at most 16 named fault presets");
+    for (const [name, fault] of Object.entries(v.faults)) {
+      if (!/^[a-z][a-z0-9_-]{0,63}$/.test(name) || ["none", "configured"].includes(name)) invalid("fault preset names must be lowercase identifiers; none and configured are reserved");
+      const { faults: _presets, ...base } = v;
+      parseWorld({ ...base, fault });
+      if (fault === void 0) invalid("fault presets require a fault definition");
+    }
+  }
+  if (v.fault !== void 0) {
+    if (!object(v.fault) || !known(v.fault) || !FAULT_TYPES.includes(v.fault.type)) invalid("fault requires an existing service/path and a supported type: timeout-after-write, blackhole, server-error or duplicate-write");
+    const f = v.fault;
+    const allowed = ["service", "path", "type"];
+    const count = f.count, windowMs = f.windowMs;
+    if (f.type === "timeout-after-write") {
+      if (!inRangeInt(f.delayMs, 1, 1e4)) invalid("timeout-after-write fault requires delayMs 1\u201310000; the delay is declared application-visible behavior, never seeded");
+      allowed.push("delayMs");
+    } else if (f.delayMs !== void 0) invalid(`${f.type} fault does not take delayMs`);
+    if (f.type === "server-error") {
+      if (!inRangeInt(count, 1, 100)) invalid("server-error fault requires count 1\u2013100 (how many matching requests are rejected)");
+      if (windowMs !== void 0 && !inRangeInt(windowMs, 0, 1e4)) invalid("server-error windowMs must be 0\u201310000 (the seeded upper delay before the rejection response)");
+      allowed.push("count", "windowMs");
+    } else {
+      if (!["blackhole", "duplicate-write"].includes(f.type) && windowMs !== void 0) invalid(`${f.type} fault does not take windowMs`);
+      if (["blackhole", "duplicate-write"].includes(f.type) && count !== void 0 && !inRangeInt(count, 1, 100)) invalid(`${f.type} fault count must be 1\u2013100`);
+      if (["blackhole", "duplicate-write"].includes(f.type)) allowed.push("count");
+    }
+    if (Object.keys(f).some((k) => !allowed.includes(k))) invalid(`unknown fault field for ${f.type}`);
+  }
+  if (v.properties !== void 0) {
+    if (!Array.isArray(v.properties) || !v.properties.length || v.properties.length > 50) invalid("properties must contain 1\u201350 named invariants");
+    for (const raw of v.properties) {
+      const p = raw;
+      if (!p || !known(p)) invalid("properties need existing service/path collections and closed kinds");
+      if (typeof p.id !== "string" || !namePattern.test(p.id)) invalid("property id must be a lowercase identifier");
+      if (policyIds.has(p.id)) invalid("property ids must be unique ids across the world's policies");
+      if (!PROPERTY_KINDS.includes(p.kind)) invalid(`unknown property kind: use one of ${PROPERTY_KINDS.join(", ")}`);
+      const params = object(p.params) ? p.params : {};
+      if (p.kind === "unique-per-act") {
+        const field = params.field;
+        if (typeof field !== "string" || !field || field.length > 64 || Object.keys(params).some((k) => k !== "field")) invalid(`property "${p.id}" (unique-per-act) requires params.field (a record field name), nothing else`);
+      } else if (p.kind === "no-loss") {
+        if (p.params !== void 0 && (!object(params) || !object(params.where) || Object.keys(params).some((k) => k !== "where"))) invalid(`property "${p.id}" (no-loss) takes only an optional params.where object`);
+      } else {
+        if (!object(params) || !inRangeInt(params.count, 0, 1e5)) invalid(`property "${p.id}" (effect-count) requires params.count 0\u2013100000`);
+        if (params.operation !== void 0 && !["write", "read", "replay"].includes(String(params.operation))) invalid(`property "${p.id}" (effect-count) operation must be write, read or replay`);
+        if (params.where !== void 0 && !object(params.where)) invalid(`property "${p.id}" (effect-count) params.where must be an object`);
+        if (Object.keys(params).some((k) => !["count", "operation", "where"].includes(k))) invalid(`property "${p.id}" (effect-count) takes only count, operation and where`);
+      }
+      policyIds.add(p.id);
+    }
+  }
+  if (v.latency !== void 0) {
+    const allowed = ["minMs", "maxMs"];
+    if (!object(v.latency) || Object.keys(v.latency).some((k) => !allowed.includes(k))) invalid("latency requires minMs and maxMs");
+    const l = v.latency;
+    if (!inRangeInt(l.minMs, 0, 1e4) || !inRangeInt(l.maxMs, 0, 1e4) || Number(l.minMs) > Number(l.maxMs)) invalid("latency requires minMs and maxMs in 0\u201310000 with minMs <= maxMs");
+  }
   if (v.browser !== void 0) {
     if (!object(v.browser) || typeof v.browser.baseUrl !== "string") invalid("browser requires baseUrl");
     const browser = v.browser;
@@ -759,20 +2115,20 @@ function parseWorld(value) {
     }
   }
   if (v.background !== void 0 && (!object(v.background) || !known(v.background) || !Number.isSafeInteger(v.background.count) || Number(v.background.count) < 0 || !Number.isInteger(v.background.timeoutMs) || Number(v.background.timeoutMs) < 1 || Number(v.background.timeoutMs) > Number(v.timeoutSeconds) * 1e3 || v.background.where !== void 0 && !object(v.background.where) || Object.keys(v.background).some((k) => !["service", "path", "count", "where", "timeoutMs"].includes(k)))) invalid("background requires a known collection, expected count, optional where, and bounded timeoutMs");
-  const keys = ["schema", "name", "workflowId", "files", "command", "timeoutSeconds", "browser", "background", "services", "assertions", "forbiddenEffects", "preservedState", "scenario", "postgres", "redis", "fault"];
+  const keys = ["schema", "name", "workflowId", "files", "command", "timeoutSeconds", "browser", "background", "services", "assertions", "forbiddenEffects", "preservedState", "properties", "scenario", "postgres", "redis", "fault", "faults", "latency"];
   if (Object.keys(v).some((k) => !keys.includes(k))) invalid("unknown world field");
   return v;
 }
 
 // src/runtime/scenarios.ts
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { mkdir, readFile, readdir, writeFile as writeFile2 } from "fs/promises";
 import { join as join2 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
 var identifier = /^[a-z][a-z0-9_]{0,39}$/;
 var object2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var sort = (v) => Array.isArray(v) ? v.map(sort) : object2(v) ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, sort(v[k])])) : v;
-var scenarioDigest = (scenario) => createHash("sha256").update(JSON.stringify(sort(scenario))).digest("hex");
+var scenarioDigest = (scenario) => createHash3("sha256").update(JSON.stringify(sort(scenario))).digest("hex");
 function parseScenario(value) {
   const fail = (detail) => {
     throw new Error(`Invalid scenario: ${detail}`);
@@ -795,8 +2151,8 @@ function parseScenario(value) {
     const services = /* @__PURE__ */ new Set();
     for (const ref of entity.refs) {
       if (!object2(ref) || typeof ref.service !== "string" || typeof ref.path !== "string" || !object2(ref.where) || !Object.keys(ref.where).length || Object.keys(ref).some((k) => !["service", "path", "where"].includes(k))) fail("entity reference needs service, path and a nonempty where selector");
-      const rows = scenario.services.find((s) => s.name === ref.service)?.collections.find((c) => c.path === ref.path)?.seed;
-      if (!rows || rows.filter((row) => Object.entries(ref.where).every(([k, v]) => isDeepStrictEqual4(row[k], v))).length !== 1) fail(`entity ${entity.id} reference must resolve to exactly one seeded record`);
+      const rows2 = scenario.services.find((s) => s.name === ref.service)?.collections.find((c) => c.path === ref.path)?.seed;
+      if (!rows2 || rows2.filter((row) => Object.entries(ref.where).every(([k, v]) => isDeepStrictEqual4(row[k], v))).length !== 1) fail(`entity ${entity.id} reference must resolve to exactly one seeded record`);
       services.add(ref.service);
     }
     if (services.size < 2) fail(`entity ${entity.id} must link at least two services`);
@@ -827,11 +2183,11 @@ function applyScenario(world, scenario) {
 init_contracts();
 
 // src/commands/run.ts
-import { mkdtemp as mkdtemp2, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4, realpath as realpath2, lstat, rm as rm3, copyFile } from "fs/promises";
+import { mkdtemp as mkdtemp2, mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5, realpath as realpath2, lstat, rm as rm3, copyFile } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { basename, dirname, isAbsolute, join as join6, relative, resolve as resolve2, sep } from "path";
+import { basename, dirname, isAbsolute, join as join7, relative as relative2, resolve as resolve3, sep } from "path";
 import { fileURLToPath } from "url";
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash5, randomUUID } from "crypto";
 
 // src/runtime/credentials.ts
 import { homedir } from "os";
@@ -872,6 +2228,11 @@ import { randomBytes as randomBytes2 } from "crypto";
 import { homedir as homedir2 } from "os";
 import { join as join5 } from "path";
 
+// src/runtime/matrix.ts
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join6, relative, resolve as resolve2 } from "path";
+
 // src/commands/run.ts
 async function stageApplication(root, files, destination) {
   const canonicalRoot = await realpath2(root);
@@ -879,16 +2240,16 @@ async function stageApplication(root, files, destination) {
   let bytes = 0;
   for (const file of files) {
     if (isAbsolute(file) || file.includes("\\") || file.split("/").some((p) => p === ".." || /^(\.env.*|\.git|\.ssh|\.aws|\.azure|\.config|\.npmrc|\.netrc|credentials.*)$/i.test(p)) || /\.(pem|key|p12|pfx)$/i.test(file)) throw new CliError(`Unsafe application file: ${file}`, { code: EXIT.USAGE });
-    const source = await realpath2(resolve2(canonicalRoot, file));
-    const rel = relative(canonicalRoot, source);
-    if (rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel) || source !== resolve2(canonicalRoot, file) || !(await lstat(source)).isFile()) throw new CliError(`Files must be regular files within the project, without symlinks: ${file}`, { code: EXIT.USAGE });
-    const contents = await readFile5(source);
+    const source = await realpath2(resolve3(canonicalRoot, file));
+    const rel = relative2(canonicalRoot, source);
+    if (rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel) || source !== resolve3(canonicalRoot, file) || !(await lstat(source)).isFile()) throw new CliError(`Files must be regular files within the project, without symlinks: ${file}`, { code: EXIT.USAGE });
+    const contents = await readFile6(source);
     bytes += contents.length;
     if (bytes > 20 * 1024 * 1024) throw new CliError("Application files exceed 20 MiB; supply a smaller built bundle", { code: EXIT.USAGE });
-    const target = join6(destination, file);
-    await mkdir3(dirname(target), { recursive: true });
-    await writeFile4(target, contents, { mode: 420 });
-    digests[file] = createHash2("sha256").update(contents).digest("hex");
+    const target = join7(destination, file);
+    await mkdir4(dirname(target), { recursive: true });
+    await writeFile5(target, contents, { mode: 420 });
+    digests[file] = createHash5("sha256").update(contents).digest("hex");
   }
   return digests;
 }
@@ -896,21 +2257,21 @@ async function stageApplication(root, files, destination) {
 // src/runtime/world-session.ts
 init_git();
 var uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
-var hash = (spec) => createHash3("sha256").update(JSON.stringify(spec)).digest("hex");
+var hash = (spec) => createHash6("sha256").update(JSON.stringify(spec)).digest("hex");
 function duration(value) {
   if (!Number.isInteger(value) || value < 1 || value > 86400) throw new Error("ttlSeconds must be 1\u201386400");
   return value;
 }
 async function persist(directory2, session) {
-  const temporary = join7(directory2, `${randomUUID2()}.tmp`);
-  await writeFile5(temporary, JSON.stringify(session, null, 2) + "\n", { mode: 384 });
-  await rename(temporary, join7(directory2, "session.json"));
+  const temporary = join8(directory2, `${randomUUID2()}.tmp`);
+  await writeFile6(temporary, JSON.stringify(session, null, 2) + "\n", { mode: 384 });
+  await rename(temporary, join8(directory2, "session.json"));
 }
 var view = ({ controlToken: _token, cwd: _cwd, file: _file, controlUrl: _control, ...session }) => session;
 async function serveWorldSession(directory2) {
-  const session = JSON.parse(await readFile6(join7(directory2, "session.json"), "utf8"));
+  const session = JSON.parse(await readFile7(join8(directory2, "session.json"), "utf8"));
   if (session.status !== "provisioning" || !uuid.test(session.id)) throw new Error("Session is not awaiting provisioning");
-  const spec = parseWorld(JSON.parse(await readFile6(join7(directory2, "world.json"), "utf8")));
+  const spec = parseWorld(JSON.parse(await readFile7(join8(directory2, "world.json"), "utf8")));
   const world = new HttpWorld(spec);
   let control;
   let timer;
@@ -935,8 +2296,8 @@ async function serveWorldSession(directory2) {
       session.status = status;
       session.credentials = void 0;
       await world.close();
-      if (control) await new Promise((resolve4) => {
-        control.close(() => resolve4());
+      if (control) await new Promise((resolve5) => {
+        control.close(() => resolve5());
         control.closeAllConnections();
       });
       await save();
@@ -1010,10 +2371,10 @@ async function serveWorldSession(directory2) {
           reply(200, { ...view(session), state: world.snapshot() });
           return;
         }
-        let current = parseWorld(JSON.parse(await readFile6(session.file, "utf8")));
+        let current = parseWorld(JSON.parse(await readFile7(session.file, "utf8")));
         if (session.scenario) current = applyScenario(current, await loadScenario(session.cwd, session.scenario));
         if (hash(current) !== hash(spec)) throw new Error("World specification or scenario changed; provision a new world. Source patches are allowed.");
-        const stage = await mkdtemp3(join7(tmpdir3(), "agenttwin-session-run-"));
+        const stage = await mkdtemp3(join8(tmpdir3(), "agenttwin-session-run-"));
         active = new AbortController();
         let result;
         try {
@@ -1029,15 +2390,15 @@ async function serveWorldSession(directory2) {
           const runId = randomUUID2();
           let project = "local-workspace";
           try {
-            project = JSON.parse(await readFile6(join7(session.cwd, ".agenttwin/inventory.json"), "utf8")).name ?? project;
+            project = JSON.parse(await readFile7(join8(session.cwd, ".agenttwin/inventory.json"), "utf8")).name ?? project;
           } catch {
           }
-          const receipt = { ...report, sourceDirectory: relative2(session.cwd, dirname2(session.file)).split(sep2).join("/"), runId, worldId: session.id, runtime: "local", project, git: await captureGit(session.cwd), createdAt: (/* @__PURE__ */ new Date()).toISOString(), sourceDigests, specDigest: hash(spec), provenance: "CLI-reported execution; not independently attested" };
-          const out = join7(session.cwd, ".agenttwin/runs", runId);
-          await mkdir4(out, { recursive: true, mode: 448 });
-          const evidencePath = join7(out, "run.json");
-          await writeFile5(evidencePath, JSON.stringify(receipt, null, 2) + "\n", { mode: 384 });
-          await writeFile5(join7(out, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
+          const receipt = { ...report, sourceDirectory: relative3(session.cwd, dirname2(session.file)).split(sep2).join("/"), runId, worldId: session.id, runtime: "local", project, git: await captureGit(session.cwd), createdAt: (/* @__PURE__ */ new Date()).toISOString(), sourceDigests, specDigest: hash(spec), provenance: "CLI-reported execution; not independently attested" };
+          const out = join8(session.cwd, ".agenttwin/runs", runId);
+          await mkdir5(out, { recursive: true, mode: 448 });
+          const evidencePath = join8(out, "run.json");
+          await writeFile6(evidencePath, JSON.stringify(receipt, null, 2) + "\n", { mode: 384 });
+          await writeFile6(join8(out, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
           session.lastRunId = runId;
           result = { ...receipt, evidencePath };
         } finally {
@@ -1056,11 +2417,11 @@ async function serveWorldSession(directory2) {
       }
     });
     control.requestTimeout = 1e4;
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       control.once("error", reject);
-      control.listen(0, "127.0.0.1", resolve4);
+      control.listen(0, "127.0.0.1", resolve5);
     });
-    const latest = JSON.parse(await readFile6(join7(directory2, "session.json"), "utf8"));
+    const latest = JSON.parse(await readFile7(join8(directory2, "session.json"), "utf8"));
     if (latest.status !== "provisioning") throw new Error("Provisioning was abandoned");
     session.controlUrl = `http://127.0.0.1:${control.address().port}`;
     if (stopping) throw new Error("World expired during provisioning");