@oddington/sdk 0.1.23 → 0.1.25

package/dist/browser.js

@@ -405,44 +405,51 @@ 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 invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("unavailable", 503, !0);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   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 invalid7();
+  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 invalid8();
   let d = f.details;
   if (d.kind === "other") {
-    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid7();
+    if (Object.keys(d).length !== 1 || ![
+      "application/octet-stream",
+      "text/plain",
+      "text/markdown",
+      "application/json",
+      "image/png",
+      "image/jpeg"
+    ].includes(f.mediaType)) return invalid8();
   } 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 invalid7();
+    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 invalid8();
   } 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 invalid7();
-  } else return invalid7();
+    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 invalid8();
+  } else return invalid8();
   for (let [name, descriptor] of Object.entries(f.enrichments)) {
-    if (!safeEnrichmentName(name)) return invalid7();
+    if (!safeEnrichmentName(name)) return invalid8();
     parseEnrichmentDescriptor(descriptor);
   }
-  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid7() : f;
+  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid8() : f;
 }
 function parseEnrichmentDescriptor(value) {
-  let invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("unavailable", 503, !0);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   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) ? invalid7() : 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) ? invalid8() : d;
 }
 function safeEnrichmentName(value) {
   return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
 }
 function parseFileEnrichMetadata(value, maxBytes) {
-  let invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   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 invalid7();
+  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 invalid8();
   if (d.size > maxBytes) throw new FileOperationError("request_too_large", 413);
   return d;
 }
@@ -452,31 +459,36 @@ function safeFileName(value) {
 function safeFilePath(value) {
   return typeof value == "string" && value.length <= 1024 && value.split("/").every(safeFileName);
 }
+var ORIGINAL_MEDIA_TYPES = ["application/pdf", "text/plain", "text/markdown", "application/json", "image/png", "image/jpeg"];
+function declaredOriginalMediaType(value) {
+  let normalized = value.split(";", 1)[0].trim().toLowerCase();
+  return ORIGINAL_MEDIA_TYPES.includes(normalized) ? normalized : void 0;
+}
 function parseFileCreateMetadata(value, maxBytes) {
-  let invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   let input = value;
-  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid7();
+  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid8();
   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 invalid7();
+  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 && (typeof input.inputMediaType != "string" || !ORIGINAL_MEDIA_TYPES.includes(input.inputMediaType)) || !Number.isSafeInteger(input.size) || input.size < 0) return invalid8();
   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 invalid7();
+  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 invalid8();
   let csv;
   if (input.csv !== void 0) {
-    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid7();
+    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid8();
     let hints = input.csv;
-    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid7();
+    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid8();
     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 invalid7();
+    if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "	"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5) return invalid8();
     csv = { encoding, delimiter, headerRow };
   }
   return {
     name: input.name,
     path,
     ...input.storage ? { storage: input.storage } : {},
-    ...input.inputMediaType === "application/pdf" ? { inputMediaType: input.inputMediaType } : {},
+    ...input.inputMediaType === void 0 ? {} : { inputMediaType: input.inputMediaType },
     ...csv ? { csv } : {},
     size: input.size,
     requestKey: input.requestKey
@@ -590,14 +602,16 @@ function validateRoutineSchemaValue(schema2, value) {
 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());
+}, object2 = (value, fields5, field) => ((!value || typeof value != "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null || Reflect.ownKeys(value).some((key) => typeof key != "string" || !fields5.includes(key) || !Object.getOwnPropertyDescriptor(value, key).enumerable || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value"))) && 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");
+  let access = object2(v.access === void 0 ? {} : v.access, ["repositories", "connections", "ai", "files", "publish"], "access");
+  Object.hasOwn(access, "ai") && access.ai !== !0 && invalid("access.ai");
+  let 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())
@@ -615,7 +629,7 @@ function parseRoutineDeclaration(value) {
     access: {
       repositories: grants,
       connections: list(access.connections, "access.connections", void 0, !0),
-      models: list(access.models, "access.models"),
+      ...access.ai === !0 ? { ai: !0 } : {},
       ...access.files === void 0 ? {} : { files: access.files },
       publish: list(access.publish, "access.publish", ["asks", "digests"])
     },
@@ -663,7 +677,7 @@ function assertRoutineFields(value, allowed) {
 }
 function parseRoutineAccess(value) {
   try {
-    value !== void 0 && assertRoutineJson(value), assertRoutineFields(value ?? {}, ["repositories", "connections", "models", "files", "publish"]);
+    value !== void 0 && assertRoutineJson(value), assertRoutineFields(value ?? {}, ["repositories", "connections", "ai", "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;
@@ -673,6 +687,52 @@ function parseRoutineAccess(value) {
   }
 }
 
+var ROUTINE_AI_VALUE_BYTES = 256 * 1024, ROUTINE_AI_EVIDENCE_BYTES = 4 * 1024;
+var RoutineAIError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "RoutineAIError";
+  }
+  code;
+};
+function capture(value, invalid8, oversized) {
+  try {
+    assertRoutineJson(value);
+    let encoded = JSON.stringify(value);
+    if (new TextEncoder().encode(encoded).byteLength > ROUTINE_AI_VALUE_BYTES) throw new RoutineAIError(oversized);
+    return freezeRoutineMetadata(JSON.parse(encoded));
+  } catch (error) {
+    throw error instanceof RoutineAIError ? error : new RoutineAIError(invalid8);
+  }
+}
+function parseRoutineAIRequest(value) {
+  let v = capture(value, "invalid_input", "input_too_large");
+  try {
+    if (assertRoutineFields(v, v.kind === "generateObject" ? ["kind", "instructions", "input", "schema"] : ["kind", "instructions", "input"]), !["generateText", "generateObject"].includes(v.kind) || typeof v.instructions != "string" || !v.instructions.trim()) throw new Error();
+    let input = typeof v.input == "string" ? v.input : parseFileDescriptor(v.input);
+    if (v.kind === "generateText") return freezeRoutineMetadata({ kind: v.kind, instructions: v.instructions, input });
+    let schema2 = parseAppRoutineContract({ routine: "ai", input: v.schema, steps: [{ id: "generate" }] }).input;
+    return freezeRoutineMetadata({ kind: v.kind, instructions: v.instructions, input, schema: schema2 });
+  } catch {
+    throw new RoutineAIError("invalid_input");
+  }
+}
+function parseRoutineAIResult(request2, value) {
+  let v = capture(value, "invalid_output", "output_too_large");
+  try {
+    if (request2.kind === "generateText") {
+      if (assertRoutineFields(v, ["text"]), typeof v.text != "string" || !v.text.trim()) throw new Error();
+      return freezeRoutineMetadata({ text: v.text });
+    } else {
+      if (assertRoutineFields(v, ["object"]), !Object.hasOwn(v, "object")) throw new Error();
+      return validateRoutineSchemaValue(request2.schema, v.object), freezeRoutineMetadata({ object: v.object });
+    }
+  } catch {
+    throw new RoutineAIError("invalid_output");
+  }
+}
+
 var LIMIT = 256 * 1024, invalid3 = () => {
   throw new AppRoutineContractError("invalid_value");
 }, invalidContract3 = () => {
@@ -683,7 +743,7 @@ function captureJson(value) {
   let encoded = JSON.stringify(value);
   return new TextEncoder().encode(encoded).byteLength > LIMIT ? invalid3() : freezeRoutineMetadata(JSON.parse(encoded));
 }
-function capture(schema2, value) {
+function capture2(schema2, value) {
   let captured = captureJson(value);
   return validateRoutineSchemaValue(schema2, captured), captured;
 }
@@ -709,7 +769,7 @@ function declaration(value, defaults) {
   } 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 }) });
