@oddington/sdk 0.1.42 → 0.1.44

package/README.md

@@ -171,13 +171,22 @@ finite numbers and safe integers with optional inclusive bounds, and Files.
 Omitting `maxItems` imposes no item-count ceiling; the complete serialized input
 still shares the Run's byte bound, including every File descriptor and other field.
 Definitions allow at most 64 steps, 64 total object properties across their schemas,
-and eight schema levels. Run input, each summary, each detail value, and the result
-accept at most 256 KiB of UTF-8 serialized JSON, without truncation. Step inputs
-remain closed, immutable JSON but have no separate byte ceiling because they are
-transient in-process values rather than transported or retained Run evidence.
-Across 64 steps, retained summary plus detail is at most 32 MiB, plus 512 KiB for
-Run input and result. Schema defaults share the input bound. Titles contain at
-most 256 UTF-16 code units;
+and eight schema levels. Run input, the result, and each step summary accept at
+most 256 KiB of compact UTF-8 JSON. Each step accepts at most 1 MiB across its
+summary and data together, measured as the sum of their compact UTF-8 JSON sizes
+(including JSON quotes and escapes, excluding transport envelopes), without
+truncation. Step inputs remain closed, immutable JSON but have no separate byte
+ceiling because they are transient in-process values rather than transported or
+retained Run evidence.
+Across 64 steps, retained summary plus data is at most 64 MiB without a separate
+aggregate output limit, plus 512 KiB for Run input and result. An oversized output
+fails the step and Run once, even if routine code catches the rejection; later
+steps do not execute and customer code is not automatically retried. The rejected
+summary and data are not retained. The safe `step_output_too_large` failure keeps
+only `step`, `sizeBytes`, `limitBytes`, `summaryBytes`, and `dataBytes` and explains
+how to return fewer fields or process a smaller batch. `limitBytes` identifies
+the violated summary or combined bound. Schema defaults share the input bound.
+Titles contain at most 256 UTF-16 code units;
 access dimensions and response handlers each have at most 64 entries. Functions,
 accessors, sparse arrays, cycles and non-JSON values reject. The canonical routine
 ID is a bounded lowercase alphanumeric/hyphen name, independent of its directory.
@@ -186,8 +195,9 @@ No entry, workspace, credentials or placement are authored in this definition.
 Local Run history returns the newest 20 summaries per canonical routine, without
 deleting older Runs or unpublished changes. Step titles and bounded summary/detail
 values are saved with the accepted Run, so later source edits cannot rewrite them.
-Each checkout-private execution/preparation JSON file has a 64 MiB total bound,
-including private diagnostics; app summaries never include those diagnostics.
+Checkout-private execution JSON has a 128 MiB read envelope for up to 64 MiB
+of step output plus existing evidence; other local state files keep their 64 MiB
+envelope, including private diagnostics; app summaries never include those diagnostics.
 Publication reads the existing confirmed-receipt journal independently from the
 successful execution status. Refresh reads materialized state; watching provides
 connected updates without replay or interrupted-execution recovery.
@@ -349,9 +359,11 @@ the current remote Run owner through the same bindings. Operations reject with
 `AppRoutineError.reason`: `authority_unavailable`, `execution_unavailable`, or
 `invalid_input`. Starts are not automatically retried. A
 disconnected watch ends and requires `current()`. History returns at most 20
-summaries without deleting older Runs. Each JSON value is bounded to 256 KiB.
-Transport envelopes allow 17 MiB per summary, 514 KiB per detail and 20 summaries
-per list; execution retains at most 10 MiB of report evidence. Raw process
+summaries without deleting older Runs. Input, result and each step summary are
+bounded to 256 KiB; each step's summary plus on-demand data is bounded to 1 MiB.
+Transport envelopes allow 17 MiB per summary, 1 MiB plus 4 KiB per detail and
+20 summaries per list. Local child reports allow 1 MiB plus 64 KiB of framing;
+non-output report evidence retains its 10 MiB bound independently of step output. Raw process
 output and private authority stay private.
 
 The exact-origin browser credential survives document disposal, reload and tab

package/dist/browser.js

