@oddington/sdk 0.1.20 → 0.1.22

package/dist/browser.js

@@ -1,10 +1,10 @@
 var InboxContractError = class extends Error {
-  constructor(message) {
-    super(message), this.name = "InboxContractError";
+  constructor(message2) {
+    super(message2), this.name = "InboxContractError";
   }
 };
-function fail(message) {
-  throw new InboxContractError(message);
+function fail(message2) {
+  throw new InboxContractError(message2);
 }
 function object(value, label) {
   return (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) && fail(`${label} must be a plain object`), value;
@@ -12,8 +12,8 @@ function object(value, label) {
 function keys(value, allowed, label) {
   for (let key of Reflect.ownKeys(value)) {
     (typeof key != "string" || !allowed.includes(key)) && fail(`${label} does not support ${String(key)}`);
-    let descriptor2 = Object.getOwnPropertyDescriptor(value, key);
-    (!descriptor2.enumerable || !("value" in descriptor2)) && fail(`${label} must contain only JSON data`);
+    let descriptor = Object.getOwnPropertyDescriptor(value, key);
+    (!descriptor.enumerable || !("value" in descriptor)) && fail(`${label} must contain only JSON data`);
   }
 }
 function text(value, label) {
@@ -26,8 +26,8 @@ function id(value, label) {
 function array(value, label) {
   (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1) && fail(`${label} must be a dense array`);
   for (let index = 0; index < value.length; index += 1) {
-    let descriptor2 = Object.getOwnPropertyDescriptor(value, String(index));
-    (!descriptor2?.enumerable || !("value" in descriptor2)) && fail(`${label} must contain only JSON data`);
+    let descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    (!descriptor?.enumerable || !("value" in descriptor)) && fail(`${label} must contain only JSON data`);
   }
   return value;
 }
@@ -268,12 +268,12 @@ function presentation(source) {
     return keys(view, ["id", "view", "input"], "view"), { id: id(view.id, "view ID"), view: id(view.view, "view name"), input: serializable(view.input) };
   });
   new Set(views.map((view) => view.id)).size !== views.length && fail("Duplicate view ID");
-  let body2 = source.body === void 0 ? [] : array(source.body, "body").map(validateBlock);
-  for (let block2 of body2) {
+  let body = source.body === void 0 ? [] : array(source.body, "body").map(validateBlock);
+  for (let block2 of body) {
     let targets = block2.kind === "record" ? [block2.view] : block2.kind === "records" ? [block2.view, ...block2.records.map((record3) => record3.view)] : [];
     for (let target of targets) target !== void 0 && !views.some((view) => view.id === target) && fail(`Unknown Block View target: ${target}`);
   }
-  return { title: text(source.title, "title"), description: text(source.description, "description"), views, body: body2 };
+  return { title: text(source.title, "title"), description: text(source.description, "description"), views, body };
 }
 function validatePublication(value) {
   let source = object(value, "publication");
@@ -391,44 +391,44 @@ var FileOperationError = class extends Error {
   retryable;
 }, FILE_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/, FILE_ORIGINAL_MAX_BYTES = 5 * 1024 ** 3;
 function parseFileDescriptor(value) {
-  let invalid5 = () => {
+  let invalid7 = () => {
     throw new FileOperationError("unavailable", 503, !0);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
   let f = value;
-  if (Object.keys(f).sort().join(",") !== "details,enrichments,id,mediaType,name,path,sha256,size" || typeof f.id != "string" || !FILE_ID_PATTERN.test(f.id) || !safeFileName(f.name) || !safeFilePath(f.path) || !Number.isSafeInteger(f.size) || f.size < 0 || f.size > FILE_ORIGINAL_MAX_BYTES || typeof f.sha256 != "string" || !/^[0-9a-f]{64}$/.test(f.sha256) || !f.enrichments || typeof f.enrichments != "object" || Array.isArray(f.enrichments) || !f.details || typeof f.details != "object" || Array.isArray(f.details)) return invalid5();
+  if (Object.keys(f).sort().join(",") !== "details,enrichments,id,mediaType,name,path,sha256,size" || typeof f.id != "string" || !FILE_ID_PATTERN.test(f.id) || !safeFileName(f.name) || !safeFilePath(f.path) || !Number.isSafeInteger(f.size) || f.size < 0 || f.size > FILE_ORIGINAL_MAX_BYTES || typeof f.sha256 != "string" || !/^[0-9a-f]{64}$/.test(f.sha256) || !f.enrichments || typeof f.enrichments != "object" || Array.isArray(f.enrichments) || !f.details || typeof f.details != "object" || Array.isArray(f.details)) return invalid7();
   let d = f.details;
   if (d.kind === "other") {
-    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid5();
+    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid7();
   } else if (d.kind === "csv") {
-    if (Object.keys(d).sort().join(",") !== "dataRows,delimiter,encoding,headerRow,kind" || f.mediaType !== "text/csv" || !["utf-8", "windows-1252"].includes(d.encoding) || ![",", ";", "	"].includes(d.delimiter) || !Number.isSafeInteger(d.headerRow) || d.headerRow < 1 || !Number.isSafeInteger(d.dataRows) || d.dataRows < 0) return invalid5();
+    if (Object.keys(d).sort().join(",") !== "dataRows,delimiter,encoding,headerRow,kind" || f.mediaType !== "text/csv" || !["utf-8", "windows-1252"].includes(d.encoding) || ![",", ";", "	"].includes(d.delimiter) || !Number.isSafeInteger(d.headerRow) || d.headerRow < 1 || !Number.isSafeInteger(d.dataRows) || d.dataRows < 0) return invalid7();
   } else if (d.kind === "pdf") {
-    if (f.mediaType !== "application/pdf" || Object.keys(d).some((key) => !["kind", "pages"].includes(key)) || "pages" in d && (!Number.isSafeInteger(d.pages) || d.pages < 1)) return invalid5();
-  } else return invalid5();
-  for (let [name, descriptor2] of Object.entries(f.enrichments)) {
-    if (!safeEnrichmentName(name)) return invalid5();
-    parseEnrichmentDescriptor(descriptor2);
+    if (f.mediaType !== "application/pdf" || Object.keys(d).some((key) => !["kind", "pages"].includes(key)) || "pages" in d && (!Number.isSafeInteger(d.pages) || d.pages < 1)) return invalid7();
+  } else return invalid7();
+  for (let [name, descriptor] of Object.entries(f.enrichments)) {
+    if (!safeEnrichmentName(name)) return invalid7();
+    parseEnrichmentDescriptor(descriptor);
   }
-  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid5() : f;
+  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid7() : f;
 }
 function parseEnrichmentDescriptor(value) {
-  let invalid5 = () => {
+  let invalid7 = () => {
     throw new FileOperationError("unavailable", 503, !0);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
   let d = value;
-  return Object.keys(d).sort().join(",") !== "mediaType,sha256,size" || !["application/octet-stream", "text/plain", "text/markdown", "application/json"].includes(d.mediaType) || !Number.isSafeInteger(d.size) || d.size < 0 || d.size > 16 * 1024 * 1024 || typeof d.sha256 != "string" || !/^[0-9a-f]{64}$/.test(d.sha256) ? invalid5() : d;
+  return Object.keys(d).sort().join(",") !== "mediaType,sha256,size" || !["application/octet-stream", "text/plain", "text/markdown", "application/json"].includes(d.mediaType) || !Number.isSafeInteger(d.size) || d.size < 0 || d.size > 16 * 1024 * 1024 || typeof d.sha256 != "string" || !/^[0-9a-f]{64}$/.test(d.sha256) ? invalid7() : d;
 }
 function safeEnrichmentName(value) {
   return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
 }
 function parseFileEnrichMetadata(value, maxBytes) {
-  let invalid5 = () => {
+  let invalid7 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
   let d = value;
-  if (Object.keys(d).some((key) => !["name", "size", "mediaType", "replace"].includes(key)) || !safeEnrichmentName(d.name) || !Number.isSafeInteger(d.size) || d.size < 0 || d.mediaType !== void 0 && (typeof d.mediaType != "string" || d.mediaType.length > 255 || /[\u0000-\u001f\u007f]/.test(d.mediaType)) || d.replace !== void 0 && (typeof d.replace != "string" || !/^[0-9a-f]{64}$/.test(d.replace))) return invalid5();
+  if (Object.keys(d).some((key) => !["name", "size", "mediaType", "replace"].includes(key)) || !safeEnrichmentName(d.name) || !Number.isSafeInteger(d.size) || d.size < 0 || d.mediaType !== void 0 && (typeof d.mediaType != "string" || d.mediaType.length > 255 || /[\u0000-\u001f\u007f]/.test(d.mediaType)) || d.replace !== void 0 && (typeof d.replace != "string" || !/^[0-9a-f]{64}$/.test(d.replace))) return invalid7();
   if (d.size > maxBytes) throw new FileOperationError("request_too_large", 413);
   return d;
 }
@@ -439,23 +439,23 @@ function safeFilePath(value) {
   return typeof value == "string" && value.length <= 1024 && value.split("/").every(safeFileName);
 }
 function parseFileCreateMetadata(value, maxBytes) {
-  let invalid5 = () => {
+  let invalid7 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
   let input = value;
-  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid5();
+  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid7();
   let path = input.path === void 0 ? "Files" : input.path;
-  if (!safeFileName(input.name) || !safeFilePath(path) || path.split("/")[0].toLowerCase() === ".os" || input.storage !== void 0 && input.storage !== "remote" && input.storage !== "local" || input.inputMediaType !== void 0 && input.inputMediaType !== "application/pdf" || !Number.isSafeInteger(input.size) || input.size < 0) return invalid5();
+  if (!safeFileName(input.name) || !safeFilePath(path) || path.split("/")[0].toLowerCase() === ".os" || input.storage !== void 0 && input.storage !== "remote" && input.storage !== "local" || input.inputMediaType !== void 0 && input.inputMediaType !== "application/pdf" || !Number.isSafeInteger(input.size) || input.size < 0) return invalid7();
   if (input.size > maxBytes) throw new FileOperationError("request_too_large", 413);
-  if (typeof input.requestKey != "string" || input.requestKey.length < 1 || input.requestKey.length > 256 || input.requestKey !== input.requestKey.trim() || /[\u0000-\u001f\u007f]/.test(input.requestKey)) return invalid5();
+  if (typeof input.requestKey != "string" || input.requestKey.length < 1 || input.requestKey.length > 256 || input.requestKey !== input.requestKey.trim() || /[\u0000-\u001f\u007f]/.test(input.requestKey)) return invalid7();
   let csv;
   if (input.csv !== void 0) {
-    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid5();
+    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid7();
     let hints = input.csv;
-    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid5();
+    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid7();
     let encoding = hints.encoding === void 0 ? "utf-8" : hints.encoding, delimiter = hints.delimiter === void 0 ? "," : hints.delimiter, headerRow = hints.headerRow === void 0 ? 1 : hints.headerRow;
-    if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "	"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5) return invalid5();
+    if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "	"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5) return invalid7();
     csv = { encoding, delimiter, headerRow };
   }
   return {
@@ -572,54 +572,137 @@ function validateRoutineSchemaValue(schema2, value) {
   }
 }
 
-var LIMIT = 256 * 1024, invalid = () => {
+var ROUTINE_DECLARATION_SCHEMA = "https://schemas.oddington.ai/routine/v1.json", ROUTINE_SOURCE_LIMITS = { files: 2e4, bytes: 256 * 1024 * 1024, declarationBytes: 64 * 1024 };
+var invalid = (field) => {
+  throw new Error(`Invalid routine declaration: ${field}`);
+}, object2 = (value, fields5, field) => ((!value || typeof value != "object" || Array.isArray(value) || Object.keys(value).some((key) => !fields5.includes(key))) && invalid(field), value), routineAlias = (value) => typeof value == "string" && /^[a-z][a-z0-9-]{0,62}$/.test(value), list = (value, field, allowed, qualified = !1) => value === void 0 ? [] : ((!Array.isArray(value) || value.length > 64 || value.some((item) => !(routineAlias(item) || qualified && typeof item == "string" && item.split("/").length === 2 && item.split("/").every(routineAlias)) || allowed && !allowed.includes(item)) || new Set(value).size !== value.length) && invalid(field), [...value].sort());
+function routineAssetPattern(value) {
+  return typeof value == "string" && value.length <= 512 && !value.startsWith("/") && !value.includes("\\") && !value.includes(":") && value.split("/").every((part) => !!part && part !== "." && part !== ".." && /^[a-zA-Z0-9_.*-]+$/.test(part));
+}
+function parseRoutineDeclaration(value) {
+  let v = object2(value, ["$schema", "access", "runtime", "retry", "assets"], "fields");
+  v.$schema !== ROUTINE_DECLARATION_SCHEMA && invalid("$schema");
+  let access = object2(v.access === void 0 ? {} : v.access, ["repositories", "connections", "models", "files", "publish"], "access"), rawRepositories = access.repositories === void 0 ? {} : access.repositories, repositories = object2(rawRepositories, rawRepositories && typeof rawRepositories == "object" ? Object.keys(rawRepositories) : [], "access.repositories");
+  Object.keys(repositories).length > 64 && invalid("access.repositories");
+  let grants = {};
+  for (let key of Object.keys(repositories).sort())
+    (!routineAlias(key) || !["read", "write"].includes(repositories[key])) && invalid(`access.repositories.${key}`), grants[key] = repositories[key];
+  access.files !== void 0 && !["read", "read-write"].includes(access.files) && invalid("access.files");
+  let runtime = object2(v.runtime === void 0 ? {} : v.runtime, ["features", "resources", "maxDuration"], "runtime");
+  runtime.resources !== void 0 && !["standard", "large"].includes(runtime.resources) && invalid("runtime.resources");
+  let duration = runtime.maxDuration === void 0 ? "15m" : runtime.maxDuration;
+  (typeof duration != "string" || !/^(?:[1-5][0-9]|60)m$/.test(duration) || Number(duration.slice(0, -1)) < 15) && invalid("runtime.maxDuration");
+  let retry = object2(v.retry === void 0 ? {} : v.retry, ["maxAttempts"], "retry"), maxAttempts = retry.maxAttempts === void 0 ? 1 : retry.maxAttempts;
+  (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 3) && invalid("retry.maxAttempts");
+  let assets = v.assets === void 0 ? [] : v.assets;
+  return (!Array.isArray(assets) || assets.length > 64 || assets.some((item) => !routineAssetPattern(item)) || new Set(assets).size !== assets.length) && invalid("assets"), {
+    $schema: ROUTINE_DECLARATION_SCHEMA,
+    access: {
+      repositories: grants,
+      connections: list(access.connections, "access.connections", void 0, !0),
+      models: list(access.models, "access.models"),
+      ...access.files === void 0 ? {} : { files: access.files },
+      publish: list(access.publish, "access.publish", ["asks", "digests"])
+    },
+    runtime: {
+      features: list(runtime.features, "runtime.features", ["python", "documents", "browser"]),
+      resources: runtime.resources ?? "standard",
+      maxDuration: duration
+    },
+    retry: { maxAttempts },
+    assets: [...assets].sort()
+  };
+}
+
+var invalid2 = () => {
   throw new AppRoutineContractError("invalid_value");
 }, invalidContract2 = () => {
   throw new AppRoutineContractError("invalid_contract");
-}, empty = { type: "object", properties: {}, required: [], additionalProperties: !1 };
-function freeze(value) {
+}, routineTitle = (value) => typeof value == "string" && value.trim().length > 0 && value.length <= 256;
+function freezeRoutineMetadata(value) {
   if (value !== null && typeof value == "object") {
-    for (let child of Object.values(value)) freeze(child);
+    for (let child of Object.values(value)) freezeRoutineMetadata(child);
     Object.freeze(value);
   }
   return value;
 }
-function json(value, ancestors = /* @__PURE__ */ new Set()) {
+function assertRoutineJson(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return;
-  if (!value || typeof value != "object" || ancestors.has(value)) return invalid();
+  if (!value || typeof value != "object" || ancestors.has(value)) return invalid2();
   let array3 = Array.isArray(value);
-  if (!array3 && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return invalid();
-  let keys5 = Reflect.ownKeys(value);
-  if (array3 && (keys5.length !== value.length + 1 || !Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)).every(Boolean))) return invalid();
+  if (!array3 && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return invalid2();
+  let keys4 = Reflect.ownKeys(value);
+  if (array3 && (keys4.length !== value.length + 1 || !Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)).every(Boolean))) return invalid2();
   ancestors.add(value);
-  for (let key of keys5) {
+  for (let key of keys4) {
     if (array3 && key === "length") continue;
-    if (typeof key != "string") return invalid();
-    let descriptor2 = Object.getOwnPropertyDescriptor(value, key);
-    if (!descriptor2.enumerable || !Object.hasOwn(descriptor2, "value")) return invalid();
-    json(descriptor2.value, ancestors);
+    if (typeof key != "string") return invalid2();
+    let descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.enumerable || !Object.hasOwn(descriptor, "value")) return invalid2();
+    assertRoutineJson(descriptor.value, ancestors);
   }
   ancestors.delete(value);
 }
-function capture(schema2, value) {
-  json(value), validateRoutineSchemaValue(schema2, value);
-  let encoded = JSON.stringify(value);
-  return new TextEncoder().encode(encoded).byteLength > LIMIT ? invalid() : freeze(JSON.parse(encoded));
+function assertRoutineFields(value, allowed) {
+  if (!value || typeof value != "object" || Object.getPrototypeOf(value) !== Object.prototype || Reflect.ownKeys(value).some((key) => typeof key != "string" || allowed && !allowed.includes(key) || !Object.getOwnPropertyDescriptor(value, key).enumerable || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value"))) return invalidContract2();
 }
-function declaration(value) {
+function parseRoutineAccess(value) {
   try {
-    json(value);
+    value !== void 0 && assertRoutineJson(value), assertRoutineFields(value ?? {}, ["repositories", "connections", "models", "files", "publish"]);
+    let access = value, names = access?.connections ?? [];
+    if (!Array.isArray(names) || names.length > 64 || new Set(names).size !== names.length || names.some((name) => typeof name != "string" || name.split("/").length !== 2 || name.split("/").some((part) => !isAppRoutineName(part)))) return invalidContract2();
+    let parsed = parseRoutineDeclaration({ $schema: ROUTINE_DECLARATION_SCHEMA, access: { ...access, connections: [] } }).access;
+    return freezeRoutineMetadata({ ...parsed, connections: [...names] });
   } catch {
     return invalidContract2();
   }
-  return freeze(parseAppRoutineContract({ routine: "definition", input: value, steps: [{ id: "inspect" }] }).input);
+}
+
+var LIMIT = 256 * 1024, invalid3 = () => {
+  throw new AppRoutineContractError("invalid_value");
+}, invalidContract3 = () => {
+  throw new AppRoutineContractError("invalid_contract");
+}, empty = { type: "object", properties: {}, required: [], additionalProperties: !1 };
+function captureJson(value) {
+  assertRoutineJson(value);
+  let encoded = JSON.stringify(value);
+  return new TextEncoder().encode(encoded).byteLength > LIMIT ? invalid3() : freezeRoutineMetadata(JSON.parse(encoded));
+}
+function capture(schema2, value) {
+  let captured = captureJson(value);
+  return validateRoutineSchemaValue(schema2, captured), captured;
+}
+var schemas = /* @__PURE__ */ new WeakMap();
+function nestedSchema(value) {
+  let metadata = schemaMetadata(value);
+  return Object.hasOwn(metadata, "default") ? invalidContract3() : metadata.schema;
+}
+function schemaMetadata(value) {
+  if (!value || typeof value != "object") return invalidContract3();
+  let registered = schemas.get(value);
+  if (registered) return registered;
+  try {
+    assertRoutineJson(value);
+  } catch {
+    return invalidContract3();
+  }
+  return { schema: parseAppRoutineContract({ routine: "definition", input: value, steps: [{ id: "inspect" }] }).input };
+}
+function declaration(value, defaults) {
+  try {
+    assertRoutineJson(value);
+  } catch {
+    return invalidContract3();
+  }
+  let parsed = freezeRoutineMetadata(parseAppRoutineContract({ routine: "definition", input: value, steps: [{ id: "inspect" }] }).input), captured = defaults ? capture(parsed, defaults.value) : void 0, builder = Object.defineProperty({ ...parsed }, "default", { value: (value2) => declaration(parsed, { value: value2 }) });
+  return schemas.set(builder, { schema: parsed, ...defaults ? { default: captured } : {} }), Object.freeze(builder);
 }
 var schema = {
   object(properties) {
-    return declaration({ type: "object", properties, required: Object.keys(properties), additionalProperties: !1 });
+    return declaration({ type: "object", properties: Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, nestedSchema(value)])), required: Object.keys(properties), additionalProperties: !1 });
   },
   array(items, options) {
-    return declaration({ type: "array", items, maxItems: options.maxItems });
+    return declaration({ type: "array", items: nestedSchema(items), maxItems: options.maxItems });
   },
   string(options = {}) {
     return declaration({ type: "string", ...options });
@@ -634,75 +717,123 @@ var schema = {
     return declaration({ type: "boolean" });
   }
 }, file = () => declaration({ type: "file" }), definitions = /* @__PURE__ */ new WeakMap(), defineRoutine = (definition) => {
-  if (!definition || typeof definition != "object" || Object.getPrototypeOf(definition) !== Object.prototype || Reflect.ownKeys(definition).some((key) => typeof key != "string" || !["input", "steps", "result", "run"].includes(key) || !Object.getOwnPropertyDescriptor(definition, key).enumerable || !Object.hasOwn(Object.getOwnPropertyDescriptor(definition, key), "value")) || typeof definition.run != "function") return invalidContract2();
-  try {
-    for (let key of ["input", "steps", "result"])
-      definition[key] !== void 0 && json(definition[key]);
-  } catch {
-    return invalidContract2();
+  if (assertRoutineFields(definition, ["id", "title", "input", "steps", "result", "access", "responses", "run"]), !isAppRoutineName(definition.id) || definition.title !== void 0 && !routineTitle(definition.title) || typeof definition.run != "function") return invalidContract3();
+  let input = definition.input === void 0 ? { schema: empty, default: {} } : schemaMetadata(definition.input), result2 = definition.result === void 0 ? void 0 : schemaMetadata(definition.result).schema, access = parseRoutineAccess(definition.access);
+  assertRoutineFields(definition.steps ?? {});
+  let executable = Object.fromEntries(Object.entries(definition.steps ?? {}).map(([id3, step]) => (assertRoutineFields(step, ["title", "run"]), !routineTitle(step.title) || typeof step.run != "function" ? invalidContract3() : [id3, Object.freeze({ title: step.title, run: step.run })]))), steps = Object.entries(executable).map(([id3, step]) => ({ id: id3, title: step.title }));
+  parseAppRoutineContract({
+    routine: definition.id,
+    input: input.schema,
+    steps: steps.length ? steps.map(({ id: id3 }) => ({ id: id3 })) : [{ id: "inspect" }],
+    ...result2 ? { result: result2 } : {}
+  });
+  let responses = [], ids = /* @__PURE__ */ new Set();
+  if (definition.responses !== void 0) {
+    if (!Array.isArray(definition.responses) || definition.responses.length > 64 || Reflect.ownKeys(definition.responses).length !== definition.responses.length + 1) return invalidContract3();
+    for (let index = 0; index < definition.responses.length; index++) {
+      let descriptor = Object.getOwnPropertyDescriptor(definition.responses, String(index));
+      if (!descriptor || !Object.hasOwn(descriptor, "value")) return invalidContract3();
+      let response2 = descriptor.value;
+      if (assertRoutineFields(response2, ["id", "results", "run"]), !isAppRoutineName(response2.id) || ids.has(response2.id)) return invalidContract3();
+      if (ids.add(response2.id), response2.results !== void 0)
+        try {
+          assertRoutineJson(response2.results);
+        } catch {
+          return invalidContract3();
+        }
+      try {
+        responses.push(defineHandler(response2));
+      } catch {
+        return invalidContract3();
+      }
+    }
   }
-  if (definition.steps !== void 0 && (!definition.steps || typeof definition.steps != "object" || Array.isArray(definition.steps))) return invalidContract2();
-  let steps = definition.steps === void 0 ? [] : Object.entries(definition.steps).map(([id3, summary]) => ({ id: id3, ...summary === null ? {} : { summary } })), parsed = parseAppRoutineContract({
-    routine: "definition",
-    input: definition.input === void 0 ? empty : definition.input,
-    steps: steps.length ? steps : [{ id: "inspect" }],
-    ...definition.result === void 0 ? {} : { result: definition.result }
-  }), contract = freeze({
-    input: parsed.input,
-    steps: steps.length ? parsed.steps : [],
-    ...parsed.result === void 0 ? {} : { result: parsed.result }
+  let contract = freezeRoutineMetadata({
+    id: definition.id,
+    ...definition.title === void 0 ? {} : { title: definition.title },
+    input: input.schema,
+    ...Object.hasOwn(input, "default") ? { inputDefault: input.default } : {},
+    access,
+    responses: responses.map(({ id: id3 }) => ({ id: id3 })),
+    steps,
+    ...result2 ? { result: result2 } : {}
   }), captured = Object.freeze({
     ...definition,
-    ...definition.input === void 0 ? {} : { input: contract.input },
-    ...definition.steps === void 0 ? {} : { steps: freeze(Object.fromEntries(contract.steps.map((step) => [step.id, step.summary ?? null]))) },
-    ...definition.result === void 0 ? {} : { result: contract.result },
+    access,
+    steps: Object.freeze(executable),
+    responses: Object.freeze(responses),
+    ...definition.input === void 0 ? {} : { input: declaration(
+      input.schema,
+      Object.hasOwn(input, "default") ? { value: input.default } : void 0
+    ) },
+    ...result2 === void 0 ? {} : { result: declaration(result2) },
     // Only this authored definition is callable; no generic runner is exported.
-    run: (input, os2) => executeRoutineDefinition(captured, input, os2)
+    run: (input2, os2) => executeRoutineDefinition(captured, input2, os2)
   });
-  return definitions.set(captured, { contract, run: definition.run }), captured;
+  return definitions.set(captured, { contract, steps: executable, run: definition.run }), captured;
 };
 function inspectRoutineDefinition(definition) {
-  if (!definition || typeof definition != "object") return invalidContract2();
+  if (!definition || typeof definition != "object") return invalidContract3();
   let registered = definitions.get(definition);
-  return registered ? registered.contract : invalidContract2();
+  return registered ? registered.contract : invalidContract3();
 }
 function captureRoutineInput(definition, input) {
-  return capture(inspectRoutineDefinition(definition).input, input);
+  let contract = inspectRoutineDefinition(definition);
+  return capture(contract.input, input === void 0 && Object.hasOwn(contract, "inputDefault") ? contract.inputDefault : input);
 }
 async function executeRoutineDefinition(definition, input, runtime) {
-  let captured = captureRoutineInput(definition, input), { contract, run } = definitions.get(definition), active2 = !0, broken = !1, reports = Promise.resolve(), os2 = Object.freeze({
-    ...runtime,
-    run: freeze({ ...runtime.run }),
-    async artifact(input2) {
-      if (!active2) throw new Error("Run authority ended");
-      if (!runtime.artifact) throw new Error("Run artifact transport unavailable");
-      return runtime.artifact(input2);
-    },
-    step(id3, ...summary) {
-      if (!active2 || broken || summary.length > 1)
-        return broken = !0, Promise.reject(new AppRoutineContractError("invalid_value"));
-      let value;
+  let captured = captureRoutineInput(definition, input), { contract, steps, run } = definitions.get(definition), active2 = !0, accepting = !0, broken = !1, work = Promise.resolve(), called = /* @__PURE__ */ new Set(), reached = /* @__PURE__ */ new Set(), guarded = (value, receiver) => typeof value == "function" ? (...args) => {
+    if (!active2 || broken) throw new Error("Run authority ended");
+    return guarded(Reflect.apply(value, receiver, args));
+  } : value && typeof value == "object" && !(value instanceof Promise) ? new Proxy({ ...value }, {
+    // Copy the surface so wrapping a frozen host capability does not violate
+    // Proxy invariants; methods still receive their original host receiver.
+    get(_target, key) {
+      return guarded(Reflect.get(value, key, value), value);
+    }
+  }) : value, qualify = (value) => value.questions === void 0 ? value : { ...value, questions: value.questions.map((question2) => question2.handler ? contract.responses.some((handler) => handler.id === question2.handler.id) ? { ...question2, handler: { ...question2.handler, id: `${contract.id}/${question2.handler.id}` } } : invalid3() : question2) }, os2 = Object.freeze({
+    ...guarded({
+      ...runtime,
+      run: freezeRoutineMetadata({ ...runtime.run }),
+      inbox: { ...runtime.inbox, publishAsk: (value, options) => runtime.inbox.publishAsk(qualify(value), options) }
+    }),
+    step(id3, ...input2) {
+      let saved;
       try {
-        let step = contract.steps.find((step2) => step2.id === id3);
-        if (!step) return invalid();
-        if (step.summary === void 0) {
-          if (summary.length) return invalid();
-        } else value = capture(step.summary, summary[0]);
+        if (!active2 || !accepting || broken || !Object.hasOwn(steps, id3) || called.has(id3) || input2.length > 1) return invalid3();
+        input2.length && (saved = captureJson(input2[0])), called.add(id3);
       } catch (error) {
         return broken = !0, Promise.reject(error);
       }
-      let report = reports.then(() => broken ? invalid() : runtime.step(id3, value));
-      return reports = report.catch(() => {
+      let next = work.then(async () => {
+        if (broken) return invalid3();
+        reached.add(id3);
+        try {
+          await runtime.step(id3, { status: "running" });
+          let output = await steps[id3].run(saved, os2);
+          if (assertRoutineFields(output, ["summary", "data"]), !Object.hasOwn(output, "summary") || !Object.hasOwn(output, "data")) return invalid3();
+          let summary2 = captureJson(output.summary), data3 = captureJson(output.data);
+          return await runtime.step(id3, { status: "completed", summary: summary2, data: data3 }), freezeRoutineMetadata({ summary: summary2, data: data3 });
+        } catch (error) {
+          throw broken = !0, await runtime.step(id3, { status: "failed" }), error;
+        }
+      });
+      return work = next.then(() => {
+      }, () => {
         broken = !0;
-      }), report;
+      }), next;
     }
-  });
+  }), result2, failure;
   try {
-    let result2 = await run(captured, os2);
-    return active2 = !1, await reports, broken ? invalid() : contract.result !== void 0 ? capture(contract.result, result2) : result2 !== void 0 ? invalid() : void 0;
-  } finally {
-    active2 = !1;
+    result2 = await run(captured, os2);
+  } catch (error) {
+    failure = error, broken = !0;
   }
+  accepting = !1, await work, active2 = !1;
+  for (let step of contract.steps) reached.has(step.id) || await runtime.step(step.id, { status: "skipped" });
+  if (broken) throw failure ?? new AppRoutineContractError("invalid_value");
+  if (contract.result !== void 0) return capture(contract.result, result2);
+  if (result2 !== void 0) return invalid3();
 }
 
 var DataOperationError = class extends Error {
@@ -720,46 +851,46 @@ var DataOperationError = class extends Error {
   component;
 };
 
-var invalid2 = () => {
+var invalid4 = () => {
   throw new DataOperationError("invalid_query");
 }, historyText = (value) => typeof value == "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
 function historyVersion(value) {
   return historyText(value) && value.length > 0 && new TextEncoder().encode(value).length <= 1024 && !/[\u0000-\u001f\u007f-\u009f]/.test(value) && !/^[0-9a-f]{40}$/i.test(value);
 }
 function historyProperties(value) {
-  if (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return invalid2();
+  if (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return invalid4();
   let descriptors = Object.getOwnPropertyDescriptors(value);
-  return Reflect.ownKeys(value).some((key) => typeof key != "string" || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")) ? invalid2() : descriptors;
+  return Reflect.ownKeys(value).some((key) => typeof key != "string" || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")) ? invalid4() : descriptors;
 }
 var historyCollection = (value) => typeof value == "string" && value.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value), historyCursor = (value) => typeof value == "string" && value.length <= 128 * 1024 && /^history-cursor-v1\.[A-Za-z0-9_-]{1,64}\.[A-Za-z0-9_-]{16}\.[A-Za-z0-9_-]+$/.test(value);
 function historyArray(value) {
-  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return invalid2();
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return invalid4();
   let descriptors = Object.getOwnPropertyDescriptors(value);
-  if (Reflect.ownKeys(value).length !== value.length + 1) return invalid2();
+  if (Reflect.ownKeys(value).length !== value.length + 1) return invalid4();
   let result2 = [];
   for (let i = 0; i < value.length; i++) {
-    let descriptor2 = descriptors[i];
-    if (!descriptor2?.enumerable || !Object.hasOwn(descriptor2, "value")) return invalid2();
-    result2.push(descriptor2.value);
+    let descriptor = descriptors[i];
+    if (!descriptor?.enumerable || !Object.hasOwn(descriptor, "value")) return invalid4();
+    result2.push(descriptor.value);
   }
   return result2;
 }
 function captureOptions(value, changes) {
   if (value === void 0) return {};
   let descriptors = historyProperties(value), result2 = {}, allowed = changes ? ["collections", "refs", "from", "through", "limit", "after"] : ["limit", "before"];
-  if (Object.keys(descriptors).some((key) => !allowed.includes(key))) return invalid2();
+  if (Object.keys(descriptors).some((key) => !allowed.includes(key))) return invalid4();
   for (let key of allowed) {
     if (!Object.hasOwn(descriptors, key)) continue;
     let scalar = descriptors[key].value;
     if (key === "collections" || key === "refs") {
       let values = historyArray(scalar);
-      if (!values.length || values.length > (key === "collections" ? 16 : 100) || !values.every(key === "collections" ? historyCollection : validRecordRef) || new Set(values).size !== values.length) return invalid2();
+      if (!values.length || values.length > (key === "collections" ? 16 : 100) || !values.every(key === "collections" ? historyCollection : validRecordRef) || new Set(values).size !== values.length) return invalid4();
       result2[key] = values;
     } else if (key === "limit") {
-      if (!Number.isInteger(scalar) || scalar < 1 || scalar > (changes ? 500 : 100)) return invalid2();
+      if (!Number.isInteger(scalar) || scalar < 1 || scalar > (changes ? 500 : 100)) return invalid4();
       result2.limit = scalar;
     } else {
-      if (!(key === "after" ? historyCursor(scalar) : historyVersion(scalar))) return invalid2();
+      if (!(key === "after" ? historyCursor(scalar) : historyVersion(scalar))) return invalid4();
       result2[key] = scalar;
     }
   }
@@ -767,39 +898,39 @@ function captureOptions(value, changes) {
 }
 var captureHistoryListOptions = (value) => captureOptions(value, !1), captureHistoryChangesOptions = (value) => captureOptions(value, !0);
 function captureHistoryInstant(value) {
-  if (!historyText(value) || value.length > 1024) return invalid2();
+  if (!historyText(value) || value.length > 1024) return invalid4();
   let match = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?([Zz]|([+-])(\d{2}):(\d{2}))$/.exec(value);
-  if (!match) return invalid2();
+  if (!match) return invalid4();
   let [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number), days = new Date(Date.UTC(year, month, 0));
-  return days.setUTCFullYear(year), year < 1 || month < 1 || month > 12 || day < 1 || day > days.getUTCDate() || hour > 23 || minute > 59 || second > 59 || Number(match[9] ?? 0) > 23 || Number(match[10] ?? 0) > 59 ? invalid2() : value;
+  return days.setUTCFullYear(year), year < 1 || month < 1 || month > 12 || day < 1 || day > days.getUTCDate() || hour > 23 || minute > 59 || second > 59 || Number(match[9] ?? 0) > 23 || Number(match[10] ?? 0) > 59 ? invalid4() : value;
 }
 
-var invalid3 = () => {
+var invalid5 = () => {
   throw new DataOperationError("invalid_query");
 };
 function captureRecordsSearchInput(query, options) {
-  if (!historyText(query)) return invalid3();
+  if (!historyText(query)) return invalid5();
   let length = [...query.trim()].length;
-  if (length < 1 || length > 256) return invalid3();
+  if (length < 1 || length > 256) return invalid5();
   if (options === void 0) return { query };
   let descriptors = historyProperties(options);
-  if (Object.keys(descriptors).some((key) => !["collections", "limit"].includes(key))) return invalid3();
+  if (Object.keys(descriptors).some((key) => !["collections", "limit"].includes(key))) return invalid5();
   let captured = {};
   if (Object.hasOwn(descriptors, "collections")) {
     let supplied = descriptors.collections.value;
-    if (!Array.isArray(supplied) || supplied.length < 1 || supplied.length > 16 || Reflect.ownKeys(supplied).length !== supplied.length + 1) return invalid3();
+    if (!Array.isArray(supplied) || supplied.length < 1 || supplied.length > 16 || Reflect.ownKeys(supplied).length !== supplied.length + 1) return invalid5();
     let collections = [];
     for (let index = 0; index < supplied.length; index++) {
-      let descriptor2 = Object.getOwnPropertyDescriptor(supplied, String(index));
-      if (!descriptor2?.enumerable || !Object.hasOwn(descriptor2, "value") || !historyText(descriptor2.value)) return invalid3();
-      collections.push(descriptor2.value);
+      let descriptor = Object.getOwnPropertyDescriptor(supplied, String(index));
+      if (!descriptor?.enumerable || !Object.hasOwn(descriptor, "value") || !historyText(descriptor.value)) return invalid5();
+      collections.push(descriptor.value);
     }
-    if (new Set(collections).size !== collections.length) return invalid3();
+    if (new Set(collections).size !== collections.length) return invalid5();
     captured.collections = collections;
   }
   if (Object.hasOwn(descriptors, "limit")) {
     let supplied = descriptors.limit.value;
-    if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100) return invalid3();
+    if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100) return invalid5();
     captured.limit = supplied;
   }
   return { query, options: captured };
@@ -1051,7 +1182,7 @@ var data = {
   }
 };
 
-var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES = 4096, RESULT_BYTES = 16 * 1024, CONTROL_RESULT_BYTES = 128 * 1024, TIMEOUT_MS = 3e4, MAX_ACTIVE = 4, ATTEMPTS = 2, active = 0, invalid4 = () => new FileOperationError("invalid_input", 400), unavailable = () => new FileOperationError("unavailable", 503, !0), failures = {
+var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES = 4096, RESULT_BYTES = 16 * 1024, CONTROL_RESULT_BYTES = 128 * 1024, TIMEOUT_MS = 3e4, MAX_ACTIVE = 4, ATTEMPTS = 2, active = 0, invalid6 = () => new FileOperationError("invalid_input", 400), unavailable = () => new FileOperationError("unavailable", 503, !0), failures = {
   400: ["invalid_input", "unsupported_context"],
   401: ["unauthenticated"],
   403: ["access_denied"],
@@ -1068,7 +1199,7 @@ async function boundedBytes(stream, limit) {
     for (; ; ) {
       let { done, value } = await reader.read();
       if (done) break;
-      if (!(value instanceof Uint8Array)) throw invalid4();
+      if (!(value instanceof Uint8Array)) throw invalid6();
       if (size += value.byteLength, size > limit) throw new FileOperationError("request_too_large", 413);
       bytes.set(value, size - value.byteLength);
     }
@@ -1119,7 +1250,7 @@ async function hostedContent(url, init2, parent, upstream = fetch) {
           reader?.releaseLock();
         }
       }
-    }, body2 = new ReadableStream({
+    }, body = new ReadableStream({
       async pull(controller) {
         try {
           reader ??= source.getReader();
@@ -1133,7 +1264,7 @@ async function hostedContent(url, init2, parent, upstream = fetch) {
         }
       },
       cancel
-    }, { highWaterMark: 0 }), wrapped = new Response(body2, { status: response2.status, statusText: response2.statusText, headers: response2.headers });
+    }, { highWaterMark: 0 }), wrapped = new Response(body, { status: response2.status, statusText: response2.statusText, headers: response2.headers });
     for (let key of ["url", "redirected", "type"])
       Object.defineProperty(wrapped, key, { value: response2[key] });
     return wrapped;
@@ -1141,7 +1272,7 @@ async function hostedContent(url, init2, parent, upstream = fetch) {
     throw detach(), delivery.abort(error), error;
   }
 }
-async function send(suffix, init2, descriptor2, initial, parent) {
+async function send(suffix, init2, descriptor, initial, parent) {
   let original = initial, checkCurrent = (context2 = original) => {
     if (parent?.aborted) throw unavailable();
     if (!original.isCurrent() || context2.url !== original.url) throw new FileOperationError("unsupported_context", 400);
@@ -1152,20 +1283,20 @@ async function send(suffix, init2, descriptor2, initial, parent) {
     checkCurrent(context2);
     try {
       let response2 = await (async () => {
-        let url = `${context2.url}${suffix}`, request = {
+        let url = `${context2.url}${suffix}`, request2 = {
           ...init2,
           signal: parent,
           headers: { ...context2.headers, ...init2.headers },
           redirect: "error",
           cache: "no-store"
         };
-        return descriptor2 ? fetch(url, request) : hostedContent(url, request, parent);
+        return descriptor ? fetch(url, request2) : hostedContent(url, request2, parent);
       })();
       if (!response2.ok) {
         let value2 = await result(response2), error = value2 && typeof value2 == "object" && "error" in value2 ? value2.error : void 0, received = error && typeof error == "object" && "code" in error ? error.code : void 0, code = failures[response2.status]?.find((code2) => code2 === received);
         throw code ? new FileOperationError(code, response2.status, code === "capacity" || code === "unavailable") : unavailable();
       }
-      if (response2.status !== (descriptor2 === 204 ? 204 : 200) || descriptor2 === 204 && response2.body !== null)
+      if (response2.status !== (descriptor === 204 ? 204 : 200) || descriptor === 204 && response2.body !== null)
         throw response2.body?.cancel().catch(() => {
         }), unavailable();
       try {
@@ -1174,13 +1305,13 @@ async function send(suffix, init2, descriptor2, initial, parent) {
         throw response2.body?.cancel().catch(() => {
         }), error;
       }
-      if (descriptor2 === 204) return;
-      if (!descriptor2) return response2;
-      let value = await result(response2, descriptor2 === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
-      if (descriptor2 === "control")
+      if (descriptor === 204) return;
+      if (!descriptor) return response2;
+      let value = await result(response2, descriptor === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
+      if (descriptor === "control")
         return checkCurrent(), value;
       let parsed;
-      if (descriptor2 === "enrichment") {
+      if (descriptor === "enrichment") {
         if (!value || typeof value != "object" || Array.isArray(value)) throw unavailable();
         let { name, ...metadata } = value;
         if (!safeEnrichmentName(name)) throw unavailable();
@@ -1195,22 +1326,22 @@ async function send(suffix, init2, descriptor2, initial, parent) {
   throw unavailable();
 }
 function idPath(id3) {
-  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid4();
+  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid6();
   return `/${id3}`;
 }
 async function multipartCreate(input, metadata, exchange, release = () => {
   active--;
 }, upload) {
-  let route = upload ? `${idPath(upload.file.id)}/upload/multipart` : "/multipart", ticket, reader, chunk, offset = 0, receipts = [], pending = /* @__PURE__ */ new Set(), request = (work, timeout = TIMEOUT_MS) => timed((signal) => {
+  let route = upload ? `${idPath(upload.file.id)}/upload/multipart` : "/multipart", ticket, reader, chunk, offset = 0, receipts = [], pending = /* @__PURE__ */ new Set(), request2 = (work, timeout = TIMEOUT_MS) => timed((signal) => {
     let task = work(signal);
     return pending.add(task), task.then(() => pending.delete(task), () => pending.delete(task)), task;
-  }, void 0, timeout), control = (body2) => ({
+  }, void 0, timeout), control = (body) => ({
     method: "POST",
     headers: { "content-type": "application/json", ...ticket ? { "x-oddington-transfer": ticket } : {} },
-    body: JSON.stringify(body2)
+    body: JSON.stringify(body)
   });
   try {
-    let start = await request((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
+    let start = await request2((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
     if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable();
     let session = start;
     if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket != "string" || !session.ticket || session.ticket.length > 64 * 1024) throw unavailable();
@@ -1218,7 +1349,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
     let lastProgress = Date.now(), next = async () => {
       try {
         if (Date.now() - lastProgress >= TIMEOUT_MS) throw unavailable();
-        let value = await request(() => reader.read(), Math.max(1, TIMEOUT_MS - (Date.now() - lastProgress)));
+        let value = await request2(() => reader.read(), Math.max(1, TIMEOUT_MS - (Date.now() - lastProgress)));
         return value.value?.byteLength && (lastProgress = Date.now()), value;
       } catch (error) {
         throw await reader.cancel(error).catch(() => {
@@ -1230,7 +1361,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
       if (input.file instanceof Uint8Array) part = input.file.subarray(sent, sent + length).slice();
       else if (input.file instanceof Blob) {
         let slice = input.file.slice(sent, sent + length);
-        part = new Uint8Array(await request(() => slice.arrayBuffer()));
+        part = new Uint8Array(await request2(() => slice.arrayBuffer()));
       } else {
         part = new Uint8Array(length);
         let filled = 0;
@@ -1238,20 +1369,20 @@ async function multipartCreate(input, metadata, exchange, release = () => {
           if (!chunk || offset === chunk.byteLength) {
             chunk = void 0, offset = 0;
             let value2 = await next();
-            if (value2.done || !(value2.value instanceof Uint8Array) || (chunk = value2.value, chunk.byteLength > metadata.size - sent - filled)) throw invalid4();
+            if (value2.done || !(value2.value instanceof Uint8Array) || (chunk = value2.value, chunk.byteLength > metadata.size - sent - filled)) throw invalid6();
           }
           let take = Math.min(length - filled, chunk.byteLength - offset);
           part.set(chunk.subarray(offset, offset + take), filled), filled += take, offset += take, offset === chunk.byteLength && (chunk = void 0, offset = 0);
         }
       }
-      if (part.byteLength !== length) throw invalid4();
+      if (part.byteLength !== length) throw invalid6();
       if (reader && sent + length === metadata.size)
         for (lastProgress = Date.now(); ; ) {
           let value2 = await next();
           if (value2.done) break;
-          if (!(value2.value instanceof Uint8Array) || value2.value.byteLength) throw invalid4();
+          if (!(value2.value instanceof Uint8Array) || value2.value.byteLength) throw invalid6();
         }
-      let value = await request((signal) => exchange(`${route}/part`, {
+      let value = await request2((signal) => exchange(`${route}/part`, {
         method: "POST",
         headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket, "x-oddington-part": String(partNumber) },
         body: part.buffer
@@ -1262,9 +1393,9 @@ async function multipartCreate(input, metadata, exchange, release = () => {
       receipts.push({ partNumber, etag: receipt.etag }), sent += length, lastProgress = Date.now();
     }
     if (upload) for (let name of Object.keys(upload.file.enrichments)) {
-      let bytes = await request(() => upload.enrichment(name));
-      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid4();
-      await request((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
+      let bytes = await request2(() => upload.enrichment(name));
+      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid6();
+      await request2((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
         method: "POST",
         headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket },
         body: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
@@ -1273,13 +1404,13 @@ async function multipartCreate(input, metadata, exchange, release = () => {
     await upload?.beforeComplete();
     let completion = control({ parts: receipts });
     if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024) throw unavailable();
-    return parseFileDescriptor(await request(
+    return parseFileDescriptor(await request2(
       (signal) => exchange(`${route}/complete`, completion, !0, signal),
       TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1e3
     ));
   } catch (error) {
     throw reader && await reader.cancel(error).catch(() => {
-    }), ticket && await request((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {
+    }), ticket && await request2((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {
     }), error instanceof FileOperationError ? error : unavailable();
   } finally {
     chunk = void 0, reader?.releaseLock(), pending.size ? Promise.allSettled([...pending]).then(release) : release();
@@ -1301,7 +1432,7 @@ async function operation(work, initial, parent) {
 function contentPath(id3, name) {
   let path = idPath(id3);
   if (name === void 0) return `${path}/content`;
-  if (!safeEnrichmentName(name)) throw invalid4();
+  if (!safeEnrichmentName(name)) throw invalid6();
   return `${path}/enrichments/${encodeURIComponent(name)}/content`;
 }
 async function read(id3, names) {
@@ -1310,12 +1441,12 @@ async function read(id3, names) {
     let path = contentPath(id3, names);
     return operation((context3, signal) => send(path, { method: "GET" }, !1, context3, signal), context2);
   }
-  if (!Array.isArray(names)) throw invalid4();
+  if (!Array.isArray(names)) throw invalid6();
   let distinct = [], seen = /* @__PURE__ */ new Set();
   for (let name of names) {
-    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid4();
+    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid6();
     if (!seen.has(name)) {
-      if (seen.size === 16) throw invalid4();
+      if (seen.size === 16) throw invalid6();
       seen.add(name), distinct.push(name);
     }
   }
@@ -1350,11 +1481,11 @@ var files = {
   async create(input, options) {
     let context2 = await resolveFilesContext();
     if (!input || typeof input != "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "size", "path", "name", "storage", "csv"].includes(key)) || options !== void 0 && (!options || typeof options != "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "requestKey")))
-      throw invalid4();
+      throw invalid6();
     let blob = input.file instanceof Blob, array3 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
-    if (!blob && !array3 && !stream) throw invalid4();
+    if (!blob && !array3 && !stream) throw invalid6();
     let intrinsic = blob ? input.file.size : array3 ? input.file.byteLength : void 0;
-    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid4();
+    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid6();
     let name = input.name;
     name === void 0 && blob && "name" in input.file && typeof input.file.name == "string" && (name = typeof globalThis.File < "u" && input.file instanceof globalThis.File ? input.file.name : input.file.name.split(/[\\/]/).at(-1));
     let metadata = parseFileCreateMetadata({
@@ -1368,7 +1499,7 @@ var files = {
     }, FILE_ORIGINAL_MAX_BYTES);
     if (!context2.local && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
     let header = encodeURIComponent(JSON.stringify(metadata));
-    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid4();
+    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid6();
     if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
     return active++, metadata.size > MAX_BYTES ? multipartCreate(input, metadata, (suffix, init2, kind, signal) => kind === !0 ? send(suffix, init2, !0, context2, signal) : send(suffix, init2, "control", context2, signal)) : timed(async (signal) => {
       try {
@@ -1376,7 +1507,7 @@ var files = {
           blob ? input.file.stream() : input.file,
           metadata.size
         );
-        if (bytes.byteLength !== metadata.size) throw invalid4();
+        if (bytes.byteLength !== metadata.size) throw invalid6();
         if (signal.aborted) throw unavailable();
         return await send("", {
           method: "POST",
@@ -1392,7 +1523,7 @@ var files = {
   },
   async enrich(input) {
     let context2 = await resolveFilesContext();
-    if (!input || typeof input != "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "name", "content", "mediaType", "replace"].includes(key)) || typeof input.content != "string" && !(input.content instanceof Uint8Array)) throw invalid4();
+    if (!input || typeof input != "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "name", "content", "mediaType", "replace"].includes(key)) || typeof input.content != "string" && !(input.content instanceof Uint8Array)) throw invalid6();
     let path = `${idPath(input.file)}/enrichments`;
     if (typeof input.content == "string" ? input.content.length > MAX_BYTES : input.content.byteLength > MAX_BYTES)
       throw new FileOperationError("request_too_large", 413);
@@ -1409,7 +1540,7 @@ var files = {
         ...input.mediaType === void 0 ? {} : { mediaType: input.mediaType },
         ...input.replace === void 0 ? {} : { replace: input.replace }
       }, MAX_BYTES), header = encodeURIComponent(JSON.stringify(metadata));
-      if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid4();
+      if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid6();
       let result2 = await send(path, { method: "POST", headers: {
         "content-type": "application/octet-stream",
         "x-oddington-enrichment": header
@@ -1445,8 +1576,8 @@ function parseConnectionLease(raw, now = Date.now()) {
 }
 
 var AirtableOperationError = class extends Error {
-  constructor(message, effect = "unapplied", receipts = []) {
-    super(message);
+  constructor(message2, effect = "unapplied", receipts = []) {
+    super(message2);
     this.effect = effect;
     this.receipts = receipts;
     this.name = "AirtableOperationError";
@@ -1456,10 +1587,10 @@ var AirtableOperationError = class extends Error {
 };
 
 var recordId = (v) => typeof v == "string" && /^rec[A-Za-z0-9]+$/.test(v), tableId = (v) => typeof v == "string" && /^tbl[A-Za-z0-9]+$/.test(v);
-function fail2(message) {
-  throw new AirtableOperationError(message);
+function fail2(message2) {
+  throw new AirtableOperationError(message2);
 }
-function object2(v) {
+function object3(v) {
   return (!v || typeof v != "object" || Array.isArray(v) || ![null, Object.prototype].includes(Object.getPrototypeOf(v))) && fail2("Invalid Airtable data"), v;
 }
 function keys2(v, allowed, required = allowed) {
@@ -1469,7 +1600,7 @@ function text2(v) {
   return typeof v == "string" && v.length > 0 && v.length <= 1024;
 }
 function fields3(v, nonempty = !1) {
-  let result2 = object2(v);
+  let result2 = object3(v);
   (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text2(k))) && fail2("Invalid Airtable fields");
   try {
     return serializable(result2);
@@ -1478,7 +1609,7 @@ function fields3(v, nonempty = !1) {
   }
 }
 function record2(v) {
-  let r = object2(v);
+  let r = object3(v);
   return (!recordId(r.id) || r.createdTime !== void 0 && (typeof r.createdTime != "string" || !Number.isFinite(Date.parse(r.createdTime)))) && fail2("Malformed Airtable record"), { id: r.id, ...r.createdTime === void 0 ? {} : { createdTime: r.createdTime }, fields: fields3(r.fields) };
 }
 function equal(a, b) {
@@ -1511,7 +1642,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
   (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(name) || !/^app[A-Za-z0-9]+$/.test(baseId) || !/^[A-Za-z0-9._~+/-]{1,8192}={0,2}$/.test(accessToken)) && fail2("Airtable connection unavailable");
   let input;
   try {
-    input = object2(serializable(raw));
+    input = object3(serializable(raw));
   } catch {
     return fail2("Invalid Airtable input");
   }
@@ -1523,7 +1654,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     operation: operation2.slice(8),
     records: ids2.map((id3) => ({ id: id3 }))
   });
-  async function request(path2, init2 = {}, write = !1) {
+  async function request2(path2, init2 = {}, write = !1) {
     let response2;
     try {
       response2 = await (options.fetch ?? fetch)(`https://api.airtable.com/v0/${path2}`, {
@@ -1540,7 +1671,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
       }), new AirtableOperationError("Airtable request rejected", write && (response2.status >= 500 || response2.status === 408 || response2.status < 400) ? "uncertain" : "unapplied");
     try {
       if (!response2.headers.get("content-type")?.toLowerCase().includes("application/json")) throw new Error();
-      let value = object2(await response2.json()), safe = serializable(value);
+      let value = object3(await response2.json()), safe = serializable(value);
       if (Object.hasOwn(value, "error") || JSON.stringify(safe).includes(accessToken)) throw new Error();
       return value;
     } catch {
@@ -1551,13 +1682,13 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     keys2(input, []);
     let tables = [], seen = /* @__PURE__ */ new Set(), offset;
     do {
-      let query2 = new URLSearchParams(offset ? { offset } : {}), page = await request(`meta/bases/${baseId}/tables?${query2}`);
+      let query2 = new URLSearchParams(offset ? { offset } : {}), page = await request2(`meta/bases/${baseId}/tables?${query2}`);
       Array.isArray(page.tables) || fail2("Malformed Airtable tables");
       for (let value of page.tables) {
-        let t = object2(value);
+        let t = object3(value);
         (!tableId(t.id) || !text2(t.name) || !text2(t.primaryFieldId) || !Array.isArray(t.fields) || tables.some((existing) => existing.id === t.id)) && fail2("Malformed Airtable table");
         let metadata = t.fields.map((value2) => {
-          let f = object2(value2);
+          let f = object3(value2);
           return (typeof f.id != "string" || !/^fld[A-Za-z0-9]+$/.test(f.id) || !text2(f.name) || !text2(f.type)) && fail2("Malformed Airtable field"), { id: f.id, name: f.name, type: f.type, ...f.options === void 0 ? {} : { options: serializable(f.options) } };
         });
         (!metadata.some((f) => f.id === t.primaryFieldId) || new Set(metadata.map((f) => f.id)).size !== metadata.length) && fail2("Malformed Airtable fields"), tables.push({ id: t.id, name: t.name, primaryFieldId: t.primaryFieldId, fields: metadata });
@@ -1570,7 +1701,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
   let path = `${baseId}/${encodeURIComponent(input.table)}`;
   if (operation2 === "records.get") {
     keys2(input, ["table", "id"]), recordId(input.id) || fail2("Invalid Airtable record ID");
-    let result3 = record2(await request(`${path}/${input.id}`));
+    let result3 = record2(await request2(`${path}/${input.id}`));
     return result3.id !== input.id && fail2("Malformed Airtable record"), result3;
   }
   if (operation2 === "records.list") {
@@ -1580,7 +1711,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
       let query2 = new URLSearchParams();
       for (let field of input.fields ?? []) query2.append("fields[]", field);
       offset && query2.set("offset", offset);
-      let page = await request(`${path}?${query2}`);
+      let page = await request2(`${path}?${query2}`);
       Array.isArray(page.records) || fail2("Malformed Airtable records");
       for (let value of page.records) {
         let r = record2(value);
@@ -1592,7 +1723,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
   }
   mutation || fail2("Unsupported Airtable operation"), keys2(input, ["table", "records"]), (!Array.isArray(input.records) || !input.records.length || input.records.length > 10) && fail2("Invalid Airtable batch");
   let kind = operation2.slice(8), ids = /* @__PURE__ */ new Set(), records = input.records.map((value) => {
-    let r = object2(value);
+    let r = object3(value);
     if (keys2(r, kind === "create" ? ["fields"] : kind === "update" ? ["id", "expected", "set"] : ["id", "expected"]), kind === "create") return { fields: fields3(r.fields, !0) };
     (!recordId(r.id) || ids.has(r.id)) && fail2("Invalid Airtable batch record ID"), ids.add(r.id);
     let set = kind === "update" ? fields3(r.set, !0) : void 0;
@@ -1600,7 +1731,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
   });
   for (let r of records) {
     if (!("id" in r)) continue;
-    let current2 = record2(await request(`${path}/${r.id}`));
+    let current2 = record2(await request2(`${path}/${r.id}`));
     current2.id !== r.id && fail2("Malformed Airtable record");
     for (let [key, value] of Object.entries(r.expected))
       (value === null ? Object.hasOwn(current2.fields, key) : !Object.hasOwn(current2.fields, key) || !equal(current2.fields[key], value)) && fail2("Airtable reviewed values are stale");
@@ -1608,14 +1739,14 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
   await options.beforeMutation?.();
   let query = new URLSearchParams();
   if (kind === "delete") for (let id3 of ids) query.append("records[]", id3);
-  let result2 = await request(`${path}${kind === "delete" ? `?${query}` : ""}`, {
+  let result2 = await request2(`${path}${kind === "delete" ? `?${query}` : ""}`, {
     method: kind === "create" ? "POST" : kind === "update" ? "PATCH" : "DELETE",
     ...kind === "delete" ? {} : { body: JSON.stringify({ records: records.map((r) => "id" in r ? { id: r.id, fields: r.set } : r) }) }
   }, !0), acknowledged = [], returned = [];
   try {
     if (!Array.isArray(result2.records)) throw new Error();
     for (let value of result2.records) {
-      let r = object2(value);
+      let r = object3(value);
       if (!recordId(r.id) || acknowledged.includes(r.id) || kind !== "create" && !ids.has(r.id) || kind === "delete" && r.deleted !== !0) throw new Error();
       acknowledged.push(r.id), kind !== "delete" && returned.push(record2(r));
     }
@@ -1717,8 +1848,8 @@ var connections = /* @__PURE__ */ createConnections(async (name, operation2, inp
 var LOCAL_ROUTINE_VALUE_BYTES = 256 * 1024;
 
 var RECORD_WRITE_INPUT_LIMIT = 8 * 1024 * 1024, RoutineRecordWriteError = class extends Error {
-  constructor(message, effect) {
-    super(message);
+  constructor(message2, effect) {
+    super(message2);
     this.effect = effect;
     this.name = "RoutineRecordWriteError";
   }
@@ -1769,10 +1900,10 @@ function validateRecordChange(value) {
   return writes.length && validateRecordWrite({ repository: input.repository, records: writes }), deletes.length && validateRecordDelete({ repository: input.repository, records: deletes }), structuredClone(input);
 }
 function validateRoutineRecordWrite(value) {
-  let body2 = serializable(value);
-  if (!body2 || typeof body2 != "object" || Array.isArray(body2) || Object.keys(body2).sort().join(",") !== "input,requestKey" || typeof body2.requestKey != "string" || !body2.requestKey.trim() || body2.requestKey !== body2.requestKey.trim() || body2.requestKey.length > 512)
+  let body = serializable(value);
+  if (!body || typeof body != "object" || Array.isArray(body) || Object.keys(body).sort().join(",") !== "input,requestKey" || typeof body.requestKey != "string" || !body.requestKey.trim() || body.requestKey !== body.requestKey.trim() || body.requestKey.length > 512)
     throw new InboxContractError("A stable routine request key is required");
-  return { input: validateRecordChange(body2.input), requestKey: body2.requestKey };
+  return { input: validateRecordChange(body.input), requestKey: body.requestKey };
 }
 function validCreatePath(value) {
   return value === value.trim() && value.endsWith(".md") && !value.startsWith("/") && value.split("/").every((segment) => !!segment && ![".", ".."].includes(segment) && /^[a-zA-Z0-9_.-]+$/.test(segment));
@@ -1808,10 +1939,10 @@ var operations = {
 function assert(value) {
   if (!value) throw new Error("Invalid Inbox result");
 }
-function object3(value) {
+function object4(value) {
   return assert(value && typeof value == "object" && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value)) && Reflect.ownKeys(value).every((key) => {
-    let descriptor2 = typeof key == "string" ? Object.getOwnPropertyDescriptor(value, key) : void 0;
-    return !!descriptor2?.enumerable && "value" in descriptor2;
+    let descriptor = typeof key == "string" ? Object.getOwnPropertyDescriptor(value, key) : void 0;
+    return !!descriptor?.enumerable && "value" in descriptor;
   })), value;
 }
 function keys3(value, allowed, required = allowed) {
@@ -1834,41 +1965,41 @@ function optionalDate(value) {
 }
 function array2(value) {
   return assert(Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype && Reflect.ownKeys(value).length === value.length + 1 && value.every((_entry, index) => {
-    let descriptor2 = Object.getOwnPropertyDescriptor(value, String(index));
-    return !!descriptor2?.enumerable && "value" in descriptor2;
+    let descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    return !!descriptor?.enumerable && "value" in descriptor;
   })), value;
 }
-function json2(value, ancestors = /* @__PURE__ */ new Set()) {
+function json(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value == "boolean" || typeof value == "string" || typeof value == "number" && Number.isFinite(value)) return value;
   assert(value && typeof value == "object" && !ancestors.has(value)), ancestors.add(value);
   try {
-    return Array.isArray(value) ? array2(value).map((entry) => json2(entry, ancestors)) : Object.fromEntries(Object.entries(object3(value)).map(([key, entry]) => [key, json2(entry, ancestors)]));
+    return Array.isArray(value) ? array2(value).map((entry) => json(entry, ancestors)) : Object.fromEntries(Object.entries(object4(value)).map(([key, entry]) => [key, json(entry, ancestors)]));
   } finally {
     ancestors.delete(value);
   }
 }
 function recordReference(value) {
-  let record3 = object3(value);
+  let record3 = object4(value);
   return keys3(record3, ["repository", "ref"]), assert(text3(record3.repository) && record3.repository === record3.repository.trim() && /^[a-z0-9][a-z0-9._/-]{0,127}$/.test(record3.repository) && !/\.\.|\/\//.test(record3.repository) && text3(record3.ref) && record3.ref === record3.ref.trim() && record3.ref.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)+$/.test(record3.ref)), record3;
 }
 function responseDefinition(value) {
-  let definition = object3(value);
+  let definition = object4(value);
   keys3(definition, ["type", "source"]), assert(definition.type === "selection");
-  let source = object3(definition.source);
+  let source = object4(definition.source);
   if (source.type === "authored") {
     keys3(source, ["type", "options", "suggestions", "search"], ["type", "options"]);
     let options = array2(source.options);
     assert(options.length > 0);
     let values = options.map((value2) => {
-      let option = object3(value2);
+      let option = object4(value2);
       if (keys3(option, ["value", "label", "description", "note"], ["value", "label"]), assert(text3(option.value) && option.value === option.value.trim() && text3(option.label)), "description" in option && assert(text3(option.description)), "note" in option) {
-        let note = object3(option.note);
+        let note = object4(option.note);
         keys3(note, ["placeholder"]), assert(text3(note.placeholder));
       }
       return option.value;
     });
     if (assert(new Set(values).size === values.length), "search" in source || "suggestions" in source) {
-      let search = object3(source.search);
+      let search = object4(source.search);
       keys3(search, ["triggerLabel", "placeholder", "emptyLabel"]), assert(text3(search.triggerLabel) && text3(search.placeholder) && text3(search.emptyLabel));
       let suggestions2 = array2(source.suggestions);
       assert(suggestions2.length <= 8 && suggestions2.every((value2) => text3(value2) && values.includes(value2)) && new Set(suggestions2).size === suggestions2.length);
@@ -1876,16 +2007,16 @@ function responseDefinition(value) {
     return;
   }
   assert(source.type === "records"), keys3(source, ["type", "collection", "refPrefix", "where", "display", "suggestions"], ["type", "collection", "display"]);
-  let collection = object3(source.collection);
+  let collection = object4(source.collection);
   keys3(collection, ["repository", "name"]), recordReference({ repository: collection.repository, ref: "records/example" }), assert(text3(collection.name) && /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/.test(collection.name)), "refPrefix" in source && assert(text3(source.refPrefix) && source.refPrefix.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)*\/$/.test(source.refPrefix));
-  let where = object3(source.where ?? {});
+  let where = object4(source.where ?? {});
   assert(Object.entries(where).every(([name, value2]) => /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name) && !["constructor", "prototype"].includes(name) && (value2 === null || typeof value2 == "string" || typeof value2 == "boolean" || typeof value2 == "number" && Number.isFinite(value2))));
-  let display = object3(source.display);
+  let display = object4(source.display);
   keys3(display, ["labelFields"]);
   let labels = array2(display.labelFields);
   assert(labels.length > 0 && labels.length <= 2 && new Set(labels).size === labels.length && labels.every((value2) => text3(value2) && /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value2)));
   let suggestions = array2(source.suggestions ?? []), refs = suggestions.map((value2) => {
-    let suggestion = object3(value2);
+    let suggestion = object4(value2);
     keys3(suggestion, ["record", "reason"], ["record"]);
     let record3 = recordReference(suggestion.record);
     return assert(record3.repository === collection.repository), "reason" in suggestion && assert(text3(suggestion.reason)), record3.ref;
@@ -1893,20 +2024,20 @@ function responseDefinition(value) {
   assert(suggestions.length <= 8 && new Set(refs).size === refs.length);
 }
 function inboxFile(value) {
-  let file2 = object3(value);
+  let file2 = object4(value);
   keys3(file2, ["id", "name", "mediaType", "size", "sha256", "details"]), assert(id2(file2.id) && text3(file2.name) && !/[\x00-\x1f\x7f/\\]/.test(file2.name) && text3(file2.mediaType) && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(file2.mediaType) && integer(file2.size, 0) && file2.size <= 25 * 1024 * 1024 && typeof file2.sha256 == "string" && /^[0-9a-f]{64}$/.test(file2.sha256));
-  let details = object3(file2.details);
+  let details = object4(file2.details);
   details.kind === "csv" ? (keys3(details, ["kind", "encoding", "delimiter", "headerRow", "dataRows"]), assert(file2.mediaType === "text/csv" && ["utf-8", "windows-1252"].includes(String(details.encoding)) && [",", ";", "	"].includes(String(details.delimiter)) && integer(details.headerRow, 0) && integer(details.dataRows, 0))) : details.kind === "pdf" ? (keys3(details, ["kind", "pages"], ["kind"]), assert(file2.mediaType === "application/pdf" && (!("pages" in details) || integer(details.pages)))) : (keys3(details, ["kind"]), assert(details.kind === "other" && !["text/csv", "application/pdf"].includes(file2.mediaType)));
 }
 function fields4(value) {
   let labels = array2(value).map((value2) => {
-    let field = object3(value2);
+    let field = object4(value2);
     return keys3(field, ["label", "value"]), assert(text3(field.label) && text3(field.value)), field.label;
   });
   assert(new Set(labels).size === labels.length);
 }
 function block(value) {
-  let entry = object3(value);
+  let entry = object4(value);
   if (entry.kind === "rich-text") {
     keys3(entry, ["kind", "markdown"]), assert(text3(entry.markdown));
     return;
@@ -1922,31 +2053,31 @@ function block(value) {
     ["kind", "label", "initiallyExpanded", ...entry.kind === "record" ? ["record", "view"] : entry.kind === "records" ? ["records", "view"] : ["files"]],
     ["kind", "label", entry.kind === "record" ? "record" : entry.kind === "records" ? "records" : "files"]
   ), assert(text3(entry.label) && (!("initiallyExpanded" in entry) || typeof entry.initiallyExpanded == "boolean") && (!("view" in entry) || text3(entry.view) && entry.view === entry.view.trim())), entry.kind === "record") {
-    let record3 = object3(entry.record);
+    let record3 = object4(entry.record);
     keys3(record3, ["ref", "title", "fields"]), assert(text3(record3.ref) && record3.ref === record3.ref.trim() && text3(record3.title)), fields4(record3.fields);
     return;
   }
   if (entry.kind === "records") {
     let records = array2(entry.records), refs = records.map((value2) => {
-      let record3 = object3(value2);
+      let record3 = object4(value2);
       return keys3(record3, ["ref", "title", "description", "facts", "view"], ["ref", "title"]), assert(text3(record3.ref) && record3.ref === record3.ref.trim() && text3(record3.title)), "description" in record3 && assert(text3(record3.description)), "facts" in record3 && fields4(record3.facts), "view" in record3 && assert(text3(record3.view) && record3.view === record3.view.trim()), record3.ref;
     });
     assert(records.length > 0 && new Set(refs).size === refs.length);
     return;
   }
   let files3 = array2(entry.files);
-  files3.forEach(inboxFile), assert(files3.length > 0 && new Set(files3.map((value2) => object3(value2).id)).size === files3.length);
+  files3.forEach(inboxFile), assert(files3.length > 0 && new Set(files3.map((value2) => object4(value2).id)).size === files3.length);
 }
 function response(value) {
-  let answer = object3(value);
+  let answer = object4(value);
   return assert(Object.keys(answer).every((key) => ["selection", "note"].includes(key))), typeof answer.selection == "string" ? assert(text3(answer.selection) && answer.selection === answer.selection.trim()) : recordReference(answer.selection), Object.hasOwn(answer, "note") && assert(text3(answer.note)), answer;
 }
-function parseInboxRequest(value, questionListContext = "local") {
+function parseInboxRequest(value) {
   try {
-    let envelope = object3(value);
+    let envelope = object4(value);
     assert(Object.keys(envelope).sort().join(",") === "input,operation"), assert(typeof envelope.operation == "string" && Object.hasOwn(operations, envelope.operation));
-    let operation2 = envelope.operation, input = { ...object3(envelope.input) }, required = operations[operation2];
-    assert(required.every((key) => Object.hasOwn(input, key)) && Object.keys(input).every((key) => required.includes(key) || operation2 === "questions.searchRecords" && key === "selected" || (operation2 === "items.list" || operation2 === "questions.list") && key === "beforeNumber" || operation2 === "questions.list" && questionListContext === "hosted" && key === "routines")), operation2 === "questions.list" && questionListContext === "hosted" && (assert(Object.hasOwn(input, "routines")), assert(array2(input.routines).every(isAppRoutineName)));
+    let operation2 = envelope.operation, input = { ...object4(envelope.input) }, required = operations[operation2];
+    assert(required.every((key) => Object.hasOwn(input, key)) && Object.keys(input).every((key) => required.includes(key) || operation2 === "questions.searchRecords" && key === "selected" || (operation2 === "items.list" || operation2 === "questions.list") && key === "beforeNumber" || operation2 === "questions.list" && key === "routines")), operation2 === "questions.list" && (assert(Object.hasOwn(input, "routines")), assert(array2(input.routines).every(isAppRoutineName)));
     for (let key of ["itemId", "personId", "fileId"]) key in input && assert(id2(input[key]));
     return "revision" in input && assert(integer(input.revision)), "beforeNumber" in input && assert(integer(input.beforeNumber)), "questionId" in input && assert(text3(input.questionId) && input.questionId === input.questionId.trim()), "title" in input && assert(text3(input.title)), "lifecycle" in input && assert(input.lifecycle === "open" || input.lifecycle === "closed"), "query" in input && assert(text3(input.query, !0) && input.query.length <= 256), "selected" in input && recordReference(input.selected), "response" in input && response(input.response), assert(new TextEncoder().encode(JSON.stringify(envelope)).byteLength <= INBOX_INPUT_BYTES), "routines" in input && (input.routines = [...new Set(input.routines)]), { operation: operation2, input };
   } catch {
@@ -1954,80 +2085,84 @@ function parseInboxRequest(value, questionListContext = "local") {
   }
 }
 function parseInboxCurrent(value) {
-  let current2 = object3(value), workspace = object3(current2.workspace), viewer = object3(current2.viewer);
+  let current2 = object4(value), workspace = object4(current2.workspace), viewer = object4(current2.viewer);
   return assert(id2(workspace.id) && text3(workspace.slug) && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace.slug) && text3(workspace.name) && text3(workspace.locale) && text3(workspace.timezone)), assert(id2(viewer.id) && text3(viewer.name) && text3(viewer.email)), {
     workspace: { id: workspace.id, slug: workspace.slug, name: workspace.name, locale: workspace.locale, timezone: workspace.timezone },
     viewer: { id: viewer.id, name: viewer.name, email: viewer.email }
   };
 }
 function parseInboxItem(value) {
-  let item = object3(json2(value));
-  return assert(id2(item.id) && id2(item.workspaceId) && integer(item.number) && integer(item.revision) && integer(item.activityVersion, 0) && ["ask", "digest"].includes(String(item.kind)) && ["open", "closed"].includes(String(item.lifecycle)) && text3(item.title) && text3(item.description, !0) && text3(item.author) && date(item.publishedAt) && optionalDate(item.seenAt) && optionalDate(item.digestReadAt)), item.outcome !== null && assert(text3(object3(item.outcome).outcome)), array2(item.body).forEach(block), array2(item.views).forEach((value2) => {
-    let view = object3(value2);
-    assert(text3(view.id) && text3(view.view) && text3(view.implementation)), json2(view.input);
+  let item = object4(json(value));
+  return assert(id2(item.id) && id2(item.workspaceId) && integer(item.number) && integer(item.revision) && integer(item.activityVersion, 0) && ["ask", "digest"].includes(String(item.kind)) && ["open", "closed"].includes(String(item.lifecycle)) && text3(item.title) && text3(item.description, !0) && text3(item.author) && date(item.publishedAt) && optionalDate(item.seenAt) && optionalDate(item.digestReadAt)), item.outcome !== null && assert(text3(object4(item.outcome).outcome)), "canonicalRoutineId" in item && assert(item.canonicalRoutineId === null || isAppRoutineName(item.canonicalRoutineId)), array2(item.body).forEach(block), array2(item.views).forEach((value2) => {
+    let view = object4(value2);
+    assert(text3(view.id) && text3(view.view) && text3(view.implementation)), json(view.input);
   }), array2(item.people).forEach((value2) => {
-    let person = object3(value2);
+    let person = object4(value2);
     assert(id2(person.id) && text3(person.name));
   }), array2(item.questions).forEach((value2) => {
-    let question2 = object3(value2);
+    let question2 = object4(value2);
     if (assert(text3(question2.id) && id2(question2.to) && text3(question2.prompt) && (question2.instructions === null || text3(question2.instructions, !0)) && typeof question2.available == "boolean"), responseDefinition(question2.response), assert(array2(question2.allowedResponders).every(id2)), question2.acceptedResponse !== null) {
-      let accepted = object3(question2.acceptedResponse);
+      let accepted = object4(question2.acceptedResponse);
       assert(id2(accepted.id) && id2(accepted.userId) && date(accepted.acceptedAt)), response(accepted.response), accepted.label === null ? delete accepted.label : "label" in accepted && assert(text3(accepted.label)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder));
     }
     if (question2.execution !== null) {
-      let execution = object3(question2.execution);
+      let execution = object4(question2.execution);
       if (assert(id2(execution.id) && ["pending", "running", "completed", "failed"].includes(String(execution.state)) && integer(execution.attempt, 0)), "consequence" in execution) {
-        let consequence = object3(execution.consequence);
+        let consequence = object4(execution.consequence);
         assert(["pending", "running", "applied", "no-write", "stopped", "partial", "uncertain"].includes(String(consequence.state)) && (consequence.phase === null || ["loading", "invoking", "committing"].includes(String(consequence.phase))) && date(consequence.updatedAt) && typeof consequence.needsReconciliation == "boolean" && (consequence.reason === null || text3(consequence.reason, !0))), array2(consequence.evidence).forEach((value3) => {
-          let receipt = object3(value3);
+          let receipt = object4(value3);
           assert(text3(receipt.repository) && text3(receipt.commit) && text3(receipt.diff, !0));
         });
       }
     }
   }), array2(item.linkedAsks).forEach((value2) => {
-    let linked = object3(value2);
+    let linked = object4(value2);
     if (assert(id2(linked.id)), linked.state === "unavailable") assert(typeof linked.done == "boolean");
     else if (assert(["yours", "done", "open", "theirs"].includes(String(linked.state)) && text3(linked.title)), linked.state === "theirs") {
-      let assignee = object3(linked.assignee);
+      let assignee = object4(linked.assignee);
       assert(id2(assignee.id) && text3(assignee.name));
     }
   }), array2(item.activity).forEach((value2) => {
-    let event2 = object3(value2);
-    assert(integer(event2.id) && text3(event2.type) && (event2.actorId === null || id2(event2.actorId)) && (event2.questionId === null || text3(event2.questionId)) && integer(event2.revision) && date(event2.createdAt)), object3(event2.data);
+    let event = object4(value2);
+    assert(integer(event.id) && text3(event.type) && (event.actorId === null || id2(event.actorId)) && (event.questionId === null || text3(event.questionId)) && integer(event.revision) && date(event.createdAt)), object4(event.data);
   }), array2(item.work).forEach((value2) => {
-    let work = object3(value2);
+    let work = object4(value2);
     assert(id2(work.id) && text3(work.questionId) && text3(work.reason) && optionalDate(work.settledAt));
   }), item;
 }
 function parseAnswerableQuestion(value) {
-  let entry = object3(json2(value));
-  keys3(entry, ["item", "origin", "question", "recordRefs"]);
-  let item = object3(entry.item);
-  keys3(item, ["id", "number", "revision", "title", "href"]), assert(id2(item.id) && integer(item.number) && integer(item.revision) && text3(item.title) && text3(item.href));
-  let link = new URL(item.href), slug = link.hostname.slice(0, -13);
-  assert(link.hostname.endsWith(".oddington.ai") && slug.length <= 63 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) && !["auth", "www", "api", "os"].includes(slug) && item.href === `https://${slug}.oddington.ai/inbox/${item.id}`);
-  let origin = object3(entry.origin);
-  keys3(origin, ["routine"]), assert(text3(origin.routine) && origin.routine === origin.routine.trim());
-  let question2 = object3(entry.question);
-  keys3(question2, ["id", "prompt", "instructions", "response"]), assert(text3(question2.id) && question2.id === question2.id.trim() && text3(question2.prompt) && (question2.instructions === null || text3(question2.instructions, !0))), responseDefinition(question2.response);
+  let entry = object4(json(value));
+  keys3(
+    entry,
+    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "recordRefs", "instructions"],
+    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "recordRefs"]
+  ), assert(id2(entry.itemId) && integer(entry.revision) && text3(entry.title) && text3(entry.inboxUrl));
+  let link = new URL(entry.inboxUrl), slug = link.hostname.slice(0, -13);
+  assert(link.hostname.endsWith(".oddington.ai") && slug.length <= 63 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) && !["auth", "www", "api", "os"].includes(slug) && entry.inboxUrl === `https://${slug}.oddington.ai/inbox/${entry.itemId}`), assert(isAppRoutineName(entry.routine) && text3(entry.questionId) && entry.questionId === entry.questionId.trim() && text3(entry.prompt) && (!("instructions" in entry) || text3(entry.instructions, !0)) && typeof entry.answerable == "boolean"), responseDefinition(entry.response);
   let refs = array2(entry.recordRefs);
-  return assert(refs.every((ref) => text3(ref) && ref === ref.trim()) && new Set(refs).size === refs.length), entry;
+  return refs.forEach((value2) => {
+    let ref = object4(value2);
+    keys3(ref, ["repository", "id"]), assert(validRepositoryAlias(ref.repository) && text3(ref.id) && /^[a-zA-Z0-9][a-zA-Z0-9._/-]*$/.test(ref.id) && !ref.id.split("/").some((part) => !part || part === "." || part === ".."));
+  }), assert(new Set(refs.map((value2) => {
+    let ref = object4(value2);
+    return JSON.stringify([ref.repository, ref.id]);
+  })).size === refs.length), entry;
 }
 function parseInboxAcceptance(value) {
-  let accepted = object3(value);
+  let accepted = object4(value);
   return assert(id2(accepted.responseId) && date(accepted.acceptedAt)), "executionId" in accepted && assert(id2(accepted.executionId)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder)), "label" in accepted && assert(text3(accepted.label)), accepted;
 }
 function parseInboxResult(operation2, value) {
   if (operation2 === "current") return parseInboxCurrent(value);
   if (operation2 === "questions.list") {
-    let page = object3(value);
+    let page = object4(value);
     keys3(page, ["questions", "nextBeforeNumber"]);
     let questions = array2(page.questions).map(parseAnswerableQuestion);
     return assert(page.nextBeforeNumber === null || integer(page.nextBeforeNumber)), { questions, nextBeforeNumber: page.nextBeforeNumber };
   }
   if (operation2 === "items.read") return parseInboxItem(value);
   if (operation2 === "items.list") {
-    let page = object3(value), items = array2(page.items).map(parseInboxItem);
+    let page = object4(value), items = array2(page.items).map(parseInboxItem);
     return assert(items.length <= 100 && (page.nextBeforeNumber === null || integer(page.nextBeforeNumber))), { items, nextBeforeNumber: page.nextBeforeNumber };
   }
   if (operation2 === "items.see") {
@@ -2035,30 +2170,30 @@ function parseInboxResult(operation2, value) {
     return;
   }
   if (operation2 === "items.markDigestRead") {
-    let read2 = object3(value);
+    let read2 = object4(value);
     return assert(integer(read2.activityId) && date(read2.readAt)), read2;
   }
   if (operation2 === "items.rename" || operation2 === "items.setLifecycle") {
-    let update = object3(value), item = parseInboxItem(update.item);
+    let update = object4(value), item = parseInboxItem(update.item);
     return assert((update.activityId === null || integer(update.activityId)) && optionalDate(update.changedAt)), { ...update, item };
   }
   if (operation2 === "items.listRecipientCandidates") {
     let candidates = array2(value);
     return candidates.forEach((value2) => {
-      let person = object3(value2);
+      let person = object4(value2);
       assert(id2(person.id) && text3(person.name) && text3(person.email));
-    }), assert(new Set(candidates.map((value2) => object3(value2).id)).size === candidates.length), candidates;
+    }), assert(new Set(candidates.map((value2) => object4(value2).id)).size === candidates.length), candidates;
   }
   if (operation2 === "items.addRecipient") {
-    let addition = object3(value), item = parseInboxItem(addition.item);
+    let addition = object4(value), item = parseInboxItem(addition.item);
     return assert(id2(addition.addedPersonId) && item.people.some((person) => person.id === addition.addedPersonId)), { ...addition, item };
   }
   if (operation2 === "questions.answer") return parseInboxAcceptance(value);
   if (operation2 === "questions.searchRecords") {
-    let result2 = object3(value);
+    let result2 = object4(value);
     assert(text3(result2.recordType) && integer(result2.eligibleCount, 0) && integer(result2.matchCount, 0) && Number(result2.matchCount) <= Number(result2.eligibleCount));
     let labeled = (value2) => {
-      let record3 = object3(value2);
+      let record3 = object4(value2);
       recordReference({ repository: record3.repository, ref: record3.ref }), assert(text3(record3.label)), "reason" in record3 && assert(text3(record3.reason));
     };
     return array2(result2.matches).forEach(labeled), array2(result2.suggestions).forEach(labeled), "selected" in result2 && labeled(result2.selected), result2;
@@ -2066,9 +2201,9 @@ function parseInboxResult(operation2, value) {
   throw new Error("File content is not a JSON result");
 }
 
-async function limitedBody(request, limit, timeoutMs) {
-  if (!request.body) return new Uint8Array();
-  let reader = request.body.getReader(), expired = !1, timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+async function limitedBody(request2, limit, timeoutMs) {
+  if (!request2.body) return new Uint8Array();
+  let reader = request2.body.getReader(), expired = !1, timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
     expired = !0, reader.cancel().catch(() => {
     });
   }, timeoutMs), chunks = [], length = 0;
@@ -2213,7 +2348,7 @@ function appContext(origin, active2) {
     }
   }, cancel = () => {
     controller.abort(), access.abort(), clearTimeout(expiry), clearTimeout(startup), clearTimeout(renewalTimer), clearInterval(monitor), globalThis.removeEventListener?.("storage", storageChanged);
-    for (let event2 of ["pageshow", "focus", "visibilitychange"]) globalThis.removeEventListener?.(event2, wake);
+    for (let event of ["pageshow", "focus", "visibilitychange"]) globalThis.removeEventListener?.(event, wake);
   }, invalidate = () => {
     denied = !0, cancel();
     try {
@@ -2226,7 +2361,7 @@ function appContext(origin, active2) {
     } catch {
       return !1;
     }
-  }, sameSession = (value) => !binding || ["appId", "memberId", "workspace", "sessionId"].every((key) => value[key] === binding[key]), bounded = (value) => validBinding(value) && value.expiresAt > Date.now() && value.expiresAt <= Date.now() + 6e5 && sameSession(value), readPair = (candidate) => {
+  }, sameSession = (value) => !binding || ["appId", "memberId", "workspace", "sessionId"].every((key) => value[key] === binding[key]), bounded2 = (value) => validBinding(value) && value.expiresAt > Date.now() && value.expiresAt <= Date.now() + 6e5 && sameSession(value), readPair = (candidate) => {
     let value = JSON.parse(candidate ?? "null");
     if (!validPair(value) || value.context.expiresAt > Date.now() + 6e5 || !sameSession(value.context)) throw new Error();
     return value;
@@ -2261,7 +2396,7 @@ function appContext(origin, active2) {
     if (response2.status >= 500) throw new AppRenewalUnavailable();
     if (!response2.ok) throw new Error();
     let value = await appResponse(response2, 4096, signal);
-    if (!alive() || !bounded(value)) throw new Error();
+    if (!alive() || !bounded2(value)) throw new Error();
     return value;
   }
   function install(value, candidate, raw) {
@@ -2333,7 +2468,7 @@ function appContext(origin, active2) {
           return;
         }
         if (!response2.ok) throw new Error();
-        if (!alive() || !validPair(value) || !bounded(value.context) || (/* @__PURE__ */ new Set([value.credential, value.renewalCredential, pair.credential, pair.renewalCredential])).size !== 4) throw new Error();
+        if (!alive() || !validPair(value) || !bounded2(value.context) || (/* @__PURE__ */ new Set([value.credential, value.renewalCredential, pair.credential, pair.renewalCredential])).size !== 4) throw new Error();
         if (stored() !== previous) {
           await synchronize(requestController.signal);
           return;
@@ -2382,7 +2517,7 @@ function appContext(origin, active2) {
     alive() && resolve().catch(() => {
     });
   };
-  for (let event2 of ["pageshow", "focus", "visibilitychange"]) globalThis.addEventListener?.(event2, wake);
+  for (let event of ["pageshow", "focus", "visibilitychange"]) globalThis.addEventListener?.(event, wake);
   let dispose = () => {
     disposed = !0, cancel();
   };
@@ -2497,13 +2632,13 @@ function hostFailure(error, context2) {
   return !context2.isCurrent() || context2.expiresAt <= Date.now() || error instanceof InboxContextError && error.status === 401 ? stale() : error instanceof InboxContextError && error.status === 403 ? new InboxOperationError(403, "access_denied") : unavailable2();
 }
 async function send2(operation2, input) {
-  let envelope = operation2 === "questions.list" ? void 0 : parseInboxRequest({ operation: operation2, input }), context2;
+  let envelope = parseInboxRequest({ operation: operation2, input }), context2;
   try {
     context2 = await resolveAppContext();
   } catch {
     throw stale();
   }
-  if (envelope ??= parseInboxRequest({ operation: operation2, input }, context2.kind === "local" ? "local" : "hosted"), context2.kind === "local") {
+  if (context2.kind === "local") {
     if (!isAppQuestionOperation(operation2)) throw new InboxOperationError(403, "access_denied");
     let check2 = () => {
       if (!context2.isCurrent() || context2.signal.aborted || context2.expiresAt <= Date.now()) throw stale();
@@ -2524,16 +2659,18 @@ async function send2(operation2, input) {
   }
   if (context2.endpoint !== `https://${context2.workspace}.oddington.ai` || ["auth", "www", "api", "os"].includes(context2.workspace)) throw stale();
   let host;
-  try {
-    host = await resolveHostedInboxContext(context2);
-  } catch (error) {
-    throw hostFailure(error, context2);
+  if (!isAppQuestionOperation(operation2)) {
+    try {
+      host = await resolveHostedInboxContext(context2);
+    } catch (error) {
+      throw hostFailure(error, context2);
+    }
+    if (!host) throw unavailable2();
   }
-  if (!host) throw unavailable2();
   let check = () => {
-    if (!context2.isCurrent() || !host.isCurrent() || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now()) throw stale();
+    if (!context2.isCurrent() || host && !host.isCurrent() || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now()) throw stale();
   };
-  if (check(), host.context.kind === "focused" && !isAppQuestionOperation(operation2))
+  if (check(), host?.context.kind === "focused")
     throw new InboxOperationError(403, "access_denied");
   try {
     let response2 = await fetch(`${context2.endpoint}/api/inbox`, {
@@ -2567,7 +2704,7 @@ async function send2(operation2, input) {
         } finally {
           reader?.releaseLock();
         }
-      }, body2 = new ReadableStream({
+      }, body = new ReadableStream({
         async pull(controller) {
           try {
             check(), reader ??= source.getReader();
@@ -2585,7 +2722,7 @@ async function send2(operation2, input) {
         },
         cancel
       }, { highWaterMark: 0 });
-      return new Response(body2, { status: response2.status, headers: response2.headers });
+      return new Response(body, { status: response2.status, headers: response2.headers });
     }
     let bytes = await limitedBody(response2, INBOX_RESULT_BYTES);
     if (check(), !bytes) throw unavailable2();
@@ -2641,33 +2778,24 @@ var inbox = {
   },
   questions: {
     async list(input) {
-      let supplied = input === void 0 ? void 0 : parseInboxRequest({ operation: "questions.list", input }, "hosted").input;
-      if (supplied && Object.hasOwn(supplied, "beforeNumber")) throw new InboxOperationError(400, "invalid_input");
-      let routines = supplied ? Object.freeze(supplied.routines) : void 0, questions = [], beforeNumber, initial;
+      let supplied = parseInboxRequest({ operation: "questions.list", input }).input;
+      if (Object.hasOwn(supplied, "beforeNumber")) throw new InboxOperationError(400, "invalid_input");
+      let routines = Object.freeze(supplied.routines), questions = [], beforeNumber, initial;
       try {
         initial = await resolveAppContext();
       } catch {
         throw stale();
       }
-      if (initial.kind === "local" ? input !== void 0 : routines === void 0)
-        throw new InboxOperationError(400, "invalid_input");
-      let host;
-      try {
-        host = initial.kind !== "local" && await resolveHostedInboxContext(initial);
-      } catch (error) {
-        throw hostFailure(error, initial);
-      }
-      if (initial.kind !== "local" && !host) throw unavailable2();
       let check = () => {
-        if (!initial.isCurrent() || host && !host.isCurrent() || initial.expiresAt <= Date.now()) throw stale();
+        if (!initial.isCurrent() || initial.expiresAt <= Date.now()) throw stale();
       };
       do {
         check();
         let page = await send2("questions.list", {
-          ...routines === void 0 ? {} : { routines },
+          routines,
           ...beforeNumber === void 0 ? {} : { beforeNumber }
         });
-        if (check(), page.questions.some((question2) => question2.item.href !== `https://${initial.workspace}.oddington.ai/inbox/${question2.item.id}` || routines !== void 0 && !routines.includes(question2.origin.routine)) || beforeNumber !== void 0 && (page.questions.some((question2) => question2.item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable2();
+        if (check(), page.questions.some((question2) => question2.inboxUrl !== `https://${initial.workspace}.oddington.ai/inbox/${question2.itemId}` || !routines.includes(question2.routine)) || beforeNumber !== void 0 && page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber) throw unavailable2();
         if (questions.push(...page.questions), page.nextBeforeNumber === null) return questions;
         beforeNumber = page.nextBeforeNumber;
       } while (!0);
@@ -2704,8 +2832,8 @@ function init({ auth: input }) {
     url.protocol === "https:" && !url.port && !url.username && !url.password && !url.search && !url.hash && url.pathname === "/" && /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(slug) && slug !== "auth" && (endpoint = url.origin, workspace = slug);
   } catch {
   }
-  let active2 = !0, revision = 0, person, token, binding = {}, local = localOrigin ? appContext(localOrigin, () => active2) : void 0, subscription, stopDisposal, uninstall = installMemberContext(async () => {
-    if (local) return local.resolve();
+  let active2 = !0, revision = 0, person, token, binding = {}, local2 = localOrigin ? appContext(localOrigin, () => active2) : void 0, subscription, stopDisposal, uninstall = installMemberContext(async () => {
+    if (local2) return local2.resolve();
     if (!active2 || !endpoint || !workspace || globalThis.location.origin !== endpoint) throw new Error("Hosted Data context unavailable.");
     let started = revision, { data: { session }, error } = await auth2.getSession();
     if (!active2 || globalThis.location.origin !== endpoint || started !== revision || error || !session || person !== void 0 && person !== session.user.id)
@@ -2725,12 +2853,12 @@ function init({ auth: input }) {
       binding
     };
   }), dispose = () => {
-    active2 && (active2 = !1, local?.dispose(), revision++, subscription?.unsubscribe(), stopDisposal?.(), uninstall(), installedDispose === dispose && (installedDispose = void 0));
+    active2 && (active2 = !1, local2?.dispose(), revision++, subscription?.unsubscribe(), stopDisposal?.(), uninstall(), installedDispose === dispose && (installedDispose = void 0));
   };
-  installedDispose = dispose, stopDisposal = registered?.onDispose(dispose), active2 && (subscription = auth2.onAuthStateChange((event2, session) => {
+  installedDispose = dispose, stopDisposal = registered?.onDispose(dispose), active2 && (subscription = auth2.onAuthStateChange((event, session) => {
     let next = session?.user.id ?? null;
-    (event2 === "SIGNED_OUT" || person !== void 0 && next !== person || registered && person !== void 0 && event2 === "SIGNED_IN" && token !== session?.access_token) && (revision++, local?.invalidate()), person = next, token = session?.access_token;
-  }).data.subscription, local?.start());
+    (event === "SIGNED_OUT" || person !== void 0 && next !== person || registered && person !== void 0 && event === "SIGNED_IN" && token !== session?.access_token) && (revision++, local2?.invalidate()), person = next, token = session?.access_token;
+  }).data.subscription, local2?.start());
 }
 var os = { init };
 
@@ -2780,19 +2908,19 @@ function createBrowserAuth(runtime) {
       } catch {
       }
   }
-  function notify(c, event2) {
+  function notify(c, event) {
     for (let listener of c.sessions)
       try {
-        listener(event2, event2 === "SIGNED_OUT" ? null : c.session);
+        listener(event, event === "SIGNED_OUT" ? null : c.session);
       } catch {
       }
   }
   function expire(c) {
     !c.active || !c.session && c.state.status === "expired" || (c.revision++, c.timer && clearTimeout(c.timer), c.session = null, publish(c, { status: "expired" }), notify(c, "SIGNED_OUT"));
   }
-  function accept(c, event2, session) {
-    if (!c.active || event2 === "INITIAL_SESSION" && c.state.status !== "initializing" || event2 === "TOKEN_REFRESHED" && !c.session && c.state.status !== "initializing") return;
-    let replaced = c.session?.user?.id !== session?.user?.id || event2 === "SIGNED_OUT" || !!(event2 === "SIGNED_IN" && c.session && session?.access_token !== c.session.access_token);
+  function accept(c, event, session) {
+    if (!c.active || event === "INITIAL_SESSION" && c.state.status !== "initializing" || event === "TOKEN_REFRESHED" && !c.session && c.state.status !== "initializing") return;
+    let replaced = c.session?.user?.id !== session?.user?.id || event === "SIGNED_OUT" || !!(event === "SIGNED_IN" && c.session && session?.access_token !== c.session.access_token);
     replaced && c.revision++, c.timer && clearTimeout(c.timer);
     let pending = c.state.pending;
     if (!session) {
@@ -2805,7 +2933,7 @@ function createBrowserAuth(runtime) {
     }
     c.session = session;
     let email = typeof session.user.email == "string" ? session.user.email.trim() : "", metadata = session.user.user_metadata, name = ["name", "full_name", "first_name"].map((key) => metadata?.[key]).find((value) => typeof value == "string" && value.trim())?.trim() || email, account = !replaced && c.state.account?.email === email && c.state.account.displayName === name ? c.state.account : Object.freeze({ email, displayName: name });
-    publish(c, { status: "signed_in", account, ...pending ? { pending } : {} }), notify(c, event2);
+    publish(c, { status: "signed_in", account, ...pending ? { pending } : {} }), notify(c, event);
     let checkExpiry = () => {
       if (!c.active || !c.session) return;
       let remaining = c.session.expires_at * 1e3 - Date.now();
@@ -2845,8 +2973,8 @@ function createBrowserAuth(runtime) {
           c.provider.dispose();
           return;
         }
-        let subscription = c.provider.onAuthStateChange((event2, session) => {
-          c.state.status === "initializing" && c.state.pending === "sign_out" || accept(c, event2, session);
+        let subscription = c.provider.onAuthStateChange((event, session) => {
+          c.state.status === "initializing" && c.state.pending === "sign_out" || accept(c, event, session);
         }).data.subscription;
         c.unsubscribe = () => subscription.unsubscribe();
         let started = c.revision, { data: data3, error } = await c.provider.getSession();
@@ -3008,7 +3136,7 @@ function createBrowserAuth(runtime) {
         if (!active2)
           return callback("SIGNED_OUT", null), { data: { subscription: { unsubscribe() {
           } } } };
-        let listener = (event2, session) => callback(event2, session);
+        let listener = (event, session) => callback(event, session);
         return coordinator.sessions.add(listener), sessionObservers.add(listener), callback("INITIAL_SESSION", coordinator.session), { data: { subscription: { unsubscribe() {
           coordinator.sessions.delete(listener), sessionObservers.delete(listener);
         } } } };
@@ -3081,19 +3209,19 @@ async function provider(configuration, guard) {
       }
     },
     fetch: Object.assign(async (input, init2) => {
-      let revision = guard.revision(), request = String(input).startsWith(`${configuration.providerUrl}/auth/v1/oauth/authorizations/`) ? authorizationRequest : void 0, rejectStale = () => {
-        throw request && (request.rejected = !0), new BrowserAuthError("stale");
+      let revision = guard.revision(), request2 = String(input).startsWith(`${configuration.providerUrl}/auth/v1/oauth/authorizations/`) ? authorizationRequest : void 0, rejectStale = () => {
+        throw request2 && (request2.rejected = !0), new BrowserAuthError("stale");
       };
-      request && (!request.current() || !guard.canAuthorize(new Headers(init2?.headers).get("authorization")?.replace(/^Bearer /, "") ?? "")) && rejectStale();
-      let response2 = await fetch(input, { ...init2, redirect: "error" }), body2 = await response2.arrayBuffer();
-      (!guard.current(revision) || request && !request.current()) && rejectStale();
+      request2 && (!request2.current() || !guard.canAuthorize(new Headers(init2?.headers).get("authorization")?.replace(/^Bearer /, "") ?? "")) && rejectStale();
+      let response2 = await fetch(input, { ...init2, redirect: "error" }), body = await response2.arrayBuffer();
+      (!guard.current(revision) || request2 && !request2.current()) && rejectStale();
       let result2 = new Response(
-        [204, 205, 304].includes(response2.status) ? null : body2,
+        [204, 205, 304].includes(response2.status) ? null : body,
         { status: response2.status, statusText: response2.statusText, headers: response2.headers }
-      ), json3 = result2.json.bind(result2);
+      ), json2 = result2.json.bind(result2);
       return result2.json = async () => {
-        let value = await json3();
-        return (!guard.current(revision) || request && !request.current()) && rejectStale(), value && typeof value.access_token == "string" && provenance.set(value.access_token, revision), value;
+        let value = await json2();
+        return (!guard.current(revision) || request2 && !request2.current()) && rejectStale(), value && typeof value.access_token == "string" && provenance.set(value.access_token, revision), value;
       }, result2;
     }, { preconnect: fetch.preconnect })
   });
@@ -3102,15 +3230,15 @@ async function provider(configuration, guard) {
     authorizationQueue = new Promise((resolve) => {
       release = resolve;
     }), await previous;
-    let request = { current: current2, rejected: !1 };
-    authorizationRequest = request;
+    let request2 = { current: current2, rejected: !1 };
+    authorizationRequest = request2;
     try {
       if (!current2()) throw new BrowserAuthError("stale");
       let result2 = await (kind === "get" ? client.oauth.getAuthorizationDetails(id3) : kind === "approve" ? client.oauth.approveAuthorization(id3, { skipBrowserRedirect: !0 }) : client.oauth.denyAuthorization(id3, { skipBrowserRedirect: !0 }));
-      if (request.rejected || !current2()) throw new BrowserAuthError("stale");
+      if (request2.rejected || !current2()) throw new BrowserAuthError("stale");
       return result2;
     } catch (error) {
-      throw request.rejected || !current2() ? new BrowserAuthError("stale") : error;
+      throw request2.rejected || !current2() ? new BrowserAuthError("stale") : error;
     } finally {
       authorizationRequest = void 0, release();
     }
@@ -3122,9 +3250,9 @@ async function provider(configuration, guard) {
       deny: (id3, current2) => authorization("deny", id3, current2)
     },
     getSession: () => client.getSession(),
-    onAuthStateChange: (callback) => client.onAuthStateChange((event2, session) => {
+    onAuthStateChange: (callback) => client.onAuthStateChange((event, session) => {
       let revision = session ? provenance.get(session.access_token) : void 0;
-      revision !== void 0 && !guard.current(revision) || (callback(event2, session), session && provenance.delete(session.access_token));
+      revision !== void 0 && !guard.current(revision) || (callback(event, session), session && provenance.delete(session.access_token));
     }),
     signInWithOtp: (input) => client.signInWithOtp(input),
     verifyOtp: (input) => client.verifyOtp(input),
@@ -3143,188 +3271,166 @@ async function provider(configuration, guard) {
 }
 var auth = /* @__PURE__ */ createBrowserAuth({ provider, failure: (reason) => new BrowserAuthError(reason) });
 
-var identifier = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, isReason = (value) => value === "not_enabled" || value === "authority_unavailable" || value === "execution_unavailable" || value === "invalid_input", AppRoutineError = class extends Error {
+function routineRunHandle(operations2) {
+  return Object.freeze({
+    current: operations2.current,
+    step: operations2.step,
+    ...operations2.publish ? { publish: operations2.publish } : {},
+    async *watch() {
+      let previous;
+      for (; ; ) {
+        let state = await operations2.current(), encoded = JSON.stringify(state);
+        if (encoded !== previous && (previous = encoded, yield state), state.status === "succeeded" || state.status === "failed") return;
+        await (operations2.wait?.() ?? new Promise((resolve) => setTimeout(resolve, 100)));
+      }
+    }
+  });
+}
+
+var identifier = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?![\s\S])/i, SUMMARY_BYTES = 17 * 1024 * 1024, AppRoutineError = class extends Error {
   constructor(reason) {
     super(reason);
     this.reason = reason;
     this.name = "AppRoutineError";
   }
   reason;
-};
-function fail3(reason) {
+}, fail3 = (reason) => {
   throw new AppRoutineError(reason);
-}
-function object4(value) {
-  return !!value && typeof value == "object" && !Array.isArray(value);
-}
-function keys4(value, expected) {
-  return Object.keys(value).sort().join(",") === expected;
-}
+};
 function current(context2) {
   (!context2.isCurrent() || context2.signal.aborted) && fail3("authority_unavailable");
 }
-async function body(context2, response2, maximum) {
+function appDescriptors() {
+  return globalThis[/* @__PURE__ */ Symbol.for("oddington.app.descriptor")]?.routines ?? [];
+}
+async function local() {
+  let context2 = await resolveAppContext().catch(() => fail3("authority_unavailable"));
+  return context2.kind !== "local" ? fail3("execution_unavailable") : (current(context2), context2);
+}
+async function request(key, suffix, init2, maximum = SUMMARY_BYTES, retained) {
+  (!identifier.test(key) || !appDescriptors().some((item) => item.id === key)) && fail3("authority_unavailable");
+  let context2 = retained ?? await local();
+  current(context2);
   try {
-    let value = await appResponse(response2, maximum, context2.signal);
-    return current(context2), response2.ok || (object4(value) && keys4(value, "error") && isReason(value.error) && (value.error === "authority_unavailable" && context2.invalidate(), fail3(value.error)), fail3("authority_unavailable")), value;
+    let response2 = await context2.requestRoutine(key, suffix, init2), value = await appResponse(response2, maximum, context2.signal);
+    if (current(context2), !response2.ok) {
+      let reason = value?.error;
+      reason === "authority_unavailable" && (context2.invalidate(), fail3(reason)), (reason === "invalid_input" || reason === "execution_unavailable") && fail3(reason), fail3("execution_unavailable");
+    }
+    return value;
   } catch (error) {
-    if (current(context2), error instanceof AppResponseReadError || error instanceof AppRoutineError) throw error;
-    return fail3("execution_unavailable");
+    if (current(context2), error instanceof AppRoutineError) throw error;
+    fail3("execution_unavailable");
   }
 }
-function descriptor(value, key) {
-  return (!object4(value) || !keys4(value, "after,key,routine,runId") || value.key !== key || typeof value.runId != "string" || !uuid.test(value.runId) || value.after !== 0 || typeof value.routine != "string" || !identifier.test(value.routine)) && fail3("execution_unavailable"), value;
+function summary(value, key, id3) {
+  let run = value;
+  return (!only(run, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure,publication") || typeof run.id != "string" || !uuid.test(run.id) || id3 !== void 0 && run.id !== id3 || run.routine !== key || run.placement !== "local" || !["queued", "running", "succeeded", "failed"].includes(run.status) || !timestamp(run.createdAt) || !optionalTimes(run) || !Array.isArray(run.steps) || run.steps.length > 64 || run.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,summary,detailAvailable") || typeof step.detailAvailable != "boolean" || !validStep(step)) || new Set(run.steps.map((step) => step.id)).size !== run.steps.length || Object.hasOwn(run, "result") && (run.status !== "succeeded" || !bounded(run.result)) || run.failure !== void 0 && (run.status !== "failed" || !only(run.failure, "message") || !message(run.failure.message)) || run.publication !== void 0 && (run.status !== "succeeded" || !validPublication(run.publication))) && fail3("execution_unavailable"), run;
 }
-function safeValue(value, depth = 0) {
-  return depth > 32 ? !1 : value === null || typeof value == "string" || typeof value == "boolean" ? !0 : typeof value == "number" ? Number.isFinite(value) : Array.isArray(value) ? value.every((item) => safeValue(item, depth + 1)) : object4(value) && Object.entries(value).every(([key, item]) => !["__proto__", "constructor", "prototype"].includes(key) && safeValue(item, depth + 1));
+function only(value, allowed) {
+  return !!value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).every((key) => allowed.split(",").includes(key));
 }
-function event(value, run, steps) {
-  (!object4(value) || value.runId !== run.runId || value.key !== run.key || value.routine !== run.routine || !Number.isSafeInteger(value.sequence) || value.sequence < 1 || new TextEncoder().encode(JSON.stringify(value)).byteLength > 16 * 1024) && fail3("execution_unavailable");
-  let common = "key,routine,runId,sequence,";
-  if (value.type === "started" && keys4(value, common + "type") && value.sequence === 1) return { type: "started" };
-  if (value.type === "step" && typeof value.id == "string" && identifier.test(value.id) && (!steps || steps.includes(value.id)) && keys4(value, "id," + common + (Object.hasOwn(value, "summary") ? "summary,type" : "type")) && (!Object.hasOwn(value, "summary") || safeValue(value.summary)))
-    return {
-      type: "step",
-      id: value.id,
-      ...Object.hasOwn(value, "summary") ? { summary: value.summary } : {}
-    };
-  if (value.type === "finished") {
-    if (value.state === "succeeded" && keys4(value, "key," + (Object.hasOwn(value, "result") ? "result," : "") + "routine,runId,sequence,state,type") && (!Object.hasOwn(value, "result") || safeValue(value.result)))
-      return {
-        type: "finished",
-        state: "succeeded",
-        ...Object.hasOwn(value, "result") ? { result: value.result } : {}
-      };
-    if (value.state === "failed" && value.error === "execution_failed" && keys4(value, "error," + common + "state,type"))
-      return { type: "finished", state: "failed", error: "execution_failed" };
-    if (value.state === "cancelled" && keys4(value, common + "state,type")) return { type: "finished", state: "cancelled" };
-  }
-  return fail3("execution_unavailable");
-}
-async function pause(context2, delay) {
-  current(context2), await new Promise((resolve, reject) => {
-    let abort = () => {
-      clearTimeout(timer), reject(new AppRoutineError("authority_unavailable"));
-    }, timer = setTimeout(() => {
-      context2.signal.removeEventListener("abort", abort), resolve();
-    }, delay);
-    context2.signal.addEventListener("abort", abort, { once: !0 });
-  }), current(context2);
-}
-function handle(context2, run, steps) {
-  return Object.freeze({
-    async *events(...args) {
-      args.length && fail3("invalid_input");
-      let cursor = 0, terminal = !1, delay = 100, retainedBytes = 0, seen = [];
-      for (; !terminal; ) {
-        current(context2);
-        let response2;
-        try {
-          response2 = await context2.requestRoutine(run.key, `runs/${run.runId}/events?after=${cursor}`);
-        } catch {
-          current(context2), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
-          continue;
-        }
-        if (response2.status >= 500) {
-          await response2.body?.cancel(), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
-          continue;
-        }
-        let value;
-        try {
-          value = await body(context2, response2, 80 * 1024);
-        } catch (error) {
-          if (!(error instanceof AppResponseReadError)) throw error;
-          await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
-          continue;
-        }
-        (!object4(value) || !keys4(value, "after,events,terminal") || !Array.isArray(value.events) || value.events.length > 256 || typeof value.terminal != "boolean" || !Number.isSafeInteger(value.after)) && fail3("execution_unavailable");
-        let delivery = [];
-        for (let raw of value.events) {
-          let publicEvent = event(raw, run, steps), encoded = JSON.stringify(raw), sequence = raw.sequence;
-          if (sequence <= cursor) {
-            seen[sequence - 1] !== encoded && fail3("execution_unavailable");
-            continue;
-          }
-          (terminal || sequence !== cursor + 1 || sequence > 256 || (cursor === 0 ? publicEvent.type !== "started" : publicEvent.type === "started")) && fail3("execution_unavailable"), retainedBytes += new TextEncoder().encode(encoded).byteLength, retainedBytes > 1024 * 1024 && fail3("execution_unavailable"), seen.push(encoded), cursor = sequence, terminal = publicEvent.type === "finished", delivery.push(publicEvent);
-        }
-        (value.after !== cursor || value.terminal !== terminal) && fail3("execution_unavailable");
-        for (let item of delivery)
-          current(context2), yield item;
-        delay = 100, terminal || await pause(context2, delivery.length ? 100 : 250);
-      }
+var timestamp = (value) => typeof value == "string" && value.length <= 32 && Number.isFinite(Date.parse(value)), message = (value) => typeof value == "string" && value.length > 0 && value.length <= 512, bounded = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= 256 * 1024;
+function optionalTimes(value) {
+  return (value.startedAt === void 0 || timestamp(value.startedAt)) && (value.finishedAt === void 0 || timestamp(value.finishedAt));
+}
+function validStep(step) {
+  return typeof step.id == "string" && identifier.test(step.id) && typeof step.title == "string" && step.title.length > 0 && step.title.length <= 256 && ["pending", "running", "completed", "failed", "skipped"].includes(step.status) && optionalTimes(step) && (!Object.hasOwn(step, "summary") || bounded(step.summary)) && (!Object.hasOwn(step, "data") || bounded(step.data));
+}
+function validPublication(value) {
+  return value && only(value, value.state === "failed" ? "state,message" : "state") && (["not_needed", "ready", "published"].includes(value.state) || value.state === "failed" && message(value.message));
+}
+function jsonInput(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return;
+  if (!value || typeof value != "object" || ancestors.has(value)) return fail3("invalid_input");
+  let array3 = Array.isArray(value), keys4 = Reflect.ownKeys(value);
+  if (!array3 && ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || array3 && (keys4.length !== value.length + 1 || !Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)).every(Boolean))) return fail3("invalid_input");
+  ancestors.add(value);
+  for (let key of keys4) {
+    if (array3 && key === "length") continue;
+    let descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key != "string" || !descriptor.enumerable || !Object.hasOwn(descriptor, "value")) return fail3("invalid_input");
+    jsonInput(descriptor.value, ancestors);
+  }
+  ancestors.delete(value);
+}
+function structure(value) {
+  return JSON.stringify(value, (_key, item) => item && typeof item == "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
+}
+function handle(key, id3, context2) {
+  return (typeof id3 != "string" || !uuid.test(id3)) && fail3("invalid_input"), routineRunHandle({
+    current: async () => summary(await request(key, `runs/${id3}`, void 0, SUMMARY_BYTES, context2), key, id3),
+    async step(step) {
+      (typeof step != "string" || !identifier.test(step)) && fail3("invalid_input");
+      let value = await request(key, `runs/${id3}/steps/${step}`, void 0, 514 * 1024, context2);
+      return (!only(value, "id,title,status,startedAt,finishedAt,summary,data") || value.id !== step || !validStep(value)) && fail3("execution_unavailable"), value;
     },
-    async cancel(...args) {
-      args.length && fail3("invalid_input");
-      try {
-        let value = await body(context2, await context2.requestRoutine(run.key, `runs/${run.runId}/cancel`, { method: "POST" }), 1024);
-        (!object4(value) || !keys4(value, "cancelled") || value.cancelled !== !0) && fail3("execution_unavailable");
-      } catch (error) {
-        if (current(context2), error instanceof AppRoutineError) throw error;
-        fail3("execution_unavailable");
-      }
+    async publish() {
+      return summary(await request(key, `runs/${id3}/publish`, { method: "POST" }, SUMMARY_BYTES, context2), key, id3);
     }
   });
 }
-async function appRoutineOperation(key, input, recover) {
-  let context2;
-  try {
-    identifier.test(key) || fail3("authority_unavailable");
-    let resolved = await resolveAppContext();
-    if (resolved.kind !== "local" && fail3("execution_unavailable"), context2 = resolved, recover) {
-      let value2 = await body(context2, await context2.requestRoutine(key, "runs"), 16384);
-      (!object4(value2) || !keys4(value2, "runs") || !Array.isArray(value2.runs) || value2.runs.length > 20) && fail3("execution_unavailable");
-      let runs = value2.runs.map((run) => descriptor(run, key));
-      return (new Set(runs.map((run) => run.runId)).size !== runs.length || new Set(runs.map((run) => run.routine)).size > 1) && fail3("execution_unavailable"), runs.map((run) => handle(resolved, run));
-    }
-    let available = await body(context2, await context2.requestAvailability(key), 16 * 1024);
-    object4(available) && keys4(available, "available,reason") && available.available === !1 && isReason(available.reason) && fail3(available.reason), (!object4(available) || !keys4(available, "available,steps") || available.available !== !0 || !Array.isArray(available.steps) || available.steps.length < 1 || available.steps.length > 64 || !available.steps.every((step) => typeof step == "string" && identifier.test(step)) || new Set(available.steps).size !== available.steps.length) && fail3("execution_unavailable");
-    let steps = [...available.steps], encoded;
-    try {
-      encoded = JSON.stringify(input), (encoded === void 0 || new TextEncoder().encode(encoded).byteLength > 16 * 1024) && fail3("invalid_input");
-    } catch {
-      fail3("invalid_input");
-    }
-    let value = await body(context2, await context2.requestRoutine(key, "runs", {
-      method: "POST",
-      body: `{"input":${encoded}}`
-    }), 16 * 1024);
-    return handle(context2, descriptor(value, key), steps);
-  } catch (error) {
-    if (context2 && current(context2), error instanceof AppRoutineError) throw error;
-    return fail3(context2 ? "execution_unavailable" : "authority_unavailable");
-  }
-}
-
-var authorityUnavailable = () => ({ available: !1, reason: "authority_unavailable" }), MAX_RESPONSE_BYTES = 16 * 1024;
-async function availability(key) {
+async function describeAppRoutine(key) {
+  let descriptor = appDescriptors().find((item) => item.id === key);
+  if (!descriptor) return fail3("authority_unavailable");
+  let unavailable3 = () => ({
+    ...structuredClone(descriptor),
+    connections: descriptor.connections.map((connection) => ({ ...connection, available: !1 })),
+    readiness: { state: "unavailable", reason: "capability_unavailable", message: "Routine capability unavailable." }
+  });
   try {
-    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/.test(key)) return authorityUnavailable();
-    let context2 = await resolveAppContext();
-    if (context2.kind !== "local") return { available: !1, reason: "execution_unavailable" };
-    let response2 = await context2.requestAvailability(key);
-    if (!response2.ok || response2.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json")
-      return authorityUnavailable();
-    let value = await appResponse(response2, MAX_RESPONSE_BYTES, context2.signal);
-    if (!context2.isCurrent() || !value || typeof value != "object" || Array.isArray(value)) return authorityUnavailable();
-    let result2 = value;
-    return result2.available === !1 && Object.keys(result2).sort().join(",") === "available,reason" && (result2.reason === "not_enabled" || result2.reason === "authority_unavailable" || result2.reason === "execution_unavailable") ? { available: !1, reason: result2.reason } : result2.available !== !0 || Object.keys(result2).sort().join(",") !== "available,steps" || !Array.isArray(result2.steps) || result2.steps.length < 1 || result2.steps.length > 64 || !result2.steps.every((step) => typeof step == "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/.test(step)) || new Set(result2.steps).size !== result2.steps.length ? authorityUnavailable() : { available: !0, steps: [...result2.steps] };
+    let value = await request(key, "describe", void 0, 1048576);
+    return (!only(value, "id,title,input,connections,steps,readiness") || !value.readiness || !Array.isArray(value.connections) || structure({ ...value, readiness: void 0, connections: value.connections.map(({ available, ...item }) => item) }) !== structure(descriptor) || value.connections.some((item) => typeof item.available != "boolean") || !(value.readiness.state === "ready" && only(value.readiness, "state,placement") && value.readiness.placement === "local" || value.readiness.state === "unavailable" && only(value.readiness, "state,reason,message") && ["not_deployed", "definition_invalid", "capability_unavailable"].includes(value.readiness.reason) && message(value.readiness.message))) && fail3("execution_unavailable"), value;
   } catch {
-    return authorityUnavailable();
+    return unavailable3();
   }
 }
-var app = Object.freeze({ routines: new Proxy(/* @__PURE__ */ Object.create(null), {
-  get(_target, key) {
-    if (typeof key == "string")
-      return Object.freeze({
-        availability: (...args) => args.length ? Promise.resolve(authorityUnavailable()) : availability(key),
-        run: (...args) => args.length === 1 ? appRoutineOperation(key, args[0], !1) : Promise.reject(new AppRoutineError("invalid_input")),
-        recover: (...args) => args.length === 0 ? appRoutineOperation(key, void 0, !0) : Promise.reject(new AppRoutineError("invalid_input"))
-      });
-  },
-  set: () => !1,
-  defineProperty: () => !1,
-  deleteProperty: () => !1
-}) });
+function appRoutineBinding(key) {
+  return Object.freeze({
+    describe: () => describeAppRoutine(key),
+    async run(...args) {
+      args.length > 1 && fail3("invalid_input");
+      let encoded;
+      try {
+        if (args[0] === void 0) encoded = "{}";
+        else {
+          jsonInput(args[0]);
+          let input = JSON.stringify(args[0]);
+          new TextEncoder().encode(input).byteLength > 256 * 1024 && fail3("invalid_input"), encoded = `{"input":${input}}`;
+        }
+      } catch {
+        return fail3("invalid_input");
+      }
+      let context2 = await local(), run = summary(await request(key, "runs", { method: "POST", body: encoded }, SUMMARY_BYTES, context2), key);
+      return handle(key, run.id, context2);
+    },
+    runs: Object.freeze({
+      async list() {
+        let value = await request(key, "runs", void 0, 20 * SUMMARY_BYTES);
+        if (!Array.isArray(value) || value.length > 20) return fail3("execution_unavailable");
+        let runs = value.map((run) => summary(run, key));
+        return new Set(runs.map((run) => run.id)).size !== runs.length && fail3("execution_unavailable"), runs;
+      },
+      async get(id3) {
+        let run = handle(key, id3, await local());
+        return await run.current(), run;
+      }
+    })
+  });
+}
+
+var app = Object.freeze({
+  listRoutines: () => Promise.all(appDescriptors().map(({ id: id3 }) => describeAppRoutine(id3))),
+  routines: new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, key) {
+      if (!(typeof key != "string" || !appDescriptors().some((item) => item.id === key)))
+        return appRoutineBinding(key);
+    },
+    set: () => !1,
+    defineProperty: () => !1,
+    deleteProperty: () => !1
+  })
+});
 
 var LIMIT2 = 16 * 1024, context;
 var appRun = {
@@ -3354,10 +3460,10 @@ function routineDataEnvelope(command) {
 }
 
 function routinePublicationClient2(options = {}) {
-  let environment = {}, installed2 = routineTransport(), local = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
+  let environment = {}, installed2 = routineTransport(), local2 = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
   if (!workspace || !/^[a-z0-9][a-z0-9-]*$/.test(workspace) || capability !== void 0 && !/^[0-9a-f]{64}$/.test(capability))
     throw new Error("A workspace and valid optional routine capability are required");
-  let workingRoot = options.workingRoot ?? environment.ODDINGTON_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-oddington-run": capability } : {}, request = options.request ?? (capability ? async (path, init2) => {
+  let workingRoot = options.workingRoot ?? environment.ODDINGTON_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-oddington-run": capability } : {}, request2 = options.request ?? (capability ? async (path, init2) => {
     if (path === "/api/data") return fetch(`https://${workspace}.oddington.ai/api/data`, { ...init2, redirect: "error" });
     let origin = `https://${workspace}.oddington.ai`, target = new URL(path, `${origin}/`);
     if (workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || target.origin !== origin || target.search || target.hash || target.username || target.password || !/^\/api\/inbox\/(check|publish|resolve|files)$/.test(path) || init2?.method !== "POST")
@@ -3366,16 +3472,16 @@ function routinePublicationClient2(options = {}) {
   } : async () => {
     throw new Error("Member publication requires a host-supplied request");
   });
-  async function send3(operation2, body2) {
-    if (local) return await local(operation2, body2);
-    let writing = operation2 === "records/update", reading = operation2 === "records/read", response2 = await request(writing || reading ? "/api/data" : `/api/inbox/${operation2}`, {
+  async function send3(operation2, body) {
+    if (local2) return await local2(operation2, body);
+    let writing = operation2 === "records/update", reading = operation2 === "records/read", response2 = await request2(writing || reading ? "/api/data" : `/api/inbox/${operation2}`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
         ...headers,
         ...writing || reading ? { "x-oddington-workspace": workspace, "x-oddington-captured-records": "1" } : {}
       },
-      body: JSON.stringify(writing ? routineDataEnvelope(validateRoutineRecordWrite(body2)) : reading ? { operation: "records.select", request: validateRecordRead(body2) } : body2)
+      body: JSON.stringify(writing ? routineDataEnvelope(validateRoutineRecordWrite(body)) : reading ? { operation: "records.select", request: validateRecordRead(body) } : body)
     }), result2 = await response2.json();
     if (!response2.ok && operation2 === "records/update")
       throw new RoutineRecordWriteError(result2.error ?? "Could not confirm routine preparation", result2.effect ?? "uncertain");
@@ -3383,11 +3489,11 @@ function routinePublicationClient2(options = {}) {
     return result2;
   }
   let transport = {
-    async publish(body2) {
-      return await send3("publish", body2);
+    async publish(body) {
+      return await send3("publish", body);
     },
-    async resolve(body2) {
-      await send3("resolve", body2);
+    async resolve(body) {
+      await send3("resolve", body);
     }
   };
   async function readRecords(input) {
@@ -3414,12 +3520,12 @@ function routinePublicationClient2(options = {}) {
     files: {
       async add(value) {
         let input = validateFileAddOptions(value);
-        if (local) return validateInboxFile(await local("files/add", input));
+        if (local2) return validateInboxFile(await local2("files/add", input));
         throw workingRoot ? new Error("Inbox file reads require a Node working root") : new Error("Inbox file reads require a working root");
       }
     },
-    async check(body2) {
-      await send3("check", { requestKey: body2.requestKey, item: validatePublication(body2.item) });
+    async check(body) {
+      await send3("check", { requestKey: body.requestKey, item: validatePublication(body.item) });
     }
   };
 }