@lostgradient/weft 0.11.0 → 0.13.0

package/dist/storage/http.js

@@ -1,2 +1,200 @@
-var u=Object.defineProperty;var k=(F)=>F;function w(F,G){this[F]=k.bind(null,G)}var JF=(F,G)=>{for(var J in G)u(F,J,{get:G[J],enumerable:!0,configurable:!0,set:w.bind(G,J)})};function N(F){let G=[];for(let J=0;J<F.length;J+=512)G.push(String.fromCharCode(...F.subarray(J,J+512)));return btoa(G.join(""))}function R(F){let G=atob(F),J=new Uint8Array(G.length);for(let Y=0;Y<G.length;Y+=1)J[Y]=G.charCodeAt(Y);return J}function D(F){return typeof F==="object"&&F!==null&&!Array.isArray(F)}async function j(F,G){return await F.get(G)!==null}async function*X(F,G,J){for await(let[Y]of F.scan(G,J))yield Y}async function W(F,G){let J=0;for await(let Y of X(F,G))J++;return J}async function H(F,G){let J=[];for await(let Y of X(F,G))J.push({type:"delete",key:Y});if(J.length===0)return 0;return await F.batch(J),J.length}async function L(F,G,J){let Y=[];for await(let Z of X(F,G,J))Y.push({type:"delete",key:Z});if(Y.length===0)return 0;return await F.batch(Y),Y.length}function q(F,G,J){if(!F.capabilities()[G])throw Error(`Feature "${J}" requires storage capability "${G}", but this storage backend does not provide it.`)}var S="default";var T=1e4,jF=1e4;class K extends Error{code="StorageBatchOperationLimitExceededError";cap=T;count;target;constructor(F,G){super(`${F} count ${G} exceeds MAX_BATCH_OPERATIONS (${T}).`);this.name="StorageBatchOperationLimitExceededError",this.target=F,this.count=G}}function $(F,G){if(G>T)throw new K(F,G)}function O(F){return F.length>0?F.slice(0,-1)+String.fromCharCode(F.charCodeAt(F.length-1)+1):"ÿ"}function WF(F,G={}){if(G.gt!==void 0&&F<=G.gt)return!1;if(G.gte!==void 0&&F<G.gte)return!1;if(G.lt!==void 0&&F>=G.lt)return!1;if(G.lte!==void 0&&F>G.lte)return!1;return!0}function HF(F,G){if(F===null||G===null)return F===G;if(F.byteLength!==G.byteLength)return!1;for(let J=0;J<F.byteLength;J++)if(F[J]!==G[J])return!1;return!0}async function h(F,G){if(F.has)return F.has(G);return j(F,G)}function b(F,G,J){if(F.keys)return F.keys(G,J);return X(F,G,J)}async function v(F,G){if(F.count)return F.count(G);return W(F,G)}async function m(F,G){if(F.deletePrefix)return F.deletePrefix(G);return H(F,G)}async function LF(F,G){$("batch operations",G.length),await F.batch(G)}async function x(F,G,J){if($("conditionalBatch conditions",G.length),$("conditionalBatch operations",J.length),q(F,"conditionalBatch","storageConditionalBatch"),!F.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return F.conditionalBatch(G,J)}function Q(F){return encodeURIComponent(F)}function UF(F){return decodeURIComponent(F)}function NF(F){try{return decodeURIComponent(F)}catch{return null}}var _=(F)=>String(F).padStart(16,"0"),f="0",l="1",P=(F,G,J,Y)=>`sig:${Q(F)}:${Q(G)}:${Y}:${Q(J)}`,DF={workflow:(F)=>`wf:${Q(F)}`,checkpoint:(F)=>`wf:${Q(F)}:ckpt`,checkpointHistory:(F,G)=>`wf:${Q(F)}:ckpt:${String(G).padStart(10,"0")}`,timelinePrefix:(F)=>`wf:${Q(F)}:timeline:`,timeline:(F,G)=>`wf:${Q(F)}:timeline:${String(G).padStart(10,"0")}`,schedule:(F)=>`schedule:${Q(F)}`,scheduleTick:(F,G)=>`schedule-due:${String(F).padStart(16,"0")}:${Q(G)}`,scheduleRun:(F)=>`schedule-run:${Q(F)}`,operation:(F,G,J)=>`op:${F}:${_(G)}:${J}`,operationInflight:(F)=>`op:inflight:${F}`,operationQueued:(F)=>`op:queued:${F}`,operationResolved:(F)=>`op:resolved:${F}`,operationDeadLetterPrefix:()=>"op:dead-letter:",operationDeadLetter:(F)=>`op:dead-letter:${F}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(F,G,J)=>`audit:bulk:${_(F)}:${Q(G)}:${Q(J)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(F,G)=>`op:resolved-by-time:${_(F)}:${Q(G)}`,asyncActivity:(F,G)=>`async-act:v1:${Q(F)}:${Q(G)}`,asyncActivityResolution:(F,G)=>`async-act:v1:${Q(F)}:${Q(G)}:resolution`,activityReconciliationPrefix:(F)=>`actrec:v1:${Q(F)}:`,activityReconciliation:(F,G,J)=>`actrec:v1:${Q(F)}:${Q(G)}:${J}`,eventPrefix:(F)=>`ev:${Q(F)}:`,event:(F,G)=>`ev:${Q(F)}:${String(G).padStart(10,"0")}`,eventHead:(F)=>`ev:${Q(F)}:head`,eventWatermark:(F)=>`ev:${Q(F)}:watermark`,fleetEventPrefix:()=>"fleet-event:",fleetEvent:(F)=>`fleet-event:${String(F).padStart(10,"0")}`,fleetEventTail:()=>"fleet-event-tail",fleetEventByWorkflowPrefix:(F)=>`fleet-event-by-workflow:${Q(F)}:`,fleetEventByWorkflow:(F,G)=>`fleet-event-by-workflow:${Q(F)}:${String(G).padStart(10,"0")}`,signal:(F,G,J)=>P(F,G,J,l),startSignal:(F,G,J)=>P(F,G,J,f),signalSequence:(F)=>`sigseq:v1:${Q(F)}`,signalAcceptedResponsePrefix:(F)=>`sigres:v1:${Q(F)}:`,signalAcceptedResponse:(F,G,J)=>`sigres:v1:${Q(F)}:${Q(G)}:${Q(J)}`,deadline:(F,G)=>`wf-deadline:${_(F)}:${Q(G)}`,terminalCleanup:(F,G)=>`wf-cleanup:${_(F)}:${Q(G)}`,teardownTimer:(F,G)=>`wf-teardown:${_(F)}:${Q(G)}`,delayedStart:(F,G)=>`wf-delayed:${_(F)}:${Q(G)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(F,G)=>`wf-terminal:${_(F)}:${Q(G)}`,attribute:(F)=>`attr:${Q(F)}`,attributeIndex:(F,G,J)=>`idx:${F}:${G}:${Q(J)}`,tagIndex:(F,G)=>`tag:${Q(F)}:${Q(G)}`,updatePrefix:(F)=>`upd:${Q(F)}:`,update:(F,G)=>`upd:${Q(F)}:${G}`,updateResponse:(F)=>`upr:${F}`,updateIdempotency:(F,G)=>`upk:${Q(F)}:${G}`,startIdempotency:(F)=>`start-idem:${Q(F)}`,startIdempotencySignalId:(F)=>`start-idem:${F}`,livenessPrefix:()=>"liveness:",liveness:(F)=>`liveness:${Q(F)}`,leasePrefix:()=>"lease:",leaseEpoch:()=>"lease:epoch",leaseHolder:()=>"lease:holder",budget:(F,G,J)=>`budget:${F}:${G}:${J}`,review:(F,G)=>`review:${Q(F)}:${G}`,workflowHeaders:(F)=>`wf-headers:${Q(F)}`,childCancellationPrefix:(F)=>`child-cancel:${Q(F)}:`,childCancellation:(F,G)=>`child-cancel:${Q(F)}:${Q(G)}`,terminalCleanupNeeded:(F)=>`wf-cleanup-needed:${Q(F)}`,workflowConcurrency:(F,G)=>`wf-concurrency:${Q(F)}:${Q(G)}`,workflowConcurrencyHolder:(F)=>`wf-concurrency-holder:${Q(F)}`,workflowHasServices:(F)=>`wf-has-services:${Q(F)}`,finalizerState:(F)=>`wf-finalizer-state:${Q(F)}`,teardownOwed:(F)=>`wf-teardown-needed:${Q(F)}`,teardownDeadLetter:(F)=>`wf-teardown-deadletter:${Q(F)}`,offload:(F,G)=>`offload:${Q(F)}:${G}`,archive:(F,G)=>`archive:${Q(F)}:${G}`,stateExecution:(F,G)=>`state:execution:${Q(F)}:${Q(G)}`,stateWorkflow:(F,G)=>`state:workflow-scope:${S}:${Q(F)}:${Q(G)}`,streamChunkPrefix:(F,G)=>`blob:${Q(F)}:${G}:chunk:`,streamChunk:(F,G,J)=>`blob:${Q(F)}:${G}:chunk:${String(J).padStart(10,"0")}`,streamTail:(F,G)=>`blob:${Q(F)}:${G}:tail`,streamMetadata:(F,G)=>`blob:${Q(F)}:${G}:meta`,budgetCharged:(F)=>`budget-charged:${F}`,toolEffect:(F,G,J)=>`tool-effect:${Q(F)}:${G}:${J}`,workflowVisibilityStatus:(F,G)=>`wf-idx-status:${Q(F)}:${Q(G)}`,workflowVisibilityType:(F,G)=>`wf-idx-type:${Q(F)}:${Q(G)}`,workflowVisibilityCreated:(F,G)=>`wf-idx-created:${_(F)}:${Q(G)}`,workflowVisibilityUpdated:(F,G)=>`wf-idx-updated:${_(F)}:${Q(G)}`,workflowVisibilityDeadline:(F,G)=>`wf-idx-deadline:${_(F)}:${Q(G)}`,workflowVisibilityManifest:(F)=>`wf-idx-manifest:${Q(F)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"};function d(F){if(F===void 0)return;if(typeof F!=="number"||!Number.isInteger(F)||F<0)throw Error("deleteRange limit must be a finite non-negative integer");return F===0?0:F}function V(F){let G={},J=!1;for(let Z of["gt","gte","lt","lte"]){let M=F[Z];if(M===void 0)continue;if(typeof M!=="string")throw Error("deleteRange bounds must be strings");G[Z]=M,J=!0}if(!J)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Y=d(F.limit);if(Y!==void 0)G.limit=Y;return G}async function c(F,G,J){let Y=V(J);if(F.deleteRange)return F.deleteRange(G,Y);return L(F,G,Y)}function p(F,G){let J={key:F,open:!1};if(G.gte!==void 0&&G.gte>J.key)J.key=G.gte,J.open=!1;if(G.gt!==void 0&&G.gt>=J.key)J.key=G.gt,J.open=!0;return J}function a(F,G){let J={key:O(F),open:!0};if(G.lt!==void 0&&G.lt<=J.key)J.key=G.lt,J.open=!0;if(G.lte!==void 0&&G.lte<J.key)J.key=G.lte,J.open=!1;return J}function BF(F,G){let J=p(F,G),Y=a(F,G);if(J.key>Y.key||J.key===Y.key&&(J.open||Y.open))return null;return{lower:J,upper:Y}}function A(F){return F.replaceAll(/:+$/g,"")}function s(F,G){let J=A(F),Y=A(G);if(J.length===0)return Y;if(Y.length===0)return J;return`${J}:${Y}`}class z{#G;#J;constructor(F,G){this.#G=F,this.#J=A(G)}#F(F){if(this.#J.length===0)return F;return F.length===0?`${this.#J}:`:`${this.#J}:${F}`}#Q(F){if(this.#J.length===0)return F;return F.slice(this.#J.length+1)}#Y(F={}){let G={};if(F.limit!==void 0)G.limit=F.limit;if(F.reverse!==void 0)G.reverse=F.reverse;if(F.gt!==void 0)G.gt=this.#F(F.gt);if(F.gte!==void 0)G.gte=this.#F(F.gte);if(F.lt!==void 0)G.lt=this.#F(F.lt);if(F.lte!==void 0)G.lte=this.#F(F.lte);return G}#_(F){let G={};if(F.limit!==void 0)G.limit=F.limit;if(F.gt!==void 0)G.gt=this.#F(F.gt);if(F.gte!==void 0)G.gte=this.#F(F.gte);if(F.lt!==void 0)G.lt=this.#F(F.lt);if(F.lte!==void 0)G.lte=this.#F(F.lte);return G}capabilities(){return this.#G.capabilities()}scoped(F){return new z(this.#G,s(this.#J,F))}async get(F){return this.#G.get(this.#F(F))}async put(F,G){await this.#G.put(this.#F(F),G)}async delete(F){await this.#G.delete(this.#F(F))}async*scan(F,G){for await(let[J,Y]of this.#G.scan(this.#F(F),this.#Y(G)))yield[this.#Q(J),Y]}async batch(F){$("batch operations",F.length),await this.#G.batch(F.map((G)=>{if(G.type==="put")return{type:"put",key:this.#F(G.key),value:G.value};return{type:"delete",key:this.#F(G.key)}}))}async conditionalBatch(F,G){return x(this.#G,F.map((J)=>({key:this.#F(J.key),expectedValue:J.expectedValue})),G.map((J)=>{if(J.type==="put")return{type:"put",key:this.#F(J.key),value:J.value};return{type:"delete",key:this.#F(J.key)}}))}async has(F){return h(this.#G,this.#F(F))}async deletePrefix(F){return m(this.#G,this.#F(F))}async deleteRange(F,G){let J=this.#_(V(G));return c(this.#G,this.#F(F),J)}async*keys(F,G){for await(let J of b(this.#G,this.#F(F),this.#Y(G)))yield this.#Q(J)}async count(F){return v(this.#G,this.#F(F))}[Symbol.dispose](){this.#G[Symbol.dispose]()}}function g(F,G){return new z(F,G)}var n=67108864;function y(F){if(F.type==="put")return{type:"put",key:F.key,value:N(F.value)};return{type:"delete",key:F.key}}function r(F){return{key:F.key,expectedValue:F.expectedValue===null?null:N(F.expectedValue)}}function i(F){if(!D(F)||typeof F.key!=="string"||typeof F.value!=="string")throw Error("HTTPStorage scan response contained an invalid NDJSON entry.");return{key:F.key,value:F.value}}function t(F){if(!D(F)||typeof F.applied!=="boolean")throw Error('HTTPStorage conditional batch response must include a boolean "applied" field.');return F.applied}function E(F,G,J){if(J!==void 0)F.searchParams.set(G,String(J))}function o(F){if(F.trim().length===0)return null;let G=i(JSON.parse(F));return[G.key,R(G.value)]}function e(F){if(F>n)throw Error("HTTPStorage scan response exceeded the maximum allowed size.")}async function*FF(F){if(F.body===null)return;let G=F.body.getReader(),J=new TextDecoder,Y="",Z=0,M=!1;try{while(!0){let{done:U,value:B}=await G.read();if(U){M=!0;break}Z+=B.byteLength,e(Z),Y+=J.decode(B,{stream:!0});let C=Y.split(`
-`);Y=C.pop()??"";for(let I of C)yield I}if(Y+=J.decode(),Y.length>0)yield Y}finally{try{if(!M)await G.cancel()}catch{}G.releaseLock()}}class GF{#G;#J;#F;constructor(F){this.#G=F.baseUrl instanceof URL?F.baseUrl:new URL(F.baseUrl),this.#J={...F.headers},this.#F=F.remoteConditionalBatch??!1}capabilities(){return{persistence:"remote",readAfterWrite:"eventual",scanConsistency:"best-effort",atomicBatch:!0,conditionalBatch:this.#F,boundedRangeDelete:!1}}#Q(F){let G=this.#G.href.endsWith("/")?this.#G.href:`${this.#G.href}/`;return new URL(F.replace(/^\/+/,""),G)}#Y(F){return this.#Q(`/v1/storage/${encodeURIComponent(F)}`)}#_(F,G){let J=this.#Q("/v1/storage");return J.searchParams.set("prefix",F),E(J,"limit",G.limit),E(J,"reverse",G.reverse),E(J,"gt",G.gt),E(J,"gte",G.gte),E(J,"lt",G.lt),E(J,"lte",G.lte),J}async#Z(F,G={},J=[]){let Y=new Headers(this.#J);for(let[M,U]of new Headers(G.headers).entries())Y.set(M,U);let Z=await fetch(F,{...G,headers:Y});if(!Z.ok&&!J.includes(Z.status))throw Error(`HTTPStorage request failed: ${G.method??"GET"} ${F.pathname} returned ${String(Z.status)}.`);return Z}async get(F){let G=await this.#Z(this.#Y(F),{method:"GET"},[404]);if(G.status===404)return null;return new Uint8Array(await G.arrayBuffer())}async put(F,G){await this.#Z(this.#Y(F),{method:"PUT",headers:{"content-type":"application/octet-stream"},body:new Blob([G])})}async delete(F){await this.#Z(this.#Y(F),{method:"DELETE"})}async*scan(F,G={}){let J=await this.#Z(this.#_(F,G),{method:"GET",headers:{accept:"application/x-ndjson"}});for await(let Y of FF(J)){let Z=o(Y);if(Z!==null)yield Z}}async batch(F){$("batch operations",F.length),await this.#Z(this.#Q("/v1/storage/-/batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({operations:F.map(y)})})}async conditionalBatch(F,G){$("conditionalBatch conditions",F.length),$("conditionalBatch operations",G.length);let J=await this.#Z(this.#Q("/v1/storage/-/conditional-batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({conditions:F.map(r),operations:G.map(y)})});return t(await J.json())}has(F){return j(this,F)}async*keys(F,G){yield*X(this,F,G)}count(F){return W(this,F)}deletePrefix(F){return H(this,F)}deleteRange(F,G){return L(this,F,V(G))}scoped(F){return g(this,F)}[Symbol.dispose](){}}export{GF as HTTPStorage};
+import { decodeBase64ToBytes, encodeBytesToBase64, isRecord } from "./byte-encoding.js";
+import { normalizeDeleteRangeOptions } from "./delete-range.js";
+import {
+  storageCountCore,
+  storageDeletePrefixCore,
+  storageDeleteRangeCore,
+  storageHasCore,
+  storageKeysCore
+} from "./derived-operations.js";
+import {
+  assertStorageBatchOperationCount
+} from "./interface.js";
+import { scopedStorage } from "./scoped-storage.js";
+const MAX_SCAN_RESPONSE_BYTES = 67108864;
+function encodeOperation(operation) {
+  if (operation.type === "put")
+    return {
+      type: "put",
+      key: operation.key,
+      value: encodeBytesToBase64(operation.value)
+    };
+  return { type: "delete", key: operation.key };
+}
+function encodeCondition(condition) {
+  return {
+    key: condition.key,
+    expectedValue: condition.expectedValue === null ? null : encodeBytesToBase64(condition.expectedValue)
+  };
+}
+function parseScanEntry(value) {
+  if (!isRecord(value) || typeof value.key !== "string" || typeof value.value !== "string")
+    throw Error("HTTPStorage scan response contained an invalid NDJSON entry.");
+  return { key: value.key, value: value.value };
+}
+function parseConditionalBatchResponse(value) {
+  if (!isRecord(value) || typeof value.applied !== "boolean")
+    throw Error('HTTPStorage conditional batch response must include a boolean "applied" field.');
+  return value.applied;
+}
+function appendOptionalSearchParameter(url, name, value) {
+  if (value !== void 0)
+    url.searchParams.set(name, String(value));
+}
+function parseScanLine(line) {
+  if (line.trim().length === 0)
+    return null;
+  const entry = parseScanEntry(JSON.parse(line));
+  return [entry.key, decodeBase64ToBytes(entry.value)];
+}
+function assertScanResponseSize(bytesRead) {
+  if (bytesRead > MAX_SCAN_RESPONSE_BYTES)
+    throw Error("HTTPStorage scan response exceeded the maximum allowed size.");
+}
+async function* readNdjsonLines(response) {
+  if (response.body === null)
+    return;
+  const reader = response.body.getReader(), decoder = new TextDecoder;
+  let bufferedText = "", bytesRead = 0, reachedEndOfStream = !1;
+  try {
+    while (!0) {
+      const { done, value } = await reader.read();
+      if (done) {
+        reachedEndOfStream = !0;
+        break;
+      }
+      bytesRead += value.byteLength;
+      assertScanResponseSize(bytesRead);
+      bufferedText += decoder.decode(value, { stream: !0 });
+      const lines = bufferedText.split(`
+`);
+      bufferedText = lines.pop() ?? "";
+      for (const line of lines)
+        yield line;
+    }
+    bufferedText += decoder.decode();
+    if (bufferedText.length > 0)
+      yield bufferedText;
+  } finally {
+    try {
+      if (!reachedEndOfStream)
+        await reader.cancel();
+    } catch {}
+    reader.releaseLock();
+  }
+}
+
+export class HTTPStorage {
+  #baseUrl;
+  #headers;
+  #remoteConditionalBatch;
+  constructor(options) {
+    this.#baseUrl = options.baseUrl instanceof URL ? options.baseUrl : new URL(options.baseUrl);
+    this.#headers = { ...options.headers };
+    this.#remoteConditionalBatch = options.remoteConditionalBatch ?? !1;
+  }
+  capabilities() {
+    return {
+      persistence: "remote",
+      readAfterWrite: "eventual",
+      scanConsistency: "best-effort",
+      atomicBatch: !0,
+      conditionalBatch: this.#remoteConditionalBatch,
+      boundedRangeDelete: !1
+    };
+  }
+  #url(path) {
+    const base = this.#baseUrl.href.endsWith("/") ? this.#baseUrl.href : `${this.#baseUrl.href}/`;
+    return new URL(path.replace(/^\/+/, ""), base);
+  }
+  #storageKeyUrl(key) {
+    return this.#url(`/v1/storage/${encodeURIComponent(key)}`);
+  }
+  #scanUrl(prefix, options) {
+    const url = this.#url("/v1/storage");
+    url.searchParams.set("prefix", prefix);
+    appendOptionalSearchParameter(url, "limit", options.limit);
+    appendOptionalSearchParameter(url, "reverse", options.reverse);
+    appendOptionalSearchParameter(url, "gt", options.gt);
+    appendOptionalSearchParameter(url, "gte", options.gte);
+    appendOptionalSearchParameter(url, "lt", options.lt);
+    appendOptionalSearchParameter(url, "lte", options.lte);
+    return url;
+  }
+  async#request(url, init = {}, allowedStatuses = []) {
+    const headers = new Headers(this.#headers);
+    for (const [key, value] of new Headers(init.headers).entries())
+      headers.set(key, value);
+    const response = await fetch(url, { ...init, headers });
+    if (!response.ok && !allowedStatuses.includes(response.status))
+      throw Error(`HTTPStorage request failed: ${init.method ?? "GET"} ${url.pathname} returned ${String(response.status)}.`);
+    return response;
+  }
+  async get(key) {
+    const response = await this.#request(this.#storageKeyUrl(key), { method: "GET" }, [404]);
+    if (response.status === 404)
+      return null;
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  async put(key, value) {
+    await this.#request(this.#storageKeyUrl(key), {
+      method: "PUT",
+      headers: { "content-type": "application/octet-stream" },
+      body: new Blob([value])
+    });
+  }
+  async delete(key) {
+    await this.#request(this.#storageKeyUrl(key), { method: "DELETE" });
+  }
+  async* scan(prefix, options = {}) {
+    const response = await this.#request(this.#scanUrl(prefix, options), {
+      method: "GET",
+      headers: { accept: "application/x-ndjson" }
+    });
+    for await (const line of readNdjsonLines(response)) {
+      const entry = parseScanLine(line);
+      if (entry !== null)
+        yield entry;
+    }
+  }
+  async batch(operations) {
+    assertStorageBatchOperationCount("batch operations", operations.length);
+    await this.#request(this.#url("/v1/storage/-/batch"), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ operations: operations.map(encodeOperation) })
+    });
+  }
+  async conditionalBatch(conditions, operations) {
+    assertStorageBatchOperationCount("conditionalBatch conditions", conditions.length);
+    assertStorageBatchOperationCount("conditionalBatch operations", operations.length);
+    const response = await this.#request(this.#url("/v1/storage/-/conditional-batch"), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        conditions: conditions.map(encodeCondition),
+        operations: operations.map(encodeOperation)
+      })
+    });
+    return parseConditionalBatchResponse(await response.json());
+  }
+  has(key) {
+    return storageHasCore(this, key);
+  }
+  async* keys(prefix, options) {
+    yield* storageKeysCore(this, prefix, options);
+  }
+  count(prefix) {
+    return storageCountCore(this, prefix);
+  }
+  deletePrefix(prefix) {
+    return storageDeletePrefixCore(this, prefix);
+  }
+  deleteRange(prefix, options) {
+    return storageDeleteRangeCore(this, prefix, normalizeDeleteRangeOptions(options));
+  }
+  scoped(prefix) {
+    return scopedStorage(this, prefix);
+  }
+  [Symbol.dispose]() {}
+}

