@sanity/workflow-engine 0.19.0 → 0.20.0

package/dist/index.cjs

@@ -4016,12 +4016,27 @@ function assertInputValueShape(entry, value) {
 function assertGdrShape(value, context) {
     if (typeof value != "object" || value === null) throw new invariants.ContractViolationError(`Invalid GDR for ${context}: expected { id: "<scheme>:...", type: "<schema>" }, got ${typeof value}.`);
     const v2 = value;
-    if (typeof v2.id != "string" || !invariants.isGdrUri(v2.id)) throw new invariants.ContractViolationError(`Invalid GDR for ${context}: \`id\` must be a GDR URI ("<scheme>:<...id-parts>" with scheme dataset|canvas|media-library|dashboard). Got ${JSON.stringify(v2.id)}. Construct via \`gdrFromResource\` / \`refDataset\` / \`refCanvas\` etc. — bare document ids are not accepted.`);
+    if (typeof v2.id != "string") throw invalidGdrUriError(context, v2.id);
+    try {
+        invariants.parseGdr(v2.id);
+    } catch (error) {
+        throw error instanceof invariants.VersionSpecificDatasetGdrError ? new invariants.ContractViolationError(`Invalid GDR for ${context}: ${error.message}`) : invalidGdrUriError(context, v2.id);
+    }
     if (typeof v2.type != "string" || v2.type.length === 0) throw new invariants.ContractViolationError(`Invalid GDR for ${context}: \`type\` (schema name) must be a non-empty string. Got ${JSON.stringify(v2.type)}.`);
 }
 
+function invalidGdrUriError(context, id) {
+    return new invariants.ContractViolationError(`Invalid GDR for ${context}: \`id\` must be a GDR URI ("<scheme>:<...id-parts>" with scheme dataset|canvas|media-library|dashboard). Got ${JSON.stringify(id)}. Construct via \`gdrFromResource\` / \`refDataset\` / \`refCanvas\` etc. — bare document ids are not accepted.`);
+}
+
 function normalizeQueryResult({entryType: entryType, raw: raw, workflowResource: workflowResource}) {
-    return raw == null ? raw : invariants.isSingleDocRefKind(entryType) ? coerceToGdr(raw, workflowResource) : entryType === "doc.refs" ? Array.isArray(raw) ? raw.map(item => coerceToGdr(item, workflowResource)).filter(v2 => v2 !== null) : [] : raw;
+    if (raw == null) return raw;
+    try {
+        return invariants.isSingleDocRefKind(entryType) ? coerceToGdr(raw, workflowResource) : entryType === "doc.refs" ? Array.isArray(raw) ? raw.map(item => coerceToGdr(item, workflowResource)).filter(v2 => v2 !== null) : [] : raw;
+    } catch (error) {
+        if (error instanceof invariants.VersionSpecificDatasetGdrError) return raw;
+        throw error;
+    }
 }
 
 function coerceGdrShape(raw, workflowResource) {
@@ -4477,65 +4492,119 @@ function buildInstanceBase(args) {
 }
 
 async function hydrateSnapshot(args) {
-    const {client: client, clientForGdr: clientForGdr, instance: instance, overlay: overlay} = args, loaded = [], visited = /* @__PURE__ */ new Set, loadInto = async (uri, perspective) => {
-        if (visited.has(uri)) return;
-        const held = overlay?.get(uri);
-        if (held !== void 0) {
-            loaded.push(held), visited.add(uri);
-            return;
-        }
-        const fetched = await loadByGdr({
-            defaultClient: client,
-            clientForGdr: clientForGdr,
-            defaultResource: instance.workflowResource,
-            uri: uri,
-            perspective: perspective
-        });
-        fetched && (loaded.push(fetched), visited.add(uri));
-    };
+    const {client: client, clientForGdr: clientForGdr, instance: instance, overlay: overlay} = args, loaded = [], visited = /* @__PURE__ */ new Set;
     loaded.push({
         doc: instance,
         resource: instance.workflowResource
     }), visited.add(invariants.selfGdr(instance));
-    for (const ref of collectWatchRefs(instance)) await loadInto(ref.id, readsRaw(ref) ? "raw" : instance.perspective ?? DEFAULT_CONTENT_PERSPECTIVE);
+    const {pending: pending, ordered: ordered} = planReads({
+        client: client,
+        clientForGdr: clientForGdr,
+        instance: instance,
+        overlay: overlay,
+        visited: visited
+    }), fetched = await readPending(pending);
+    for (const entry of ordered) if (!isPendingRead(entry)) loaded.push(entry); else {
+        const doc = fetched.get(entry);
+        doc !== void 0 && loaded.push({
+            doc: doc,
+            resource: entry.resource
+        });
+    }
     return buildSnapshot({
         docs: loaded
     });
 }
 
-async function loadByGdr({defaultClient: defaultClient, clientForGdr: clientForGdr, defaultResource: defaultResource, uri: uri, perspective: perspective}) {
-    const parsed = invariants.tryParseGdr(uri);
-    if (parsed === void 0) {
-        const doc2 = await readDoc({
-            client: defaultClient,
-            id: uri,
-            perspective: perspective
-        });
-        return doc2 ? {
-            doc: doc2,
-            resource: defaultResource
-        } : null;
+function planReads(args) {
+    const {client: client, clientForGdr: clientForGdr, instance: instance, overlay: overlay, visited: visited} = args, pending = [], ordered = [];
+    for (const ref of collectWatchRefs(instance)) {
+        if (visited.has(ref.id)) continue;
+        visited.add(ref.id);
+        const held = overlay?.get(ref.id);
+        if (held !== void 0) ordered.push(held); else {
+            const read = routeRead({
+                defaultClient: client,
+                clientForGdr: clientForGdr,
+                defaultResource: instance.workflowResource,
+                uri: ref.id,
+                perspective: readsRaw(ref) ? "raw" : instance.perspective ?? DEFAULT_CONTENT_PERSPECTIVE
+            });
+            pending.push(read), ordered.push(read);
+        }
     }
-    const routed = clientForGdr(parsed), doc = await readDoc({
-        client: routed,
+    return {
+        pending: pending,
+        ordered: ordered
+    };
+}
+
+function isPendingRead(entry) {
+    return "client" in entry;
+}
+
+const SNAPSHOT_READ_BATCH_SIZE = 100, SNAPSHOT_READ_CONCURRENCY = 4, snapshotDocsQuery = "*[_id in $ids]";
+
+function routeRead({defaultClient: defaultClient, clientForGdr: clientForGdr, defaultResource: defaultResource, uri: uri, perspective: perspective}) {
+    const parsed = invariants.tryParseGdr(uri);
+    return parsed === void 0 ? {
+        client: defaultClient,
+        id: uri,
+        perspective: perspective,
+        resource: defaultResource
+    } : {
+        client: clientForGdr(parsed),
         id: parsed.documentId,
-        perspective: perspective
-    });
-    return doc ? {
-        doc: doc,
+        perspective: perspective,
         resource: invariants.resourceFromParsed(parsed)
-    } : null;
+    };
 }
 
-async function readDoc({client: client, id: id, perspective: perspective}) {
-    if (perspective === "raw") {
-        const doc2 = await client.getDocument(id) ?? null;
-        return doc2 ? doc2._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc2) : invariants.assertReadableModel(doc2) : null;
+async function readPending(reads) {
+    const batches = groupReads(reads).flatMap(group => chunks(group.reads, SNAPSHOT_READ_BATCH_SIZE).map(batch => ({
+        group: group,
+        batch: batch
+    }))), results = [];
+    for (const wave of chunks(batches, SNAPSHOT_READ_CONCURRENCY)) results.push(...await Promise.all(wave.map(readBatch)));
+    return new Map(results.flat());
+}
+
+async function readBatch(args) {
+    const {group: group, batch: batch} = args, ids = batch.map(read => read.id), docs = await group.client.fetch(snapshotDocsQuery, {
+        ids: ids
+    }, {
+        perspective: group.perspective
+    }), byId = new Map(docs.map(doc => [ doc._id, validateRawDoc(doc, group.perspective) ]));
+    return batch.flatMap(read => {
+        const doc = byId.get(read.id);
+        return doc === void 0 ? [] : [ [ read, doc ] ];
+    });
+}
+
+function validateRawDoc(doc, perspective) {
+    return perspective !== "raw" ? doc : doc._type === invariants.WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : invariants.assertReadableModel(doc);
+}
+
+function groupReads(reads) {
+    const byClient = /* @__PURE__ */ new Map;
+    for (const read of reads) {
+        let clientGroups = byClient.get(read.client);
+        clientGroups === void 0 && (clientGroups = /* @__PURE__ */ new Map, byClient.set(read.client, clientGroups));
+        const key = JSON.stringify(read.perspective);
+        let group = clientGroups.get(key);
+        group === void 0 && (group = {
+            client: read.client,
+            perspective: read.perspective,
+            reads: []
+        }, clientGroups.set(key, group)), group.reads.push(read);
     }
-    const {query: query, params: params} = contentDocQuery(id);
-    return await client.fetch(query, params, {
-        perspective: perspective
-    }) ?? null;
+    return [ ...byClient.values() ].flatMap(groups => [ ...groups.values() ]);
+}
+
+function chunks(values, size) {
+    return Array.from({
+        length: Math.ceil(values.length / size)
+    }, (_, index) => values.slice(index * size, (index + 1) * size));
 }
 
 function collectEntryDocUris(resolvedFieldEntries) {
@@ -4939,7 +5008,7 @@ function unwrapPatch(patch) {
     return typeof patch == "object" && patch !== null && RAW_PATCH in patch ? patch[RAW_PATCH] : patch;
 }
 
-const wrapperCache = /* @__PURE__ */ new WeakMap, RAW_CLIENT = /* @__PURE__ */ Symbol("workflow-engine.raw-client");
+const wrapperCache = /* @__PURE__ */ new WeakMap, effectHandlerClientCache = /* @__PURE__ */ new WeakMap, RAW_CLIENT = /* @__PURE__ */ Symbol("workflow-engine.raw-client");
 
 function unwrapRequestTag(client) {
     let current = client;
@@ -4956,6 +5025,30 @@ function withRequestTag(client, fallback) {
     return byTag.set(fallback, wrapped), wrapped;
 }
 
+function effectHandlerClient(client) {
+    const cached = effectHandlerClientCache.get(client);
+    if (cached !== void 0) return cached;
+    let tagged;
+    if (client.withConfig === void 0) tagged = withRequestTag(client, REQUEST_TAG.effect); else {
+        const prefix = clientRequestTagPrefix(client), effectTag = composeRequestTag(prefix, REQUEST_TAG.effect);
+        tagged = client.withConfig({
+            requestTagPrefix: effectTag
+        });
+    }
+    return effectHandlerClientCache.set(client, tagged), tagged;
+}
+
+function effectHandlerResolver(resolver) {
+    return mapResourceClientResolver(resolver, effectHandlerClient);
+}
+
+function mapResourceClientResolver(resolver, mapClient) {
+    if (resolver !== void 0) return parsed => {
+        const client = resolver(parsed);
+        return client === void 0 ? void 0 : mapClient(client);
+    };
+}
+
 function isWorkflowsFamilyPrefix(prefix) {
     return prefix === void 0 ? !1 : prefix === "sanity.workflows" || prefix.startsWith("sanity.workflows.") || prefix === "sanity.workflows-mcp";
 }
@@ -4965,8 +5058,18 @@ function clientRequestTagPrefix(client) {
     return typeof probe.config == "function" ? probe.config().requestTagPrefix : void 0;
 }
 
+function composeRequestTag(prefix, tag) {
+    if (prefix === void 0) return tag;
+    const relative = isWorkflowsFamilyPrefix(prefix) ? stripWorkflowRoot(tag) : tag;
+    return `${prefix}.${relative}`;
+}
+
+function stripWorkflowRoot(tag) {
+    return tag.startsWith("workflow.") ? tag.slice(9) : tag;
+}
+
 function buildTaggedClient(client, fallback) {
-    const strip = isWorkflowsFamilyPrefix(clientRequestTagPrefix(unwrapRequestTag(client))), normalize = tag => strip && tag.startsWith("workflow.") ? tag.slice(9) : tag, stamp = options => options === void 0 ? {
+    const strip = isWorkflowsFamilyPrefix(clientRequestTagPrefix(unwrapRequestTag(client))), normalize = tag => strip ? stripWorkflowRoot(tag) : tag, stamp = options => options === void 0 ? {
         tag: normalize(fallback)
     } : options.tag === void 0 ? {
         ...options,
@@ -4996,8 +5099,7 @@ function buildTaggedClient(client, fallback) {
             commit: options => target.commit(stamp(options))
         };
         return wrapped;
-    };
-    return {
+    }, overrides = {
         [RAW_CLIENT]: unwrapRequestTag(client),
         fetch: (query, params, options) => client.fetch(query, params, stamp(options)),
         getDocument: (id, options) => client.getDocument(id, stamp(options)),
@@ -5014,6 +5116,14 @@ function buildTaggedClient(client, fallback) {
             request: opts => client.request(stamp(opts))
         } : {}
     };
+    return new Proxy(client, {
+        has: (target, property) => Object.hasOwn(overrides, property) || property in target,
+        get: (target, property) => {
+            if (Object.hasOwn(overrides, property)) return Reflect.get(overrides, property, overrides);
+            const value = Reflect.get(target, property, target);
+            return typeof value == "function" ? value.bind(target) : value;
+        }
+    });
 }
 
 const pinCache = /* @__PURE__ */ new WeakMap, enginePinned = /* @__PURE__ */ new WeakSet;
@@ -5028,10 +5138,7 @@ function pinApiVersion(client) {
 }
 
 function taggedResolver(resolver, fallback) {
-    if (resolver !== void 0) return parsed => {
-        const client = resolver(parsed);
-        return client === void 0 ? void 0 : withRequestTag(pinApiVersion(client), fallback);
-    };
+    return mapResourceClientResolver(resolver, client => withRequestTag(pinApiVersion(client), fallback));
 }
 
 function taggedScope(args, tag) {
@@ -5061,16 +5168,20 @@ function guardsForResource(client) {
     });
 }
 
-function instanceGuardQuery(instanceId) {
+function instancesGuardQuery(instanceIds) {
     return {
-        query: "*[_type == $guardType && sourceInstanceId == $instanceId]",
+        query: "*[_type == $guardType && sourceInstanceId in $instanceIds] | order(_id asc)",
         params: {
             guardType: GUARD_DOC_TYPE,
-            instanceId: instanceId
+            instanceIds: [ ...instanceIds ]
         }
     };
 }
 
+function instanceGuardQuery(instanceId) {
+    return instancesGuardQuery([ instanceId ]);
+}
+
 function verdictGuardsForInstance(client, instanceId) {
     const {query: query, params: params} = instanceGuardQuery(instanceId);
     return fetchGuards({
@@ -5172,7 +5283,7 @@ function dedupById(guards) {
     return [ ...new Map(guards.map(g => [ g._id, g ])).values() ].sort((a, b) => a._id.localeCompare(b._id));
 }
 
-const GUARD_OWNER = "robot:workflow-engine";
+const GUARD_OWNER = "robot:workflow-engine", DELETE_CHUNK_SIZE = 200;
 
 function resolveGuardRoute(guard, ctx) {
     const targets = resolveIdRefTargets(guard.match.idRefs, ctx);
@@ -5225,10 +5336,9 @@ function resolveGuard({guard: guard, instance: instance, stageName: stageName, n
     };
 }
 
-async function upsertGuard(client, doc) {
-    if (!await client.getDocument(doc._id, {
-        tag: REQUEST_TAG.guardDeploy
-    })) {
+async function upsertGuard(args) {
+    const {client: client, doc: doc, exists: exists} = args;
+    if (!exists) {
         await client.create(doc, {
             ...SYNC_COMMIT,
             tag: REQUEST_TAG.guardDeploy
@@ -5254,7 +5364,8 @@ function resolvedStageGuards(args) {
         });
         resolved !== null && out.push({
             client: args.clientForGdr(resolved.routeGdr),
-            doc: resolved.doc
+            resourceKey: invariants.resourceGdr(invariants.resourceFromParsed(resolved.routeGdr)),
+            value: resolved.doc
         });
     }
     return out;
@@ -5271,12 +5382,54 @@ function resolvedStageGuardRoutes(args) {
         const route = resolveGuardRoute(guard, ctx);
         route !== null && out.push({
             client: args.clientForGdr(route.routeGdr),
-            guardId: route.guardId
+            resourceKey: invariants.resourceGdr(invariants.resourceFromParsed(route.routeGdr)),
+            value: route.guardId
         });
     }
     return out;
 }
 
+function groupByResource(routed) {
+    const groups = /* @__PURE__ */ new Map;
+    for (const item of routed) {
+        const existing = groups.get(item.resourceKey);
+        if (existing !== void 0) {
+            existing.values.push(item.value);
+            continue;
+        }
+        groups.set(item.resourceKey, {
+            client: item.client,
+            resourceKey: item.resourceKey,
+            values: [ item.value ]
+        });
+    }
+    return [ ...groups.values() ];
+}
+
+async function existingGuardIds(groups) {
+    const entries = await Promise.all(groups.map(async ({client: client, resourceKey: resourceKey, values: values}) => {
+        const ids = values.map(doc => doc._id), existing = await client.fetch("*[_id in $ids]._id", {
+            ids: ids
+        }, {
+            tag: REQUEST_TAG.guardDeploy
+        });
+        return [ resourceKey, new Set(existing) ];
+    }));
+    return new Map(entries);
+}
+
+async function observedGuards(groups) {
+    const entries = await Promise.all(groups.map(async ({client: client, resourceKey: resourceKey, values: ids}) => {
+        const guards = await client.fetch("*[_id in $ids]{_id, predicate, _rev}", {
+            ids: ids
+        }, {
+            tag: REQUEST_TAG.guardRetract
+        });
+        return [ resourceKey, new Map(guards.map(guard => [ guard._id, guard ])) ];
+    }));
+    return new Map(entries);
+}
+
 async function committedInstance(args) {
     return getInstanceDocument(args.client, args.instance._id);
 }
@@ -5284,10 +5437,15 @@ async function committedInstance(args) {
 async function deployStageGuards(args) {
     const live = await committedInstance(args);
     if (live === void 0 || live.currentStage !== args.stageName || live.abortedAt !== void 0) return;
+    const routed = resolvedStageGuards(args), existingByResource = await existingGuardIds(groupByResource(routed));
     let deployed = 0;
-    for (const {client: client, doc: doc} of resolvedStageGuards(args)) {
+    for (const {client: client, resourceKey: resourceKey, value: doc} of routed) {
         try {
-            await upsertGuard(client, doc);
+            await upsertGuard({
+                client: client,
+                doc: doc,
+                exists: existingByResource.get(resourceKey)?.has(doc._id) ?? !1
+            });
         } catch (cause) {
             throw deployed > 0 ? new PartialGuardDeployError({
                 stageName: args.stageName,
@@ -5300,13 +5458,11 @@ async function deployStageGuards(args) {
 }
 
 async function retractStageGuards(args) {
-    const observed = [];
-    for (const {client: client, guardId: guardId} of resolvedStageGuardRoutes(args)) {
-        const guard = await client.getDocument(guardId, {
-            tag: REQUEST_TAG.guardRetract
-        });
+    const observed = [], routed = resolvedStageGuardRoutes(args), guardsByResource = await observedGuards(groupByResource(routed));
+    for (const {client: client, resourceKey: resourceKey, value: guardId} of routed) {
+        const guard = guardsByResource.get(resourceKey)?.get(guardId);
         if (guard) {
-            if (guard._rev === void 0) throw new Error(`Cannot retract guard ${guardId}: persisted document has no revision`);
+            if (guard._rev === void 0 || guard._rev === null) throw new Error(`Cannot retract guard ${guardId}: persisted document has no revision`);
             observed.push({
                 client: client,
                 guardId: guardId,
@@ -5337,10 +5493,11 @@ async function deleteOrphanedDefinitionGuards(args) {
     let count = 0;
     for (const {client: resourceClient, guards: guards} of perClient) {
         const own = guards.filter(guard => guard.sourceInstanceId.startsWith(ownPartitionPrefix));
-        if (own.length === 0) continue;
-        const tx = resourceClient.transaction();
-        for (const guard of own) tx.delete(guard._id);
-        await tx.commit(), count += own.length;
+        if (own.length !== 0) for (let start = 0; start < own.length; start += DELETE_CHUNK_SIZE) {
+            const chunk = own.slice(start, start + DELETE_CHUNK_SIZE), tx = resourceClient.transaction();
+            for (const guard of chunk) tx.delete(guard._id);
+            await tx.commit(), count += chunk.length;
+        }
     }
     return count;
 }
@@ -7773,26 +7930,26 @@ async function subjectResourceGrants(args) {
 async function evaluateInstance(args) {
     const {client: client, tag: tag, workflowResource: workflowResource, instanceId: instanceId, resourceClients: resourceClients} = args, now = (args.clock ?? wallClock)();
     invariants.validateTag(tag);
-    const {actor: actor, grants: grants} = await resolveAccess(client, {
+    const [access, instance] = await Promise.all([ resolveAccess(client, {
         ...args.grantsFromPath !== void 0 ? {
             grantsFromPath: args.grantsFromPath
         } : {}
-    }), instance = await reload({
+    }), reload({
         client: client,
         instanceId: instanceId,
         tag: tag
-    }), definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }) ]), {actor: actor, grants: grants} = access, definition = invariants.parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
         client: client,
         workflowResource: workflowResource,
         resourceClients: resourceClients
-    }), snapshot = await hydrateSnapshot({
+    }), [snapshot, guards, resourceGrants] = await Promise.all([ hydrateSnapshot({
         client: client,
         clientForGdr: clientForGdr,
         instance: instance
-    }), guards = await verdictGuardsForInstance(client, instance._id), resourceGrants = await subjectResourceGrants({
+    }), verdictGuardsForInstance(client, instance._id), subjectResourceGrants({
         clientForGdr: clientForGdr,
         instance: instance
-    });
+    }) ]);
     return evaluateFromSnapshot({
         instance: instance,
         definition: definition,
@@ -8322,14 +8479,14 @@ function documentPrefilter(documents, params) {
 
 function documentArm(filter, params) {
     if (filter.documents === void 0 && filter.document === void 0) return;
-    const documents = [ ...filter.documents ?? [], ...filter.document !== void 0 ? [ filter.document ] : [] ];
+    const documents = [ .../* @__PURE__ */ new Set([ ...filter.documents ?? [], ...filter.document !== void 0 ? [ filter.document ] : [] ]) ].sort();
     return documentPrefilter(documents, params);
 }
 
 function idsArm(filter, params) {
     if (filter.ids !== void 0) {
         for (const id of filter.ids) if (invariants.isGdrUri(id)) throw new invariants.ContractViolationError(`instancesQuery: every id must be a bare instance document id (an instance's _id is never resource-qualified); got a GDR URI: ${JSON.stringify(id)}`);
-        return params.ids = [ ...filter.ids ], "_id in $ids";
+        return params.ids = [ ...new Set(filter.ids) ].sort(), "_id in $ids";
     }
 }
 
@@ -10540,7 +10697,7 @@ function isCancelledCompletion(data) {
 }
 
 async function drainEffectsInternal(args) {
-    const {tag: tag, workflowResource: workflowResource, instanceId: instanceId, effectHandlers: effectHandlers, missingHandler: missingHandler, logger: logger, handlerClient: handlerClient, handlerResourceClients: handlerResourceClients} = args, cascadeTelemetry = drainCascadeTelemetry(args.telemetry), {client: client, resourceClients: resourceClients} = taggedScope(args, REQUEST_TAG.drain), leaseMs = args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS, clock = args.clock ?? wallClock, routeGdr = buildClientForGdr({
+    const {tag: tag, workflowResource: workflowResource, instanceId: instanceId, effectHandlers: effectHandlers, missingHandler: missingHandler, logger: logger, handlerClient: rawHandlerClient, handlerResourceClients: rawHandlerResourceClients} = args, cascadeTelemetry = drainCascadeTelemetry(args.telemetry), {client: client, resourceClients: resourceClients} = taggedScope(args, REQUEST_TAG.drain), leaseMs = args.leaseMs ?? DEFAULT_EFFECT_LEASE_MS, clock = args.clock ?? wallClock, handlerClient = effectHandlerClient(rawHandlerClient), handlerResourceClients = effectHandlerResolver(rawHandlerResourceClients), routeGdr = buildClientForGdr({
         client: handlerClient,
         workflowResource: workflowResource,
         resourceClients: handlerResourceClients
@@ -10906,22 +11063,30 @@ function createInstanceSession(args) {
     }, tickScope = opScope(REQUEST_TAG.tick), fireScope = opScope(REQUEST_TAG.fireAction), editScope = opScope(REQUEST_TAG.editField), evalScope = opScope(REQUEST_TAG.evaluate);
     let overlay = /* @__PURE__ */ new Map;
     const previews = /* @__PURE__ */ new Map;
-    let heldGuards = [], committing = !1, buffered, deferredUpdateError;
-    const selfUri = () => invariants.gdrFromResource(instance.workflowResource, instance._id), applyUpdate = docs => {
-        const next = /* @__PURE__ */ new Map;
-        for (const ld of docs) {
-            const owned = {
-                doc: structuredClone(ld.doc),
-                resource: ld.resource
-            }, uri = invariants.gdrFromResource(owned.resource, owned.doc._id);
-            if (uri === selfUri()) {
-                const rawStamp = owned.doc._updatedAt;
-                !invariants.isParseableInstant(rawStamp) || owned.doc._type !== invariants.WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
-                continue;
-            }
-            next.set(uri, owned);
+    let heldGuards = [], committing = !1, buffered;
+    const bufferedDocuments = /* @__PURE__ */ new Map;
+    let deferredUpdateError;
+    const flushDeferredError = () => {
+        if (deferredUpdateError === void 0) return;
+        const failure = deferredUpdateError;
+        throw deferredUpdateError = void 0, failure;
+    }, selfUri = () => invariants.gdrFromResource(instance.workflowResource, instance._id), applyDocument = (ld, target) => {
+        const owned = {
+            doc: structuredClone(ld.doc),
+            resource: ld.resource
+        }, uri = invariants.gdrFromResource(owned.resource, owned.doc._id);
+        if (uri === selfUri()) {
+            const rawStamp = owned.doc._updatedAt;
+            !invariants.isParseableInstant(rawStamp) || owned.doc._type !== invariants.WORKFLOW_INSTANCE_TYPE ? asHeldInstance(owned.doc) : Date.parse(rawStamp) > Date.parse(instance._updatedAt) && (instance = asHeldInstance(owned.doc));
+            return;
         }
+        target.set(uri, owned);
+    }, applyUpdate = docs => {
+        const next = /* @__PURE__ */ new Map;
+        for (const ld of docs) applyDocument(ld, next);
         overlay = next;
+    }, applyDocumentUpdate = doc => {
+        applyDocument(doc, overlay);
     }, access = () => resolveAccess(client, {
         ...args.grantsFromPath !== void 0 ? {
             grantsFromPath: args.grantsFromPath
@@ -11047,6 +11212,12 @@ function createInstanceSession(args) {
                     deferredUpdateError = err;
                 }
             }
+            for (const next of bufferedDocuments.values()) try {
+                applyDocumentUpdate(next);
+            } catch (err) {
+                deferredUpdateError = err;
+            }
+            bufferedDocuments.clear();
         }
     };
     return {
@@ -11054,15 +11225,26 @@ function createInstanceSession(args) {
             return subscriptionDocumentsForInstance(instance);
         },
         update(docs) {
-            if (committing) buffered = docs; else try {
+            if (committing) buffered = docs, bufferedDocuments.clear(); else try {
                 applyUpdate(docs);
             } catch (err) {
                 throw deferredUpdateError = void 0, err;
             }
-            if (deferredUpdateError !== void 0) {
-                const failure = deferredUpdateError;
-                throw deferredUpdateError = void 0, failure;
+            flushDeferredError();
+        },
+        updateDocument(doc) {
+            if (committing) {
+                const uri = invariants.gdrFromResource(doc.resource, doc.doc._id);
+                bufferedDocuments.set(uri, {
+                    doc: structuredClone(doc.doc),
+                    resource: doc.resource
+                });
+            } else try {
+                applyDocumentUpdate(doc);
+            } catch (err) {
+                throw deferredUpdateError = void 0, err;
             }
+            flushDeferredError();
         },
         updateGuards(guards) {
             heldGuards = guards.map(guard => parseGuardDocument(structuredClone(guard)));
@@ -12376,10 +12558,14 @@ exports.instanceGuardQuery = instanceGuardQuery;
 
 exports.instanceWatchesDocument = instanceWatchesDocument;
 
+exports.instancesGuardQuery = instancesGuardQuery;
+
 exports.instancesQuery = instancesQuery;
 
 exports.isClaimExpired = isClaimExpired;
 
+exports.isClientProjectUser = isClientProjectUser;
+
 exports.isDefinitionApplicable = isDefinitionApplicable;
 
 exports.isFilterScopedOut = isFilterScopedOut;