+  let parsed = freezeRoutineMetadata(parseAppRoutineContract({ routine: "definition", input: value, steps: [{ id: "inspect" }] }).input), captured = defaults ? capture2(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 = {
@@ -794,10 +854,32 @@ function inspectRoutineDefinition(definition) {
 }
 function captureRoutineInput(definition, input) {
   let contract = inspectRoutineDefinition(definition);
-  return capture(contract.input, input === void 0 && Object.hasOwn(contract, "inputDefault") ? contract.inputDefault : input);
+  return capture2(contract.input, input === void 0 && Object.hasOwn(contract, "inputDefault") ? contract.inputDefault : input);
 }
 async function executeRoutineDefinition(definition, input, runtime) {
-  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) => {
+  let captured = captureRoutineInput(definition, input), { contract, steps, run } = definitions.get(definition), active2 = !0, accepting = !0, broken = !1, work = Promise.resolve(), aiFailure, aiWork = /* @__PURE__ */ new Set(), generate = (kind, value) => {
+    let operation2 = (async () => {
+      if (!active2 || broken || contract.access.ai !== !0) throw new RoutineAIError("access_denied");
+      if (!runtime.ai) throw new RoutineAIError("capability_unavailable");
+      let request2;
+      try {
+        assertRoutineFields(value, kind === "generateObject" ? ["instructions", "input", "schema"] : ["instructions", "input"]), request2 = parseRoutineAIRequest({
+          kind,
+          instructions: value.instructions,
+          input: value.input,
+          ...kind === "generateObject" ? { schema: schemaMetadata(value.schema).schema } : {}
+        });
+      } catch (error) {
+        throw error instanceof RoutineAIError ? error : new RoutineAIError("invalid_input");
+      }
+      let result3 = await runtime.ai[kind](request2);
+      if (!active2 || broken) throw new RoutineAIError("access_denied");
+      return parseRoutineAIResult(request2, result3);
+    })();
+    return aiWork.add(operation2), operation2.then(() => aiWork.delete(operation2), (error) => {
+      aiFailure ??= error, broken = !0, aiWork.delete(operation2);
+    }), operation2;
+  }, 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 }, {
@@ -810,6 +892,10 @@ async function executeRoutineDefinition(definition, input, runtime) {
     ...guarded({
       ...runtime,
       run: freezeRoutineMetadata({ ...runtime.run }),
+      ai: {
+        generateText: (value) => generate("generateText", value),
+        generateObject: (value) => generate("generateObject", value)
+      },
       connections: { ...runtime.connections, get: async (identity) => {
         if (!active2 || broken || !contract.access.connections?.includes(identity)) throw new Error("Connection unavailable");
         let value = await runtime.connections.get(identity);
@@ -850,10 +936,11 @@ async function executeRoutineDefinition(definition, input, runtime) {
   } catch (error) {
     failure = error, broken = !0;
   }
-  accepting = !1, await work, active2 = !1;
+  for (accepting = !1, await work; aiWork.size; ) await Promise.allSettled([...aiWork]);
+  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 (broken) throw failure ?? aiFailure ?? new AppRoutineContractError("invalid_value");
+  if (contract.result !== void 0) return capture2(contract.result, result2);
   if (result2 !== void 0) return invalid3();
 }
 
@@ -957,6 +1044,15 @@ function captureRecordsSearchInput(query, options) {
   return { query, options: captured };
 }
 
+function captureRecordsReadRefs(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 100)
+    throw new DataOperationError("invalid_query");
+  let refs = historyArray(value);
+  if (!refs.every((ref) => validRecordRef(ref) && !/[\r\n]/.test(ref)) || new Set(refs).size !== refs.length)
+    throw new DataOperationError("invalid_query");
+  return refs;
+}
+
 var DATA_REQUEST_LIMIT = 256 * 1024, invalidChange = () => {
   throw new DataOperationError("invalid_change", !1, "unapplied");
 };
@@ -1109,14 +1205,102 @@ async function resolveFilesContext() {
 }
 function filesContext(workspace, endpoint, headers) {
   if (!workspace || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace) || workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || endpoint !== `https://${workspace}.oddington.ai`) throw new Error();
-  return { url: `${endpoint}/api/files`, headers: { ...headers, "x-oddington-workspace": workspace }, isCurrent: () => !0 };
+  return { url: `${endpoint}/api/files`, headers: { ...headers, "x-os-workspace": workspace }, isCurrent: () => !0 };
 }
 function checked(workspace, endpoint, headers) {
   if (!workspace || !/^[a-z0-9][a-z0-9-]{0,127}$/.test(workspace)) throw new Error();
   let origin = new URL(endpoint);
   if (origin.protocol !== "https:" || origin.username || origin.password || origin.search || origin.hash || origin.pathname !== "/")
     throw new Error();
-  return { url: `${origin.origin}/api/data`, headers: { ...headers, "x-oddington-workspace": workspace } };
+  return { url: `${origin.origin}/api/data`, headers: { ...headers, "x-os-workspace": workspace } };
+}
+
+var invalid6 = () => {
+  throw new DataOperationError("invalid_query");
+}, unavailable = () => {
+  throw new DataOperationError("unavailable");
+}, text2 = (value) => typeof value == "string" && value.length > 0;
+function capture3(value, ancestors = /* @__PURE__ */ new Set(), depth = 0) {
+  if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return value;
+  if (!value || typeof value != "object" || ancestors.has(value) || depth > 32) return invalid6();
+  ancestors.add(value);
+  try {
+    return Array.isArray(value) ? historyArray(value).map((item) => capture3(item, ancestors, depth + 1)) : Object.fromEntries(Object.entries(historyProperties(value)).map(([key, descriptor]) => [key, capture3(descriptor.value, ancestors, depth + 1)]));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function recordPagination(select) {
+  function pages(query) {
+    let captured = capture3(query), names = Object.keys(historyProperties(captured));
+    for (let name of names) {
+      let selection2 = historyProperties(captured[name]);
+      if (Object.hasOwn(selection2, "$")) {
+        let options = historyProperties(selection2.$.value);
+        if (Object.hasOwn(options, "after")) return invalid6();
+      }
+    }
+    return iterate();
+    async function* iterate() {
+      let state = new Map(names.map((name) => [name, {
+        seen: /* @__PURE__ */ new Set(),
+        total: 0,
+        count: void 0,
+        next: void 0
+      }])), active2 = names, version;
+      do {
+        let request2 = Object.fromEntries(active2.map((name) => {
+          let selection2 = captured[name], next = state.get(name).next;
+          return [name, next === void 0 ? selection2 : { ...selection2, $: { ...selection2.$, after: next } }];
+        })), response2 = await select(request2), page;
+        try {
+          page = capture3(response2);
+          let keys4 = Object.keys(historyProperties(page));
+          (keys4.length !== active2.length + 1 || keys4.some((key) => key !== "$meta" && !active2.includes(key))) && unavailable();
+          let meta = page.$meta;
+          (Object.keys(historyProperties(meta)).sort().join(",") !== "collections,version" || !text2(meta.version) || version !== void 0 && version !== meta.version) && unavailable(), version = meta.version, Object.keys(historyProperties(meta.collections)).some((key) => !active2.includes(key)) && unavailable();
+          for (let name of active2) {
+            let records = historyArray(page[name]), metadata = Object.hasOwn(meta.collections, name) ? meta.collections[name] : {};
+            (Object.keys(historyProperties(metadata)).some((key) => key !== "count" && key !== "next") || Object.hasOwn(metadata, "next") && !text2(metadata.next)) && unavailable();
+            for (let record3 of records) {
+              historyProperties(record3);
+              let row = record3;
+              (!validRecordRef(row.$ref) || !text2(row.$version)) && unavailable();
+            }
+            let current2 = state.get(name);
+            captured[name].$?.count === !0 ? ((!Number.isSafeInteger(metadata.count) || metadata.count < 0 || current2.count !== void 0 && current2.count !== metadata.count) && unavailable(), current2.count = metadata.count) : Object.hasOwn(metadata, "count") && unavailable(), current2.total += records.length, (!Number.isSafeInteger(current2.total) || current2.count !== void 0 && (current2.total > current2.count || metadata.next === void 0 && current2.total !== current2.count)) && unavailable(), metadata.next !== void 0 && (current2.seen.has(metadata.next) && unavailable(), current2.seen.add(metadata.next)), current2.next = metadata.next;
+          }
+        } catch {
+          return unavailable();
+        }
+        let collections = Object.fromEntries(names.map((name) => {
+          let current2 = state.get(name);
+          return [name, {
+            ...current2.count === void 0 ? {} : { count: current2.count },
+            ...current2.next === void 0 ? {} : { next: current2.next }
+          }];
+        })), output = Object.fromEntries(names.map((name) => [name, active2.includes(name) ? page[name] : []]));
+        active2 = active2.filter((name) => state.get(name).next !== void 0), yield { ...output, $meta: { version, collections } };
+      } while (active2.length);
+    }
+  }
+  async function all(query, options) {
+    let properties = historyProperties(options), maxRecords = properties.maxRecords?.value;
+    (Object.keys(properties).join(",") !== "maxRecords" || !Number.isSafeInteger(maxRecords) || maxRecords < 1) && invalid6();
+    let result2, total = 0;
+    for await (let page of pages(query)) {
+      let names = Object.keys(page.$meta.collections), size = names.reduce((sum, name) => sum + page[name].length, 0);
+      if (size > maxRecords - total) throw new DataOperationError("capacity");
+      total += size, result2 ??= { ...Object.fromEntries(names.map((name) => [name, []])), $meta: page.$meta };
+      for (let name of names) {
+        let target = result2[name];
+        for (let record3 of page[name]) target.push(record3);
+      }
+      result2.$meta = page.$meta;
+    }
+    return result2;
+  }
+  return { pages, all };
 }
 
 var data = {
@@ -1139,13 +1323,20 @@ var data = {
         throw error instanceof DataOperationError ? error : new DataOperationError("unavailable", !0);
       }
     }
+    async function read2(input) {
+      let refs = captureRecordsReadRefs(typeof input == "string" ? [input] : input), result2 = await send3({ operation: "records.read", refs });
+      return typeof input == "string" ? result2.records[0] : result2;
+    }
+    let select = (query) => send3({ operation: "records.select", query });
     return {
       collections: {
         list: () => send3({ operation: "collections.list" }),
         schema: (name) => send3({ operation: "collections.schema", name })
       },
       records: {
-        select: (query) => send3({ operation: "records.select", query }),
+        read: read2,
+        select,
+        ...recordPagination(select),
         search: async (query, options) => send3({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
       },
       history: {
@@ -1270,7 +1461,7 @@ async function hostedContent(url, init2, parent, upstream = fetch, check = async
   }
 }
 
-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 = {
+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, invalid7 = () => new FileOperationError("invalid_input", 400), unavailable2 = () => new FileOperationError("unavailable", 503, !0), failures = {
   400: ["invalid_input", "unsupported_context"],
   401: ["unauthenticated"],
   403: ["access_denied"],
@@ -1290,9 +1481,9 @@ async function boundedBytes(stream, limit, signal) {
   try {
     for (; ; ) {
       let { done, value } = await reader.read();
-      if (signal?.aborted) throw unavailable();
+      if (signal?.aborted) throw unavailable2();
       if (done) break;
-      if (!(value instanceof Uint8Array)) throw invalid6();
+      if (!(value instanceof Uint8Array)) throw invalid7();
       if (size += value.byteLength, size > limit) throw new FileOperationError("request_too_large", 413);
       bytes.set(value, size - value.byteLength);
     }
@@ -1306,7 +1497,7 @@ async function boundedBytes(stream, limit, signal) {
 async function timed(work, parent, timeout = TIMEOUT_MS) {
   let controller = new AbortController(), timer, abort, expiry = new Promise((_, reject) => {
     abort = () => {
-      controller.abort(), reject(unavailable());
+      controller.abort(), reject(unavailable2());
     }, timer = setTimeout(abort, timeout), parent?.addEventListener("abort", abort, { once: !0 }), parent?.aborted && abort();
   });
   try {
@@ -1320,12 +1511,12 @@ async function result(response2, maximum = RESULT_BYTES) {
     let bytes = await boundedBytes(response2.body, maximum);
     return JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes));
   } catch {
-    throw unavailable();
+    throw unavailable2();
   }
 }
 async function send(suffix, init2, descriptor, initial, parent) {
   let original = initial, checkCurrent = (context2 = original) => {
-    if (parent?.aborted) throw unavailable();
+    if (parent?.aborted) throw unavailable2();
     if (!original.isCurrent() || context2.url !== original.url) throw new FileOperationError("unsupported_context", 400);
   };
   for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
@@ -1345,11 +1536,11 @@ async function send(suffix, init2, descriptor, initial, 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();
+        throw code ? new FileOperationError(code, response2.status, code === "capacity" || code === "unavailable") : unavailable2();
       }
       if (response2.status !== (descriptor === 204 ? 204 : 200) || descriptor === 204 && response2.body !== null)
         throw response2.body?.cancel().catch(() => {
-        }), unavailable();
+        }), unavailable2();
       try {
         checkCurrent();
       } catch (error) {
@@ -1363,21 +1554,21 @@ async function send(suffix, init2, descriptor, initial, parent) {
         return checkCurrent(), value;
       let parsed;
       if (descriptor === "enrichment") {
-        if (!value || typeof value != "object" || Array.isArray(value)) throw unavailable();
+        if (!value || typeof value != "object" || Array.isArray(value)) throw unavailable2();
         let { name, ...metadata } = value;
-        if (!safeEnrichmentName(name)) throw unavailable();
+        if (!safeEnrichmentName(name)) throw unavailable2();
         parsed = { name, ...parseEnrichmentDescriptor(metadata) };
       } else parsed = parseFileDescriptor(value);
       return checkCurrent(), parsed;
     } catch (error) {
-      let failure = error instanceof FileOperationError ? error : unavailable();
+      let failure = error instanceof FileOperationError ? error : unavailable2();
       if (init2.body instanceof ReadableStream || !failure.retryable || attempt + 1 === ATTEMPTS) throw failure;
     }
   }
-  throw unavailable();
+  throw unavailable2();
 }
 function idPath(id3) {
-  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid6();
+  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid7();
   return `/${id3}`;
 }
 async function multipartCreate(input, metadata, exchange, release = () => {
@@ -1388,18 +1579,18 @@ async function multipartCreate(input, metadata, exchange, release = () => {
     return pending.add(task), task.then(() => pending.delete(task), () => pending.delete(task)), task;
   }, void 0, timeout), control = (body) => ({
     method: "POST",
-    headers: { "content-type": "application/json", ...ticket ? { "x-oddington-transfer": ticket } : {} },
+    headers: { "content-type": "application/json", ...ticket ? { "x-os-transfer": ticket } : {} },
     body: JSON.stringify(body)
   });
   try {
     let start = await request2((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
-    if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable();
+    if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable2();
     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();
+    if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket != "string" || !session.ticket || session.ticket.length > 64 * 1024) throw unavailable2();
     ticket = session.ticket, input.file instanceof ReadableStream && (reader = input.file.getReader());
     let lastProgress = Date.now(), next = async () => {
       try {
-        if (Date.now() - lastProgress >= TIMEOUT_MS) throw unavailable();
+        if (Date.now() - lastProgress >= TIMEOUT_MS) throw unavailable2();
         let value = await request2(() => reader.read(), Math.max(1, TIMEOUT_MS - (Date.now() - lastProgress)));
         return value.value?.byteLength && (lastProgress = Date.now()), value;
       } catch (error) {
@@ -1420,41 +1611,41 @@ 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 invalid6();
+            if (value2.done || !(value2.value instanceof Uint8Array) || (chunk = value2.value, chunk.byteLength > metadata.size - sent - filled)) throw invalid7();
           }
           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 invalid6();
+      if (part.byteLength !== length) throw invalid7();
       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 invalid6();
+          if (!(value2.value instanceof Uint8Array) || value2.value.byteLength) throw invalid7();
         }
       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) },
+        headers: { "content-type": "application/octet-stream", "x-os-transfer": ticket, "x-os-part": String(partNumber) },
         body: part.buffer
       }, "control", signal));
       part = void 0;
       let receipt = value;
-      if (!receipt || typeof receipt != "object" || Object.keys(receipt).sort().join(",") !== "etag,partNumber" || receipt.partNumber !== partNumber || typeof receipt.etag != "string" || !receipt.etag || receipt.etag.length > 256 || /[\u0000-\u001f\u007f]/.test(receipt.etag)) throw unavailable();
+      if (!receipt || typeof receipt != "object" || Object.keys(receipt).sort().join(",") !== "etag,partNumber" || receipt.partNumber !== partNumber || typeof receipt.etag != "string" || !receipt.etag || receipt.etag.length > 256 || /[\u0000-\u001f\u007f]/.test(receipt.etag)) throw unavailable2();
       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 request2(() => upload.enrichment(name));
-      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid6();
+      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid7();
       await request2((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
         method: "POST",
-        headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket },
+        headers: { "content-type": "application/octet-stream", "x-os-transfer": ticket },
         body: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
       }, "control", signal));
     }
     await upload?.beforeComplete();
     let completion = control({ parts: receipts });
-    if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024) throw unavailable();
+    if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024) throw unavailable2();
     return parseFileDescriptor(await request2(
       (signal) => exchange(`${route}/complete`, completion, !0, signal),
       TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1e3
@@ -1462,7 +1653,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
   } catch (error) {
     throw reader && await reader.cancel(error).catch(() => {
     }), ticket && await request2((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {
-    }), error instanceof FileOperationError ? error : unavailable();
+    }), error instanceof FileOperationError ? error : unavailable2();
   } finally {
     chunk = void 0, reader?.releaseLock(), pending.size ? Promise.allSettled([...pending]).then(release) : release();
   }
@@ -1479,13 +1670,13 @@ async function operation(work, initial, parent) {
     }
   }, signal = context2.signal && parent ? AbortSignal.any([context2.signal, parent]) : context2.signal ?? parent;
   return context2.localFiles ? execute(signal ?? new AbortController().signal) : timed(execute, signal).catch((error) => {
-    throw error instanceof FileOperationError ? error : unavailable();
+    throw error instanceof FileOperationError ? error : unavailable2();
   });
 }
 function contentPath(id3, name) {
   let path = idPath(id3);
   if (name === void 0) return `${path}/content`;
-  if (!safeEnrichmentName(name)) throw invalid6();
+  if (!safeEnrichmentName(name)) throw invalid7();
   return `${path}/enrichments/${encodeURIComponent(name)}/content`;
 }
 async function read(id3, names) {
@@ -1494,12 +1685,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 invalid6();
+  if (!Array.isArray(names)) throw invalid7();
   let distinct = [], seen = /* @__PURE__ */ new Set();
   for (let name of names) {
-    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid6();
+    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid7();
     if (!seen.has(name)) {
-      if (seen.size === 16) throw invalid6();
+      if (seen.size === 16) throw invalid7();
       seen.add(name), distinct.push(name);
     }
   }
@@ -1527,32 +1718,32 @@ var files = {
   async upload(id3) {
     return operation(async (context2, signal) => {
       let file2 = await send(`${idPath(id3)}/upload`, { method: "POST" }, !0, context2, signal);
-      if (file2.id !== id3) throw unavailable();
+      if (file2.id !== id3) throw unavailable2();
       return file2;
     });
   },
   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 invalid6();
+      throw invalid7();
     let blob = input.file instanceof Blob, array3 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
-    if (!blob && !array3 && !stream) throw invalid6();
+    if (!blob && !array3 && !stream) throw invalid7();
     let intrinsic = blob ? input.file.size : array3 ? input.file.byteLength : void 0;
-    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid6();
+    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid7();
     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({
+    let inputMediaType = blob ? declaredOriginalMediaType(input.file.type) : void 0, metadata = parseFileCreateMetadata({
       name,
       size: intrinsic ?? input.size,
       path: input.path,
       storage: input.storage,
       csv: input.csv,
-      ...blob && input.file.type === "application/pdf" ? { inputMediaType: "application/pdf" } : {},
+      ...inputMediaType === void 0 ? {} : { inputMediaType },
       requestKey: options?.requestKey === void 0 ? routineTransport()?.key("files") ?? crypto.randomUUID() : options.requestKey
     }, FILE_ORIGINAL_MAX_BYTES);
     if (!context2.local && !context2.localFiles && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
     let header = encodeURIComponent(JSON.stringify(metadata));
-    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid6();
+    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid7();
     if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
     if (active++, context2.localFiles && !routineTransport() && metadata.size > MAX_BYTES) {
       let signal = context2.signal ?? new AbortController().signal, file2 = input.file, offset = 0, body = file2 instanceof Blob ? context2.signal ? file2 : file2.stream() : file2 instanceof ReadableStream ? file2 : new ReadableStream({
@@ -1568,7 +1759,7 @@ var files = {
       try {
         return await send("", { method: "POST", headers: {
           "content-type": "application/octet-stream",
-          "x-oddington-file": header
+          "x-os-file": header
         }, body }, !0, context2, signal);
       } finally {
         active--;
@@ -1581,23 +1772,23 @@ var files = {
           metadata.size,
           signal
         );
-        if (bytes.byteLength !== metadata.size) throw invalid6();
-        if (signal.aborted) throw unavailable();
+        if (bytes.byteLength !== metadata.size) throw invalid7();
+        if (signal.aborted) throw unavailable2();
         return await send("", {
           method: "POST",
-          headers: { "content-type": "application/octet-stream", "x-oddington-file": header },
+          headers: { "content-type": "application/octet-stream", "x-os-file": header },
           body: bytes.buffer
         }, !0, context2, signal);
       } finally {
         active--;
       }
     }, context2.signal).catch((error) => {
-      throw error instanceof FileOperationError ? error : unavailable();
+      throw error instanceof FileOperationError ? error : unavailable2();
     });
   },
   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 invalid6();
+    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 invalid7();
     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);
@@ -1614,12 +1805,12 @@ 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 invalid6();
+      if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid7();
       let result2 = await send(path, { method: "POST", headers: {
         "content-type": "application/octet-stream",
-        "x-oddington-enrichment": header
+        "x-os-enrichment": header
       }, body: bytes.buffer }, "enrichment", context3, signal);
-      if (result2.name !== metadata.name) throw unavailable();
+      if (result2.name !== metadata.name) throw unavailable2();
       return result2;
     }, context2);
   },
@@ -1629,29 +1820,58 @@ var files = {
   read
 };
 
+function validDropboxRootPath(value) {
+  return typeof value == "string" && value.length <= 2048 && value.startsWith("/") && !/[\\\x00-\x1f\x7f]/.test(value) && value.slice(1).split("/").every((segment) => segment.length > 0 && segment.trim() === segment && segment !== "." && segment !== "..");
+}
 function validGoogleScopes(value) {
   return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every((scope) => typeof scope == "string" && scope.length <= 256 && /^(https:\/\/www\.googleapis\.com\/auth\/[A-Za-z0-9._-]+|https:\/\/mail\.google\.com\/|openid|email|profile)$/.test(scope)) && new Set(value).size === value.length;
 }
+var DROPBOX_FILE_SCOPES = ["account_info.read", "files.metadata.read", "files.content.read", "files.content.write"];
+function validDropboxFileScopes(value) {
+  return Array.isArray(value) && value.length === DROPBOX_FILE_SCOPES.length && new Set(value).size === value.length && DROPBOX_FILE_SCOPES.every((scope) => value.includes(scope));
+}
 
-var ROUTINE_CONNECTION_CREDENTIALS_ENV = "ODDINGTON_ROUTINE_CONNECTION_CREDENTIALS";
+var ROUTINE_CONNECTION_CREDENTIALS_ENV = "OS_ROUTINE_CONNECTION_CREDENTIALS";
+function parseRoutineConnectionNames(value) {
+  if (!Array.isArray(value) || value.some((name) => typeof name != "string" || !/^(gmail|airtable|dropbox)\/[a-z0-9][a-z0-9-]{0,62}$/.test(name)) || new Set(value).size !== value.length)
+    throw new Error("Invalid routine connections");
+  return value;
+}
 var connectionUuid = (v) => typeof v == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(v);
 function runtimeConnection(lease) {
-  return lease.provider === "gmail" ? {
-    id: `gmail/${lease.name}`,
-    provider: lease.provider,
-    name: lease.name,
-    accountEmail: lease.accountEmail,
-    scopes: [...lease.scopes],
-    accessToken: lease.accessToken,
-    expiresAt: lease.expiresAt
-  } : {
-    id: `airtable/${lease.name}`,
-    provider: lease.provider,
-    name: lease.name,
-    baseId: lease.baseId,
-    accessToken: lease.accessToken,
-    runExpiresAt: lease.runExpiresAt
-  };
+  switch (lease.provider) {
+    case "gmail":
+      return {
+        id: `gmail/${lease.name}`,
+        provider: lease.provider,
+        name: lease.name,
+        accountEmail: lease.accountEmail,
+        scopes: [...lease.scopes],
+        accessToken: lease.accessToken,
+        expiresAt: lease.expiresAt
+      };
+    case "airtable":
+      return {
+        id: `airtable/${lease.name}`,
+        provider: lease.provider,
+        name: lease.name,
+        baseId: lease.baseId,
+        accessToken: lease.accessToken,
+        runExpiresAt: lease.runExpiresAt
+      };
+    case "dropbox":
+      return {
+        id: `dropbox/${lease.name}`,
+        provider: lease.provider,
+        name: lease.name,
+        accountId: lease.accountId,
+        access: lease.access,
+        rootPath: lease.rootPath,
+        scopes: [...lease.scopes],
+        accessToken: lease.accessToken,
+        expiresAt: lease.expiresAt
+      };
+  }
 }
 function parseConnectionLease(raw, now = Date.now()) {
   let v = raw;
@@ -1662,7 +1882,7 @@ function parseConnectionLease(raw, now = Date.now()) {
       throw new Error("Invalid connection credential");
     return v;
   }
-  if (v.provider === "airtable" && Object.keys(v).sort().join(",") === "accessToken,baseId,connectionId,name,provider,runExpiresAt,runId" && typeof v.baseId == "string" && /^app[A-Za-z0-9]+$/.test(v.baseId) && typeof v.runExpiresAt == "string" && Number.isFinite(Date.parse(v.runExpiresAt)) && Date.parse(v.runExpiresAt) > now + 6e4 && Date.parse(v.runExpiresAt) <= now + 15 * 6e4)
+  if (v.provider === "airtable" && Object.keys(v).sort().join(",") === "accessToken,baseId,connectionId,name,provider,runExpiresAt,runId" && typeof v.baseId == "string" && /^app[A-Za-z0-9]+$/.test(v.baseId) && typeof v.runExpiresAt == "string" && Number.isFinite(Date.parse(v.runExpiresAt)) && Date.parse(v.runExpiresAt) > now + 6e4 && Date.parse(v.runExpiresAt) <= now + 15 * 6e4 || v.provider === "dropbox" && Object.keys(v).sort().join(",") === "access,accessToken,accountId,connectionId,expiresAt,name,provider,rootPath,runId,scopes" && typeof v.accountId == "string" && /^dbid:[A-Za-z0-9_-]{1,128}$/.test(v.accountId) && v.access === "full_dropbox" && validDropboxRootPath(v.rootPath) && validDropboxFileScopes(v.scopes) && typeof v.expiresAt == "string" && Number.isFinite(Date.parse(v.expiresAt)) && Date.parse(v.expiresAt) > now + 6e4 && Date.parse(v.expiresAt) <= now + 144e5)
     return v;
   throw new Error("Invalid connection credential");
 }
@@ -1688,12 +1908,12 @@ function object3(v) {
 function keys2(v, allowed, required = allowed) {
   (Object.keys(v).some((k) => !allowed.includes(k)) || required.some((k) => !Object.hasOwn(v, k))) && fail2("Invalid Airtable input");
 }
-function text2(v) {
+function text3(v) {
   return typeof v == "string" && v.length > 0 && v.length <= 1024;
 }
 function fields3(v, nonempty = !1) {
   let result2 = object3(v);
-  (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text2(k))) && fail2("Invalid Airtable fields");
+  (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text3(k))) && fail2("Invalid Airtable fields");
   try {
     return serializable(result2);
   } catch {
@@ -1780,10 +2000,10 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
       Array.isArray(page.tables) || fail2("Malformed Airtable tables");
       for (let value of page.tables) {
         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");
+        (!tableId(t.id) || !text3(t.name) || !text3(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 = 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) } };
+          return (typeof f.id != "string" || !/^fld[A-Za-z0-9]+$/.test(f.id) || !text3(f.name) || !text3(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 });
       }
@@ -1791,7 +2011,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     } while (offset);
     return tables;
   }
-  (!text2(input.table) || input.table === "." || input.table === "..") && fail2("Invalid Airtable table"), mutation && !tableId(input.table) && fail2("Airtable writes require a stable table ID");
+  (!text3(input.table) || input.table === "." || input.table === "..") && fail2("Invalid Airtable table"), mutation && !tableId(input.table) && fail2("Airtable writes require a stable table ID");
   let path = `${baseId}/${encodeURIComponent(input.table)}`;
   if (operation2 === "records.get") {
     keys2(input, ["table", "id"]), recordId(input.id) || fail2("Invalid Airtable record ID");
@@ -1799,7 +2019,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     return result3.id !== input.id && fail2("Malformed Airtable record"), result3;
   }
   if (operation2 === "records.list") {
-    keys2(input, ["table", "fields"], ["table"]), input.fields !== void 0 && (!Array.isArray(input.fields) || !input.fields.length || input.fields.some((f) => !text2(f)) || new Set(input.fields).size !== input.fields.length) && fail2("Invalid Airtable field selection");
+    keys2(input, ["table", "fields"], ["table"]), input.fields !== void 0 && (!Array.isArray(input.fields) || !input.fields.length || input.fields.some((f) => !text3(f)) || new Set(input.fields).size !== input.fields.length) && fail2("Invalid Airtable field selection");
     let records2 = [], ids2 = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set(), offset;
     do {
       let query2 = new URLSearchParams();
@@ -1856,10 +2076,10 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
 }
 function nextOffset(value, seen) {
   if (value !== void 0)
-    return (!text2(value) || seen.has(value)) && fail2("Malformed Airtable pagination"), seen.add(value), value;
+    return (!text3(value) || seen.has(value)) && fail2("Malformed Airtable pagination"), seen.add(value), value;
 }
 
-var MANAGED_CONNECTION_CAPABILITY_ENV = "ODDINGTON_MANAGED_CONNECTION_CAPABILITY";
+var MANAGED_CONNECTION_CAPABILITY_ENV = "OS_MANAGED_CONNECTION_CAPABILITY";
 function managedConnections(capability) {
   let endpoint = new URL(capability.endpoint);
   if (endpoint.protocol !== "http:" || endpoint.hostname !== "127.0.0.1" || !endpoint.port || endpoint.pathname !== "/" || endpoint.search || endpoint.hash || endpoint.username || endpoint.password || !/^[0-9a-f-]{36}$/.test(capability.token)) throw new AirtableOperationError("Airtable capability unavailable");
@@ -2015,7 +2235,7 @@ function object4(value) {
 function keys3(value, allowed, required = allowed) {
   assert(Object.keys(value).every((key) => allowed.includes(key)) && required.every((key) => Object.hasOwn(value, key)));
 }
-function text3(value, empty2 = !1) {
+function text4(value, empty2 = !1) {
   return typeof value == "string" && (empty2 || !!value.trim());
 }
 function id2(value) {
@@ -2025,7 +2245,7 @@ function integer(value, minimum = 1) {
   return Number.isSafeInteger(value) && Number(value) >= minimum;
 }
 function date(value) {
-  return text3(value) && Number.isFinite(Date.parse(value));
+  return text4(value) && Number.isFinite(Date.parse(value));
 }
 function optionalDate(value) {
   return value === null || date(value);
@@ -2047,7 +2267,7 @@ function json(value, ancestors = /* @__PURE__ */ new Set()) {
 }
 function recordReference(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;
+  return keys3(record3, ["repository", "ref"]), assert(text4(record3.repository) && record3.repository === record3.repository.trim() && /^[a-z0-9][a-z0-9._/-]{0,127}$/.test(record3.repository) && !/\.\.|\/\//.test(record3.repository) && text4(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 = object4(value);
@@ -2059,75 +2279,75 @@ function responseDefinition(value) {
     assert(options.length > 0);
     let values = options.map((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) {
+      if (keys3(option, ["value", "label", "description", "note"], ["value", "label"]), assert(text4(option.value) && option.value === option.value.trim() && text4(option.label)), "description" in option && assert(text4(option.description)), "note" in option) {
         let note = object4(option.note);
-        keys3(note, ["placeholder"]), assert(text3(note.placeholder));
+        keys3(note, ["placeholder"]), assert(text4(note.placeholder));
       }
       return option.value;
     });
     if (assert(new Set(values).size === values.length), "search" in source || "suggestions" in source) {
       let search = object4(source.search);
-      keys3(search, ["triggerLabel", "placeholder", "emptyLabel"]), assert(text3(search.triggerLabel) && text3(search.placeholder) && text3(search.emptyLabel));
+      keys3(search, ["triggerLabel", "placeholder", "emptyLabel"]), assert(text4(search.triggerLabel) && text4(search.placeholder) && text4(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);
+      assert(suggestions2.length <= 8 && suggestions2.every((value2) => text4(value2) && values.includes(value2)) && new Set(suggestions2).size === suggestions2.length);
     } else assert(options.length <= 9);
     return;
   }
   assert(source.type === "records"), keys3(source, ["type", "collection", "refPrefix", "where", "display", "suggestions"], ["type", "collection", "display"]);
   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));
+  keys3(collection, ["repository", "name"]), recordReference({ repository: collection.repository, ref: "records/example" }), assert(text4(collection.name) && /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/.test(collection.name)), "refPrefix" in source && assert(text4(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 = 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 = 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)));
+  assert(labels.length > 0 && labels.length <= 2 && new Set(labels).size === labels.length && labels.every((value2) => text4(value2) && /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value2)));
   let suggestions = array2(source.suggestions ?? []), refs = suggestions.map((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;
+    return assert(record3.repository === collection.repository), "reason" in suggestion && assert(text4(suggestion.reason)), record3.ref;
   });
   assert(suggestions.length <= 8 && new Set(refs).size === refs.length);
 }
 function inboxFile(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));
+  keys3(file2, ["id", "name", "mediaType", "size", "sha256", "details"]), assert(id2(file2.id) && text4(file2.name) && !/[\x00-\x1f\x7f/\\]/.test(file2.name) && text4(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 = 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 = object4(value2);
-    return keys3(field, ["label", "value"]), assert(text3(field.label) && text3(field.value)), field.label;
+    return keys3(field, ["label", "value"]), assert(text4(field.label) && text4(field.value)), field.label;
   });
   assert(new Set(labels).size === labels.length);
 }
 function block(value) {
   let entry = object4(value);
   if (entry.kind === "rich-text") {
-    keys3(entry, ["kind", "markdown"]), assert(text3(entry.markdown));
+    keys3(entry, ["kind", "markdown"]), assert(text4(entry.markdown));
     return;
   }
   if (entry.kind === "asks") {
     keys3(entry, ["kind", "problem", "asks"]);
     let asks = array2(entry.asks);
-    assert(text3(entry.problem) && asks.length > 0 && asks.every(id2) && new Set(asks).size === asks.length);
+    assert(text4(entry.problem) && asks.length > 0 && asks.every(id2) && new Set(asks).size === asks.length);
     return;
   }
   if (assert(["record", "records", "files"].includes(String(entry.kind))), keys3(
     entry,
     ["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") {
+  ), assert(text4(entry.label) && (!("initiallyExpanded" in entry) || typeof entry.initiallyExpanded == "boolean") && (!("view" in entry) || text4(entry.view) && entry.view === entry.view.trim())), entry.kind === "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);
+    keys3(record3, ["ref", "title", "fields"]), assert(text4(record3.ref) && record3.ref === record3.ref.trim() && text4(record3.title)), fields4(record3.fields);
     return;
   }
   if (entry.kind === "records") {
     let records = array2(entry.records), refs = records.map((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;
+      return keys3(record3, ["ref", "title", "description", "facts", "view"], ["ref", "title"]), assert(text4(record3.ref) && record3.ref === record3.ref.trim() && text4(record3.title)), "description" in record3 && assert(text4(record3.description)), "facts" in record3 && fields4(record3.facts), "view" in record3 && assert(text4(record3.view) && record3.view === record3.view.trim()), record3.ref;
     });
     assert(records.length > 0 && new Set(refs).size === refs.length);
     return;
@@ -2137,7 +2357,7 @@ function block(value) {
 }
 function response(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;
+  return assert(Object.keys(answer).every((key) => ["selection", "note"].includes(key))), typeof answer.selection == "string" ? assert(text4(answer.selection) && answer.selection === answer.selection.trim()) : recordReference(answer.selection), Object.hasOwn(answer, "note") && assert(text4(answer.note)), answer;
 }
 function parseInboxRequest(value) {
   try {
@@ -2146,70 +2366,70 @@ function parseInboxRequest(value) {
     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 };
+    return "revision" in input && assert(integer(input.revision)), "beforeNumber" in input && assert(integer(input.beforeNumber)), "questionId" in input && assert(text4(input.questionId) && input.questionId === input.questionId.trim()), "title" in input && assert(text4(input.title)), "lifecycle" in input && assert(input.lifecycle === "open" || input.lifecycle === "closed"), "query" in input && assert(text4(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 {
     throw new InboxOperationError(400, "invalid_input");
   }
 }
 function parseInboxCurrent(value) {
   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)), {
+  return assert(id2(workspace.id) && text4(workspace.slug) && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace.slug) && text4(workspace.name) && text4(workspace.locale) && text4(workspace.timezone)), assert(id2(viewer.id) && text4(viewer.name) && text4(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 = 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)), item.kind === "ask" ? askMetadata(item) : assert(!("tags" in item) && !("recordRefs" in item)), array2(item.body).forEach(block), array2(item.views).forEach((value2) => {
+  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)) && text4(item.title) && text4(item.description, !0) && text4(item.author) && date(item.publishedAt) && optionalDate(item.seenAt) && optionalDate(item.digestReadAt)), item.outcome !== null && assert(text4(object4(item.outcome).outcome)), "canonicalRoutineId" in item && assert(item.canonicalRoutineId === null || isAppRoutineName(item.canonicalRoutineId)), item.kind === "ask" ? askMetadata(item) : assert(!("tags" in item) && !("recordRefs" in item)), 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);
+    assert(text4(view.id) && text4(view.view) && text4(view.implementation)), json(view.input);
   }), array2(item.people).forEach((value2) => {
     let person = object4(value2);
-    assert(id2(person.id) && text3(person.name));
+    assert(id2(person.id) && text4(person.name));
   }), array2(item.questions).forEach((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) {
+    if (assert(text4(question2.id) && id2(question2.to) && text4(question2.prompt) && (question2.instructions === null || text4(question2.instructions, !0)) && typeof question2.available == "boolean"), responseDefinition(question2.response), assert(array2(question2.allowedResponders).every(id2)), question2.acceptedResponse !== null) {
       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));
+      assert(id2(accepted.id) && id2(accepted.userId) && date(accepted.acceptedAt)), response(accepted.response), accepted.label === null ? delete accepted.label : "label" in accepted && assert(text4(accepted.label)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder));
     }
     if (question2.execution !== null) {
       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 = 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) => {
+        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 || text4(consequence.reason, !0))), array2(consequence.evidence).forEach((value3) => {
           let receipt = object4(value3);
-          assert(text3(receipt.repository) && text3(receipt.commit) && text3(receipt.diff, !0));
+          assert(text4(receipt.repository) && text4(receipt.commit) && text4(receipt.diff, !0));
         });
       }
     }
   }), array2(item.linkedAsks).forEach((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") {
+    else if (assert(["yours", "done", "open", "theirs"].includes(String(linked.state)) && text4(linked.title)), linked.state === "theirs") {
       let assignee = object4(linked.assignee);
-      assert(id2(assignee.id) && text3(assignee.name));
+      assert(id2(assignee.id) && text4(assignee.name));
     }
   }), array2(item.activity).forEach((value2) => {
     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);
+    assert(integer(event.id) && text4(event.type) && (event.actorId === null || id2(event.actorId)) && (event.questionId === null || text4(event.questionId)) && integer(event.revision) && date(event.createdAt)), object4(event.data);
   }), array2(item.work).forEach((value2) => {
     let work = object4(value2);
-    assert(id2(work.id) && text3(work.questionId) && text3(work.reason) && optionalDate(work.settledAt));
+    assert(id2(work.id) && text4(work.questionId) && text4(work.reason) && optionalDate(work.settledAt));
   }), item;
 }
 function parseAnswerableQuestion(value) {
   let entry = object4(json(value));
   keys3(
     entry,
-    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "tags", "recordRefs", "instructions"],
-    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable"]
-  ), assert(id2(entry.itemId) && integer(entry.revision) && text3(entry.title) && text3(entry.inboxUrl));
+    ["itemId", "number", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "tags", "recordRefs", "instructions"],
+    ["itemId", "number", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable"]
+  ), assert(id2(entry.itemId) && integer(entry.number) && integer(entry.revision) && text4(entry.title) && text4(entry.inboxUrl));
   let link = new URL(entry.inboxUrl), slug = link.hostname.slice(0, -13);
