@oddington/sdk 0.1.14 → 0.1.15

package/README.md

@@ -4,6 +4,14 @@ The importable client for Oddington apps, routines and response handlers.
 Node operations require Node.js 22.12.0 or later. The root import and hosted
 Data and Files APIs work in browsers. Installing the package grants no authority.
 
+Hosted Data and shared Files reach OS directly through `/api/data` and `/api/files`.
+Inbox owns workspace-hosted `/api/inbox/check`, `/api/inbox/publish`,
+`/api/inbox/resolve` and `/api/inbox/files`. Request-key recovery and captured
+publication validation are internal behavior of these operations. Retrying the
+same key and content returns the original result; changed content conflicts.
+Existing Inbox-retained files remain separate from shared Files, with their
+original identities, bytes and audience. The SDK exposes no raw-credential API.
+
 ```sh
 npm install @oddington/sdk
 ```

package/dist/browser.js

@@ -669,6 +669,11 @@ async function executeRoutineDefinition(definition, input, runtime) {
   let captured = captureRoutineInput(definition, input), { contract, run } = definitions.get(definition), active2 = !0, broken = !1, reports = Promise.resolve(), os2 = Object.freeze({
     ...runtime,
     run: freeze({ ...runtime.run }),
+    async artifact(input2) {
+      if (!active2) throw new Error("Run authority ended");
+      if (!runtime.artifact) throw new Error("Run artifact transport unavailable");
+      return runtime.artifact(input2);
+    },
     step(id3, ...summary) {
       if (!active2 || broken || summary.length > 1)
         return broken = !0, Promise.reject(new AppRoutineContractError("invalid_value"));
@@ -883,12 +888,10 @@ function dataTransportError(status, value) {
   );
 }
 
-var AUTH_ORIGIN = "https://auth.oddington.ai";
-function oddingtonOrigin(environment = process.env) {
-  let value = environment.ODDINGTON_OS_ORIGIN ?? AUTH_ORIGIN, url = new URL(value);
-  if (url.protocol !== "https:" && url.hostname !== "127.0.0.1")
-    throw new Error("ODDINGTON_OS_ORIGIN must use HTTPS");
-  return url.origin;
+var installed, ended = !1;
+function routineTransport() {
+  if (ended || installed && !installed.isCurrent()) throw new Error("Routine authority ended");
+  return installed;
 }
 
 var memberContext;
@@ -954,10 +957,9 @@ function checked(workspace, endpoint, headers) {
 var data = {
   repository(repository) {
     async function send3(input) {
-      let context2 = await resolveDataContext();
+      let context2 = await resolveDataContext(), envelope = { repository, ...input };
+      if (checkDataRequestSize(envelope), "local" in context2) return await context2.local("data/query", envelope);
       try {
-        let envelope = { repository, ...input };
-        if (checkDataRequestSize(envelope), "local" in context2) return await context2.local("data/query", envelope);
         let response2 = await fetch(context2.url, {
           method: "POST",
           redirect: "error",
@@ -1026,7 +1028,7 @@ var data = {
               } catch (error) {
                 return Promise.reject(error);
               }
-              publicationId ??= crypto.randomUUID(), pending = send3({ operation: "changes.publish", ...captured, publicationId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
+              publicationId ??= routineTransport()?.key("data") ?? crypto.randomUUID(), pending = send3({ operation: "changes.publish", ...captured, publicationId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
                 throw error instanceof DataOperationError ? new DataOperationError(
                   error.code,
                   error.retryable,
@@ -1358,7 +1360,7 @@ var files = {
       storage: input.storage,
       csv: input.csv,
       ...blob && input.file.type === "application/pdf" ? { inputMediaType: "application/pdf" } : {},
-      requestKey: options?.requestKey === void 0 ? crypto.randomUUID() : options.requestKey
+      requestKey: options?.requestKey === void 0 ? routineTransport()?.key("files") ?? crypto.randomUUID() : options.requestKey
     }, FILE_ORIGINAL_MAX_BYTES);
     if (!context2.local && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
     let header = encodeURIComponent(JSON.stringify(metadata));
@@ -1669,6 +1671,8 @@ async function reportLocalRoutineEffect(value) {
 
 var connections = /* @__PURE__ */ createConnections(async (name, operation2, input) => {
   try {
+    let installed2 = routineTransport();
+    if (installed2) return await installed2.request("airtable", { name, operation: operation2, input: serializable(input) });
     let managed = process.env[MANAGED_CONNECTION_CAPABILITY_ENV];
     if (managed) {
       let client = managedConnections(JSON.parse(managed)).airtable(name);
@@ -3145,13 +3149,20 @@ function validateCsvHints(value) {
   return v;
 }
 
+var PREPARED_RECORD_INPUT_LIMIT = 64 * 1024 * 1024;
+
+function routineDataEnvelope(command) {
+  return "preflight" in command ? { operation: "changes.validate", captured: command.preflight } : "apply" in command ? { operation: "changes.publish", captured: command.apply } : { operation: "changes.publish", request: command };
+}
+
 function routinePublicationClient2(options = {}) {
-  let environment = {}, local = void 0, workspace = options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
+  let environment = {}, installed2 = routineTransport(), local = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
   if (!workspace || !/^[a-z0-9][a-z0-9-]*$/.test(workspace) || capability !== void 0 && !/^[0-9a-f]{64}$/.test(capability))
     throw new Error("A workspace and valid optional routine capability are required");
   let workingRoot = options.workingRoot ?? environment.ODDINGTON_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-oddington-run": capability } : {}, request = options.request ?? (capability ? async (path, init2) => {
-    let origin = oddingtonOrigin(), target = new URL(path, `${origin}/`);
-    if (target.origin !== origin || !target.pathname.startsWith(`/api/cli/workspaces/${workspace}/inbox/`))
+    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")
       throw new Error("Invalid routine endpoint");
     return fetch(target, { ...init2, redirect: "error" });
   } : async () => {
@@ -3159,10 +3170,14 @@ function routinePublicationClient2(options = {}) {
   });
   async function send3(operation2, body2) {
     if (local) return await local(operation2, body2);
-    let response2 = await request(`/api/cli/workspaces/${workspace}/inbox/${operation2}`, {
+    let writing = operation2 === "records/update", reading = operation2 === "records/read", response2 = await request(writing || reading ? "/api/data" : `/api/inbox/${operation2}`, {
       method: "POST",
-      headers: { "content-type": "application/json", ...headers },
-      body: JSON.stringify(body2)
+      headers: {
+        "content-type": "application/json",
+        ...headers,
+        ...writing || reading ? { "x-oddington-workspace": workspace, "x-oddington-captured-records": "1" } : {}
+      },
+      body: JSON.stringify(writing ? routineDataEnvelope(validateRoutineRecordWrite(body2)) : reading ? { operation: "records.select", request: validateRecordRead(body2) } : body2)
     }), result2 = await response2.json();
     if (!response2.ok && operation2 === "records/update")
       throw new RoutineRecordWriteError(result2.error ?? "Could not confirm routine preparation", result2.effect ?? "uncertain");
@@ -3186,15 +3201,15 @@ function routinePublicationClient2(options = {}) {
     repository: {
       readRecords,
       async writeRecords(input, options2) {
-        if (!capability) throw new Error("A trusted routine launch is required");
+        if (!capability && !installed2) throw new Error("A trusted routine launch is required");
         return await send3("records/update", validateRoutineRecordWrite({ input, requestKey: options2?.requestKey }));
       },
       async updateRecords(input, options2) {
-        if (!capability) throw new Error("A trusted routine launch is required");
+        if (!capability && !installed2) throw new Error("A trusted routine launch is required");
         return await send3("records/update", validateRoutineRecordWrite({ input: validateRecordUpdate(input), requestKey: options2?.requestKey }));
       },
       async deleteRecords(input, options2) {
-        if (!capability) throw new Error("A trusted routine launch is required");
+        if (!capability && !installed2) throw new Error("A trusted routine launch is required");
         return await send3("records/update", validateRoutineRecordWrite({ input: validateRecordDelete(input), requestKey: options2?.requestKey }));
       }
     },