agenttwin 0.3.5 → 0.3.7

package/dist/world-host.js

@@ -0,0 +1,1090 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/runtime/contracts.ts
+function operationMatrix(spec) {
+  return {
+    schema: "agenttwin/contracts-v1",
+    unsupported: { status: 501, marker: "X-AgentTwin-Unsupported", coverage: "incomplete", forwardedToProduction: false },
+    adapters: CONTRACTS,
+    services: spec?.services.map((s) => ({
+      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 })))
+    })) ?? []
+  };
+}
+var CONTRACTS;
+var init_contracts = __esm({
+  "src/runtime/contracts.ts"() {
+    "use strict";
+    CONTRACTS = {
+      "json-collection": {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token",
+        operations: [
+          { method: "GET", endpoint: "<collection path>", effect: "read", response: "{data: records}", errors: ["401 invalid_test_credential", "429 world_capacity"] },
+          { method: "POST", endpoint: "<collection path>", effect: "append", response: "201 record; 200 idempotency replay", errors: ["400 expected_json_object", "409 idempotency_conflict", "413 body_too_large", "429 world_capacity"] }
+        ],
+        limitations: ["Custom API contract, not a vendor replica", "No update/delete, pagination, OAuth, webhooks or schema validation", "Idempotency compares the exact parsed JSON serialization"]
+      },
+      stripe: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; official Stripe SDK configured with test endpoint",
+        operations: [
+          { method: "POST", endpoint: "/v1/customers", effect: "append customer", parameters: ["email", "name", "description"], errors: ["400 invalid parameters"] },
+          { method: "GET", endpoint: "/v1/customers[/<id>]", effect: "retrieve or list customers", parameters: ["limit", "starting_after"], errors: ["404 resource_missing", "400 invalid pagination"] },
+          { method: "POST", endpoint: "/v1/payment_intents", effect: "create test payment intent", parameters: ["amount", "currency", "customer", "payment_method", "confirm"], errors: ["400 invalid parameters", "400 resource_missing", "402 card_declined"] },
+          { method: "GET", endpoint: "/v1/payment_intents/<id>", effect: "retrieve intent", parameters: [], errors: ["404 resource_missing"] },
+          { method: "POST", endpoint: "/v1/payment_intents/<id>/confirm", effect: "test success or decline", parameters: ["payment_method"], errors: ["404 resource_missing", "400 unsupported test method", "402 card_declined"] }
+        ],
+        limitations: ["Bounded subset, not full Stripe parity; minimal object fields only; no real money", "Only pm_card_visa and pm_card_chargeDeclined test methods", "No webhooks, refunds, subscriptions, payment-method APIs, metadata, updates or deletes", "Customers list supports limit/starting_after; payment intent listing unsupported", "POST idempotency supported; reset clears records and keys; unsupported operations/parameters return 501 and make coverage incomplete"]
+      },
+      slack: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; no Slack OAuth",
+        operations: [
+          { method: "POST", endpoint: "/api/chat.postMessage", effect: "append /messages", parameters: ["channel", "text"], errors: ["channel_not_found", "no_text"] },
+          { method: "GET|POST", endpoint: "/api/conversations.history", effect: "read /messages", parameters: ["channel"], errors: ["channel_not_found"] },
+          { 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"]
+      }
+    };
+  }
+});
+
+// src/runtime/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+async function captureGit(cwd, previousHead) {
+  const exec = promisify(execFile);
+  const git = async (...args) => (await exec("git", args, { cwd, timeout: 5e3, maxBuffer: 1024 * 1024 })).stdout.trim();
+  try {
+    const head = await git("rev-parse", "HEAD");
+    const [branch, total, status, history] = await Promise.all([git("branch", "--show-current"), git("rev-list", "--count", "HEAD"), git("status", "--porcelain", "--untracked-files=no"), git("log", "--since=14 days ago", "-100", "--format=%H %cI")]);
+    let changed = await git("diff", "--name-only", "HEAD");
+    if (previousHead && /^[a-f0-9]{40,64}$/.test(previousHead) && previousHead !== head) {
+      try {
+        changed += "\n" + await git("diff", "--name-only", previousHead, head);
+      } catch {
+        previousHead = void 0;
+      }
+    }
+    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 };
+    }) : [], changedFiles: [...new Set(changed.split("\n").filter(Boolean))].slice(0, 1e3), ...previousHead ? { previousHead } : {} };
+  } catch {
+    return void 0;
+  }
+}
+var init_git = __esm({
+  "src/runtime/git.ts"() {
+    "use strict";
+  }
+});
+
+// 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 { 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";
+
+// src/runtime/request-source.ts
+import { mkdtemp, writeFile, rm, realpath } from "fs/promises";
+import { tmpdir } from "os";
+import { join, resolve } from "path";
+function parseRequestSource(raw, spec) {
+  if (typeof raw !== "string" || raw.length > 1024) return;
+  try {
+    const source = JSON.parse(raw);
+    if (!source || typeof source.file !== "string" || !spec.files.includes(source.file) || !Number.isSafeInteger(source.line) || source.line < 1 || source.line > 1e6 || !Number.isSafeInteger(source.column) || source.column < 1 || source.column > 1e6) return;
+    return { file: source.file, line: source.line, column: source.column, provenance: "application-reported" };
+  } catch {
+    return;
+  }
+}
+async function createRequestSourceHook(app, spec, credentials) {
+  const dir = await mkdtemp(join(tmpdir(), "agenttwin-source-hook-"));
+  const path = join(dir, "hook.cjs");
+  const config = { root: await realpath(resolve(app)), files: spec.files, origins: Object.values(credentials).map((c) => new URL(c.endpoint).origin) };
+  const hook = `const config=${JSON.stringify(config)};
+` + String.raw`
+const http=require('node:http'),https=require('node:https'),path=require('node:path'),{fileURLToPath}=require('node:url');
+const origins=new Set(config.origins),files=new Set(config.files);
+function source(){for(const frame of new Error().stack.split('\n').slice(2)){const match=frame.match(/(?:\(|\s)(file:\/\/[^\s)]+|\/[^\s)]+):(\d+):(\d+)\)?$/);if(!match)continue;let file;try{file=match[1].startsWith('file:')?fileURLToPath(match[1]):match[1];}catch{continue;}file=path.relative(config.root,file);if(files.has(file))return JSON.stringify({file,line:Number(match[2]),column:Number(match[3])});}}
+const originalFetch=globalThis.fetch;
+if(originalFetch)globalThis.fetch=function(input,init){let url;try{url=new URL(typeof input==='string'||input instanceof URL?input:input.url);}catch{return originalFetch(input,init);}if(!origins.has(url.origin))return originalFetch(input,init);const location=source();if(!location)return originalFetch(input,init);const headers=new Headers(init?.headers??input?.headers);headers.set('x-agenttwin-source',location);return originalFetch(input,{...init,headers});};
+for(const mod of [http,https])for(const method of ['request','get']){const original=mod[method];mod[method]=function(...args){let options,url,index;try{if(typeof args[0]==='string'||args[0] instanceof URL){url=new URL(args[0]);index=1;options=args[1]&&typeof args[1]==='object'?args[1]:{};}else{index=0;options=args[0]||{};url=new URL((options.protocol||(mod===https?'https:':'http:'))+'//'+(options.hostname||options.host||'localhost')+(options.port?':'+options.port:''));}}catch{return original.apply(this,args);}if(!origins.has(url.origin))return original.apply(this,args);const location=source();if(!location)return original.apply(this,args);const headers=Array.isArray(options.headers)?[...options.headers,'x-agenttwin-source',location]:{...options.headers,'x-agenttwin-source':location};const updated={...options,headers};if(index===1&&typeof args[1]==='function')args.splice(1,0,updated);else args[index]=updated;return original.apply(this,args);};}
+require('node:module').syncBuiltinESMExports();
+`;
+  await writeFile(path, hook, { mode: 384 });
+  return { path, close: () => rm(dir, { recursive: true, force: true }) };
+}
+
+// src/runtime/stripe-adapter.ts
+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 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 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;
+  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") {
+    if (row.status === "succeeded") return { status: 200, body: row, collection, operation: "replay" };
+    const payment = params.payment_method ?? row.payment_method;
+    if (payment !== "pm_card_visa" && payment !== "pm_card_chargeDeclined") return { ...error(400, "parameter_invalid", "Only pm_card_visa and pm_card_chargeDeclined are supported", "payment_method"), collection };
+    row.payment_method = payment;
+    row.status = payment === "pm_card_visa" ? "succeeded" : "requires_payment_method";
+    row.last_payment_error = payment === "pm_card_chargeDeclined" ? { code: "card_declined", decline_code: "generic_decline", message: "Your card was declined." } : null;
+    return { status: payment === "pm_card_chargeDeclined" ? 402 : 200, body: payment === "pm_card_chargeDeclined" ? { error: { type: "card_error", code: "card_declined", decline_code: "generic_decline", message: "Your card was declined.", payment_intent: structuredClone(row) } } : row, collection, record: structuredClone(row), operation: "write" };
+  }
+  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 };
+  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 });
+  } 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 };
+    if (typeof params.currency !== "string" || !/^[a-z]{3}$/.test(params.currency)) return { ...error(400, "parameter_invalid", "currency must be a lowercase three-letter code", "currency"), collection };
+    if (params.customer && !data["/v1/customers"].some((r) => r.id === params.customer)) return { ...error(400, "resource_missing", "No such customer", "customer"), collection };
+    if (params.payment_method !== void 0 && !["pm_card_visa", "pm_card_chargeDeclined"].includes(String(params.payment_method))) return { ...error(400, "parameter_invalid", "Unsupported test payment method", "payment_method"), collection };
+    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 });
+  }
+  if (rows.length >= 1e4) return { ...error(429, "world_capacity", "World record capacity reached"), collection };
+  rows.push(created);
+  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" };
+}
+
+// src/runtime/http-world.ts
+var HttpWorld = class {
+  constructor(spec) {
+    this.spec = spec;
+  }
+  spec;
+  events = [];
+  state = /* @__PURE__ */ Object.create(null);
+  credentials = /* @__PURE__ */ Object.create(null);
+  unsupported = [];
+  servers = [];
+  timers = /* @__PURE__ */ new Set();
+  fired = false;
+  epoch = 0;
+  replayKeys = /* @__PURE__ */ new Map();
+  sourceContext = new AsyncLocalStorage();
+  record(service, operation, path, detail, record) {
+    if (this.events.length >= 5e4) return;
+    const source = this.sourceContext.getStore();
+    this.events.push({ sequence: this.events.length + 1, service, operation, path, detail, ...record ? { record: structuredClone(record) } : {}, ...source ? { source } : {} });
+  }
+  rejectUnsupported(service, method, path, detail) {
+    this.unsupported.push(`${service}: ${method} ${path}: ${detail}`);
+    this.record(service, "unsupported", path, detail);
+  }
+  async start() {
+    if (this.servers.length) throw new Error("World is already started");
+    for (const service of this.spec.services) {
+      const token = `at_world_${randomBytes(24).toString("hex")}`;
+      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 server = createServer((req, res) => this.sourceContext.run(parseRequestSource(req.headers["x-agenttwin-source"], this.spec), async () => {
+        const epoch = this.epoch;
+        const send = (code, body) => {
+          if (!res.destroyed) {
+            res.writeHead(code, { "content-type": "application/json", ...code === 501 ? { "X-AgentTwin-Unsupported": "true" } : {} });
+            res.end(JSON.stringify(body));
+          }
+        };
+        try {
+          if (req.headers.authorization !== `Bearer ${token}`) {
+            this.record(service.name, "auth-denied", req.url ?? "", "invalid test credential");
+            send(401, { error: "invalid_test_credential" });
+            return;
+          }
+          if (this.events.length >= 5e4 || this.unsupported.length >= 1e3) {
+            send(429, { error: "world_capacity" });
+            return;
+          }
+          const url = new URL(req.url ?? "/", "http://localhost");
+          let path = url.pathname;
+          const slack = service.adapter === "slack";
+          const slackMethod = path.replace(/^\/api\//, "");
+          let payload;
+          if (req.method === "POST") {
+            const chunks = [];
+            let bytes = 0;
+            for await (const chunk of req) {
+              bytes += chunk.length;
+              if (bytes > 1024 * 1024) {
+                send(413, { error: "body_too_large" });
+                return;
+              }
+              chunks.push(Buffer.from(chunk));
+            }
+            const text = Buffer.concat(chunks).toString("utf8");
+            let parsed;
+            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" });
+              return;
+            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+              send(400, { error: "expected_json_object" });
+              return;
+            }
+            payload = parsed;
+          }
+          if (epoch !== this.epoch) {
+            send(409, { error: "world_reset" });
+            return;
+          }
+          if (service.adapter === "stripe") {
+            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;
+            const signature2 = JSON.stringify(params);
+            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" } });
+                return;
+              }
+              this.record(service.name, "replay", path, "same-key response replay", previous2.record);
+              send(200, previous2.record);
+              return;
+            }
+            const result = 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 });
+              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) {
+              this.fired = true;
+              this.record(service.name, "fault", result.collection, `write committed; response delayed ${fault2.delayMs}ms`);
+              const timer = setTimeout(() => {
+                this.timers.delete(timer);
+                send(result.status, result.body);
+              }, fault2.delayMs);
+              this.timers.add(timer);
+            } else send(result.status, result.body);
+            return;
+          }
+          if (slack) {
+            const params = payload ?? Object.fromEntries(url.searchParams);
+            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 });
+              return;
+            }
+            if (slackMethod === "chat.postMessage" && req.method === "POST") path = "/messages";
+            else if (slackMethod === "conversations.history" && ["GET", "POST"].includes(req.method ?? "")) path = "/messages";
+            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 });
+              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 });
+            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: "" } });
+            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] });
+            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" });
+              return;
+            }
+            if (typeof message.text !== "string" || !message.text) {
+              send(200, { ok: false, error: "no_text" });
+              return;
+            }
+          }
+          if (data[path].length >= 1e4 || this.events.length >= 5e4) {
+            send(429, { error: "world_capacity" });
+            return;
+          }
+          const keyHeader = slack ? void 0 : req.headers["idempotency-key"];
+          const key = typeof keyHeader === "string" ? `${path}:${keyHeader}` : void 0;
+          const signature = JSON.stringify(body);
+          const previous = key ? keys.get(key) : void 0;
+          if (previous) {
+            if (previous.body !== signature) {
+              send(409, { error: "idempotency_conflict" });
+              return;
+            }
+            this.record(service.name, "replay", path, "same-key response replay", previous.record);
+            send(200, previous.record);
+            return;
+          }
+          let index = data[path].length + 1;
+          while (data[path].some((r) => r.id === `${service.name}_${index}`)) index++;
+          const row = { ...body, id: `${service.name}_${index}` };
+          if (slack) row.ts = `${index}.000001`;
+          const reply = slack ? { ok: true, channel: row.channel, ts: row.ts, message: row } : row;
+          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) {
+            this.fired = true;
+            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);
+            }, fault.delayMs);
+            this.timers.add(timer);
+          } else send(slack ? 200 : 201, reply);
+        } catch {
+          send(500, { error: "world_request_error" });
+        }
+      }));
+      server.requestTimeout = 1e4;
+      await new Promise((resolve4, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", resolve4);
+      });
+      this.servers.push(server);
+      this.credentials[service.name] = { endpoint: `http://127.0.0.1:${server.address().port}`, token };
+    }
+    return this.credentials;
+  }
+  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 };
+    });
+  }
+  get faultTriggered() {
+    return this.fired;
+  }
+  snapshot() {
+    return structuredClone(this.state);
+  }
+  quiesce() {
+    this.epoch++;
+    for (const server of this.servers) server.closeAllConnections();
+    for (const timer of this.timers) clearTimeout(timer);
+    this.timers.clear();
+  }
+  reset() {
+    this.quiesce();
+    for (const service of this.spec.services) {
+      for (const collection of service.collections) this.state[service.name][collection.path] = structuredClone(collection.seed);
+      this.replayKeys.get(service.name)?.clear();
+    }
+    this.events.length = 0;
+    this.unsupported.length = 0;
+    this.fired = false;
+    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());
+      server.closeAllConnections();
+    })));
+    this.servers.length = 0;
+  }
+};
+
+// src/runtime/browser-execution.ts
+import { chromium } from "playwright";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+async function browserExecution(spec, world, signal) {
+  signal?.throwIfAborted();
+  const recipe = spec.browser;
+  const browser = await chromium.launch({ headless: true, timeout: spec.timeoutSeconds * 1e3, ...process.env.AGENTTWIN_CHROMIUM_EXECUTABLE_PATH ? { executablePath: process.env.AGENTTWIN_CHROMIUM_EXECUTABLE_PATH } : {} });
+  const abort = () => {
+    void browser.close().catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    signal?.throwIfAborted();
+    const context = await browser.newContext({ serviceWorkers: "block", viewport: { width: 1280, height: 720 } });
+    const origins = /* @__PURE__ */ new Set([new URL(recipe.baseUrl).origin, ...Object.values(world.credentials).map((c) => new URL(c.endpoint).origin)]);
+    const blocked = /* @__PURE__ */ new Set();
+    await context.route("**/*", (route) => {
+      const origin = new URL(route.request().url()).origin;
+      if (origins.has(origin)) return route.continue();
+      if (blocked.size < 100) blocked.add(origin);
+      return route.abort("blockedbyclient");
+    });
+    const page = await context.newPage();
+    page.setDefaultTimeout(Math.min(spec.timeoutSeconds * 500, 1e4));
+    const deadline = Date.now() + Math.min(spec.timeoutSeconds * 1e3, 1e4);
+    while (true) {
+      signal?.throwIfAborted();
+      try {
+        const r = await fetch(recipe.baseUrl, { signal: AbortSignal.timeout(300) });
+        if (r.ok) break;
+      } catch {
+      }
+      if (Date.now() > deadline) throw new Error("Application browser readiness timed out");
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    const steps = [];
+    let error;
+    for (const step of recipe.steps) {
+      signal?.throwIfAborted();
+      try {
+        if (step.action === "goto") await page.goto(new URL(step.path, recipe.baseUrl).href);
+        else if (step.action === "click") await page.locator(step.selector).click();
+        else if (step.action === "fill") await page.locator(step.selector).fill(step.value);
+        else await page.locator(step.selector).filter({ hasText: step.text }).waitFor({ state: "visible" });
+        steps.push({ action: step.action, passed: true });
+      } catch (cause) {
+        error = cause instanceof Error ? cause.message : String(cause);
+        for (const s of recipe.steps) if (s.action === "fill" && s.value) error = error.split(s.value).join("[input]");
+        steps.push({ action: step.action, passed: false });
+        break;
+      }
+    }
+    let screenshot;
+    try {
+      const bytes = await page.screenshot({ type: "jpeg", quality: 65 });
+      if (bytes.length <= 768 * 1024) screenshot = { mimeType: "image/jpeg", base64: bytes.toString("base64") };
+    } catch {
+    }
+    for (const origin of blocked) world.unsupported.push(`browser: blocked unmodeled request origin ${origin}`);
+    return { engine: "playwright-chromium", steps, passed: !error, error, blockedOrigins: [...blocked], screenshot };
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    await browser.close();
+  }
+}
+async function waitBackground(spec, world, signal) {
+  const check = spec.background, deadline = Date.now() + check.timeoutMs;
+  while (true) {
+    signal?.throwIfAborted();
+    const actual = world.state[check.service][check.path].filter((row) => !check.where || Object.entries(check.where).every(([k, v]) => isDeepStrictEqual2(row[k], v))).length;
+    if (actual === check.count) return { ...check, actual, passed: true };
+    if (Date.now() >= deadline) return { ...check, actual, passed: false };
+    await new Promise((r) => setTimeout(r, 25));
+  }
+}
+
+// src/runtime/local.ts
+import { spawn } from "child_process";
+
+// src/runtime/evaluation.ts
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+var matches = (row, where) => !where || Object.entries(where).every(([k, v]) => isDeepStrictEqual3(row[k], v));
+function evaluateState(spec, initial, final, events) {
+  const checks = spec.assertions.map((a, index) => {
+    const before = initial[a.service]?.[a.path];
+    const after = final[a.service]?.[a.path];
+    const actual = after?.filter((row) => matches(row, a.where)).length;
+    return {
+      id: `assertion_${index + 1}`,
+      kind: "required-outcome",
+      service: a.service,
+      path: a.path,
+      passed: actual === a.count,
+      expected: a.count,
+      actual: actual ?? null,
+      evidence: {
+        initial: `/initialState/${escape(a.service)}/${escape(a.path)}`,
+        final: `/finalState/${escape(a.service)}/${escape(a.path)}`,
+        beforeCount: before?.filter((row) => matches(row, a.where)).length ?? null,
+        eventSequences: events.filter((e) => e.service === a.service && e.path === a.path).map((e) => e.sequence)
+      }
+    };
+  });
+  const forbidden = (spec.forbiddenEffects ?? []).map((policy) => {
+    const hits = events.filter((e) => e.service === policy.service && e.path === policy.path && e.operation === policy.operation && (!policy.where || e.record !== void 0 && matches(e.record, policy.where)));
+    const unknown = events.some((e) => e.service === policy.service && e.path === policy.path && e.operation === policy.operation && policy.where && !e.record);
+    return {
+      id: policy.id,
+      kind: "forbidden-effect",
+      service: policy.service,
+      path: policy.path,
+      passed: hits.length === 0 && !unknown,
+      expected: 0,
+      actual: hits.length,
+      evidence: { eventSequences: hits.map((e) => e.sequence), evidenceGap: unknown }
+    };
+  });
+  const preserved = (spec.preservedState ?? []).map((policy) => {
+    const before = initial[policy.service]?.[policy.path];
+    const after = final[policy.service]?.[policy.path];
+    const passed = !!before && !!after && isDeepStrictEqual3(before.filter((row) => matches(row, policy.where)), after.filter((row) => matches(row, policy.where)));
+    return {
+      id: policy.id,
+      kind: "preserved-state",
+      service: policy.service,
+      path: policy.path,
+      passed,
+      expected: "unchanged",
+      actual: passed ? "unchanged" : "changed or missing",
+      evidence: { initial: `/initialState/${escape(policy.service)}/${escape(policy.path)}`, final: `/finalState/${escape(policy.service)}/${escape(policy.path)}` }
+    };
+  });
+  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] };
+}
+var escape = (value) => value.replace(/~/g, "~0").replace(/\//g, "~1");
+
+// src/runtime/local.ts
+init_contracts();
+async function executeLocal(app, spec, signal, existingWorld) {
+  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();
+  try {
+    const credentials = existingWorld ? world.credentials : await world.start();
+    const initialState = world.snapshot();
+    const env = { PATH: process.env.PATH ?? "", NODE_ENV: "test" };
+    for (const [name, c] of Object.entries(credentials)) {
+      env[`AGENTTWIN_${name.toUpperCase()}_URL`] = c.endpoint;
+      env[`AGENTTWIN_${name.toUpperCase()}_TOKEN`] = c.token;
+    }
+    let stdout = "", stderr = "", timedOut = false;
+    const hook = await createRequestSourceHook(app, spec, credentials);
+    const child = spawn(process.execPath, ["--require", hook.path, ...spec.command.slice(1)], { cwd: app, env, stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32" });
+    child.stdout.on("data", (b) => {
+      stdout = (stdout + b.toString()).slice(-65536);
+    });
+    child.stderr.on("data", (b) => {
+      stderr = (stderr + b.toString()).slice(-65536);
+    });
+    const kill = () => {
+      if (child.pid) {
+        try {
+          process.platform === "win32" ? child.kill("SIGKILL") : process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    };
+    const executionAbort = new AbortController();
+    const abort = () => {
+      executionAbort.abort();
+      kill();
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      executionAbort.abort();
+      kill();
+    }, spec.timeoutSeconds * 1e3);
+    const completion = new Promise((resolve4, reject) => {
+      child.once("error", reject);
+      child.once("close", resolve4);
+    });
+    let browser, background, executionError;
+    let exitCode;
+    try {
+      if (spec.browser || spec.background) {
+        const work = (async () => {
+          if (spec.browser) browser = await browserExecution(spec, world, executionAbort.signal);
+          if (spec.background) background = await waitBackground(spec, world, executionAbort.signal);
+          return 0;
+        })();
+        exitCode = await Promise.race([work, completion.then((code) => {
+          if (!spec.browser && code === 0) return work;
+          throw new Error(`Application exited before browser/background completion (${code})`);
+        })]);
+      } else exitCode = await completion;
+    } catch (error) {
+      executionError = error instanceof Error ? error.message : String(error);
+      exitCode = 1;
+    } finally {
+      executionAbort.abort();
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      kill();
+      await completion.catch(() => {
+      });
+      await hook.close();
+    }
+    signal?.throwIfAborted();
+    if (existingWorld) world.quiesce();
+    else await world.close();
+    for (const c of Object.values(credentials)) {
+      stdout = stdout.split(c.token).join("[test-token]");
+      stderr = stderr.split(c.token).join("[test-token]");
+    }
+    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" } };
+  } finally {
+    if (existingWorld) world.quiesce();
+    else await world.close();
+  }
+}
+
+// src/runtime/spec.ts
+var object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var namePattern = /^[a-z][a-z0-9_]{0,39}$/;
+function parseWorld(value) {
+  const invalid = (message) => {
+    throw new Error(`Invalid world: ${message}`);
+  };
+  if (!object(value) || value.schema !== "agenttwin/world-v1") invalid("schema must be agenttwin/world-v1");
+  const v = value;
+  if (typeof v.name !== "string" || !namePattern.test(v.name)) invalid("name must be lowercase letters, digits or underscores");
+  if (!Array.isArray(v.files) || !v.files.length || v.files.length > 100 || !v.files.every((f) => typeof f === "string" && f.length > 0)) invalid("files must explicitly list 1\u2013100 application files");
+  if (new Set(v.files).size !== v.files.length) invalid("files must be unique");
+  if (!Array.isArray(v.command) || !v.command.length || !v.command.every((c) => typeof c === "string" && c.length > 0) || v.command[0] !== "node") invalid("command must be an argv array starting with node; supply a bundled Node application");
+  if (!Number.isInteger(v.timeoutSeconds) || Number(v.timeoutSeconds) < 1 || Number(v.timeoutSeconds) > 300) invalid("timeoutSeconds must be 1\u2013300");
+  if (v.workflowId !== void 0 && (typeof v.workflowId !== "string" || !v.workflowId)) invalid("workflowId must be a nonempty string");
+  if (!Array.isArray(v.services) || !v.services.length || v.services.length > 10) invalid("services must contain 1\u201310 HTTP services");
+  const services = /* @__PURE__ */ new Map();
+  for (const service of v.services) {
+    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");
+    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");
+      const collection = entry;
+      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");
+    services.set(item.name, paths);
+  }
+  const known = (entry) => typeof entry.service === "string" && typeof entry.path === "string" && services.get(entry.service)?.has(entry.path);
+  if (!Array.isArray(v.assertions) || !v.assertions.length || v.assertions.length > 100) invalid("at least one final-state assertion is required (maximum 100)");
+  for (const assertion of v.assertions) {
+    if (!object(assertion) || !known(assertion) || !Number.isSafeInteger(assertion.count) || Number(assertion.count) < 0 || assertion.where !== void 0 && !object(assertion.where)) invalid("assertions need an existing service/path, nonnegative count, and optional where object");
+  }
+  const policyIds = /* @__PURE__ */ new Set();
+  for (const field of ["forbiddenEffects", "preservedState"]) {
+    if (v[field] === void 0) continue;
+    if (!Array.isArray(v[field]) || v[field].length > 100) invalid(`${field} must contain at most 100 checks`);
+    for (const entry of v[field]) {
+      if (!object(entry) || typeof entry.id !== "string" || !namePattern.test(entry.id) || policyIds.has(entry.id) || !known(entry) || entry.where !== void 0 && !object(entry.where)) invalid(`${field} requires unique ids, known collections and an optional where object`);
+      const item = entry;
+      if (field === "forbiddenEffects" && !["write", "read", "replay"].includes(String(item.operation))) invalid("forbiddenEffects operation must be write, read or replay");
+      if (Object.keys(item).some((k) => !["id", "service", "path", "where", ...field === "forbiddenEffects" ? ["operation"] : []].includes(k))) invalid(`unknown ${field} field`);
+      policyIds.add(item.id);
+    }
+  }
+  if (v.scenario !== void 0 && (!object(v.scenario) || typeof v.scenario.id !== "string" || !namePattern.test(v.scenario.id) || !Number.isSafeInteger(v.scenario.version) || Number(v.scenario.version) < 1 || typeof v.scenario.digest !== "string" || !/^[a-f0-9]{64}$/.test(v.scenario.digest) || Object.keys(v.scenario).some((k) => !["id", "version", "digest"].includes(k)))) invalid("scenario requires id, positive version and SHA-256 digest");
+  if (v.postgres !== void 0) {
+    if (!object(v.postgres) || v.postgres.seedFile !== void 0 && !v.files.includes(String(v.postgres.seedFile)) || !Array.isArray(v.postgres.assertions) || !v.postgres.assertions.length || v.postgres.assertions.length > 100) invalid("postgres requires assertions and seedFile must be listed in files");
+    for (const a of v.postgres.assertions) {
+      if (!object(a) || typeof a.query !== "string" || !/^select\s/i.test(a.query) || a.query.includes(";") || !Array.isArray(a.equals) || !a.equals.every(object)) invalid("postgres assertions require a SELECT query without semicolons and an equals array");
+    }
+  }
+  if (v.redis !== void 0) {
+    if (!object(v.redis) || !Array.isArray(v.redis.assertions) || !v.redis.assertions.length || v.redis.assertions.length > 100) invalid("redis requires assertions");
+    for (const a of v.redis.assertions) {
+      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.browser !== void 0) {
+    if (!object(v.browser) || typeof v.browser.baseUrl !== "string") invalid("browser requires baseUrl");
+    const browser = v.browser;
+    let u;
+    try {
+      u = new URL(String(v.browser.baseUrl));
+    } catch {
+      invalid("browser baseUrl must be a loopback HTTP URL");
+    }
+    if (u.protocol !== "http:" || u.hostname !== "127.0.0.1" || !u.port || u.username || u.password || u.pathname !== "/" || u.search || u.hash) invalid("browser baseUrl must be http://127.0.0.1:<port>");
+    if (!Array.isArray(browser.steps) || !browser.steps.length || browser.steps.length > 100 || Object.keys(browser).some((k) => !["baseUrl", "steps"].includes(k))) invalid("browser needs 1\u2013100 steps");
+    for (const raw of browser.steps) {
+      const step = raw;
+      if (!object(step) || !["goto", "click", "fill", "expectText"].includes(String(step.action))) invalid("unsupported browser action");
+      if (step.action === "goto") {
+        if (typeof step.path !== "string" || !step.path.startsWith("/") || step.path.startsWith("//") || step.path.includes("\\") || Object.keys(step).some((k) => !["action", "path"].includes(k))) invalid("goto requires a relative application path");
+      } else {
+        if (typeof step.selector !== "string" || !step.selector || step.action === "fill" && typeof step.value !== "string" || step.action === "expectText" && typeof step.text !== "string" || Object.keys(step).some((k) => !["action", "selector", ...step.action === "fill" ? ["value"] : step.action === "expectText" ? ["text"] : []].includes(k))) invalid("invalid browser selector/action parameters");
+      }
+    }
+  }
+  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"];
+  if (Object.keys(v).some((k) => !keys.includes(k))) invalid("unknown world field");
+  return v;
+}
+
+// src/runtime/scenarios.ts
+import { createHash } 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");
+function parseScenario(value) {
+  const fail = (detail) => {
+    throw new Error(`Invalid scenario: ${detail}`);
+  };
+  if (!object2(value) || value.schema !== "agenttwin/scenario-v1" || typeof value.id !== "string" || !identifier.test(value.id) || !Number.isSafeInteger(value.version) || Number(value.version) < 1 || typeof value.description !== "string" || value.description.length > 2e3 || !Array.isArray(value.services) || !Array.isArray(value.entities) || value.entities.length > 100 || Object.keys(value).some((k) => !["schema", "id", "version", "description", "services", "entities"].includes(k))) fail("schema, id, version, description, services and entities are required");
+  const scenario = value;
+  parseWorld({
+    schema: "agenttwin/world-v1",
+    name: scenario.id,
+    files: ["app.mjs"],
+    command: ["node", "app.mjs"],
+    timeoutSeconds: 1,
+    services: scenario.services,
+    assertions: [{ service: scenario.services[0]?.name, path: scenario.services[0]?.collections?.[0]?.path, count: 0 }]
+  });
+  const ids = /* @__PURE__ */ new Set();
+  for (const entity of scenario.entities) {
+    if (!object2(entity) || typeof entity.id !== "string" || !identifier.test(entity.id) || ids.has(entity.id) || !Array.isArray(entity.refs) || entity.refs.length < 2 || entity.refs.length > 20 || Object.keys(entity).some((k) => !["id", "refs"].includes(k))) fail("entities need unique ids and 2\u201320 cross-service references");
+    ids.add(entity.id);
+    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`);
+      services.add(ref.service);
+    }
+    if (services.size < 2) fail(`entity ${entity.id} must link at least two services`);
+  }
+  return structuredClone(scenario);
+}
+function reference(ref) {
+  const match = /^([a-z][a-z0-9_]{0,39})@([1-9][0-9]*)$/.exec(ref);
+  if (!match || !Number.isSafeInteger(Number(match[2]))) throw new Error("Scenario reference must be id@version");
+  return { id: match[1], version: Number(match[2]) };
+}
+async function loadScenario(cwd, ref) {
+  const { id, version } = reference(ref);
+  const path = join2(cwd, ".agenttwin/scenarios", id, `${version}.json`);
+  const bytes = await readFile(path);
+  if (bytes.length > 2 * 1024 * 1024) throw new Error("Scenario exceeds 2 MiB");
+  const scenario = parseScenario(JSON.parse(bytes.toString()));
+  if (scenario.id !== id || scenario.version !== version) throw new Error("Scenario identity does not match its stored version");
+  return scenario;
+}
+function applyScenario(world, scenario) {
+  const shape = (services) => services.map((s) => ({ name: s.name, adapter: s.adapter ?? "json-collection", paths: s.collections.map((c) => c.path).sort() })).sort((a, b) => a.name.localeCompare(b.name));
+  if (!isDeepStrictEqual4(shape(world.services), shape(scenario.services))) throw new Error("Scenario services, adapters and collections must exactly match the world");
+  return parseWorld({ ...world, services: structuredClone(scenario.services), scenario: { id: scenario.id, version: scenario.version, digest: scenarioDigest(scenario) } });
+}
+
+// src/runtime/world-session.ts
+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 { tmpdir as tmpdir2 } from "os";
+import { basename, dirname, isAbsolute, join as join6, relative, resolve as resolve2, sep } from "path";
+import { fileURLToPath } from "url";
+import { createHash as createHash2, randomUUID } from "crypto";
+
+// src/runtime/credentials.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { readFile as readFile2, mkdir as mkdir2, writeFile as writeFile3, chmod, rm as rm2 } from "fs/promises";
+
+// src/runtime/remote.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/lib/exit.ts
+var EXIT = {
+  OK: 0,
+  ERROR: 1,
+  BLOCKED: 2,
+  USAGE: 3
+};
+var CliError = class extends Error {
+  code;
+  action;
+  resume;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "CliError";
+    this.code = opts.code ?? EXIT.ERROR;
+    this.action = opts.action;
+    this.resume = opts.resume;
+  }
+};
+
+// src/commands/run.ts
+init_git();
+
+// src/runtime/e2b.ts
+import { Sandbox } from "e2b";
+import { readFile as readFile4 } from "fs/promises";
+import { randomBytes as randomBytes2 } from "crypto";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+
+// src/commands/run.ts
+async function stageApplication(root, files, destination) {
+  const canonicalRoot = await realpath2(root);
+  const digests = {};
+  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);
+    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");
+  }
+  return digests;
+}
+
+// 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");
+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"));
+}
+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"));
+  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 world = new HttpWorld(spec);
+  let control;
+  let timer;
+  let active;
+  let busy = false;
+  let stopping = false;
+  let shutdownPromise;
+  let saving = Promise.resolve();
+  const save = () => {
+    const snapshot = { ...session };
+    const next = saving.catch(() => {
+    }).then(() => persist(directory2, snapshot));
+    saving = next;
+    return next;
+  };
+  const shutdown = (status) => {
+    if (shutdownPromise) return shutdownPromise;
+    stopping = true;
+    clearTimeout(timer);
+    active?.abort();
+    shutdownPromise = (async () => {
+      session.status = status;
+      session.credentials = void 0;
+      await world.close();
+      if (control) await new Promise((resolve4) => {
+        control.close(() => resolve4());
+        control.closeAllConnections();
+      });
+      await save();
+    })();
+    return shutdownPromise;
+  };
+  const arm = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      void shutdown("expired");
+    }, Math.max(1, Date.parse(session.expiresAt) - Date.now()));
+  };
+  try {
+    session.credentials = await world.start();
+    control = createServer2(async (req, res) => {
+      const reply = (status, value) => {
+        if (!res.destroyed) {
+          res.writeHead(status, { "content-type": "application/json" });
+          res.end(JSON.stringify(value));
+        }
+      };
+      if (req.headers.origin || req.headers.authorization !== `Bearer ${session.controlToken}`) {
+        reply(401, { error: "Unauthorized world control request" });
+        return;
+      }
+      if (stopping || Date.now() >= Date.parse(session.expiresAt)) {
+        reply(410, { error: "World expired or terminated" });
+        void shutdown("expired");
+        return;
+      }
+      const action = req.url?.slice(1);
+      if (action === "status" && req.method === "GET") {
+        reply(200, { ...view(session), contracts: operationMatrix(spec) });
+        return;
+      }
+      if (req.method !== "POST" || !["reset", "extend", "run", "teardown"].includes(action ?? "")) {
+        reply(404, { error: "Unknown world control operation" });
+        return;
+      }
+      if (busy && action !== "teardown") {
+        reply(409, { error: "World is busy; wait for the active operation to finish" });
+        return;
+      }
+      busy = true;
+      try {
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of req) {
+          bytes += chunk.length;
+          if (bytes > 8192) throw new Error("Control request exceeds 8 KiB");
+          chunks.push(Buffer.from(chunk));
+        }
+        const input = JSON.parse(Buffer.concat(chunks).toString() || "{}");
+        if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((k) => action !== "extend" || k !== "ttlSeconds")) throw new Error("Unknown control parameters");
+        if (action === "teardown") {
+          reply(200, { id: session.id, status: "terminated" });
+          setImmediate(() => {
+            void shutdown("terminated");
+          });
+          return;
+        }
+        if (action === "extend") {
+          session.expiresAt = new Date(Date.now() + duration(Number(input.ttlSeconds ?? 3600)) * 1e3).toISOString();
+          await save();
+          if (!stopping) arm();
+          reply(200, view(session));
+          return;
+        }
+        if (action === "reset") {
+          world.reset();
+          reply(200, { ...view(session), state: world.snapshot() });
+          return;
+        }
+        let current = parseWorld(JSON.parse(await readFile6(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-"));
+        active = new AbortController();
+        let result;
+        try {
+          if (stopping) throw new Error("World expired during execution");
+          session.status = "running";
+          await save();
+          active.signal.throwIfAborted();
+          const sourceDigests = await stageApplication(dirname2(session.file), spec.files, stage);
+          active.signal.throwIfAborted();
+          world.reset();
+          const report = await executeLocal(stage, spec, active.signal, world);
+          if (stopping) throw new Error("World expired during execution");
+          const runId = randomUUID2();
+          let project = "local-workspace";
+          try {
+            project = JSON.parse(await readFile6(join7(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 });
+          session.lastRunId = runId;
+          result = { ...receipt, evidencePath };
+        } finally {
+          active = void 0;
+          await rm4(stage, { recursive: true, force: true });
+          if (!stopping) {
+            session.status = "ready";
+            await save();
+          }
+        }
+        reply(200, result);
+      } catch (error) {
+        reply(400, { error: error instanceof Error ? error.message : "World operation failed" });
+      } finally {
+        busy = false;
+      }
+    });
+    control.requestTimeout = 1e4;
+    await new Promise((resolve4, reject) => {
+      control.once("error", reject);
+      control.listen(0, "127.0.0.1", resolve4);
+    });
+    const latest = JSON.parse(await readFile6(join7(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");
+    session.status = "ready";
+    await save();
+    if (!stopping) arm();
+    return { session: view(session), close: () => shutdown("terminated") };
+  } catch (error) {
+    session.error = error instanceof Error ? error.message : "Provisioning failed";
+    await shutdown("failed");
+    throw error;
+  }
+}
+
+// src/runtime/world-host.ts
+var directory = process.argv[2];
+if (!directory) throw new Error("World host requires a session directory");
+serveWorldSession(directory).then((host) => {
+  const stop = () => {
+    void host.close();
+  };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+}).catch((error) => {
+  process.stderr.write(String(error) + "\n");
+  process.exitCode = 1;
+});