@sanity/workflow-engine 0.19.0 → 0.20.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { terminalState, andConditions, deriveActivityKind, parseDefinitionSnapshot, CALLER_BOUND_VARS, START_ALLOWED_VARS, CONDITION_VARS, SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR, isSubjectEntry, isUnevaluable, ContractViolationError, isStartableDefinition, conditionFieldReadNames, rethrowWithContext, conditionParameterNames, isGdr, WORKFLOW_INSTANCE_TYPE, START_FILTER_VARS, gdrFromResource, selfGdr, isSingleDocRefKind, parentRef, actorFulfillsRole, toBareId, WorkflowError, sameResource, resourceFromParsed, tryParseGdr, isTerminalActivityStatus, errorMessage, FieldValueShapeError, validateFieldValue, validateFieldAppendItem, evaluateCondition, isSingleDocRefEntry, choiceValueIssues, scalarValidationIssues, StoredFieldOpSchema, formatIssues, conditionSyntaxIssues, checkWorkflowInvariants, formatIssuePath, isGuardReadExpr, conditionEffectReads, EFFECTS_READ, datasetResourceParts, evaluatePredicates, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, isCascadeFired, parseGdr, isGdrUri, gdrRef, isInputSourced, checkFieldValue, toPhysicalGdr, isBareSeedId, tolerantEntries, NonEmptyString, FIELD_VALUE_KINDS, tolerantObject, ActorShape, IsoTimestamp, ACTIVITY_STATUSES, GdrShape, DRIVER_KINDS, FIELD_SCOPES, fieldValueSchemas, parsePersistedDoc, assertReadableModel, InstanceNotFoundError, modelStampFor, evaluateConditionOutcome, runGroq, FIELD_READ, MUTATION_GUARD_ACTIONS, resourceGdr, minReaderModelOf, resourceFromGdrUri, refTypeIssues, rejectedRefTypes, DOCUMENT_VALUE_PERMISSIONS, driverKind, EffectNotFoundError, deriveExecutorClassification, validateTag, extractDocumentId, parseStoredDefinition, validateResourceAliasName, labelFor, DefinitionNotFoundError, definitionDocId, SpawnContractsInvalidError, gdrResourcePrefix, RESOURCE_ALIAS_NAME_SOURCE, isUnprimed, DefinitionInUseError, assertReaderModelAcknowledgement, isParseableInstant, groupMembershipNames } from "./_chunks-es/invariants.js";
+import { terminalState, andConditions, deriveActivityKind, parseDefinitionSnapshot, CALLER_BOUND_VARS, START_ALLOWED_VARS, CONDITION_VARS, SUBJECT_HAS_IN_FLIGHT_INSTANCE_VAR, isSubjectEntry, isUnevaluable, ContractViolationError, isStartableDefinition, conditionFieldReadNames, rethrowWithContext, conditionParameterNames, isGdr, WORKFLOW_INSTANCE_TYPE, START_FILTER_VARS, gdrFromResource, selfGdr, isSingleDocRefKind, parentRef, actorFulfillsRole, toBareId, WorkflowError, sameResource, resourceFromParsed, tryParseGdr, isTerminalActivityStatus, errorMessage, FieldValueShapeError, validateFieldValue, validateFieldAppendItem, evaluateCondition, isSingleDocRefEntry, choiceValueIssues, scalarValidationIssues, StoredFieldOpSchema, formatIssues, conditionSyntaxIssues, checkWorkflowInvariants, formatIssuePath, isGuardReadExpr, conditionEffectReads, EFFECTS_READ, datasetResourceParts, evaluatePredicates, WORKFLOW_DEFINITION_TYPE, tagScopeFilter, isCascadeFired, parseGdr, isGdrUri, gdrRef, isInputSourced, checkFieldValue, VersionSpecificDatasetGdrError, toPhysicalGdr, isBareSeedId, tolerantEntries, NonEmptyString, FIELD_VALUE_KINDS, tolerantObject, ActorShape, IsoTimestamp, ACTIVITY_STATUSES, GdrShape, DRIVER_KINDS, FIELD_SCOPES, fieldValueSchemas, parsePersistedDoc, assertReadableModel, InstanceNotFoundError, modelStampFor, evaluateConditionOutcome, runGroq, FIELD_READ, MUTATION_GUARD_ACTIONS, resourceGdr, minReaderModelOf, resourceFromGdrUri, refTypeIssues, rejectedRefTypes, DOCUMENT_VALUE_PERMISSIONS, driverKind, EffectNotFoundError, deriveExecutorClassification, validateTag, extractDocumentId, parseStoredDefinition, validateResourceAliasName, labelFor, DefinitionNotFoundError, definitionDocId, SpawnContractsInvalidError, gdrResourcePrefix, RESOURCE_ALIAS_NAME_SOURCE, isUnprimed, DefinitionInUseError, assertReaderModelAcknowledgement, isParseableInstant, groupMembershipNames } from "./_chunks-es/invariants.js";
 
 import { ACTION_SEMANTICS, ACTIVITY_KINDS, ACTOR_KINDS, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_TRANSITION_WHEN, EXECUTOR_CLASSIFICATIONS, FILTER_SCOPE_VARS, GROUP_KINDS, GUARD_PREDICATE_VARS, ModelVersionAheadError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, clientConfigFromResource, fieldTreeShape, gdrUri, isNotesEntry, isTodoListEntry, isTodoListItem, modelVersionOf, parseResourceGdr, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, releaseDocId, releaseRef, requiredModelFeatures, requiredReaderModel, resourceAliasesToMap, schemaTreeShape, startKindOf } from "./_chunks-es/invariants.js";
 