@@ -63,6 +63,8 @@ function fileErrorMessage(error) {
       return "Sign in to OS before accessing files.";
     case "access_denied":
       return "You don\u2019t have access to this file operation.";
+    case "not_found":
+      return "This file isn\u2019t available in this workspace.";
     case "request_too_large":
       return "The file request exceeds the size limit.";
     case "conflict":
@@ -996,6 +998,42 @@ function acceptText(request2, text5) {
   return validateObject(request2.schema, object5, text5), capture({ object: object5 }, "invalid_output", "output_too_large");
 }
 
+var ROUTINE_STEP_SUMMARY_BYTES = 256 * 1024, ROUTINE_STEP_OUTPUT_BYTES = 1024 * 1024;
+function parseRoutineStepOutputDetail(value) {
+  let invalid9 = () => {
+    throw new AppRoutineContractError("invalid_value");
+  };
+  assertRoutineFields(value, ["step", "sizeBytes", "limitBytes", "summaryBytes", "dataBytes"]);
+  let { step, sizeBytes, limitBytes, summaryBytes, dataBytes } = value;
+  return !isAppRoutineName(step) || ![sizeBytes, limitBytes, summaryBytes, dataBytes].every((bytes) => Number.isSafeInteger(bytes) && bytes > 0) || sizeBytes !== summaryBytes + dataBytes || limitBytes !== (summaryBytes > ROUTINE_STEP_SUMMARY_BYTES ? ROUTINE_STEP_SUMMARY_BYTES : ROUTINE_STEP_OUTPUT_BYTES) || (limitBytes === ROUTINE_STEP_SUMMARY_BYTES ? summaryBytes : sizeBytes) <= limitBytes ? invalid9() : freezeRoutineMetadata({ step, sizeBytes, limitBytes, summaryBytes, dataBytes });
+}
+function routineStepOutputMessage(value) {
+  let detail = parseRoutineStepOutputDetail(value), size = `${(detail.sizeBytes / (1024 * 1024)).toFixed(1)} MB`, bound = detail.limitBytes === ROUTINE_STEP_SUMMARY_BYTES ? `, including ${(detail.summaryBytes / 1024).toFixed(1)} KB of summary. Each step's summary can return up to 256 KB.` : ". Each step can return up to 1 MB across its summary and data.";
+  return `Step ${detail.step} returned ${size} of output${bound} Return fewer fields or process a smaller batch, then try again.`;
+}
+var RoutineStepOutputError = class extends Error {
+  code = "step_output_too_large";
+  detail;
+  constructor(detail) {
+    let captured = parseRoutineStepOutputDetail(detail);
+    super(routineStepOutputMessage(captured)), this.detail = captured, Object.freeze(this);
+  }
+};
+function captureRoutineStepOutput(step, summary2, data3) {
+  assertRoutineJson(summary2), assertRoutineJson(data3);
+  let summaryJson = JSON.stringify(summary2), dataJson = JSON.stringify(data3), summaryBytes = new TextEncoder().encode(summaryJson).byteLength, dataBytes = new TextEncoder().encode(dataJson).byteLength, sizeBytes = summaryBytes + dataBytes, limitBytes = summaryBytes > ROUTINE_STEP_SUMMARY_BYTES ? ROUTINE_STEP_SUMMARY_BYTES : ROUTINE_STEP_OUTPUT_BYTES;
+  if (summaryBytes > ROUTINE_STEP_SUMMARY_BYTES || sizeBytes > ROUTINE_STEP_OUTPUT_BYTES)
+    throw new RoutineStepOutputError({ step, sizeBytes, limitBytes, summaryBytes, dataBytes });
+  return freezeRoutineMetadata({ summary: JSON.parse(summaryJson), data: JSON.parse(dataJson) });
+}
+function captureRetainedStepOutput(step, value) {
+  let hasSummary = Object.hasOwn(value, "summary"), hasData = Object.hasOwn(value, "data");
+  if (hasSummary && hasData) return captureRoutineStepOutput(step, value.summary, value.data);
+  for (let key of ["summary", "data"]) if (Object.hasOwn(value, key) && (assertRoutineJson(value[key]), new TextEncoder().encode(JSON.stringify(value[key])).byteLength > (key === "summary" ? ROUTINE_STEP_SUMMARY_BYTES : ROUTINE_STEP_OUTPUT_BYTES)))
+    throw new AppRoutineContractError("invalid_value");
+  return freezeRoutineMetadata(JSON.parse(JSON.stringify(value)));
+}
+
 var LIMIT = 256 * 1024, invalid3 = () => {
   throw new AppRoutineContractError("invalid_value");
 }, invalidContract3 = () => {
@@ -1120,7 +1158,7 @@ function captureRoutineInput(definition, 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(), aiWork = /* @__PURE__ */ new Set(), generate = (kind, value) => {
+  let captured = captureRoutineInput(definition, input), { contract, steps, run } = definitions.get(definition), active2 = !0, accepting = !0, broken = !1, outputFailure, work = Promise.resolve(), aiWork = /* @__PURE__ */ new Set(), generate = (kind, value) => {
     let operation2 = (async () => {
       if (!active2 || broken || contract.access.ai !== !0) throw new AIError("access_denied");
       if (!runtime.ai) throw new AIError("capability_unavailable");
@@ -1190,10 +1228,10 @@ async function executeRoutineDefinition(definition, input, runtime) {
           await runtime.step(id3, { status: "running" }), activeStep = id3;
           let output = await steps[id3].run(saved, os2);
           if (assertRoutineFields(output, ["summary", "data"]), !Object.hasOwn(output, "summary") || !Object.hasOwn(output, "data")) return invalid3();
-          let summary2 = captureJson(output.summary), data3 = captureJson(output.data);
+          let { summary: summary2, data: data3 } = captureRoutineStepOutput(id3, output.summary, output.data);
           return await runtime.step(id3, { status: "completed", summary: summary2, data: data3 }), activeStep = void 0, freezeRoutineMetadata({ summary: summary2, data: data3 });
         } catch (error) {
-          throw broken = !0, activeStep = void 0, await runtime.step(id3, { status: "failed" }), error;
+          throw error instanceof RoutineStepOutputError && (outputFailure ??= error), broken = !0, activeStep = void 0, await runtime.step(id3, { status: "failed" }), error;
         }
       });
       return work = next.then(() => {
@@ -1209,8 +1247,12 @@ async function executeRoutineDefinition(definition, input, runtime) {
   }
   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");
+  try {
+    for (let step of contract.steps) reached.has(step.id) || await runtime.step(step.id, { status: "skipped" });
+  } catch (error) {
+    throw outputFailure ?? error;
+  }
+  if (broken) throw outputFailure ?? failure ?? new AppRoutineContractError("invalid_value");
   if (contract.result !== void 0) return capture2(contract.result, result2);
   if (result2 !== void 0) return invalid3();
 }
@@ -1924,6 +1966,7 @@ var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES =
   400: ["invalid_input", "unsupported_context"],
   401: ["unauthenticated"],
   403: ["access_denied"],
+  404: ["not_found"],
   405: ["method_not_allowed"],
   409: ["conflict", "local_only"],
   413: ["request_too_large"],
@@ -2766,8 +2809,6 @@ function runtimeConnections() {
 }
 var connections = /* @__PURE__ */ runtimeConnections();
 
-var LOCAL_ROUTINE_VALUE_BYTES = 256 * 1024;
-
 function locationIdentity(location) {
   let coordinates = location.provider === "os" ? [location.file] : location.provider === "gmail" ? [location.connection, location.message, location.attachment] : location.provider === "dropbox" ? [location.connection, location.file] : location.provider === "outlook" ? [
     location.connection,
@@ -3926,6 +3967,7 @@ function createBrowserAuth(runtime) {
       let revision = c.revision;
       try {
         if (!allowedOrigin(origin)) throw runtime.failure("unavailable");
+        runtime.prepare?.();
         let response2 = await fetch(`${origin}/api/auth`, { method: "GET", credentials: "same-origin", redirect: "error", cache: "no-store" });
         if (!response2.ok) throw runtime.failure("unavailable");
         let configuration = validateConfiguration(await response2.json());
@@ -4195,9 +4237,9 @@ var BrowserAuthError = class extends Error {
     this.name = "BrowserAuthError";
   }
   reason;
-};
+}, providerModule, prepareProvider = () => providerModule ??= import("./auth-provider.js");
 async function provider(configuration, guard) {
-  let { AuthClient } = await import("./auth-provider.js");
+  let { AuthClient } = await prepareProvider();
   if (!guard.current(guard.revision())) throw new BrowserAuthError("stale");
   let provenance = /* @__PURE__ */ new Map(), removalRevision, authorizationRequest, authorizationQueue = Promise.resolve(), storage = globalThis.localStorage, client = new AuthClient({
     url: `${configuration.providerUrl}/auth/v1`,
@@ -4279,7 +4321,16 @@ async function provider(configuration, guard) {
     }
   };
 }
-var auth = /* @__PURE__ */ createBrowserAuth({ provider, failure: (reason) => new BrowserAuthError(reason) });
+var auth = /* @__PURE__ */ createBrowserAuth({
+  // Preloading is opportunistic. Construction below still observes and
+  // normalizes a failed import, without leaving an unhandled preload promise.
+  prepare: () => {
+    prepareProvider().catch(() => {
+    });
+  },
+  provider,
+  failure: (reason) => new BrowserAuthError(reason)
+});
 
 function routineRunHandle(operations2) {
   return Object.freeze({
@@ -4318,14 +4369,19 @@ function progress(value) {
 }
 function parseRunStep(value, expected) {
   let v = record3(value);
-  return typeof v.id != "string" || !name.test(v.id) || expected !== void 0 && v.id !== expected || typeof v.title != "string" || !v.title.trim() || v.title.length > 256 || !["pending", "running", "completed", "failed", "skipped"].includes(v.status) ? invalid8() : {
+  if (typeof v.id != "string" || !name.test(v.id) || expected !== void 0 && v.id !== expected || typeof v.title != "string" || !v.title.trim() || v.title.length > 256 || !["pending", "running", "completed", "failed", "skipped"].includes(v.status)) return invalid8();
+  let output = captureRetainedStepOutput(v.id, {
+    ...Object.hasOwn(v, "summary") ? { summary: v.summary } : {},
+    ...Object.hasOwn(v, "data") ? { data: v.data } : {}
+  });
+  return {
     id: v.id,
     title: v.title,
     status: v.status,
     ...times(v),
     ...progress(v.progress),
     ...Object.hasOwn(v, "summary") ? { summary: bounded(v.summary) } : {},
-    ...Object.hasOwn(v, "data") ? { data: bounded(v.data) } : {}
+    ...Object.hasOwn(output, "data") ? { data: output.data } : {}
   };
 }
 function parseRemoteRun(value, expected = {}) {
@@ -4340,7 +4396,11 @@ function parseRemoteRun(value, expected = {}) {
   if (v.failure !== void 0) {
     let f = record3(v.failure);
     if (v.status !== "failed" || typeof f.message != "string" || !f.message || f.message.length > 512) return invalid8();
-    failure = { message: f.message };
+    if (f.code === "step_output_too_large") {
+      let { code, message: message2, ...facts } = f, detail = parseRoutineStepOutputDetail(facts);
+      if (!steps.some((step) => step.id === detail.step && step.status === "failed") || message2 !== routineStepOutputMessage(detail)) return invalid8();
+      failure = { code, message: message2, ...detail };
+    } else failure = { message: f.message };
   }
   return Object.hasOwn(v, "result") && v.status !== "succeeded" ? invalid8() : {
     id: v.id,
@@ -4427,12 +4487,23 @@ async function request(key, suffix, init2, maximum = SUMMARY_BYTES, retained, re
 function summary(value, key, context, id3) {
   if (context.kind !== "local")
     try {
-      return (!only(value, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure") || !Array.isArray(value.steps) || value.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,progress,summary,detailAvailable")) || value.failure !== void 0 && !only(value.failure, "message")) && fail3("execution_unavailable"), parseRemoteRun(value, { routine: key, id: id3 });
+      return (!only(value, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure") || !Array.isArray(value.steps) || value.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,progress,summary,detailAvailable")) || value.failure !== void 0 && !validFailure(value.failure, value.steps)) && fail3("execution_unavailable"), parseRemoteRun(value, { routine: key, id: id3 });
     } catch {
       return fail3("execution_unavailable");
     }
   let run = value;
-  return (!only(run, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure,local") || typeof run.id != "string" || !uuid2.test(run.id) || id3 !== void 0 && run.id !== id3 || run.routine !== key || run.placement !== "local" || !["queued", "running", "succeeded", "failed"].includes(run.status) || !timestamp(run.createdAt) || !optionalTimes(run) || !Array.isArray(run.steps) || run.steps.length > 64 || run.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,progress,summary,detailAvailable") || typeof step.detailAvailable != "boolean" || !validStep(step)) || new Set(run.steps.map((step) => step.id)).size !== run.steps.length || Object.hasOwn(run, "result") && (run.status !== "succeeded" || !bounded2(run.result)) || run.failure !== void 0 && (run.status !== "failed" || !only(run.failure, "message") || !message(run.failure.message)) || run.local !== void 0 && !validLocalActivity(run.local)) && fail3("execution_unavailable"), run;
+  return (!only(run, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure,local") || typeof run.id != "string" || !uuid2.test(run.id) || id3 !== void 0 && run.id !== id3 || run.routine !== key || run.placement !== "local" || !["queued", "running", "succeeded", "failed"].includes(run.status) || !timestamp(run.createdAt) || !optionalTimes(run) || !Array.isArray(run.steps) || run.steps.length > 64 || run.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,progress,summary,detailAvailable") || typeof step.detailAvailable != "boolean" || !validStep(step)) || new Set(run.steps.map((step) => step.id)).size !== run.steps.length || Object.hasOwn(run, "result") && (run.status !== "succeeded" || !bounded2(run.result)) || run.failure !== void 0 && (run.status !== "failed" || !validFailure(run.failure, run.steps)) || run.local !== void 0 && !validLocalActivity(run.local)) && fail3("execution_unavailable"), run;
+}
+function validFailure(value, steps) {
+  if (!only(value, "message,code,step,sizeBytes,limitBytes,summaryBytes,dataBytes") || !message(value.message)) return !1;
+  if (value.code === void 0) return only(value, "message");
+  if (value.code !== "step_output_too_large") return !1;
+  try {
+    let { code: _, message: message2, ...facts } = value, detail = parseRoutineStepOutputDetail(facts);
+    return message2 === routineStepOutputMessage(detail) && steps.some((step) => step.id === detail.step && step.status === "failed");
+  } catch {
+    return !1;
+  }
 }
 function only(value, allowed) {
   return !!value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).every((key) => allowed.split(",").includes(key));
@@ -4442,7 +4513,16 @@ function optionalTimes(value) {
   return (value.startedAt === void 0 || timestamp(value.startedAt)) && (value.finishedAt === void 0 || timestamp(value.finishedAt));
 }
 function validStep(step) {
-  return typeof step.id == "string" && identifier.test(step.id) && typeof step.title == "string" && step.title.length > 0 && step.title.length <= 256 && ["pending", "running", "completed", "failed", "skipped"].includes(step.status) && optionalTimes(step) && (step.progress === void 0 || only(step.progress, "completed,total") && Number.isSafeInteger(step.progress.completed) && Number.isSafeInteger(step.progress.total) && step.progress.completed > 0 && step.progress.completed <= step.progress.total) && (!Object.hasOwn(step, "summary") || bounded2(step.summary)) && (!Object.hasOwn(step, "data") || bounded2(step.data));
+  return typeof step.id == "string" && identifier.test(step.id) && typeof step.title == "string" && step.title.length > 0 && step.title.length <= 256 && ["pending", "running", "completed", "failed", "skipped"].includes(step.status) && optionalTimes(step) && (step.progress === void 0 || only(step.progress, "completed,total") && Number.isSafeInteger(step.progress.completed) && Number.isSafeInteger(step.progress.total) && step.progress.completed > 0 && step.progress.completed <= step.progress.total) && (() => {
+    try {
+      return captureRetainedStepOutput(step.id, {
+        ...Object.hasOwn(step, "summary") ? { summary: step.summary } : {},
+        ...Object.hasOwn(step, "data") ? { data: step.data } : {}
+      }), !0;
+    } catch {
+      return !1;
+    }
+  })();
 }
 function validLocalActivity(value) {
   let paths = (value2) => Array.isArray(value2) && value2.every((path) => typeof path == "string" && path.length > 0 && path.length <= 4096 && !path.startsWith("/") && !path.includes("\\") && !path.split("/").some((part) => !part || part === "." || part === "..") && !/[\x00-\x1f\x7f]/.test(path));
@@ -4480,7 +4560,7 @@ function handle(key, id3, context) {
     },
     async step(step) {
       (typeof step != "string" || !identifier.test(step)) && fail3("invalid_input");
-      let value = await request(key, `runs/${id3}/steps/${step}`, void 0, 514 * 1024, context, !0);
+      let value = await request(key, `runs/${id3}/steps/${step}`, void 0, ROUTINE_STEP_OUTPUT_BYTES + 4096, context, !0);
       if (context.kind !== "local")
         try {
           return only(value, "id,title,status,startedAt,finishedAt,progress,summary,data") || fail3("execution_unavailable"), parseRunStep(value, step);