package/dist/storage/index.d.ts

@@ -14,6 +14,7 @@
  * import { LMDBStorage }       from '@lostgradient/weft/storage/lmdb';       // peer: lmdb
  * import { TursoStorage }      from '@lostgradient/weft/storage/turso';      // peer: @libsql/client
  * import { NeonStorage }       from '@lostgradient/weft/storage/neon';       // peer: @neondatabase/serverless
+ * import { CloudflareDurableObjectSQLiteStorage } from '@lostgradient/weft/storage/cloudflare'; // caller-injected `sql` binding, zero runtime deps
  * import { IndexedDBStorage }  from '@lostgradient/weft/storage/indexeddb';  // browser-only
  * import { WebExtensionStorage } from '@lostgradient/weft/storage/web-extension'; // extension-only
  * import { HTTPStorage }       from '@lostgradient/weft/storage/http';       // remote storage
@@ -89,6 +90,9 @@ declare const exportedKeys: {
     readonly schedule: (id: string) => string;
     readonly scheduleTick: (fireAt: number, id: string) => string;
     readonly scheduleRun: (workflowId: string) => string;
+    readonly scheduleRunLink: (workflowId: string) => string;
+    readonly scheduleRunBySchedulePrefix: (scheduleId: string) => string;
+    readonly scheduleRunBySchedule: (scheduleId: string, workflowId: string) => string;
     readonly operation: (queue: string, scheduledAt: number, id: string) => string;
     readonly operationInflight: (id: string) => string;
     readonly operationQueued: (id: string) => string;
@@ -142,12 +146,15 @@ declare const exportedKeys: {
     readonly workflowHeaders: (workflowId: string) => string;
     readonly childCancellationPrefix: (workflowId: string) => string;
     readonly childCancellation: (workflowId: string, childWorkflowId: string) => string;
+    readonly childWorkflowByParentPrefix: (parentWorkflowId: string, parentWorkflowExecutionToken?: string) => string;
+    readonly childWorkflowByParent: (parentWorkflowId: string, parentWorkflowExecutionToken: string | undefined, childWorkflowId: string) => string;
     readonly terminalCleanupNeeded: (workflowId: string) => string;
     readonly workflowConcurrency: (workflowType: string, partitionKey: string) => string;
     readonly workflowConcurrencyHolder: (workflowId: string) => string;
     readonly workflowHasServices: (workflowId: string) => string;
     readonly finalizerState: (workflowId: string) => string;
     readonly teardownOwed: (workflowId: string) => string;
+    readonly teardownSucceeded: (workflowId: string) => string;
     readonly teardownDeadLetter: (workflowId: string) => string;
     readonly offload: (workflowId: string, key: string) => string;
     readonly archive: (workflowId: string, key: string) => string;
@@ -348,7 +355,7 @@ declare const exportedTextValueStore: typeof textValueStore;
  * void isWeftKey;
  * ```
  */
-declare const exportedWeftReservedKeyPrefixes: readonly ["actrec:", "archive:", "async-act:", "attr:", "audit:bulk:", "blob:", "budget:", "budget-charged:", "ev:", "fleet-event-by-workflow:", "fleet-event:", "fleet-event-tail", "idx:", "lease:", "liveness:", "offload:", "op:", "review:", "schedule:", "schedule-due:", "schedule-run:", "sig:", "sigres:", "sigseq:", "start-idem:", "state:", "tag:", "tool-effect:", "upd:", "upk:", "upr:", "wf:", "wf-cleanup:", "wf-cleanup-needed:", "wf-concurrency:", "wf-concurrency-holder:", "wf-deadline:", "wf-delayed:", "wf-finalizer-state:", "wf-has-services:", "wf-headers:", "wf-idx-", "wf-teardown:", "wf-teardown-deadletter:", "wf-teardown-needed:", "wf-terminal:"];
+declare const exportedWeftReservedKeyPrefixes: readonly ["actrec:", "archive:", "async-act:", "attr:", "audit:bulk:", "blob:", "budget:", "budget-charged:", "child-by-parent:", "ev:", "fleet-event-by-workflow:", "fleet-event:", "fleet-event-tail", "idx:", "lease:", "liveness:", "offload:", "op:", "review:", "schedule:", "schedule-due:", "schedule-run-by-schedule:", "schedule-run-link:", "schedule-run:", "sig:", "sigres:", "sigseq:", "start-idem:", "state:", "tag:", "tool-effect:", "upd:", "upk:", "upr:", "wf:", "wf-cleanup:", "wf-cleanup-needed:", "wf-concurrency:", "wf-concurrency-holder:", "wf-deadline:", "wf-delayed:", "wf-finalizer-state:", "wf-has-services:", "wf-headers:", "wf-idx-", "wf-teardown:", "wf-teardown-deadletter:", "wf-teardown-needed:", "wf-teardown-succeeded:", "wf-terminal:"];
 /**
  * Re-exported {@link withCodec}. See the original declaration for full docs.
  *

package/dist/storage/indexeddb.js

@@ -1 +1,311 @@
-var s=Object.defineProperty;var n=(U)=>U;function i(U,Y){this[U]=n.bind(null,Y)}var QU=(U,Y)=>{for(var G in Y)s(U,G,{get:Y[G],enumerable:!0,configurable:!0,set:i.bind(Y,G)})};async function E(U,Y){return await U.get(Y)!==null}async function*S(U,Y,G){for await(let[Q]of U.scan(Y,G))yield Q}async function R(U,Y){let G=0;for await(let Q of S(U,Y))G++;return G}async function v(U,Y){let G=[];for await(let Q of S(U,Y))G.push({type:"delete",key:Q});if(G.length===0)return 0;return await U.batch(G),G.length}async function b(U,Y,G){let Q=[];for await(let X of S(U,Y,G))Q.push({type:"delete",key:X});if(Q.length===0)return 0;return await U.batch(Q),Q.length}function A(U,Y,G){if(!U.capabilities()[Y])throw Error(`Feature "${G}" requires storage capability "${Y}", but this storage backend does not provide it.`)}var m="default";var P=1e4,BU=1e4;class y extends Error{code="StorageBatchOperationLimitExceededError";cap=P;count;target;constructor(U,Y){super(`${U} count ${Y} exceeds MAX_BATCH_OPERATIONS (${P}).`);this.name="StorageBatchOperationLimitExceededError",this.target=U,this.count=Y}}function T(U,Y){if(Y>P)throw new y(U,Y)}function K(U){return U.length>0?U.slice(0,-1)+String.fromCharCode(U.charCodeAt(U.length-1)+1):"ÿ"}function C(U,Y={}){if(Y.gt!==void 0&&U<=Y.gt)return!1;if(Y.gte!==void 0&&U<Y.gte)return!1;if(Y.lt!==void 0&&U>=Y.lt)return!1;if(Y.lte!==void 0&&U>Y.lte)return!1;return!0}function I(U,Y){if(U===null||Y===null)return U===Y;if(U.byteLength!==Y.byteLength)return!1;for(let G=0;G<U.byteLength;G++)if(U[G]!==Y[G])return!1;return!0}async function g(U,Y){if(U.has)return U.has(Y);return E(U,Y)}function k(U,Y,G){if(U.keys)return U.keys(Y,G);return S(U,Y,G)}async function c(U,Y){if(U.count)return U.count(Y);return R(U,Y)}async function w(U,Y){if(U.deletePrefix)return U.deletePrefix(Y);return v(U,Y)}async function DU(U,Y){T("batch operations",Y.length),await U.batch(Y)}async function u(U,Y,G){if(T("conditionalBatch conditions",Y.length),T("conditionalBatch operations",G.length),A(U,"conditionalBatch","storageConditionalBatch"),!U.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return U.conditionalBatch(Y,G)}function J(U){return encodeURIComponent(U)}function _U(U){return decodeURIComponent(U)}function zU(U){try{return decodeURIComponent(U)}catch{return null}}var z=(U)=>String(U).padStart(16,"0"),r="0",t="1",x=(U,Y,G,Q)=>`sig:${J(U)}:${J(Y)}:${Q}:${J(G)}`,MU={workflow:(U)=>`wf:${J(U)}`,checkpoint:(U)=>`wf:${J(U)}:ckpt`,checkpointHistory:(U,Y)=>`wf:${J(U)}:ckpt:${String(Y).padStart(10,"0")}`,timelinePrefix:(U)=>`wf:${J(U)}:timeline:`,timeline:(U,Y)=>`wf:${J(U)}:timeline:${String(Y).padStart(10,"0")}`,schedule:(U)=>`schedule:${J(U)}`,scheduleTick:(U,Y)=>`schedule-due:${String(U).padStart(16,"0")}:${J(Y)}`,scheduleRun:(U)=>`schedule-run:${J(U)}`,operation:(U,Y,G)=>`op:${U}:${z(Y)}:${G}`,operationInflight:(U)=>`op:inflight:${U}`,operationQueued:(U)=>`op:queued:${U}`,operationResolved:(U)=>`op:resolved:${U}`,operationDeadLetterPrefix:()=>"op:dead-letter:",operationDeadLetter:(U)=>`op:dead-letter:${U}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(U,Y,G)=>`audit:bulk:${z(U)}:${J(Y)}:${J(G)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(U,Y)=>`op:resolved-by-time:${z(U)}:${J(Y)}`,asyncActivity:(U,Y)=>`async-act:v1:${J(U)}:${J(Y)}`,asyncActivityResolution:(U,Y)=>`async-act:v1:${J(U)}:${J(Y)}:resolution`,activityReconciliationPrefix:(U)=>`actrec:v1:${J(U)}:`,activityReconciliation:(U,Y,G)=>`actrec:v1:${J(U)}:${J(Y)}:${G}`,eventPrefix:(U)=>`ev:${J(U)}:`,event:(U,Y)=>`ev:${J(U)}:${String(Y).padStart(10,"0")}`,eventHead:(U)=>`ev:${J(U)}:head`,eventWatermark:(U)=>`ev:${J(U)}:watermark`,fleetEventPrefix:()=>"fleet-event:",fleetEvent:(U)=>`fleet-event:${String(U).padStart(10,"0")}`,fleetEventTail:()=>"fleet-event-tail",fleetEventByWorkflowPrefix:(U)=>`fleet-event-by-workflow:${J(U)}:`,fleetEventByWorkflow:(U,Y)=>`fleet-event-by-workflow:${J(U)}:${String(Y).padStart(10,"0")}`,signal:(U,Y,G)=>x(U,Y,G,t),startSignal:(U,Y,G)=>x(U,Y,G,r),signalSequence:(U)=>`sigseq:v1:${J(U)}`,signalAcceptedResponsePrefix:(U)=>`sigres:v1:${J(U)}:`,signalAcceptedResponse:(U,Y,G)=>`sigres:v1:${J(U)}:${J(Y)}:${J(G)}`,deadline:(U,Y)=>`wf-deadline:${z(U)}:${J(Y)}`,terminalCleanup:(U,Y)=>`wf-cleanup:${z(U)}:${J(Y)}`,teardownTimer:(U,Y)=>`wf-teardown:${z(U)}:${J(Y)}`,delayedStart:(U,Y)=>`wf-delayed:${z(U)}:${J(Y)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(U,Y)=>`wf-terminal:${z(U)}:${J(Y)}`,attribute:(U)=>`attr:${J(U)}`,attributeIndex:(U,Y,G)=>`idx:${U}:${Y}:${J(G)}`,tagIndex:(U,Y)=>`tag:${J(U)}:${J(Y)}`,updatePrefix:(U)=>`upd:${J(U)}:`,update:(U,Y)=>`upd:${J(U)}:${Y}`,updateResponse:(U)=>`upr:${U}`,updateIdempotency:(U,Y)=>`upk:${J(U)}:${Y}`,startIdempotency:(U)=>`start-idem:${J(U)}`,startIdempotencySignalId:(U)=>`start-idem:${U}`,livenessPrefix:()=>"liveness:",liveness:(U)=>`liveness:${J(U)}`,leasePrefix:()=>"lease:",leaseEpoch:()=>"lease:epoch",leaseHolder:()=>"lease:holder",budget:(U,Y,G)=>`budget:${U}:${Y}:${G}`,review:(U,Y)=>`review:${J(U)}:${Y}`,workflowHeaders:(U)=>`wf-headers:${J(U)}`,childCancellationPrefix:(U)=>`child-cancel:${J(U)}:`,childCancellation:(U,Y)=>`child-cancel:${J(U)}:${J(Y)}`,terminalCleanupNeeded:(U)=>`wf-cleanup-needed:${J(U)}`,workflowConcurrency:(U,Y)=>`wf-concurrency:${J(U)}:${J(Y)}`,workflowConcurrencyHolder:(U)=>`wf-concurrency-holder:${J(U)}`,workflowHasServices:(U)=>`wf-has-services:${J(U)}`,finalizerState:(U)=>`wf-finalizer-state:${J(U)}`,teardownOwed:(U)=>`wf-teardown-needed:${J(U)}`,teardownDeadLetter:(U)=>`wf-teardown-deadletter:${J(U)}`,offload:(U,Y)=>`offload:${J(U)}:${Y}`,archive:(U,Y)=>`archive:${J(U)}:${Y}`,stateExecution:(U,Y)=>`state:execution:${J(U)}:${J(Y)}`,stateWorkflow:(U,Y)=>`state:workflow-scope:${m}:${J(U)}:${J(Y)}`,streamChunkPrefix:(U,Y)=>`blob:${J(U)}:${Y}:chunk:`,streamChunk:(U,Y,G)=>`blob:${J(U)}:${Y}:chunk:${String(G).padStart(10,"0")}`,streamTail:(U,Y)=>`blob:${J(U)}:${Y}:tail`,streamMetadata:(U,Y)=>`blob:${J(U)}:${Y}:meta`,budgetCharged:(U)=>`budget-charged:${U}`,toolEffect:(U,Y,G)=>`tool-effect:${J(U)}:${Y}:${G}`,workflowVisibilityStatus:(U,Y)=>`wf-idx-status:${J(U)}:${J(Y)}`,workflowVisibilityType:(U,Y)=>`wf-idx-type:${J(U)}:${J(Y)}`,workflowVisibilityCreated:(U,Y)=>`wf-idx-created:${z(U)}:${J(Y)}`,workflowVisibilityUpdated:(U,Y)=>`wf-idx-updated:${z(U)}:${J(Y)}`,workflowVisibilityDeadline:(U,Y)=>`wf-idx-deadline:${z(U)}:${J(Y)}`,workflowVisibilityManifest:(U)=>`wf-idx-manifest:${J(U)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"};function o(U){if(U===void 0)return;if(typeof U!=="number"||!Number.isInteger(U)||U<0)throw Error("deleteRange limit must be a finite non-negative integer");return U===0?0:U}function h(U){let Y={},G=!1;for(let X of["gt","gte","lt","lte"]){let $=U[X];if($===void 0)continue;if(typeof $!=="string")throw Error("deleteRange bounds must be strings");Y[X]=$,G=!0}if(!G)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Q=o(U.limit);if(Q!==void 0)Y.limit=Q;return Y}async function f(U,Y,G){let Q=h(G);if(U.deleteRange)return U.deleteRange(Y,Q);return b(U,Y,Q)}function e(U,Y){let G={key:U,open:!1};if(Y.gte!==void 0&&Y.gte>G.key)G.key=Y.gte,G.open=!1;if(Y.gt!==void 0&&Y.gt>=G.key)G.key=Y.gt,G.open=!0;return G}function UU(U,Y){let G={key:K(U),open:!0};if(Y.lt!==void 0&&Y.lt<=G.key)G.key=Y.lt,G.open=!0;if(Y.lte!==void 0&&Y.lte<G.key)G.key=Y.lte,G.open=!1;return G}function l(U,Y){let G=e(U,Y),Q=UU(U,Y);if(G.key>Q.key||G.key===Q.key&&(G.open||Q.open))return null;return{lower:G,upper:Q}}function q(U){return U.replaceAll(/:+$/g,"")}function YU(U,Y){let G=q(U),Q=q(Y);if(G.length===0)return Q;if(Q.length===0)return G;return`${G}:${Q}`}class O{#Y;#G;constructor(U,Y){this.#Y=U,this.#G=q(Y)}#U(U){if(this.#G.length===0)return U;return U.length===0?`${this.#G}:`:`${this.#G}:${U}`}#J(U){if(this.#G.length===0)return U;return U.slice(this.#G.length+1)}#Q(U={}){let Y={};if(U.limit!==void 0)Y.limit=U.limit;if(U.reverse!==void 0)Y.reverse=U.reverse;if(U.gt!==void 0)Y.gt=this.#U(U.gt);if(U.gte!==void 0)Y.gte=this.#U(U.gte);if(U.lt!==void 0)Y.lt=this.#U(U.lt);if(U.lte!==void 0)Y.lte=this.#U(U.lte);return Y}#X(U){let Y={};if(U.limit!==void 0)Y.limit=U.limit;if(U.gt!==void 0)Y.gt=this.#U(U.gt);if(U.gte!==void 0)Y.gte=this.#U(U.gte);if(U.lt!==void 0)Y.lt=this.#U(U.lt);if(U.lte!==void 0)Y.lte=this.#U(U.lte);return Y}capabilities(){return this.#Y.capabilities()}scoped(U){return new O(this.#Y,YU(this.#G,U))}async get(U){return this.#Y.get(this.#U(U))}async put(U,Y){await this.#Y.put(this.#U(U),Y)}async delete(U){await this.#Y.delete(this.#U(U))}async*scan(U,Y){for await(let[G,Q]of this.#Y.scan(this.#U(U),this.#Q(Y)))yield[this.#J(G),Q]}async batch(U){T("batch operations",U.length),await this.#Y.batch(U.map((Y)=>{if(Y.type==="put")return{type:"put",key:this.#U(Y.key),value:Y.value};return{type:"delete",key:this.#U(Y.key)}}))}async conditionalBatch(U,Y){return u(this.#Y,U.map((G)=>({key:this.#U(G.key),expectedValue:G.expectedValue})),Y.map((G)=>{if(G.type==="put")return{type:"put",key:this.#U(G.key),value:G.value};return{type:"delete",key:this.#U(G.key)}}))}async has(U){return g(this.#Y,this.#U(U))}async deletePrefix(U){return w(this.#Y,this.#U(U))}async deleteRange(U,Y){let G=this.#X(h(Y));return f(this.#Y,this.#U(U),G)}async*keys(U,Y){for await(let G of k(this.#Y,this.#U(U),this.#Q(Y)))yield this.#J(G)}async count(U){return c(this.#Y,this.#U(U))}[Symbol.dispose](){this.#Y[Symbol.dispose]()}}function d(U,Y){return new O(U,Y)}var F="kv";function GU(U=globalThis){let{indexedDB:Y,IDBKeyRange:G}=U;if(Y===void 0||G===void 0)throw Error("IndexedDBStorage requires both indexedDB and IDBKeyRange runtime globals.");return{indexedDB:Y,IDBKeyRange:G}}function N(U){return new Promise((Y,G)=>{U.onsuccess=()=>Y(U.result),U.onerror=()=>G(U.error)})}function p(U,Y){let G=null,Q=null,X=null,$=(Z,L)=>{let H=Z??Error(L);if(Q){let B=Q;G=null,Q=null,B(H);return}X=H};return U.onsuccess=()=>{if(!G)return;let Z=G;G=null,Q=null,Z(U.result)},U.onerror=()=>{$(U.error,"IndexedDB cursor request failed.")},Y.onerror=()=>{$(Y.error,"IndexedDB transaction failed.")},Y.onabort=()=>{$(Y.error,"IndexedDB transaction aborted.")},()=>{return new Promise((Z,L)=>{if(X){let H=X;X=null,L(H);return}if(G=Z,Q=L,U.readyState==="done"){let H=G;G=null,Q=null,H?.(U.result)}})}}class JU{#Y;#G=null;#U;#J;constructor(U="weft",Y=GU()){this.#Y=U,this.#J=Y,this.#U=this.#Q()}capabilities(){return{persistence:"local",readAfterWrite:"linearizable",scanConsistency:"best-effort",atomicBatch:!0,conditionalBatch:!0,boundedRangeDelete:!0}}#Q(){let U=this.#J.indexedDB.open(this.#Y,1);return U.onupgradeneeded=()=>{let Y=U.result;if(!Y.objectStoreNames.contains(F))Y.createObjectStore(F)},N(U).then((Y)=>{return this.#G=Y,Y})}async get(U){let Q=(await this.#U).transaction(F,"readonly").objectStore(F),X=await N(Q.get(U));return X===void 0?null:new Uint8Array(X)}async put(U,Y){let X=(await this.#U).transaction(F,"readwrite").objectStore(F);await N(X.put(Y,U))}async delete(U){let Q=(await this.#U).transaction(F,"readwrite").objectStore(F);await N(Q.delete(U))}async has(U){let Q=(await this.#U).transaction(F,"readonly").objectStore(F);return await N(Q.count(U))>0}async deletePrefix(U){let Y=await this.#U,G=K(U),Q=this.#J.IDBKeyRange.bound(U,G,!1,!0);return new Promise((X,$)=>{let Z=Y.transaction(F,"readwrite"),L=Z.objectStore(F),H=0,B=L.count(Q);B.onsuccess=()=>{H=B.result,L.delete(Q)},Z.oncomplete=()=>X(H),Z.onerror=()=>$(Z.error)})}async deleteRange(U,Y){let G=h(Y),Q=l(U,G);if(Q===null)return 0;let X=this.#J.IDBKeyRange.bound(Q.lower.key,Q.upper.key,Q.lower.open,Q.upper.open),$=await this.#U,{limit:Z}=G;return new Promise((L,H)=>{let B=$.transaction(F,"readwrite"),M=B.objectStore(F),D=0;if(Z===void 0){let W=M.count(X);W.onsuccess=()=>{D=W.result,M.delete(X)}}else{let W=M.openCursor(X,"next");W.onsuccess=()=>{let _=W.result;if(_===null||D>=Z)return;if(_.delete(),D++,D<Z)_.continue()}}B.oncomplete=()=>L(D),B.onerror=()=>H(B.error)})}async*scan(U,Y={}){let{limit:G,reverse:Q}=Y,X=await this.#U,$=K(U),Z=this.#J.IDBKeyRange.bound(U,$,!1,!0),L=Q?"prev":"next",H=X.transaction(F,"readonly"),M=H.objectStore(F).openCursor(Z,L),D=0,W=p(M,H),_=!1;try{let V=await W();while(V){if(G!==void 0&&D>=G)break;let j=V.key;if(C(j,Y))yield[j,new Uint8Array(V.value)],D++;V.continue(),V=await W()}_=!0}finally{if(!_)try{H.abort()}catch{}}}async batch(U){if(T("batch operations",U.length),U.length===0)return;let Y=await this.#U;return new Promise((G,Q)=>{let X=Y.transaction(F,"readwrite"),$=X.objectStore(F);for(let Z of U)if(Z.type==="put")$.put(Z.value,Z.key);else $.delete(Z.key);X.oncomplete=()=>G(),X.onerror=()=>Q(X.error)})}async conditionalBatch(U,Y){T("conditionalBatch conditions",U.length),T("conditionalBatch operations",Y.length);let G=await this.#U;return new Promise((Q,X)=>{let $=G.transaction(F,"readwrite"),Z=$.objectStore(F),L=!1,H=!1,B=(W,_)=>{if(L)return;L=!0,X(W??Error(_))};$.oncomplete=()=>{if(L)return;L=!0,Q(!0)},$.onerror=()=>{B($.error,"IndexedDB conditionalBatch transaction failed.")},$.onabort=()=>{if(L)return;if(L=!0,H){Q(!1);return}X($.error??Error("IndexedDB conditionalBatch transaction aborted."))};let M=()=>{for(let W of Y)if(W.type==="put")Z.put(W.value,W.key);else Z.delete(W.key)},D=(W)=>{if(W>=U.length){M();return}let _=U[W],V=Z.get(_.key);V.onsuccess=()=>{let j=V.result,a=j===void 0?null:new Uint8Array(j);if(!I(a,_.expectedValue)){H=!0,$.abort();return}D(W+1)},V.onerror=()=>{B(V.error,"IndexedDB conditionalBatch condition check failed.")}};D(0)})}async*keys(U,Y={}){let{limit:G,reverse:Q}=Y,X=await this.#U,$=K(U),Z=this.#J.IDBKeyRange.bound(U,$,!1,!0),L=Q?"prev":"next",H=X.transaction(F,"readonly"),M=H.objectStore(F).openKeyCursor(Z,L),D=0,W=p(M,H),_=!1;try{let V=await W();while(V){if(G!==void 0&&D>=G)break;let j=V.key;if(C(j,Y))yield j,D++;V.continue(),V=await W()}_=!0}finally{if(!_)try{H.abort()}catch{}}}async count(U){let Y=await this.#U,G=K(U),X=Y.transaction(F,"readonly").objectStore(F);return N(X.count(this.#J.IDBKeyRange.bound(U,G,!1,!0)))}scoped(U){return d(this,U)}[Symbol.dispose](){if(this.#G)this.#G.close(),this.#G=null}}export{JU as IndexedDBStorage};
+import {
+  normalizeDeleteRangeOptions,
+  resolveDeleteRangeBounds
+} from "./delete-range.js";
+import {
+  assertStorageBatchOperationCount,
+  matchesScanOptions,
+  resolvePrefixRangeEnd,
+  storageValuesEqual
+} from "./interface.js";
+import { scopedStorage } from "./scoped-storage.js";
+const STORE_NAME = "kv";
+function resolveIndexedDbRuntime(runtime = globalThis) {
+  const { indexedDB: indexedDbFactory, IDBKeyRange: keyRangeFactory } = runtime;
+  if (indexedDbFactory === void 0 || keyRangeFactory === void 0)
+    throw Error("IndexedDBStorage requires both indexedDB and IDBKeyRange runtime globals.");
+  return {
+    indexedDB: indexedDbFactory,
+    IDBKeyRange: keyRangeFactory
+  };
+}
+function promisify(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function createCursorRequestAwaiter(request, transaction) {
+  let resolveCurrent = null, rejectCurrent = null, pendingError = null;
+  const rejectPendingCursor = (error, fallbackMessage) => {
+    const reason = error ?? Error(fallbackMessage);
+    if (rejectCurrent) {
+      const reject = rejectCurrent;
+      resolveCurrent = null;
+      rejectCurrent = null;
+      reject(reason);
+      return;
+    }
+    pendingError = reason;
+  };
+  request.onsuccess = () => {
+    if (!resolveCurrent)
+      return;
+    const resolve = resolveCurrent;
+    resolveCurrent = null;
+    rejectCurrent = null;
+    resolve(request.result);
+  };
+  request.onerror = () => {
+    rejectPendingCursor(request.error, "IndexedDB cursor request failed.");
+  };
+  transaction.onerror = () => {
+    rejectPendingCursor(transaction.error, "IndexedDB transaction failed.");
+  };
+  transaction.onabort = () => {
+    rejectPendingCursor(transaction.error, "IndexedDB transaction aborted.");
+  };
+  return () => {
+    return new Promise((resolve, reject) => {
+      if (pendingError) {
+        const error = pendingError;
+        pendingError = null;
+        reject(error);
+        return;
+      }
+      resolveCurrent = resolve;
+      rejectCurrent = reject;
+      if (request.readyState === "done") {
+        const resolveReady = resolveCurrent;
+        resolveCurrent = null;
+        rejectCurrent = null;
+        resolveReady?.(request.result);
+      }
+    });
+  };
+}
+
+export class IndexedDBStorage {
+  #databaseName;
+  #database = null;
+  #databasePromise;
+  #runtime;
+  constructor(databaseName = "weft", runtime = resolveIndexedDbRuntime()) {
+    this.#databaseName = databaseName;
+    this.#runtime = runtime;
+    this.#databasePromise = this.#open();
+  }
+  capabilities() {
+    return {
+      persistence: "local",
+      readAfterWrite: "linearizable",
+      scanConsistency: "best-effort",
+      atomicBatch: !0,
+      conditionalBatch: !0,
+      boundedRangeDelete: !0
+    };
+  }
+  #open() {
+    const request = this.#runtime.indexedDB.open(this.#databaseName, 1);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains(STORE_NAME))
+        database.createObjectStore(STORE_NAME);
+    };
+    return promisify(request).then((database) => {
+      this.#database = database;
+      return database;
+    });
+  }
+  async get(key) {
+    const store = (await this.#databasePromise).transaction(STORE_NAME, "readonly").objectStore(STORE_NAME), result = await promisify(store.get(key));
+    return result === void 0 ? null : new Uint8Array(result);
+  }
+  async put(key, value) {
+    const store = (await this.#databasePromise).transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME);
+    await promisify(store.put(value, key));
+  }
+  async delete(key) {
+    const store = (await this.#databasePromise).transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME);
+    await promisify(store.delete(key));
+  }
+  async has(key) {
+    const store = (await this.#databasePromise).transaction(STORE_NAME, "readonly").objectStore(STORE_NAME);
+    return await promisify(store.count(key)) > 0;
+  }
+  async deletePrefix(prefix) {
+    const database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), range = this.#runtime.IDBKeyRange.bound(prefix, prefixEnd, !1, !0);
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite"), store = transaction.objectStore(STORE_NAME);
+      let deletedCount = 0;
+      const countRequest = store.count(range);
+      countRequest.onsuccess = () => {
+        deletedCount = countRequest.result;
+        store.delete(range);
+      };
+      transaction.oncomplete = () => resolve(deletedCount);
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+  async deleteRange(prefix, options) {
+    const normalized = normalizeDeleteRangeOptions(options), bounds = resolveDeleteRangeBounds(prefix, normalized);
+    if (bounds === null)
+      return 0;
+    const range = this.#runtime.IDBKeyRange.bound(bounds.lower.key, bounds.upper.key, bounds.lower.open, bounds.upper.open), database = await this.#databasePromise, { limit } = normalized;
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite"), store = transaction.objectStore(STORE_NAME);
+      let deletedCount = 0;
+      if (limit === void 0) {
+        const countRequest = store.count(range);
+        countRequest.onsuccess = () => {
+          deletedCount = countRequest.result;
+          store.delete(range);
+        };
+      } else {
+        const cursorRequest = store.openCursor(range, "next");
+        cursorRequest.onsuccess = () => {
+          const cursor = cursorRequest.result;
+          if (cursor === null || deletedCount >= limit)
+            return;
+          cursor.delete();
+          deletedCount++;
+          if (deletedCount < limit)
+            cursor.continue();
+        };
+      }
+      transaction.oncomplete = () => resolve(deletedCount);
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+  async* scan(prefix, options = {}) {
+    const { limit, reverse } = options, database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), range = this.#runtime.IDBKeyRange.bound(prefix, prefixEnd, !1, !0), direction = reverse ? "prev" : "next", transaction = database.transaction(STORE_NAME, "readonly"), request = transaction.objectStore(STORE_NAME).openCursor(range, direction);
+    let count = 0;
+    const nextCursor = createCursorRequestAwaiter(request, transaction);
+    let completed = !1;
+    try {
+      let cursor = await nextCursor();
+      while (cursor) {
+        if (limit !== void 0 && count >= limit)
+          break;
+        const key = cursor.key;
+        if (matchesScanOptions(key, options)) {
+          yield [key, new Uint8Array(cursor.value)];
+          count++;
+        }
+        cursor.continue();
+        cursor = await nextCursor();
+      }
+      completed = !0;
+    } finally {
+      if (!completed)
+        try {
+          transaction.abort();
+        } catch {}
+    }
+  }
+  async batch(operations) {
+    assertStorageBatchOperationCount("batch operations", operations.length);
+    if (operations.length === 0)
+      return;
+    const database = await this.#databasePromise;
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite"), store = transaction.objectStore(STORE_NAME);
+      for (const operation of operations)
+        if (operation.type === "put")
+          store.put(operation.value, operation.key);
+        else
+          store.delete(operation.key);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+  async conditionalBatch(conditions, operations) {
+    assertStorageBatchOperationCount("conditionalBatch conditions", conditions.length);
+    assertStorageBatchOperationCount("conditionalBatch operations", operations.length);
+    const database = await this.#databasePromise;
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite"), store = transaction.objectStore(STORE_NAME);
+      let settled = !1, abortedByCondition = !1;
+      const settleReject = (error, message) => {
+        if (settled)
+          return;
+        settled = !0;
+        reject(error ?? Error(message));
+      };
+      transaction.oncomplete = () => {
+        if (settled)
+          return;
+        settled = !0;
+        resolve(!0);
+      };
+      transaction.onerror = () => {
+        settleReject(transaction.error, "IndexedDB conditionalBatch transaction failed.");
+      };
+      transaction.onabort = () => {
+        if (settled)
+          return;
+        settled = !0;
+        if (abortedByCondition) {
+          resolve(!1);
+          return;
+        }
+        reject(transaction.error ?? Error("IndexedDB conditionalBatch transaction aborted."));
+      };
+      const applyOperations = () => {
+        for (const operation of operations)
+          if (operation.type === "put")
+            store.put(operation.value, operation.key);
+          else
+            store.delete(operation.key);
+      }, verifyCondition = (index) => {
+        if (index >= conditions.length) {
+          applyOperations();
+          return;
+        }
+        const condition = conditions[index], request = store.get(condition.key);
+        request.onsuccess = () => {
+          const raw = request.result, currentValue = raw === void 0 ? null : new Uint8Array(raw);
+          if (!storageValuesEqual(currentValue, condition.expectedValue)) {
+            abortedByCondition = !0;
+            transaction.abort();
+            return;
+          }
+          verifyCondition(index + 1);
+        };
+        request.onerror = () => {
+          settleReject(request.error, "IndexedDB conditionalBatch condition check failed.");
+        };
+      };
+      verifyCondition(0);
+    });
+  }
+  async* keys(prefix, options = {}) {
+    const { limit, reverse } = options, database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), range = this.#runtime.IDBKeyRange.bound(prefix, prefixEnd, !1, !0), direction = reverse ? "prev" : "next", transaction = database.transaction(STORE_NAME, "readonly"), request = transaction.objectStore(STORE_NAME).openKeyCursor(range, direction);
+    let count = 0;
+    const nextCursor = createCursorRequestAwaiter(request, transaction);
+    let completed = !1;
+    try {
+      let cursor = await nextCursor();
+      while (cursor) {
+        if (limit !== void 0 && count >= limit)
+          break;
+        const key = cursor.key;
+        if (matchesScanOptions(key, options)) {
+          yield key;
+          count++;
+        }
+        cursor.continue();
+        cursor = await nextCursor();
+      }
+      completed = !0;
+    } finally {
+      if (!completed)
+        try {
+          transaction.abort();
+        } catch {}
+    }
+  }
+  async count(prefix) {
+    const database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), store = database.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME);
+    return promisify(store.count(this.#runtime.IDBKeyRange.bound(prefix, prefixEnd, !1, !0)));
+  }
+  scoped(prefix) {
+    return scopedStorage(this, prefix);
+  }
+  [Symbol.dispose]() {
+    if (this.#database) {
+      this.#database.close();
+      this.#database = null;
+    }
+  }
+}

package/dist/storage/interface.d.ts

@@ -365,6 +365,14 @@ export declare const KEYS: {
     readonly schedule: (id: string) => string;
     readonly scheduleTick: (fireAt: number, id: string) => string;
     readonly scheduleRun: (workflowId: string) => string;
+    /**
+     * Durable per-workflow manifest for the schedule that launched a run. Unlike
+     * `scheduleRun`, this link survives terminal cleanup so schedule history can
+     * be queried until the workflow itself is purged.
+     */
+    readonly scheduleRunLink: (workflowId: string) => string;
+    readonly scheduleRunBySchedulePrefix: (scheduleId: string) => string;
+    readonly scheduleRunBySchedule: (scheduleId: string, workflowId: string) => string;
     readonly operation: (queue: string, scheduledAt: number, id: string) => string;
     readonly operationInflight: (id: string) => string;
     readonly operationQueued: (id: string) => string;
@@ -471,6 +479,8 @@ export declare const KEYS: {
     readonly workflowHeaders: (workflowId: string) => string;
     readonly childCancellationPrefix: (workflowId: string) => string;
     readonly childCancellation: (workflowId: string, childWorkflowId: string) => string;
+    readonly childWorkflowByParentPrefix: (parentWorkflowId: string, parentWorkflowExecutionToken?: string) => string;
+    readonly childWorkflowByParent: (parentWorkflowId: string, parentWorkflowExecutionToken: string | undefined, childWorkflowId: string) => string;
     readonly terminalCleanupNeeded: (workflowId: string) => string;
     readonly workflowConcurrency: (workflowType: string, partitionKey: string) => string;
     readonly workflowConcurrencyHolder: (workflowId: string) => string;
@@ -512,14 +522,16 @@ export declare const KEYS: {
      * success or when it dead-letters, which is what unblocks purge.
      */
     readonly teardownOwed: (workflowId: string) => string;
+    /** Durable successful finalizer outcome, retained until workflow purge or retention. */
+    readonly teardownSucceeded: (workflowId: string) => string;
     /**
      * Durable audit record written when a workflow's finalizer permanently fails — the
      * retry horizon is reached, or the recorded resource state vanished so the finalizer
      * can never run (issue #446 Phase 2). Holds the `TeardownDeadLetterRecord` shape
-     * `{ type, lastError, attempts, deadLetteredAt, finalizerInput? }`. **Excluded from
-     * the workflow purge delete-set** so it survives as the operator's evidence of a
-     * leaked external resource — in-process `WorkflowTeardownEvent`s are not durable, so
-     * raw inspection of this key is the supported operator surface after purge.
+     * `{ type, lastError, attempts, deadLetteredAt, workflowExecutionToken?, finalizerInput? }`.
+     * **Excluded from the workflow purge delete-set** so it survives as the operator's
+     * evidence of a leaked external resource and remains queryable through the durable
+     * finalizer-status API after purge.
      */
     readonly teardownDeadLetter: (workflowId: string) => string;
     readonly offload: (workflowId: string, key: string) => string;