@@ -4001,12 +4001,27 @@ function assertInputValueShape(entry, value) {
 function assertGdrShape(value, context) {
     if (typeof value != "object" || value === null) throw new ContractViolationError(`Invalid GDR for ${context}: expected { id: "<scheme>:...", type: "<schema>" }, got ${typeof value}.`);
     const v2 = value;
-    if (typeof v2.id != "string" || !isGdrUri(v2.id)) throw new 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 {
+        parseGdr(v2.id);
+    } catch (error) {
+        throw error instanceof VersionSpecificDatasetGdrError ? new ContractViolationError(`Invalid GDR for ${context}: ${error.message}`) : invalidGdrUriError(context, v2.id);
+    }
     if (typeof v2.type != "string" || v2.type.length === 0) throw new 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 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 : 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 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 VersionSpecificDatasetGdrError) return raw;
+        throw error;
+    }
 }
 
 function coerceGdrShape(raw, workflowResource) {
@@ -4462,65 +4477,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(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 = 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 = 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: 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 === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc2) : 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 === WORKFLOW_INSTANCE_TYPE ? readInstanceDoc(doc) : 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) {
@@ -4924,7 +4993,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;
@@ -4941,6 +5010,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";
 }
@@ -4950,8 +5043,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,
@@ -4981,8 +5084,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)),
@@ -4999,6 +5101,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;
@@ -5013,10 +5123,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) {
@@ -5046,16 +5153,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({
@@ -5157,7 +5268,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);
@@ -5210,10 +5321,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
@@ -5239,7 +5349,8 @@ function resolvedStageGuards(args) {
         });
         resolved !== null && out.push({
             client: args.clientForGdr(resolved.routeGdr),
-            doc: resolved.doc
+            resourceKey: resourceGdr(resourceFromParsed(resolved.routeGdr)),
+            value: resolved.doc
         });
     }
     return out;
@@ -5256,12 +5367,54 @@ function resolvedStageGuardRoutes(args) {
         const route = resolveGuardRoute(guard, ctx);
         route !== null && out.push({
             client: args.clientForGdr(route.routeGdr),
-            guardId: route.guardId
+            resourceKey: resourceGdr(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);
 }
@@ -5269,10 +5422,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,
@@ -5285,13 +5443,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,
@@ -5322,10 +5478,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;
 }
@@ -7757,26 +7914,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)();
     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 = parseDefinitionSnapshot(instance), clientForGdr = buildClientForGdr({
+    }) ]), {actor: actor, grants: grants} = access, definition = 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,
@@ -8306,14 +8463,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 (isGdrUri(id)) throw new 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";
     }
 }
 
@@ -10524,7 +10681,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
@@ -10890,22 +11047,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 = () => 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 = gdrFromResource(owned.resource, owned.doc._id);
-            if (uri === selfUri()) {
-                const rawStamp = owned.doc._updatedAt;
-                !isParseableInstant(rawStamp) || owned.doc._type !== 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 = () => gdrFromResource(instance.workflowResource, instance._id), applyDocument = (ld, target) => {
+        const owned = {
+            doc: structuredClone(ld.doc),
+            resource: ld.resource
+        }, uri = gdrFromResource(owned.resource, owned.doc._id);
+        if (uri === selfUri()) {
+            const rawStamp = owned.doc._updatedAt;
+            !isParseableInstant(rawStamp) || owned.doc._type !== 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
@@ -11031,6 +11196,12 @@ function createInstanceSession(args) {
                     deferredUpdateError = err;
                 }
             }
+            for (const next of bufferedDocuments.values()) try {
+                applyDocumentUpdate(next);
+            } catch (err) {
+                deferredUpdateError = err;
+            }
+            bufferedDocuments.clear();
         }
     };
     return {
@@ -11038,15 +11209,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 = 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)));
@@ -11860,4 +12042,4 @@ function displayDescription(typeKey) {
     if (typeKey) return DISPLAY[typeKey]?.description;
 }
 
