@storystick/preview 0.0.0-stage → 0.2.0-rc.0

package/dist/server/route-document-provenance.js

@@ -0,0 +1,1327 @@
+import { collectPreviewReadObservations } from '@storystick/client/internal';
+import { appliedPreviewVariantIdFromQueryResult, previewReadScopeEchoFromQueryResult, requestedPreviewVariantIdFromQueryResult, collectPreviewProvenanceSourceMappedQueryResults, collectPreviewFrameDependencies, createPreviewProvenanceEditableManifestMatcher, formatPreviewProvenanceCanonicalPath, materializePreviewProvenanceSourceMap, planPreviewProvenanceEditableTextLeaves, previewProvenanceEditableTextPathPatternMatches, previewProvenanceRichTextTextNodes, previewProvenanceSourceIdentityFromQueryResult, } from '@storystick/preview/provenance';
+import { normalizePreviewVariantId } from '@storystick/preview/identity';
+import { arrayItemSegment, documentPathKey, fieldSegment, richTextTextNodeSegment, sliceFieldKey, slicePathKey, withPreviewProvenanceRouteFrame, withPreviewProvenanceRouteRender, withPreviewProvenanceContext, } from '../provenance/render-context.js';
+import { RICHTEXT_EMBED_STORE_FIELD, formatRichtextEmbedFieldPath, } from '@storystick/types/internal/richtext-embeds';
+import { unstable_buildPreviewRenderFrameWithRuntime, } from './render-frame-provenance.js';
+import { resolvePreviewFrameReadMetadataFromObservations } from './preview-read-metadata.js';
+export async function unstable_buildPreviewRouteDocumentFrameWithRuntime(options, runtime) {
+    const enabled = options.enabled ?? runtime.config.isEnabled();
+    if (!enabled)
+        return null;
+    const plan = planPreviewDocumentRender({ ...options, enabled }, runtime);
+    return plan ? unstable_buildPreviewRenderFrameWithRuntime(plan, runtime) : null;
+}
+/** Internal planning shared by routes and independently mounted server components. */
+export function planPreviewDocumentRender(options, runtime) {
+    // Read observations live in a WeakMap so QueryResults remain plain across
+    // the RSC boundary. Resolve that out-of-band metadata before the JSON clone
+    // used for coded render data, then pass the scalar identity downstream.
+    const codeVersion = options.codeVersion ?? runtime.config.resolveCodeVersion();
+    const observations = collectPreviewReadObservations(options.document, options.context);
+    const readMetadata = resolvePreviewFrameReadMetadataFromObservations(codeVersion, observations);
+    if (observations.some((read) => read.readContext) && readMetadata === null)
+        return null;
+    const codedDocument = cloneJson(options.document);
+    const codedContext = options.context === undefined ? undefined : cloneJson(options.context);
+    const routeDocuments = collectPreviewProvenanceSourceMappedQueryResults(options.document);
+    const contextDocuments = uniqueQueryResultsByDocumentId([
+        ...routeDocuments.filter((entry) => entry.documentId !== options.document.documentId),
+        ...(options.context === undefined
+            ? []
+            : collectPreviewProvenanceSourceMappedQueryResults(options.context)),
+    ]);
+    const referencedContextDocumentIds = collectReferencedContextDocumentIds({
+        document: options.document,
+        contextDocuments,
+    });
+    const codedTextRoots = collectCodedTextRootsByDocumentId(codedDocument, codedContext);
+    const slicePlanningScopes = collectSlicePlanningScopes(options.document);
+    const routeDocumentPlan = planRouteDocumentPreviewProvenance({
+        document: options.document,
+        manifest: options.manifest,
+    });
+    const modelDocumentIds = modelIdsFromRouteDocument(options.document);
+    const contextPlan = planContextDocumentPreviewProvenance({
+        documents: contextDocuments,
+        manifest: options.manifest,
+        richTextDocumentIds: referencedContextDocumentIds,
+    });
+    const sourceMapDiagnostics = summarizeMaterializedMarkPlans([
+        routeDocumentPlan,
+        contextPlan,
+    ]);
+    const dependencies = routeDocumentFrameDependencies({
+        pathname: options.pathname,
+        document: options.document,
+        contextDocuments,
+        modelDocumentIds,
+        extraDependencies: [
+            ...(options.dependencies ?? []),
+            ...collectPreviewFrameDependencies(options.document, options.context),
+        ],
+    });
+    const marks = [
+        ...routeDocumentPlan.marks,
+        ...slicePlanningScopes.flatMap((scope) => planPreviewProvenanceBoundSliceZoneTextLeaves({
+            document: options.document,
+            slices: scope.slices,
+            sliceZonePath: scope.sliceZonePath,
+            parentPathAnchors: scope.parentPathAnchors,
+            fieldBindingsFallback: options.fieldBindingsFallback,
+        })),
+        ...slicePlanningScopes.flatMap((scope) => planPreviewProvenanceModelSliceZoneTextLeaves({
+            document: options.document,
+            codedDocument,
+            slices: scope.slices,
+            sliceZonePath: scope.sliceZonePath,
+            parentPathAnchors: scope.parentPathAnchors,
+            manifest: options.manifest,
+            fieldBindingsFallback: options.fieldBindingsFallback,
+        })),
+        ...slicePlanningScopes.flatMap((scope) => scope.sourceKind === 'embed'
+            ? planPreviewProvenanceEmbedSliceTextLeaves({
+                document: options.document,
+                slices: scope.slices,
+                sliceZonePath: scope.sliceZonePath,
+                sourceSliceZonePath: scope.sourceSliceZonePath,
+                parentPathAnchors: scope.parentPathAnchors,
+                sourceParentPathAnchors: scope.sourceParentPathAnchors,
+                sidecarByKey: scope.sidecarByKey,
+                sidecarIndexByKey: scope.sidecarIndexByKey,
+                manifest: options.manifest,
+            })
+            : []),
+        ...contextPlan.marks,
+    ];
+    const previewScopeDocuments = [
+        options.document,
+        ...contextDocuments,
+    ];
+    const echoedAppliedVariantId = appliedVariantIdFromRouteDocuments(previewScopeDocuments);
+    const echoedRequestedVariantId = requestedVariantIdFromRouteDocuments(previewScopeDocuments);
+    const previewScope = previewScopeFromRouteDocuments(previewScopeDocuments);
+    const variantId = echoedAppliedVariantId !== undefined
+        ? echoedAppliedVariantId
+        : echoedRequestedVariantId !== undefined
+            ? echoedRequestedVariantId
+            : options.variantId === undefined
+                ? variantIdFromRouteDocument(options.document)
+                : normalizePreviewVariantId(options.variantId);
+    return {
+        enabled: options.enabled,
+        frameId: options.frameId ?? 'route',
+        sessionId: options.sessionId,
+        routeHash: options.routeHash,
+        variantId: options.variantId === undefined ? variantId ?? undefined : variantId,
+        previewScope,
+        pathname: options.pathname,
+        codeVersion,
+        renderId: options.renderId,
+        generation: options.generation,
+        renderNonce: options.renderNonce,
+        emissionRevision: options.emissionRevision,
+        authoritativeDocumentIds: options.authoritativeDocumentIds ?? [
+            options.document.documentId,
+            ...modelDocumentIds,
+            ...contextDocuments.map((entry) => entry.documentId),
+        ],
+        dependencies,
+        leaves: marks,
+        sourceMapDiagnostics,
+        codedDocument,
+        codedTextRoot: codedDocument,
+        codedTextRootsByDocumentId: codedTextRoots,
+        codedContext,
+        readContext: readMetadata?.readContext,
+        receiptIds: readMetadata?.receiptIds,
+        observationId: readMetadata?.observationId,
+        renderWatermark: readMetadata?.renderWatermark,
+        fixture: options.fixture,
+        projectId: options.projectId,
+        endpoint: options.endpoint,
+        convexUrl: options.convexUrl,
+    };
+}
+export function stripPreviewRouteMetadata(document) {
+    if (!isRecord(document))
+        return document;
+    const rest = {};
+    for (const [key, value] of Object.entries(document)) {
+        if (key === '__ssPreviewRouteFrame' || key === '__ssPreviewRouteRender') {
+            continue;
+        }
+        rest[key] = value;
+    }
+    return rest;
+}
+function variantIdFromRouteDocument(document) {
+    return (normalizePreviewVariantId(document._locale?.variantId) ??
+        normalizePreviewVariantId(document._variant?.variantId));
+}
+function appliedVariantIdFromRouteDocuments(documents) {
+    let sawApplicableEcho = false;
+    for (const document of documents) {
+        const appliedVariantId = appliedPreviewVariantIdFromQueryResult(document);
+        if (appliedVariantId === undefined)
+            continue;
+        sawApplicableEcho = true;
+        if (appliedVariantId !== null)
+            return appliedVariantId;
+    }
+    return sawApplicableEcho ? null : undefined;
+}
+function requestedVariantIdFromRouteDocuments(documents) {
+    for (const document of documents) {
+        const requestedVariantId = requestedPreviewVariantIdFromQueryResult(document);
+        if (requestedVariantId !== undefined)
+            return requestedVariantId;
+    }
+    return undefined;
+}
+function previewScopeFromRouteDocuments(documents) {
+    let fallback;
+    for (const document of documents) {
+        const scope = previewReadScopeEchoFromQueryResult(document);
+        if (scope === undefined)
+            continue;
+        fallback ??= scope;
+        if (scope.appliesToDocument !== false)
+            return scope;
+    }
+    return fallback;
+}
+export function unstable_attachPreviewProvenanceRenderContext(value, attrsByKey) {
+    if (!attrsByKey)
+        return value;
+    return withPreviewProvenanceContext(value, attrsByKey);
+}
+export function unstable_attachPreviewRouteFrameContext(frame) {
+    if (!frame?.codedDocument)
+        return null;
+    return withPreviewProvenanceRouteFrame(frame.codedDocument, routeFrameContext(frame));
+}
+export function unstable_attachPreviewRouteMetadataContext(value, frame) {
+    if (!frame)
+        return value;
+    return withPreviewProvenanceRouteFrame(value, routeFrameContext(frame));
+}
+function routeFrameContext(frame) {
+    return {
+        type: 'storystick.preview.route-frame',
+        version: 1,
+        frameId: frame.frameId,
+        sessionId: frame.sessionId,
+        routeHash: frame.routeHash,
+        publicSidecar: frame.publicSidecar,
+    };
+}
+export function unstable_attachPreviewRouteRenderContext(value, frame) {
+    if (!frame?.codedDocument)
+        return value;
+    return withPreviewProvenanceRouteRender(value, {
+        type: 'storystick.preview.route-render',
+        version: 1,
+        frame: {
+            type: 'storystick.preview.route-frame',
+            version: 1,
+            frameId: frame.frameId,
+            sessionId: frame.sessionId,
+            routeHash: frame.routeHash,
+            publicSidecar: frame.publicSidecar,
+        },
+        document: frame.codedDocument,
+    });
+}
+function planRouteDocumentPreviewProvenance(input) {
+    const materialized = materializePreviewProvenanceSourceMap({
+        queryResult: input.document,
+        manifest: input.manifest,
+        keyPrefix: `route:source:${storyTypeOf(input.document)}:${input.document.documentId}`,
+        sourceSetPrefix: 'route',
+        keyForEntry: routeDocumentKeyForSourceMapEntry,
+        presence: 'optional',
+    });
+    return materializedMarkPlan(normalizeRouteDocumentSourceMapLeaves(materialized.leaves), materialized);
+}
+function normalizeRouteDocumentSourceMapLeaves(leaves) {
+    return leaves.map((leaf) => {
+        const sectionAnchor = leaf.pathAnchors.find((anchor) => anchor.path === 'sections');
+        if (sectionAnchor === undefined)
+            return leaf;
+        const documentPart = safeSourceSetPart(leaf.documentId);
+        const sectionPrefix = `route_${documentPart}_sections_${safeSourceSetPart(sectionAnchor.key)}_`;
+        if (!leaf.sourceSetId.startsWith(sectionPrefix))
+            return leaf;
+        return {
+            ...leaf,
+            sourceSetId: `route_${documentPart}_${safeSourceSetPart(sectionAnchor.key)}_${leaf.sourceSetId.slice(sectionPrefix.length)}`,
+        };
+    });
+}
+function routeDocumentKeyForSourceMapEntry(entry, defaultKey) {
+    return routeSliceKeyForSourceMapEntry(entry) ?? documentKeyForSourceMapEntry(entry, defaultKey);
+}
+function routeSliceKeyForSourceMapEntry(entry) {
+    if (entry.resultPath[0] !== 'sections')
+        return null;
+    if (typeof entry.resultPath[1] !== 'number')
+        return null;
+    const sectionAnchor = entry.pathAnchors.find((anchor) => anchor.path === 'sections');
+    if (sectionAnchor === undefined)
+        return null;
+    const path = previewPathForSourceMapEntry(entry, 2);
+    if (path.length === 0)
+        return null;
+    return slicePathKey({ _key: sectionAnchor.key }, path);
+}
+function documentKeyForSourceMapEntry(entry, defaultKey) {
+    const path = previewPathForSourceMapEntry(entry, 0);
+    if (path.length === 0)
+        return defaultKey;
+    return documentPathKey({ documentId: entry.documentId }, path);
+}
+function previewPathForSourceMapEntry(entry, startIndex) {
+    const keyByArrayPath = new Map(entry.pathAnchors.map((anchor) => [anchor.path, anchor.key]));
+    const path = [];
+    for (let index = startIndex; index < entry.resultPath.length; index++) {
+        const part = entry.resultPath[index];
+        if (typeof part === 'number') {
+            path.push(fieldSegment(String(part)));
+            continue;
+        }
+        const next = entry.resultPath[index + 1];
+        if (typeof next === 'number') {
+            const arrayPath = formatPreviewProvenanceCanonicalPath(entry.resultPath.slice(0, index + 1));
+            const itemKey = keyByArrayPath.get(arrayPath);
+            if (itemKey !== undefined && itemKey.length > 0) {
+                path.push(arrayItemSegment(part, itemKey));
+                index += 1;
+                continue;
+            }
+        }
+        path.push(fieldSegment(part));
+    }
+    if (entry.textNodeIndex !== undefined) {
+        path.push(richTextTextNodeSegment(entry.textNodeIndex));
+    }
+    return path;
+}
+function previewPathForPathParts(relativePath, rootPath, pathAnchors) {
+    const keyByArrayPath = new Map(pathAnchors.map((anchor) => [anchor.path, anchor.key]));
+    const path = [];
+    for (let index = 0; index < relativePath.length; index++) {
+        const part = relativePath[index];
+        if (typeof part === 'number') {
+            path.push(fieldSegment(String(part)));
+            continue;
+        }
+        const next = relativePath[index + 1];
+        if (typeof next === 'number') {
+            const arrayPath = formatPreviewProvenanceCanonicalPath([
+                ...rootPath,
+                ...relativePath.slice(0, index + 1),
+            ]);
+            const itemKey = keyByArrayPath.get(arrayPath);
+            if (itemKey !== undefined && itemKey.length > 0) {
+                path.push(arrayItemSegment(part, itemKey));
+                index += 1;
+                continue;
+            }
+        }
+        path.push(fieldSegment(part));
+    }
+    return path;
+}
+function planContextDocumentPreviewProvenance(input) {
+    const plans = input.documents.map((document) => {
+        const materialized = materializePreviewProvenanceSourceMap({
+            queryResult: document,
+            manifest: input.manifest,
+            keyPrefix: `route:context:${storyTypeOf(document)}:${document.documentId}`,
+            sourceSetPrefix: `route_context_${safeSourceSetPart(storyTypeOf(document))}`,
+            keyForEntry: documentKeyForSourceMapEntry,
+            presence: 'optional',
+        });
+        const marks = materialized.leaves.filter((leaf) => leaf.sourceKind !== 'richtext' ||
+            input.richTextDocumentIds.has(document.documentId));
+        return materializedMarkPlan(marks, materialized, {
+            carrierSkipped: materialized.leaves.length - marks.length,
+        });
+    });
+    return mergeMaterializedMarkPlans(plans);
+}
+function collectReferencedContextDocumentIds(input) {
+    const documentById = new Map(input.contextDocuments.map((document) => [document.documentId, document]));
+    const selected = new Set();
+    const queue = [input.document];
+    for (let index = 0; index < queue.length; index++) {
+        for (const documentId of collectDocumentReferenceStrings(queue[index])) {
+            if (!documentById.has(documentId) || selected.has(documentId))
+                continue;
+            selected.add(documentId);
+            const referenced = documentById.get(documentId);
+            if (referenced !== undefined)
+                queue.push(referenced.fields);
+        }
+    }
+    return selected;
+}
+function collectDocumentReferenceStrings(root) {
+    const out = new Set();
+    const seen = new WeakSet();
+    const visit = (value, collectString) => {
+        if (typeof value === 'string') {
+            if (collectString)
+                out.add(value);
+            visitJsonString(value);
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item, false);
+            return;
+        }
+        if (!isRecord(value))
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        for (const [key, child] of Object.entries(value)) {
+            if (key.startsWith('__ssPreview'))
+                continue;
+            visit(child, true);
+        }
+    };
+    const visitJsonString = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+            return;
+        try {
+            visit(JSON.parse(trimmed), false);
+        }
+        catch {
+            // Non-JSON strings are ordinary content, not reference containers.
+        }
+    };
+    visit(root, false);
+    return [...out];
+}
+function collectSlicePlanningScopes(document) {
+    const fields = isRecord(document.fields) ? document.fields : {};
+    const sidecarByKey = richtextEmbedSidecarByKey(fields);
+    const sidecarIndexByKey = richtextEmbedSidecarIndexByKey(fields);
+    const zoneMappings = zoneMappingsSidecar(document);
+    const zoneTargetFields = collectActiveZoneTargetFields(fields, zoneMappings, sidecarByKey);
+    const scopes = [];
+    const addSliceZoneScope = (slices, sliceZonePath, sourceSliceZonePath, parentPathAnchors, sourceParentPathAnchors) => {
+        scopes.push({
+            slices,
+            sliceZonePath,
+            sourceSliceZonePath,
+            parentPathAnchors,
+            sourceParentPathAnchors,
+            sourceKind: 'sliceZone',
+            sidecarByKey,
+            sidecarIndexByKey,
+        });
+        const sliceZoneAnchorPath = formatPreviewProvenanceCanonicalPath(sliceZonePath);
+        const sourceSliceZoneAnchorPath = formatPreviewProvenanceCanonicalPath(sourceSliceZonePath);
+        for (let index = 0; index < slices.length; index++) {
+            const slice = slices[index];
+            if (!isRecord(slice))
+                continue;
+            const sliceType = typeof slice._type === 'string' ? slice._type : null;
+            const sliceKey = typeof slice._key === 'string' ? slice._key : null;
+            if (sliceType === null || sliceKey === null || sliceKey.length === 0) {
+                continue;
+            }
+            const childParentAnchors = [
+                ...parentPathAnchors,
+                { path: sliceZoneAnchorPath, key: sliceKey },
+            ];
+            const childSourceParentAnchors = [
+                ...sourceParentPathAnchors,
+                { path: sourceSliceZoneAnchorPath, key: sliceKey },
+            ];
+            const slicePath = [...sliceZonePath, index];
+            const mapping = zoneMappings[sliceType];
+            if (mapping !== undefined) {
+                for (const fieldPath of Object.values(mapping)) {
+                    const value = getFieldPathValue(fields, fieldPath);
+                    const zonePath = [...slicePath, fieldPath];
+                    const sourceZonePath = fieldPathParts(fields, fieldPath);
+                    if (isSliceArray(value)) {
+                        addSliceZoneScope(value, zonePath, sourceZonePath, childParentAnchors, []);
+                        continue;
+                    }
+                    const embeds = sliceEmbedsFromRichText(value, sidecarByKey);
+                    if (embeds.length > 0) {
+                        scopes.push({
+                            slices: embeds,
+                            sliceZonePath: zonePath,
+                            sourceSliceZonePath: sourceZonePath,
+                            parentPathAnchors: childParentAnchors,
+                            sourceParentPathAnchors: [],
+                            sourceKind: 'embed',
+                            sidecarByKey,
+                            sidecarIndexByKey,
+                        });
+                    }
+                }
+            }
+            for (const [field, value] of Object.entries(slice)) {
+                if (field.startsWith('_'))
+                    continue;
+                const embeds = sliceEmbedsFromRichText(value, sidecarByKey);
+                if (embeds.length === 0)
+                    continue;
+                scopes.push({
+                    slices: embeds,
+                    sliceZonePath: [...slicePath, field],
+                    sourceSliceZonePath: [...sourceSliceZonePath, index, field],
+                    parentPathAnchors: childParentAnchors,
+                    sourceParentPathAnchors: childSourceParentAnchors,
+                    sourceKind: 'embed',
+                    sidecarByKey,
+                    sidecarIndexByKey,
+                });
+            }
+        }
+    };
+    for (const [field, value] of Object.entries(fields)) {
+        if (zoneTargetFields.has(field))
+            continue;
+        if (isSliceArray(value)) {
+            addSliceZoneScope(value, [field], [field], [], []);
+            continue;
+        }
+        if (field === RICHTEXT_EMBED_STORE_FIELD)
+            continue;
+        const embeds = sliceEmbedsFromRichText(value, sidecarByKey);
+        if (embeds.length > 0) {
+            scopes.push({
+                slices: embeds,
+                sliceZonePath: [field],
+                sourceSliceZonePath: [field],
+                parentPathAnchors: [],
+                sourceParentPathAnchors: [],
+                sourceKind: 'embed',
+                sidecarByKey,
+                sidecarIndexByKey,
+            });
+        }
+    }
+    return scopes;
+}
+export function unstable_collectPreviewRouteDocumentSliceTypes(document) {
+    const out = new Set();
+    for (const scope of collectSlicePlanningScopes(document)) {
+        for (const slice of scope.slices) {
+            if (!isRecord(slice))
+                continue;
+            const sliceType = slice._type;
+            if (typeof sliceType === 'string' && sliceType.length > 0) {
+                out.add(sliceType);
+            }
+        }
+    }
+    return out;
+}
+function zoneMappingsSidecar(document) {
+    const mappings = document._zoneMappings;
+    if (!isRecord(mappings))
+        return {};
+    const out = {};
+    for (const [sliceType, mapping] of Object.entries(mappings)) {
+        if (!isRecord(mapping))
+            continue;
+        const fields = {};
+        for (const [zoneName, fieldPath] of Object.entries(mapping)) {
+            if (typeof fieldPath === 'string' && fieldPath.length > 0) {
+                fields[zoneName] = fieldPath;
+            }
+        }
+        if (Object.keys(fields).length > 0)
+            out[sliceType] = fields;
+    }
+    return out;
+}
+function collectActiveZoneTargetFields(fields, mappings, sidecarByKey) {
+    const out = new Set();
+    const visitSlices = (slices) => {
+        for (const slice of slices) {
+            if (!isRecord(slice))
+                continue;
+            const sliceType = typeof slice._type === 'string' ? slice._type : null;
+            const mapping = sliceType === null ? undefined : mappings[sliceType];
+            if (mapping !== undefined) {
+                for (const fieldPath of Object.values(mapping))
+                    out.add(fieldPath);
+            }
+            for (const value of Object.values(slice)) {
+                if (isSliceArray(value))
+                    visitSlices(value);
+            }
+        }
+    };
+    for (const value of Object.values(fields)) {
+        if (isSliceArray(value)) {
+            visitSlices(value);
+            continue;
+        }
+        const embeds = sliceEmbedsFromRichText(value, sidecarByKey);
+        if (embeds.length > 0)
+            visitSlices(embeds);
+    }
+    return out;
+}
+function isSliceArray(value) {
+    return Array.isArray(value) && value.some(isSliceLike);
+}
+function isSliceLike(value) {
+    return (isRecord(value) &&
+        typeof value._type === 'string' &&
+        typeof value._key === 'string');
+}
+function getFieldPathValue(fields, fieldPath) {
+    if (Object.prototype.hasOwnProperty.call(fields, fieldPath)) {
+        return fields[fieldPath];
+    }
+    let cursor = fields;
+    for (const segment of fieldPath.split('.')) {
+        if (!isRecord(cursor))
+            return undefined;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+function fieldPathParts(fields, fieldPath) {
+    if (Object.prototype.hasOwnProperty.call(fields, fieldPath)) {
+        return [fieldPath];
+    }
+    return fieldPath.split('.');
+}
+function richtextEmbedSidecarByKey(fields) {
+    const result = new Map();
+    const raw = fields[RICHTEXT_EMBED_STORE_FIELD];
+    if (!Array.isArray(raw))
+        return result;
+    for (const record of raw) {
+        if (isRecord(record) &&
+            typeof record._key === 'string' &&
+            record._key.length > 0 &&
+            !result.has(record._key)) {
+            result.set(record._key, record);
+        }
+    }
+    return result;
+}
+function richtextEmbedSidecarIndexByKey(fields) {
+    const result = new Map();
+    const raw = fields[RICHTEXT_EMBED_STORE_FIELD];
+    if (!Array.isArray(raw))
+        return result;
+    raw.forEach((record, index) => {
+        if (isRecord(record) &&
+            typeof record._key === 'string' &&
+            record._key.length > 0 &&
+            !result.has(record._key)) {
+            result.set(record._key, index);
+        }
+    });
+    return result;
+}
+function sliceEmbedsFromRichText(value, sidecarByKey = new Map()) {
+    const root = parseRichTextRoot(value);
+    if (!isRecord(root))
+        return [];
+    const embeds = [];
+    const visit = (node, index) => {
+        if (!isRecord(node))
+            return;
+        if (node.type === 'sliceEmbed') {
+            const attrs = isRecord(node.attrs) ? node.attrs : {};
+            const embedType = attrs._type;
+            if (typeof embedType === 'string' && embedType.length > 0) {
+                const embedKey = typeof attrs._key === 'string' ? attrs._key : `rt-${index}`;
+                const sidecar = sidecarByKey.get(embedKey);
+                const data = isRecord(attrs.data)
+                    ? attrs.data
+                    : sidecar ?? {};
+                embeds.push({
+                    _type: embedType,
+                    _key: embedKey,
+                    ...(typeof attrs._variation === 'string'
+                        ? { _variation: attrs._variation }
+                        : {}),
+                    ...data,
+                });
+            }
+        }
+        const content = node.content;
+        if (!Array.isArray(content))
+            return;
+        for (let childIndex = 0; childIndex < content.length; childIndex++) {
+            visit(content[childIndex], childIndex);
+        }
+    };
+    visit(root, 0);
+    return embeds;
+}
+function parseRichTextRoot(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.startsWith('{'))
+            return null;
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return null;
+        }
+    }
+    return value;
+}
+function planPreviewProvenanceBoundSliceZoneTextLeaves(input) {
+    const fieldBindings = fieldBindingsSidecar(input.document, input.fieldBindingsFallback);
+    if (fieldBindings === null)
+        return [];
+    const sourceIdentity = previewProvenanceSourceIdentityFromQueryResult(input.document);
+    const leaves = [];
+    const sliceZoneAnchorPath = formatPreviewProvenanceCanonicalPath(input.sliceZonePath);
+    for (let index = 0; index < input.slices.length; index++) {
+        const slice = input.slices[index];
+        if (!isRecord(slice))
+            continue;
+        const sliceType = typeof slice._type === 'string' ? slice._type : null;
+        const sliceKey = typeof slice._key === 'string' ? slice._key : null;
+        if (sliceType === null || sliceKey === null || sliceKey.length === 0) {
+            continue;
+        }
+        const bindings = fieldBindingsForSlice(fieldBindings, sliceType, slice._variation);
+        if (bindings === undefined)
+            continue;
+        for (const [sliceField, ref] of Object.entries(bindings)) {
+            if (!isDocPathBindingRef(ref))
+                continue;
+            if (slice[sliceField] !== undefined)
+                continue;
+            const renderedValue = getValueByPath(input.document.fields, ref.path);
+            const richTextNodes = previewProvenanceRichTextTextNodes(renderedValue);
+            const pathAnchors = [
+                ...(input.parentPathAnchors ?? []),
+                { path: sliceZoneAnchorPath, key: sliceKey },
+            ];
+            if (richTextNodes.length > 0) {
+                for (let textNodeIndex = 0; textNodeIndex < richTextNodes.length; textNodeIndex++) {
+                    const renderedText = richTextNodes[textNodeIndex];
+                    if (!renderedText)
+                        continue;
+                    leaves.push({
+                        key: slicePathKey({ _key: sliceKey }, [
+                            fieldSegment(sliceField),
+                            richTextTextNodeSegment(textNodeIndex),
+                        ]),
+                        ...sourceIdentity,
+                        canonicalPath: ref.path,
+                        pathAnchors,
+                        sourceKind: 'binding',
+                        sourceSetId: `route_${safeSourceSetPart(sliceKey)}_${safeSourceSetPart(sliceField)}_richtext_${textNodeIndex}`,
+                        outputKind: 'text',
+                        modality: 'text',
+                        anchorKind: 'element',
+                        renderedText,
+                        codedTextPath: ['fields', ...ref.path.split('.')],
+                        codedRichTextTextNodeIndex: textNodeIndex,
+                        presence: 'optional',
+                    });
+                }
+                continue;
+            }
+            if (typeof renderedValue !== 'string' || renderedValue.length === 0) {
+                continue;
+            }
+            leaves.push({
+                key: sliceFieldKey({ _key: sliceKey }, sliceField),
+                ...sourceIdentity,
+                canonicalPath: ref.path,
+                pathAnchors,
+                sourceKind: 'binding',
+                sourceSetId: `route_${safeSourceSetPart(sliceKey)}_${safeSourceSetPart(sliceField)}`,
+                outputKind: 'text',
+                modality: 'text',
+                anchorKind: 'element',
+                renderedText: renderedValue,
+                presence: 'optional',
+            });
+        }
+    }
+    return leaves;
+}
+function planPreviewProvenanceModelSliceZoneTextLeaves(input) {
+    const models = modelSidecar(input.document);
+    if (models === null)
+        return [];
+    const codedModels = modelSidecar(input.codedDocument);
+    const fieldBindings = fieldBindingsSidecar(input.document, input.fieldBindingsFallback) ?? {};
+    const leaves = [];
+    const sliceZoneAnchorPath = formatPreviewProvenanceCanonicalPath(input.sliceZonePath);
+    for (let index = 0; index < input.slices.length; index++) {
+        const slice = input.slices[index];
+        if (!isRecord(slice))
+            continue;
+        const sliceType = typeof slice._type === 'string' ? slice._type : null;
+        const sliceKey = typeof slice._key === 'string' ? slice._key : null;
+        const modelId = typeof slice._model === 'string' ? slice._model : null;
+        if (sliceType === null ||
+            sliceKey === null ||
+            sliceKey.length === 0 ||
+            modelId === null ||
+            modelId.length === 0) {
+            continue;
+        }
+        const refPath = modelRefPath(input.sliceZonePath, index);
+        const modelValues = modelValuesForSlice(models, modelId, refPath);
+        if (!isRecord(modelValues))
+            continue;
+        const codedModelValues = codedModels === null ? null : modelValuesForSlice(codedModels, modelId, refPath);
+        const bindings = fieldBindingsForSlice(fieldBindings, sliceType, slice._variation) ?? {};
+        for (const [modelField, renderedText] of Object.entries(modelValues)) {
+            if (Object.prototype.hasOwnProperty.call(bindings, modelField))
+                continue;
+            if (slice[modelField] !== undefined)
+                continue;
+            if (typeof renderedText !== 'string' || renderedText.length === 0) {
+                continue;
+            }
+            if (previewProvenanceRichTextTextNodes(renderedText).length > 0) {
+                continue;
+            }
+            if (!modelFieldMatchesManifest({
+                manifest: input.manifest,
+                sliceType,
+                field: modelField,
+                value: renderedText,
+            })) {
+                continue;
+            }
+            leaves.push({
+                key: sliceFieldKey({ _key: sliceKey }, modelField),
+                documentId: modelId,
+                readScope: modelReadScopeForSlice({
+                    document: input.document,
+                    sidecar: models,
+                    modelId,
+                    refPath,
+                }),
+                canonicalPath: modelField,
+                pathAnchors: [
+                    ...(input.parentPathAnchors ?? []),
+                    { path: sliceZoneAnchorPath, key: sliceKey },
+                ],
+                sourceKind: 'model',
+                sourceSetId: `route_${safeSourceSetPart(sliceKey)}_${safeSourceSetPart(modelField)}`,
+                outputKind: 'text',
+                modality: 'text',
+                anchorKind: 'element',
+                renderedText,
+                codedTextPath: [modelField],
+                codedTextRoot: codedModelValues ?? undefined,
+                presence: 'optional',
+            });
+        }
+    }
+    return leaves;
+}
+function planPreviewProvenanceEmbedSliceTextLeaves(input) {
+    const leaves = [];
+    const sliceZoneAnchorPath = formatPreviewProvenanceCanonicalPath(input.sliceZonePath);
+    const sourceSliceZoneAnchorPath = formatPreviewProvenanceCanonicalPath(input.sourceSliceZonePath);
+    for (let index = 0; index < input.slices.length; index++) {
+        const slice = input.slices[index];
+        if (!isRecord(slice))
+            continue;
+        const sliceType = typeof slice._type === 'string' ? slice._type : null;
+        const sliceKey = typeof slice._key === 'string' ? slice._key : null;
+        if (sliceType === null || sliceKey === null || sliceKey.length === 0) {
+            continue;
+        }
+        const rootPath = [...input.sliceZonePath, index];
+        const sourceRootPath = [...input.sourceSliceZonePath, index];
+        const codedRootPath = ['fields', ...input.sourceSliceZonePath, index];
+        const pathAnchors = [
+            ...(input.parentPathAnchors ?? []),
+            { path: sliceZoneAnchorPath, key: sliceKey },
+        ];
+        const navigationBaseAnchors = [
+            ...(input.sourceParentPathAnchors ?? []),
+            { path: sourceSliceZoneAnchorPath, key: sliceKey },
+        ];
+        const match = createPreviewProvenanceEditableManifestMatcher(input.manifest, sliceType);
+        for (const candidate of planPreviewProvenanceEditableTextLeaves({
+            documentId: input.document.documentId,
+            root: slice,
+            rootPath,
+            pathAnchors,
+            keyPrefix: `route:embed:${safeSourceSetPart(sliceKey)}`,
+            sourceSetPrefix: `route_${safeSourceSetPart(sliceKey)}_embed`,
+            presence: 'optional',
+            match,
+        })) {
+            const navigationPath = formatPreviewProvenanceCanonicalPath([
+                ...sourceRootPath,
+                ...candidate.path,
+            ]);
+            const navigationAnchors = remapEmbedLeafNavigationAnchors({
+                renderRootPath: rootPath,
+                sourceRootPath,
+                renderPathAnchors: candidate.leaf.pathAnchors,
+                navigationBaseAnchors,
+            });
+            const previewPath = previewPathForPathParts(candidate.path, rootPath, candidate.leaf.pathAnchors);
+            const keyedPath = candidate.leaf.codedRichTextTextNodeIndex === undefined
+                ? previewPath
+                : [
+                    ...previewPath,
+                    richTextTextNodeSegment(candidate.leaf.codedRichTextTextNodeIndex),
+                ];
+            const storageAddress = embedStorageAddress({
+                sliceKey,
+                rootPath,
+                relativePath: candidate.path,
+                candidateAnchors: candidate.leaf.pathAnchors,
+            });
+            const sidecarIndex = input.sidecarIndexByKey.get(sliceKey);
+            leaves.push({
+                ...candidate.leaf,
+                key: slicePathKey({ _key: sliceKey }, keyedPath),
+                canonicalPath: storageAddress.canonicalPath,
+                pathAnchors: storageAddress.pathAnchors,
+                codedTextPath: sidecarIndex === undefined
+                    ? [...codedRootPath, ...candidate.path]
+                    : [
+                        'fields',
+                        RICHTEXT_EMBED_STORE_FIELD,
+                        sidecarIndex,
+                        ...candidate.path,
+                    ],
+                navigationPath,
+                navigationAnchors,
+                sourceKind: 'embed',
+            });
+        }
+        for (const [field, value] of Object.entries(slice)) {
+            if (field.startsWith('_'))
+                continue;
+            const embeds = sliceEmbedsFromRichText(value, input.sidecarByKey);
+            if (embeds.length === 0)
+                continue;
+            leaves.push(...planPreviewProvenanceEmbedSliceTextLeaves({
+                document: input.document,
+                slices: embeds,
+                sliceZonePath: [...rootPath, field],
+                sourceSliceZonePath: [...input.sourceSliceZonePath, index, field],
+                parentPathAnchors: pathAnchors,
+                sourceParentPathAnchors: navigationBaseAnchors,
+                sidecarByKey: input.sidecarByKey,
+                sidecarIndexByKey: input.sidecarIndexByKey,
+                manifest: input.manifest,
+            }));
+        }
+    }
+    return leaves;
+}
+function richtextEmbedKeySelector(key) {
+    return formatRichtextEmbedFieldPath(key).slice(RICHTEXT_EMBED_STORE_FIELD.length);
+}
+function embedStorageAddress(input) {
+    let canonicalPath = formatRichtextEmbedFieldPath(input.sliceKey);
+    const pathAnchors = [
+        { path: RICHTEXT_EMBED_STORE_FIELD, key: input.sliceKey },
+    ];
+    const traversed = [...input.rootPath];
+    for (const part of input.relativePath) {
+        if (typeof part === 'string') {
+            canonicalPath += `.${part}`;
+            traversed.push(part);
+            continue;
+        }
+        const sourceArrayPath = formatPreviewProvenanceCanonicalPath(traversed);
+        const anchor = input.candidateAnchors.find((candidate) => candidate.path === sourceArrayPath);
+        if (anchor) {
+            pathAnchors.push({ path: canonicalPath, key: anchor.key });
+            canonicalPath += richtextEmbedKeySelector(anchor.key);
+        }
+        else {
+            canonicalPath += `[${part}]`;
+        }
+        traversed.push(part);
+    }
+    return { canonicalPath, pathAnchors };
+}
+function remapEmbedLeafNavigationAnchors(input) {
+    const renderRootPath = formatPreviewProvenanceCanonicalPath(input.renderRootPath);
+    const sourceRootPath = formatPreviewProvenanceCanonicalPath(input.sourceRootPath);
+    const out = [...input.navigationBaseAnchors];
+    const seen = new Set(out.map((anchor) => `${anchor.path}\u0000${anchor.key}`));
+    for (const anchor of input.renderPathAnchors) {
+        if (anchor.path !== renderRootPath &&
+            !anchor.path.startsWith(`${renderRootPath}.`)) {
+            continue;
+        }
+        const path = `${sourceRootPath}${anchor.path.slice(renderRootPath.length)}`;
+        const signature = `${path}\u0000${anchor.key}`;
+        if (seen.has(signature))
+            continue;
+        seen.add(signature);
+        out.push({ path, key: anchor.key });
+    }
+    return out;
+}
+function modelFieldMatchesManifest(input) {
+    return (input.manifest[input.sliceType] ?? []).some((pattern) => previewProvenanceEditableTextPathPatternMatches({
+        path: [input.field],
+        fieldName: input.field,
+        value: input.value,
+        sourceKind: 'stored',
+        outputKind: 'text',
+    }, pattern));
+}
+function modelIdsFromRouteDocument(document) {
+    const ids = new Set();
+    for (const documentId of modelIdsFromSidecar(document))
+        ids.add(documentId);
+    for (const documentId of modelIdsFromModelRefs(document.fields))
+        ids.add(documentId);
+    return [...ids];
+}
+function modelIdsFromSidecar(document) {
+    const models = modelSidecar(document);
+    if (models === null)
+        return [];
+    const ids = new Set();
+    const byId = models.byId;
+    if (isRecord(byId)) {
+        for (const [modelId, value] of Object.entries(byId)) {
+            if (isRecord(value))
+                ids.add(modelId);
+        }
+    }
+    if (isRecord(models.unresolved)) {
+        for (const failure of Object.values(models.unresolved)) {
+            if (isRecord(failure) && typeof failure.modelId === 'string')
+                ids.add(failure.modelId);
+        }
+    }
+    return [...ids];
+}
+function modelIdsFromModelRefs(root) {
+    const ids = new Set();
+    const seen = new WeakSet();
+    const visit = (value) => {
+        if (typeof value === 'string') {
+            visitJsonString(value);
+            return;
+        }
+        if (!isRecord(value) && !Array.isArray(value))
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        const modelId = value._model;
+        if (typeof modelId === 'string' && modelId.length > 0) {
+            ids.add(modelId);
+        }
+        for (const child of Object.values(value))
+            visit(child);
+    };
+    const visitJsonString = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+            return;
+        try {
+            visit(JSON.parse(trimmed));
+        }
+        catch {
+            // Non-JSON strings are ordinary field content, not model-reference containers.
+        }
+    };
+    visit(root);
+    return [...ids];
+}
+function routeDocumentFrameDependencies(input) {
+    const routeStoryType = storyTypeOf(input.document);
+    return [
+        ...(input.pathname === undefined ? [] : [{
+                kind: 'route-lookup',
+                pathname: input.pathname,
+                ...(routeStoryType === 'unknown' ? {} : { storyTypes: [routeStoryType] }),
+            }]),
+        {
+            kind: 'document',
+            documentId: input.document.documentId,
+            ...(routeStoryType === 'unknown' ? {} : { storyType: routeStoryType }),
+            reason: input.pathname === undefined ? 'rendered-document' : 'route-document',
+        },
+        ...input.modelDocumentIds.map((documentId) => ({
+            kind: 'document',
+            documentId,
+            reason: 'model-document',
+        })),
+        ...input.contextDocuments.map((document) => ({
+            kind: 'document',
+            documentId: document.documentId,
+            ...(storyTypeOf(document) === 'unknown'
+                ? {}
+                : { storyType: storyTypeOf(document) }),
+            reason: 'context-document',
+        })),
+        ...input.extraDependencies,
+    ];
+}
+function modelSidecar(document) {
+    const sidecar = document._models;
+    return isRecord(sidecar) ? sidecar : null;
+}
+function modelValuesForSlice(sidecar, modelId, refPath) {
+    if (isRecord(sidecar.unresolved) && isRecord(sidecar.unresolved[refPath]))
+        return null;
+    const byRef = sidecar.byRef;
+    if (isRecord(byRef)) {
+        const byRefEntry = byRef[refPath];
+        if (isRecord(byRefEntry))
+            return byRefEntry;
+    }
+    const byId = sidecar.byId;
+    if (isRecord(byId)) {
+        const byIdEntry = byId[modelId];
+        if (isRecord(byIdEntry))
+            return byIdEntry;
+    }
+    return null;
+}
+function modelReadScopeForSlice(input) {
+    const hostScope = previewReadScopeEchoFromQueryResult(input.document);
+    if (hostScope === undefined)
+        return undefined;
+    const byRef = input.sidecar.scopeByRef;
+    const byId = input.sidecar.scopeById;
+    const modelScope = (isRecord(byRef) && isRecord(byRef[input.refPath])
+        ? byRef[input.refPath]
+        : null) ??
+        (isRecord(byId) && isRecord(byId[input.modelId])
+            ? byId[input.modelId]
+            : null);
+    const releaseMemberState = modelScope?.releaseMemberState;
+    return {
+        requestedVariantId: hostScope.requestedVariantId,
+        requestedDocumentId: hostScope.requestedDocumentId,
+        ...(typeof modelScope?.requestedLocale === 'string'
+            ? { requestedLocale: modelScope.requestedLocale }
+            : hostScope.requestedLocale !== undefined
+                ? { requestedLocale: hostScope.requestedLocale }
+                : {}),
+        ...(typeof modelScope?.appliedLocale === 'string'
+            ? { appliedLocale: modelScope.appliedLocale }
+            : {}),
+        appliesToDocument: hostScope.requestedDocumentId === null
+            ? null
+            : hostScope.requestedDocumentId === input.modelId,
+        // Variants are document-bound; a host variant never scopes a referenced
+        // model merely because that model supplied the painted value.
+        appliedVariantId: hostScope.requestedDocumentId === input.modelId
+            ? hostScope.appliedVariantId
+            : null,
+        requestedReleaseId: hostScope.requestedReleaseId,
+        releaseScopeStatus: hostScope.releaseScopeStatus,
+        ...(hostScope.releaseLifecycleStatus !== undefined
+            ? { releaseLifecycleStatus: hostScope.releaseLifecycleStatus }
+            : {}),
+        appliedReleaseId: typeof modelScope?.appliedReleaseId === 'string'
+            ? modelScope.appliedReleaseId
+            : null,
+        ...(releaseMemberState === 'active' ||
+            releaseMemberState === 'archived' ||
+            releaseMemberState === 'missing' ||
+            releaseMemberState === 'locale-removed'
+            ? { releaseMemberState }
+            : {}),
+        ...(releaseMemberState === 'archived' ||
+            releaseMemberState === 'missing' ||
+            releaseMemberState === 'locale-removed'
+            ? { degradedReason: releaseMemberState }
+            : {}),
+    };
+}
+function modelRefPath(sliceZonePath, index) {
+    return `${formatModelRefBasePath(sliceZonePath)}[${index}]._model`;
+}
+function formatModelRefBasePath(pathSegments) {
+    let out = '';
+    for (const segment of pathSegments) {
+        if (typeof segment === 'number') {
+            out += `[${segment}]`;
+            continue;
+        }
+        out += out.length === 0 ? segment : `.${segment}`;
+    }
+    return out;
+}
+function fieldBindingsSidecar(document, fallback) {
+    const sidecar = document
+        ._fieldBindings;
+    const runtimeBindings = isRecord(sidecar)
+        ? sidecar
+        : null;
+    if (fallback) {
+        return mergeFieldBindings(fallback, runtimeBindings ?? {});
+    }
+    return runtimeBindings;
+}
+function mergeFieldBindings(fallback, runtime) {
+    const out = { ...fallback, ...runtime };
+    for (const sliceType of new Set([
+        ...Object.keys(fallback),
+        ...Object.keys(runtime),
+    ])) {
+        const fallbackEntry = fallback[sliceType];
+        const runtimeEntry = runtime[sliceType];
+        if (!fallbackEntry && !runtimeEntry)
+            continue;
+        out[sliceType] = {
+            base: {
+                ...(fallbackEntry?.base ?? {}),
+                ...(runtimeEntry?.base ?? {}),
+            },
+            variations: mergeVariationBindings(fallbackEntry?.variations ?? {}, runtimeEntry?.variations ?? {}),
+        };
+    }
+    return out;
+}
+function mergeVariationBindings(fallback, runtime) {
+    const out = {};
+    for (const variationId of new Set([
+        ...Object.keys(fallback),
+        ...Object.keys(runtime),
+    ])) {
+        out[variationId] = {
+            ...(fallback[variationId] ?? {}),
+            ...(runtime[variationId] ?? {}),
+        };
+    }
+    return out;
+}
+function fieldBindingsForSlice(sidecar, sliceType, variation) {
+    const surfaces = sidecar[sliceType];
+    if (!surfaces)
+        return undefined;
+    if (variation === undefined)
+        return surfaces.base;
+    if (typeof variation !== 'string')
+        return undefined;
+    return surfaces.variations[variation];
+}
+function isDocPathBindingRef(value) {
+    return (isRecord(value) &&
+        value.kind === 'docPath' &&
+        typeof value.path === 'string' &&
+        value.path.length > 0);
+}
+function getValueByPath(root, path) {
+    if (!isRecord(root))
+        return null;
+    let cursor = root;
+    for (const segment of path.split('.')) {
+        if (!isRecord(cursor))
+            return null;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+function emptyMaterializedMarkPlan() {
+    return {
+        marks: [],
+        sourceMapEntries: 0,
+        skipped: {
+            manifestIneligible: 0,
+            nonIdentityDerivation: 0,
+        },
+        carrierSkipped: 0,
+    };
+}
+function materializedMarkPlan(marks, materialized, options = {}) {
+    return {
+        marks,
+        sourceMapEntries: materialized.sourceMapEntries,
+        skipped: materialized.skipped,
+        carrierSkipped: options.carrierSkipped ?? 0,
+    };
+}
+function mergeMaterializedMarkPlans(plans) {
+    if (plans.length === 0)
+        return emptyMaterializedMarkPlan();
+    return {
+        marks: plans.flatMap((plan) => plan.marks),
+        sourceMapEntries: sum(plans, (plan) => plan.sourceMapEntries),
+        skipped: {
+            manifestIneligible: sum(plans, (plan) => plan.skipped.manifestIneligible),
+            nonIdentityDerivation: sum(plans, (plan) => plan.skipped.nonIdentityDerivation),
+        },
+        carrierSkipped: sum(plans, (plan) => plan.carrierSkipped),
+    };
+}
+function summarizeMaterializedMarkPlans(plans) {
+    return {
+        entries: sum(plans, (plan) => plan.sourceMapEntries),
+        manifestIneligible: sum(plans, (plan) => plan.skipped.manifestIneligible),
+        nonIdentityDerivation: sum(plans, (plan) => plan.skipped.nonIdentityDerivation),
+        carrierSkipped: sum(plans, (plan) => plan.carrierSkipped),
+    };
+}
+function sum(values, valueOf) {
+    let total = 0;
+    for (const value of values)
+        total += valueOf(value);
+    return total;
+}
+function collectCodedTextRootsByDocumentId(...rootsToScan) {
+    const roots = new Map();
+    for (const root of rootsToScan) {
+        for (const document of collectPreviewProvenanceSourceMappedQueryResults(root)) {
+            // Prefer the route document and its canonical `byId` sidecar carrier.
+            // A matching page-data query result is still used for planning, but the
+            // SDK resolver renders the sidecar entry and that is where coded text
+            // must be materialized.
+            if (!roots.has(document.documentId)) {
+                roots.set(document.documentId, document);
+            }
+        }
+    }
+    return roots;
+}
+function uniqueQueryResultsByDocumentId(documents) {
+    const out = new Map();
+    for (const document of documents)
+        out.set(document.documentId, document);
+    return [...out.values()];
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function safeSourceSetPart(value) {
+    return value.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'field';
+}
+function storyTypeOf(document) {
+    return typeof document.storyType === 'string' && document.storyType.length > 0
+        ? document.storyType
+        : 'unknown';
+}