-  return 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), askMetadata(entry), entry;
+  return 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) && text4(entry.questionId) && entry.questionId === entry.questionId.trim() && text4(entry.prompt) && (!("instructions" in entry) || text4(entry.instructions, !0)) && typeof entry.answerable == "boolean"), responseDefinition(entry.response), askMetadata(entry), entry;
 }
 function askMetadata(entry) {
   let tags = array2(entry.tags === void 0 ? [] : entry.tags);
-  assert(tags.length <= 32 && tags.every((tag) => text3(tag) && new TextEncoder().encode(tag).byteLength <= 64)), assert(new Set(tags).size === tags.length);
+  assert(tags.length <= 32 && tags.every((tag) => text4(tag) && new TextEncoder().encode(tag).byteLength <= 64)), assert(new Set(tags).size === tags.length);
   let refs = array2(entry.recordRefs === void 0 ? [] : entry.recordRefs);
   refs.forEach((value) => {
     let ref = object4(value);
@@ -2221,7 +2441,7 @@ function askMetadata(entry) {
 }
 function parseInboxAcceptance(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;
+  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(text4(accepted.label)), accepted;
 }
 function parseInboxResult(operation2, value) {
   if (operation2 === "current") return parseInboxCurrent(value);
@@ -2252,7 +2472,7 @@ function parseInboxResult(operation2, value) {
     let candidates = array2(value);
     return candidates.forEach((value2) => {
       let person = object4(value2);
-      assert(id2(person.id) && text3(person.name) && text3(person.email));
+      assert(id2(person.id) && text4(person.name) && text4(person.email));
     }), assert(new Set(candidates.map((value2) => object4(value2).id)).size === candidates.length), candidates;
   }
   if (operation2 === "items.addRecipient") {
@@ -2262,10 +2482,10 @@ function parseInboxResult(operation2, value) {
   if (operation2 === "questions.answer") return parseInboxAcceptance(value);
   if (operation2 === "questions.searchRecords") {
     let result2 = object4(value);
-    assert(text3(result2.recordType) && integer(result2.eligibleCount, 0) && integer(result2.matchCount, 0) && Number(result2.matchCount) <= Number(result2.eligibleCount));
+    assert(text4(result2.recordType) && integer(result2.eligibleCount, 0) && integer(result2.matchCount, 0) && Number(result2.matchCount) <= Number(result2.eligibleCount));
     let labeled = (value2) => {
       let record3 = object4(value2);
-      recordReference({ repository: record3.repository, ref: record3.ref }), assert(text3(record3.label)), "reason" in record3 && assert(text3(record3.reason));
+      recordReference({ repository: record3.repository, ref: record3.ref }), assert(text4(record3.label)), "reason" in record3 && assert(text4(record3.reason));
     };
     return array2(result2.matches).forEach(labeled), array2(result2.suggestions).forEach(labeled), "selected" in result2 && labeled(result2.selected), result2;
   }
@@ -2379,7 +2599,7 @@ async function appResponse(response2, maximum, signal) {
     });
   };
   signal.addEventListener("abort", abort, { once: !0 });
-  let bytes = 0, text4 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
+  let bytes = 0, text5 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
   try {
     for (; ; ) {
       let chunk;
@@ -2390,13 +2610,13 @@ async function appResponse(response2, maximum, signal) {
       }
       if (signal.aborted) throw new Error();
       if (chunk.done) {
-        let value = JSON.parse(text4 + decoder.decode());
+        let value = JSON.parse(text5 + decoder.decode());
         if (await responseChecks.get(response2)?.(value), signal.aborted) throw new Error();
         return value;
       }
       if (bytes += chunk.value.byteLength, bytes > maximum)
         throw abort(), new Error();
-      text4 += decoder.decode(chunk.value, { stream: !0 });
+      text5 += decoder.decode(chunk.value, { stream: !0 });
     }
   } finally {
     signal.removeEventListener("abort", abort), reader.releaseLock();
@@ -2622,16 +2842,16 @@ function appContext(origin, active2) {
     return requestChecked(`routines/${encodeURIComponent(key)}/${suffix}`, {}, !1, !0);
   }
   async function requestFiles(suffix, init2, parent) {
-    let unavailable3 = () => new FileOperationError("unsupported_context", 400);
+    let unavailable4 = () => new FileOperationError("unsupported_context", 400);
     if (!current2() || !/^(?:|\/[0-9a-f-]{36}(?:\/(?:content|upload|enrichments(?:\/[^/?#]+\/content)?))?)$/i.test(suffix))
-      throw unavailable3();
-    let admitted = credential, signal = parent ? AbortSignal.any([access.signal, parent]) : access.signal, failure = () => current2() && !signal.aborted ? new FileOperationError("unavailable", 503, !0) : unavailable3();
+      throw unavailable4();
+    let admitted = credential, signal = parent ? AbortSignal.any([access.signal, parent]) : access.signal, failure = () => current2() && !signal.aborted ? new FileOperationError("unavailable", 503, !0) : unavailable4();
     try {
       return await hostedContent("", init2, signal, (_url, request2) => untilAborted(
         send3(`files${suffix}`, admitted, signal, request2).then((value) => {
           if (signal.aborted)
             throw value.body?.cancel().catch(() => {
-            }), unavailable3();
+            }), unavailable4();
           return value;
         }),
         signal
@@ -2733,9 +2953,9 @@ function validPair(value) {
   return validProof(pair.credential) && validProof(pair.renewalCredential) && pair.credential !== pair.renewalCredential && validBinding(pair.context);
 }
 
-var unavailable2 = () => new InboxOperationError(503, "unavailable"), stale = () => new InboxOperationError(401, "authority_unavailable");
+var unavailable3 = () => new InboxOperationError(503, "unavailable"), stale = () => new InboxOperationError(401, "authority_unavailable");
 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();
+  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") : unavailable3();
 }
 async function send2(operation2, input) {
   let envelope = parseInboxRequest({ operation: operation2, input }), context2;
@@ -2755,12 +2975,12 @@ async function send2(operation2, input) {
         [400, 401, 403, 409].includes(response2.status) ? response2.status : 503,
         response2.status === 400 ? "invalid_input" : response2.status === 401 ? "authority_unavailable" : response2.status === 403 ? "access_denied" : response2.status === 409 ? "conflict" : "unavailable"
       );
-      if (response2.status !== 200) throw unavailable2();
+      if (response2.status !== 200) throw unavailable3();
       let parsed = parseInboxResult(operation2, value);
-      if (check2(), operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable2();
+      if (check2(), operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable3();
       return parsed;
     } catch (error) {
-      throw check2(), error instanceof InboxOperationError ? error : unavailable2();
+      throw check2(), error instanceof InboxOperationError ? error : unavailable3();
     }
   }
   if (context2.endpoint !== `https://${context2.workspace}.oddington.ai` || ["auth", "www", "api", "os"].includes(context2.workspace)) throw stale();
@@ -2771,7 +2991,7 @@ async function send2(operation2, input) {
     } catch (error) {
       throw hostFailure(error, context2);
     }
-    if (!host) throw unavailable2();
+    if (!host) throw unavailable3();
   }
   let check = () => {
     if (!context2.isCurrent() || host && !host.isCurrent() || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now()) throw stale();
@@ -2801,9 +3021,9 @@ async function send2(operation2, input) {
       );
     if (response2.status !== 200)
       throw response2.body?.cancel().catch(() => {
-      }), unavailable2();
+      }), unavailable3();
     if (operation2 === "files.read") {
-      if (!response2.body) throw unavailable2();
+      if (!response2.body) throw unavailable3();
       let source = response2.body, reader, size = 0, cancel = async (reason) => {
         try {
           await (reader ? reader.cancel(reason) : source.cancel(reason));
@@ -2819,7 +3039,7 @@ async function send2(operation2, input) {
               reader.releaseLock(), controller.close();
               return;
             }
-            if (size += next.value.byteLength, size > 25 * 1024 * 1024) throw unavailable2();
+            if (size += next.value.byteLength, size > 25 * 1024 * 1024) throw unavailable3();
             controller.enqueue(next.value);
           } catch (error) {
             controller.error(error), await cancel(error).catch(() => {
@@ -2831,16 +3051,16 @@ async function send2(operation2, input) {
       return new Response(body, { status: response2.status, headers: response2.headers });
     }
     let bytes = await limitedBody(response2, INBOX_RESULT_BYTES);
-    if (check(), !bytes) throw unavailable2();
+    if (check(), !bytes) throw unavailable3();
     let value = JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes)), parsed = parseInboxResult(operation2, value);
-    if (check(), operation2 === "current" && parsed.workspace.slug !== context2.workspace) throw unavailable2();
+    if (check(), operation2 === "current" && parsed.workspace.slug !== context2.workspace) throw unavailable3();
     if ("itemId" in envelope.input) {
       let item = operation2 === "items.read" ? parsed : operation2 === "items.rename" || operation2 === "items.setLifecycle" || operation2 === "items.addRecipient" ? parsed.item : void 0;
-      if (item && (item.id !== envelope.input.itemId || "revision" in envelope.input && item.revision !== envelope.input.revision) || operation2 === "items.addRecipient" && parsed.addedPersonId !== envelope.input.personId || operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable2();
+      if (item && (item.id !== envelope.input.itemId || "revision" in envelope.input && item.revision !== envelope.input.revision) || operation2 === "items.addRecipient" && parsed.addedPersonId !== envelope.input.personId || operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable3();
     }
     return parsed;
   } catch (error) {
-    throw check(), error instanceof InboxOperationError ? error : unavailable2();
+    throw check(), error instanceof InboxOperationError ? error : unavailable3();
   }
 }
 var inbox = {
@@ -2860,14 +3080,14 @@ var inbox = {
         throw hostFailure(error, initial);
       }
       if (initial.kind === "local") throw new InboxOperationError(403, "access_denied");
-      if (!host) throw unavailable2();
+      if (!host) throw unavailable3();
       let check = () => {
         if (!initial.isCurrent() || !host.isCurrent() || initial.expiresAt <= Date.now()) throw stale();
       };
       do {
         check();
         let page = await send2("items.list", beforeNumber === void 0 ? {} : { beforeNumber });
-        if (check(), beforeNumber !== void 0 && (page.items.some((item) => item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable2();
+        if (check(), beforeNumber !== void 0 && (page.items.some((item) => item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable3();
         if (items.push(...page.items), page.nextBeforeNumber === null) return items;
         beforeNumber = page.nextBeforeNumber;
       } while (!0);
@@ -2901,7 +3121,7 @@ var inbox = {
           routines,
           ...beforeNumber === void 0 ? {} : { beforeNumber }
         });
-        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 (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 unavailable3();
         if (questions.push(...page.questions), page.nextBeforeNumber === null) return questions;
         beforeNumber = page.nextBeforeNumber;
       } while (!0);
@@ -3483,7 +3703,7 @@ function handle(key, id3, context2) {
 async function describeAppRoutine(key) {
   let descriptor = appDescriptors().find((item) => item.id === key);
   if (!descriptor) return fail3("authority_unavailable");
-  let unavailable3 = () => ({
+  let unavailable4 = () => ({
     ...structuredClone(descriptor),
     connections: descriptor.connections.map((connection) => ({ ...connection, available: !1 })),
     readiness: { state: "unavailable", reason: "capability_unavailable", message: "Routine capability unavailable." }
@@ -3492,11 +3712,11 @@ async function describeAppRoutine(key) {
     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 unavailable3();
+    return unavailable4();
   }
 }
 function appRoutineBinding(key) {
-  return Object.freeze({
+  return (typeof key != "string" || !identifier.test(key) || !appDescriptors().some((item) => item.id === key)) && fail3("authority_unavailable"), Object.freeze({
     describe: () => describeAppRoutine(key),
     async run(...args) {
       args.length > 1 && fail3("invalid_input");
@@ -3530,6 +3750,7 @@ function appRoutineBinding(key) {
 
 var app = Object.freeze({
   listRoutines: () => Promise.all(appDescriptors().map(({ id: id3 }) => describeAppRoutine(id3))),
+  routine: appRoutineBinding,
   routines: new Proxy(/* @__PURE__ */ Object.create(null), {
     get(_target, key) {
       if (!(typeof key != "string" || !appDescriptors().some((item) => item.id === key)))
@@ -3569,10 +3790,10 @@ function routineDataEnvelope(command) {
 }
 
 function routinePublicationClient2(options = {}) {
-  let environment = {}, installed2 = routineTransport(), local3 = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
+  let environment = {}, installed2 = routineTransport(), local3 = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.OS_ROUTINE_WORKSPACE, capability = options.capability ?? environment.OS_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 } : {}, request2 = options.request ?? (capability ? async (path, init2) => {
+  let workingRoot = options.workingRoot ?? environment.OS_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-os-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")
@@ -3588,7 +3809,7 @@ function routinePublicationClient2(options = {}) {
       headers: {
         "content-type": "application/json",
         ...headers,
-        ...writing || reading ? { "x-oddington-workspace": workspace, "x-oddington-captured-records": "1" } : {}
+        ...writing || reading ? { "x-os-workspace": workspace, "x-os-captured-records": "1" } : {}
       },
       body: JSON.stringify(writing ? routineDataEnvelope(validateRoutineRecordWrite(body)) : reading ? { operation: "records.select", request: validateRecordRead(body) } : body)
     }), result2 = await response2.json();