-export { ACTION_SEMANTICS, ACTIVITY_KINDS, ACTIVITY_KIND_DISPLAY, ACTOR_KINDS, AUTHORING_DISPLAY, ActionDisabledError, ActionParamsInvalidError, CONDITION_VARS, CONTEXT_ENTRY_DISPLAY, CascadeLimitError, ConcurrentCommitEffectOpsError, ConcurrentCompleteEffectError, ConcurrentEditFieldError, ConcurrentFireActionError, ContractViolationError, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_CONTENT_PERSPECTIVE, DEFAULT_EFFECT_LEASE_MS, DEFAULT_IDEMPOTENCY_TTL_MS, DEFAULT_TRANSITION_WHEN, DISPLAY, DRIVER_KINDS, DRIVER_KIND_DISPLAY, DefinitionInUseError, DefinitionNotFoundError, EFFECT_COMMIT_DISPATCH_CAP, EFFECT_COMMIT_QUEUE_DEPTH, ENGINE_API_VERSION, EXECUTION_KINDS, EXECUTOR_CLASSIFICATIONS, EXECUTOR_CLASSIFICATION_DISPLAY, EditFieldDeniedError, EffectCommitQueueOverflowError, EffectNotFoundError, EffectOpsInvalidError, EffectOutputsInvalidError, FIELD_KIND_DISPLAY, FILTER_SCOPE_VARS, FieldValueShapeError, GROUP_KINDS, GROUP_KIND_DISPLAY, GUARD_DOC_TYPE, GUARD_OWNER, GUARD_PREDICATE_VARS, HISTORY_DISPLAY, InitialFieldsInvalidError, InstanceNotFoundError, MAX_COUNTERFACTUAL_INDEX2 as MAX_COUNTERFACTUAL_INDEX, MissingHandlerError, ModelVersionAheadError, MutationGuardDeniedError, MutationGuardDocSchema, OP_DISPLAY, PartialGuardDeployError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, RefResourceUndeclaredError, RequiredFieldNotProvidedError, START_ALLOWED_VARS, START_FILTER_VARS, SpawnContractsInvalidError, StaleEffectClaimError, StartNotAllowedError, StartNotPrimedError, StartNotSettledError, WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, WorkflowActionFired, WorkflowDefinitionDeleted, WorkflowDefinitionDeployed, WorkflowEffectCompleted, WorkflowEffectStateReported, WorkflowEffectsDrained, WorkflowError, WorkflowFieldEdited, WorkflowInstanceAborted, WorkflowInstanceSchema, WorkflowInstanceStarted, WorkflowInstanceTicked, WorkflowStageSet, WorkflowStageTransitioned, WorkflowStateDivergedError, abortReason, acceptsDocumentType, aclPathForResource, actionDisabledDetail, actionRendering, actionVerdict, activityAutonomyOf, analyzeCondition2 as analyzeCondition, applicableDefinitions, assertReadableModel, assertReaderModelAcknowledgement, atomReadsDataset2 as atomReadsDataset, autonomySummary, availableActions, buildInitialFields, buildSnapshot, checklistLines, clientConfigFromResource, clientProjectUserDirectory, compileGuard, computeDiffEntries, conditionFieldReadNames, conditionSitesOf, contentDocQuery, contentDraftFallback, contentReleaseName, contextMap, createEngine, createTelemetryIntake, datasetResourceParts, defaultLoggerFactory, definitionDeployedData, definitionLookupGroq, definitionsListGroq, deniedGuardLabels, deniedGuardRefs, denyingGuards, deployStageGuards, deriveActivityKind, deriveExecutorClassification, deriveWorkflowAutonomy, describeAtom, describeAutonomyWait, describeCondition, describeDefinition, describeFieldInsight, describeNode, describeSite, describeSiteHeading, diagnoseInputFromEvaluation, diagnoseInstance, diffEntry, displayDescription, displayTitle, documentActionDenials, documentPrefilter, driverKind, effectOutputsMap, entryDocRefs, errorMessage, evaluateFromSnapshot, evaluateMutationGuard, evaluateStartFilter, expandResourceAliases, explainCondition2 as explainCondition, explainStartAllowed, extractDocumentId, fieldTreeShape, findCurrentActivityEntry, findOpenStageEntry, formatRead, gdrFromResource, gdrRef, gdrUri, groupMembershipNames, groupSitesOf, guardMatches, guardsForDefinition, guardsForInstance, guardsForResource, guillemets2 as guillemets, hashDefinitionContent, humanize2 as humanize, inFlightFilter, initialFieldIssues, instanceDocId, instanceGuardQuery, instanceWatchesDocument, instancesQuery, isCascadeFired, isClaimExpired, isComparisonOp, isDefinitionApplicable, isFilterScopedOut, isGdr, isInputSourced, isNotesEntry, isProjectUserNotFoundError, isSingleDocRefEntry, isSingleDocRefKind, isStartableDefinition, isSubjectEntry, isTelemetryEnvDenied, isTerminalActivityStatus, isTerminalStage, isTodoListEntry, isTodoListItem, isUnprimed, lakeGuardId, latestDeployedDefinitions, lintEffectOutputs, minReaderModelOf, missingRequiredInputs, modelVersionOf, narrateAutonomyWaits, noopTelemetry, parentRef, parseDefinitionInput, parseDefinitionSnapshot, parseGdr, parseGuardDocument, parseInstanceDocument, parseResourceGdr, processShellUserProperties, projectToWatchRef, quoted2 as quoted, readInstanceDoc, readsRaw, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, refsOf, rejectedRefTypes, releaseDocId, releaseRef, remediationsFor, requiredModelFeatures, requiredReaderModel, resolveAccess, resolveActor, resolveClientActor, resolveFieldEntry$1 as resolveFieldEntry, resourceAliasesToMap, resourceFromParsed, resourceGdr, retractStageGuards, sameResource, scalarValidationIssues, schemaTreeShape, sentenceCase, silentLogger, stageAutonomyOf, startFieldsParam, startKindOf, startRefusal, stripSystemFields, subjectDenialLabels, subscriptionDocument, subscriptionDocumentsForInstance, sweepStaleClaims, tagScopeFilter, terminalState, toBareId, tryParseGdr, unboundAllowedReads, unsatisfiedTransitionSummaries, validateDefinition, validateTag, verdictGuardsForInstance, wallClock, whatIfCondition2 as whatIfCondition, withAssignment, workflow };
+export { ACTION_SEMANTICS, ACTIVITY_KINDS, ACTIVITY_KIND_DISPLAY, ACTOR_KINDS, AUTHORING_DISPLAY, ActionDisabledError, ActionParamsInvalidError, CONDITION_VARS, CONTEXT_ENTRY_DISPLAY, CascadeLimitError, ConcurrentCommitEffectOpsError, ConcurrentCompleteEffectError, ConcurrentEditFieldError, ConcurrentFireActionError, ContractViolationError, DATA_MODEL_CHANGES, DATA_MODEL_MIN_READER, DATA_MODEL_VERSION, DEFAULT_CONTENT_PERSPECTIVE, DEFAULT_EFFECT_LEASE_MS, DEFAULT_IDEMPOTENCY_TTL_MS, DEFAULT_TRANSITION_WHEN, DISPLAY, DRIVER_KINDS, DRIVER_KIND_DISPLAY, DefinitionInUseError, DefinitionNotFoundError, EFFECT_COMMIT_DISPATCH_CAP, EFFECT_COMMIT_QUEUE_DEPTH, ENGINE_API_VERSION, EXECUTION_KINDS, EXECUTOR_CLASSIFICATIONS, EXECUTOR_CLASSIFICATION_DISPLAY, EditFieldDeniedError, EffectCommitQueueOverflowError, EffectNotFoundError, EffectOpsInvalidError, EffectOutputsInvalidError, FIELD_KIND_DISPLAY, FILTER_SCOPE_VARS, FieldValueShapeError, GROUP_KINDS, GROUP_KIND_DISPLAY, GUARD_DOC_TYPE, GUARD_OWNER, GUARD_PREDICATE_VARS, HISTORY_DISPLAY, InitialFieldsInvalidError, InstanceNotFoundError, MAX_COUNTERFACTUAL_INDEX2 as MAX_COUNTERFACTUAL_INDEX, MissingHandlerError, ModelVersionAheadError, MutationGuardDeniedError, MutationGuardDocSchema, OP_DISPLAY, PartialGuardDeployError, PersistedDocShapeError, READER_MODEL_ROLLOUT_URL, RESERVED_CONDITION_VARS, ReaderModelAcknowledgementError, RefResourceUndeclaredError, RequiredFieldNotProvidedError, START_ALLOWED_VARS, START_FILTER_VARS, SpawnContractsInvalidError, StaleEffectClaimError, StartNotAllowedError, StartNotPrimedError, StartNotSettledError, WORKFLOW_DEFINITION_TYPE, WORKFLOW_INSTANCE_TYPE, WorkflowActionFired, WorkflowDefinitionDeleted, WorkflowDefinitionDeployed, WorkflowEffectCompleted, WorkflowEffectStateReported, WorkflowEffectsDrained, WorkflowError, WorkflowFieldEdited, WorkflowInstanceAborted, WorkflowInstanceSchema, WorkflowInstanceStarted, WorkflowInstanceTicked, WorkflowStageSet, WorkflowStageTransitioned, WorkflowStateDivergedError, abortReason, acceptsDocumentType, aclPathForResource, actionDisabledDetail, actionRendering, actionVerdict, activityAutonomyOf, analyzeCondition2 as analyzeCondition, applicableDefinitions, assertReadableModel, assertReaderModelAcknowledgement, atomReadsDataset2 as atomReadsDataset, autonomySummary, availableActions, buildInitialFields, buildSnapshot, checklistLines, clientConfigFromResource, clientProjectUserDirectory, compileGuard, computeDiffEntries, conditionFieldReadNames, conditionSitesOf, contentDocQuery, contentDraftFallback, contentReleaseName, contextMap, createEngine, createTelemetryIntake, datasetResourceParts, defaultLoggerFactory, definitionDeployedData, definitionLookupGroq, definitionsListGroq, deniedGuardLabels, deniedGuardRefs, denyingGuards, deployStageGuards, deriveActivityKind, deriveExecutorClassification, deriveWorkflowAutonomy, describeAtom, describeAutonomyWait, describeCondition, describeDefinition, describeFieldInsight, describeNode, describeSite, describeSiteHeading, diagnoseInputFromEvaluation, diagnoseInstance, diffEntry, displayDescription, displayTitle, documentActionDenials, documentPrefilter, driverKind, effectOutputsMap, entryDocRefs, errorMessage, evaluateFromSnapshot, evaluateMutationGuard, evaluateStartFilter, expandResourceAliases, explainCondition2 as explainCondition, explainStartAllowed, extractDocumentId, fieldTreeShape, findCurrentActivityEntry, findOpenStageEntry, formatRead, gdrFromResource, gdrRef, gdrUri, groupMembershipNames, groupSitesOf, guardMatches, guardsForDefinition, guardsForInstance, guardsForResource, guillemets2 as guillemets, hashDefinitionContent, humanize2 as humanize, inFlightFilter, initialFieldIssues, instanceDocId, instanceGuardQuery, instanceWatchesDocument, instancesGuardQuery, instancesQuery, isCascadeFired, isClaimExpired, isClientProjectUser, isComparisonOp, isDefinitionApplicable, isFilterScopedOut, isGdr, isInputSourced, isNotesEntry, isProjectUserNotFoundError, isSingleDocRefEntry, isSingleDocRefKind, isStartableDefinition, isSubjectEntry, isTelemetryEnvDenied, isTerminalActivityStatus, isTerminalStage, isTodoListEntry, isTodoListItem, isUnprimed, lakeGuardId, latestDeployedDefinitions, lintEffectOutputs, minReaderModelOf, missingRequiredInputs, modelVersionOf, narrateAutonomyWaits, noopTelemetry, parentRef, parseDefinitionInput, parseDefinitionSnapshot, parseGdr, parseGuardDocument, parseInstanceDocument, parseResourceGdr, processShellUserProperties, projectToWatchRef, quoted2 as quoted, readInstanceDoc, readsRaw, readsRootDocument, refCanvas, refDashboard, refDataset, refKindAcceptsTypes, refMediaLibrary, refsOf, rejectedRefTypes, releaseDocId, releaseRef, remediationsFor, requiredModelFeatures, requiredReaderModel, resolveAccess, resolveActor, resolveClientActor, resolveFieldEntry$1 as resolveFieldEntry, resourceAliasesToMap, resourceFromParsed, resourceGdr, retractStageGuards, sameResource, scalarValidationIssues, schemaTreeShape, sentenceCase, silentLogger, stageAutonomyOf, startFieldsParam, startKindOf, startRefusal, stripSystemFields, subjectDenialLabels, subscriptionDocument, subscriptionDocumentsForInstance, sweepStaleClaims, tagScopeFilter, terminalState, toBareId, tryParseGdr, unboundAllowedReads, unsatisfiedTransitionSummaries, validateDefinition, validateTag, verdictGuardsForInstance, wallClock, whatIfCondition2 as whatIfCondition, withAssignment, workflow };