@agent-native/creative-context 0.1.0

package/dist/connectors/google-slides.js

@@ -0,0 +1,896 @@
+import { createHash } from "node:crypto";
+import { cropImageRegion } from "@agent-native/core/ingestion";
+import { creativeContextMediaUrl } from "../media-url.js";
+import { compileGoogleSlidesPresentation, } from "./google-slides-native.js";
+import { collectProviderText, normalizeContextItem } from "./normalize.js";
+import { fetchRemoteArtifact, rehostRemoteMedia, storePrivateArtifact, } from "./private-artifacts.js";
+import { asRecord, connectorConnectionId, cursorOffset, executeConnectorProviderRequest, isContextConnectorQuotaError, positiveLimit, stringArray, stringValue, } from "./provider-response.js";
+const SLIDES_MIME_TYPE = "application/vnd.google-apps.presentation";
+export const GOOGLE_SLIDES_CONTEXT_OAUTH_SCOPES = [
+    "https://www.googleapis.com/auth/drive.metadata.readonly",
+    "https://www.googleapis.com/auth/presentations.readonly",
+];
+export class GoogleSlidesContextConnector {
+    kind = "google-slides";
+    label = "Google Slides";
+    supportsIncremental = true;
+    verifiesContainerOwner(input) {
+        const selectedIds = [...new Set(stringArray(input.config.presentationIds))];
+        if (selectedIds.length === 0 ||
+            input.inventory.length !== selectedIds.length) {
+            return false;
+        }
+        const inventoryById = new Map(input.inventory.map((item) => [item.externalId, item]));
+        return selectedIds.every((externalId) => {
+            const metadata = asRecord(inventoryById.get(externalId)?.metadata);
+            const accessSignals = asRecord(metadata?.accessSignals);
+            return accessSignals?.ownedByMe === true;
+        });
+    }
+    async inventory(request, context) {
+        const connectionId = await connectorConnectionId("google_drive", request.config, context.resolveConnection);
+        const limit = positiveLimit(request.limit, 100, 1_000);
+        const presentationIds = stringArray(request.config.presentationIds);
+        if (presentationIds.length > 0) {
+            const offset = cursorOffset(request.cursor);
+            const selected = presentationIds.slice(offset, offset + limit);
+            const items = (await Promise.all(selected.map(async (presentationId) => {
+                const file = asRecord(await executeConnectorProviderRequest(context.providerApi, {
+                    provider: "google_drive",
+                    method: "GET",
+                    path: `/files/${encodeURIComponent(presentationId)}`,
+                    query: {
+                        fields: "id,name,mimeType,modifiedTime,webViewLink,size,parents,driveId,ownedByMe,shared,copyRequiresWriterPermission,capabilities(canCopy,canDownload,canShare),permissions(type,role,allowFileDiscovery,deleted,pendingOwner)",
+                    },
+                    connectionId,
+                    accountId: stringValue(request.config.accountId),
+                }));
+                return file ? googleDriveFileInventoryItem(file) : null;
+            }))).filter((item) => item !== null);
+            const nextOffset = offset + selected.length;
+            const nextCursor = nextOffset < presentationIds.length ? String(nextOffset) : null;
+            return {
+                items,
+                nextCursor,
+                complete: !nextCursor,
+                coverage: {
+                    inspected: selected.length,
+                    returned: items.length,
+                    truncated: Boolean(nextCursor),
+                },
+            };
+        }
+        const folderId = stringValue(request.config.folderId) ??
+            googleDriveContainerIdFromUrl(request.config.folderUrl, "folder");
+        const sharedDriveId = stringValue(request.config.sharedDriveId) ??
+            googleDriveContainerIdFromUrl(request.config.sharedDriveUrl, "shared drive");
+        if (!folderId && !sharedDriveId) {
+            throw new Error("Google Slides connector config requires presentationIds, folderId, or sharedDriveId. Recent-file suggestions are not an import boundary until confirmed as presentationIds.");
+        }
+        const q = [
+            `mimeType = '${SLIDES_MIME_TYPE}'`,
+            "trashed = false",
+            ...(folderId ? [`'${escapeDriveQuery(folderId)}' in parents`] : []),
+        ].join(" and ");
+        const payload = asRecord(await executeConnectorProviderRequest(context.providerApi, {
+            provider: "google_drive",
+            method: "GET",
+            path: "/files",
+            query: {
+                q,
+                pageSize: Math.min(limit, 1_000),
+                ...(request.cursor ? { pageToken: request.cursor } : {}),
+                fields: "nextPageToken,files(id,name,mimeType,modifiedTime,webViewLink,size,parents,driveId,ownedByMe,shared,copyRequiresWriterPermission,capabilities(canCopy,canDownload,canShare),permissions(type,role,allowFileDiscovery,deleted,pendingOwner))",
+                orderBy: "modifiedTime desc",
+                ...(sharedDriveId
+                    ? {
+                        corpora: "drive",
+                        driveId: sharedDriveId,
+                        includeItemsFromAllDrives: true,
+                        supportsAllDrives: true,
+                    }
+                    : {}),
+            },
+            connectionId,
+            accountId: stringValue(request.config.accountId),
+        }));
+        const files = Array.isArray(payload?.files) ? payload.files : [];
+        const items = files.flatMap((value) => {
+            const file = asRecord(value);
+            const id = stringValue(file?.id);
+            if (!file || !id)
+                return [];
+            const item = googleDriveFileInventoryItem(file);
+            return item ? [item] : [];
+        });
+        const nextCursor = stringValue(payload?.nextPageToken) ?? null;
+        return {
+            items,
+            nextCursor,
+            complete: !nextCursor,
+            coverage: {
+                inspected: files.length,
+                returned: items.length,
+                truncated: Boolean(nextCursor),
+            },
+        };
+    }
+    async fetch(request, context) {
+        const connectionId = await connectorConnectionId("google_drive", request.config, context.resolveConnection);
+        if (!connectionId) {
+            throw new Error("Google Slides imports require a granted Google Drive workspace connection.");
+        }
+        const presentation = asRecord(await executeConnectorProviderRequest(context.providerApi, {
+            provider: "google_slides",
+            method: "GET",
+            path: `/presentations/${encodeURIComponent(request.item.externalId)}`,
+            query: {
+                fields: "presentationId,title,locale,revisionId,pageSize,slides,masters,layouts,notesMaster",
+            },
+            connectionId,
+            accountId: stringValue(request.config.accountId),
+            maxBytes: 4 * 1024 * 1024,
+        }));
+        if (!presentation) {
+            throw new Error(`Google Slides presentation ${request.item.externalId} returned no data.`);
+        }
+        const pageSize = asRecord(presentation.pageSize);
+        const pageWidth = googleDimensionToPx(asRecord(pageSize?.width)) || 960;
+        const pageHeight = googleDimensionToPx(asRecord(pageSize?.height)) || 540;
+        const thumbnailCache = new Map();
+        const revisionId = stringValue(presentation.revisionId);
+        const sourceVersion = revisionId ??
+            request.item.sourceModifiedAt ??
+            `snapshot-${createHash("sha256")
+                .update(JSON.stringify(presentation))
+                .digest("hex")
+                .slice(0, 24)}`;
+        const assetCache = new Map();
+        const compiledSlides = await compileGoogleSlidesPresentation(presentation, {
+            presentationId: request.item.externalId,
+            revisionId: sourceVersion,
+            resolveAsset: async (asset) => {
+                let pending = assetCache.get(asset.sourceUrl);
+                if (!pending) {
+                    pending = rehostRemoteMedia({
+                        url: asset.sourceUrl,
+                        provenanceUrl: asset.provenanceUrl,
+                        filename: `${safeFilePart(asset.presentationId)}-${createHash("sha256").update(asset.sourceUrl).digest("hex").slice(0, 16)}.png`,
+                        kind: "image",
+                        context,
+                        metadata: {
+                            provider: "google-slides",
+                            presentationId: asset.presentationId,
+                            sourceKind: asset.kind,
+                        },
+                    });
+                    assetCache.set(asset.sourceUrl, pending);
+                }
+                const media = await pending;
+                return mediaWithNativeUrl({
+                    ...media,
+                    metadata: {
+                        ...media.metadata,
+                        slideObjectId: asset.slideObjectId,
+                        elementObjectId: asset.elementObjectId,
+                    },
+                }, asset, sourceVersion);
+            },
+            resolveFallback: async (fallback) => {
+                try {
+                    let pending = thumbnailCache.get(fallback.slideObjectId);
+                    if (!pending) {
+                        pending = fetchTemporarySlideRender({
+                            presentationId: fallback.presentationId,
+                            slideObjectId: fallback.slideObjectId,
+                            config: request.config,
+                            connectionId,
+                            context,
+                        });
+                        thumbnailCache.set(fallback.slideObjectId, pending);
+                    }
+                    const source = await pending;
+                    if (!source)
+                        return null;
+                    const region = thumbnailCropRegion({
+                        bounds: fallback.bounds,
+                        pageWidth,
+                        pageHeight,
+                        imageWidth: source.width,
+                        imageHeight: source.height,
+                    });
+                    const cropped = await cropImageRegion({
+                        data: source.data,
+                        ...region,
+                    });
+                    const stored = await storePrivateArtifact({
+                        data: cropped.data,
+                        filename: `${safeFilePart(fallback.presentationId)}-${safeFilePart(fallback.slideObjectId)}-${safeFilePart(fallback.elementObjectId)}-fallback.png`,
+                        mimeType: cropped.mimeType,
+                        context,
+                        metadata: {
+                            kind: "image",
+                            source: "google-slides-localized-fallback",
+                        },
+                    });
+                    const media = {
+                        kind: "image",
+                        mimeType: cropped.mimeType,
+                        accessMode: "private",
+                        storageKey: stored.reference,
+                        contentHash: stored.contentHash,
+                        width: cropped.width,
+                        height: cropped.height,
+                        captionStatus: "not-needed",
+                        metadata: {
+                            provider: "google-slides",
+                            presentationId: fallback.presentationId,
+                            slideObjectId: fallback.slideObjectId,
+                            elementObjectId: fallback.elementObjectId,
+                            localizedFallback: true,
+                            reason: fallback.reason,
+                        },
+                    };
+                    return mediaWithNativeUrl(media, fallback, sourceVersion);
+                }
+                catch (error) {
+                    if (isContextConnectorQuotaError(error))
+                        throw error;
+                    return null;
+                }
+            },
+        });
+        const items = normalizePresentationSlides(presentation, request.item, compiledSlides, sourceVersion);
+        const warnings = await hydrateSlideThumbnails({
+            presentationId: request.item.externalId,
+            items,
+            config: request.config,
+            connectionId,
+            context,
+        });
+        return {
+            items,
+            ...(warnings.length ? { warnings } : {}),
+        };
+    }
+}
+function googleDriveFileInventoryItem(file) {
+    const id = stringValue(file.id);
+    if (!id)
+        return null;
+    return {
+        externalId: id,
+        kind: "google-slides-presentation",
+        title: stringValue(file.name) ?? id,
+        canonicalUrl: stringValue(file.webViewLink) ??
+            `https://docs.google.com/presentation/d/${encodeURIComponent(id)}/edit`,
+        mimeType: stringValue(file.mimeType) ?? SLIDES_MIME_TYPE,
+        sourceModifiedAt: stringValue(file.modifiedTime),
+        sizeBytes: finiteNumber(file.size),
+        upstreamAccess: googleDriveFileAccess(file),
+        metadata: {
+            ...(Array.isArray(file.parents) ? { parents: file.parents } : {}),
+            accessSignals: googleDriveAccessSignals(file),
+        },
+    };
+}
+export function googleSlidesRecommendedPresentationIds(config) {
+    return stringArray(config.recommendedPresentationIds);
+}
+function normalizePresentationSlides(presentation, inventoryItem, compiledSlides, sourceVersion) {
+    const slides = Array.isArray(presentation.slides) ? presentation.slides : [];
+    const masters = objectMap(presentation.masters);
+    const layouts = objectMap(presentation.layouts);
+    const presentationTitle = stringValue(presentation.title) ?? inventoryItem.title;
+    const revisionId = stringValue(presentation.revisionId);
+    const compiledById = new Map(compiledSlides.map((compiled) => [compiled.objectId, compiled]));
+    const normalizedSlides = slides.flatMap((value, index) => {
+        const slide = asRecord(value);
+        const objectId = stringValue(slide?.objectId);
+        if (!slide || !objectId)
+            return [];
+        const properties = asRecord(slide.slideProperties);
+        const layout = properties
+            ? layouts.get(stringValue(properties.layoutObjectId) ?? "")
+            : undefined;
+        const layoutProperties = asRecord(layout?.layoutProperties);
+        const masterId = stringValue(properties?.masterObjectId) ??
+            stringValue(layoutProperties?.masterObjectId);
+        const master = masters.get(masterId ?? "");
+        const compiled = compiledById.get(objectId);
+        if (!compiled)
+            return [];
+        const body = compiled.plainText;
+        const notes = collectProviderText(properties?.notesPage, {
+            skipKeys: ["objectId", "elementGroup", "transform", "size"],
+        });
+        const firstLine = body.split("\n").find(Boolean);
+        const title = firstLine
+            ? `${presentationTitle} — ${firstLine.slice(0, 120)}`
+            : `${presentationTitle} — Slide ${index + 1}`;
+        const canonicalBase = inventoryItem.canonicalUrl ??
+            `https://docs.google.com/presentation/d/${encodeURIComponent(inventoryItem.externalId)}/edit`;
+        const childItems = compiled.childArtifacts.map((child, childIndex) => normalizeContextItem({
+            externalId: child.externalId,
+            kind: "google-slides-native-part",
+            title: `${title} — Native part ${childIndex + 1}`,
+            canonicalUrl: `${canonicalBase.split("#")[0]}#slide=id.${encodeURIComponent(objectId)}`,
+            mimeType: "text/html",
+            content: child.html,
+            sourceModifiedAt: inventoryItem.sourceModifiedAt,
+            sourceVersion,
+            parseStatus: "parsed",
+            upstreamAccess: inventoryItem.upstreamAccess ?? "unknown",
+            curationStatus: inventoryItem.upstreamAccess === "restricted" ? "review" : "included",
+            provenance: {
+                provider: "google-slides",
+                presentationId: inventoryItem.externalId,
+                slideObjectId: objectId,
+                sourceElementObjectId: child.objectId,
+                compiler: "@agent-native/creative-context:google-slides-native",
+            },
+            metadata: {
+                provider: "google-slides",
+                presentationTitle,
+                nativePartOf: `${inventoryItem.externalId}:${objectId}`,
+                nativeArtifact: child.nativeArtifact,
+            },
+            chunks: child.lexicalText
+                ? [
+                    {
+                        ordinal: 0,
+                        kind: "slides-native-code",
+                        text: child.lexicalText,
+                        metadata: {
+                            artifactFormat: "slides-html",
+                            includesCodeTokens: true,
+                        },
+                    },
+                ]
+                : [],
+            edges: [
+                {
+                    relation: "part-of-native-artifact",
+                    toExternalId: `${inventoryItem.externalId}:${objectId}`,
+                },
+            ],
+        }));
+        const root = normalizeContextItem({
+            externalId: `${inventoryItem.externalId}:${objectId}`,
+            kind: "google-slides-slide",
+            title,
+            canonicalUrl: `${canonicalBase.split("#")[0]}#slide=id.${encodeURIComponent(objectId)}`,
+            mimeType: "text/html",
+            content: compiled.html,
+            summary: [
+                body.slice(0, 2_000),
+                notes ? `Speaker notes: ${notes.slice(0, 500)}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n"),
+            sourceModifiedAt: inventoryItem.sourceModifiedAt,
+            sourceVersion,
+            parseStatus: "parsed",
+            upstreamAccess: inventoryItem.upstreamAccess ?? "unknown",
+            curationStatus: inventoryItem.upstreamAccess === "restricted" ? "review" : "included",
+            provenance: {
+                provider: "google-slides",
+                presentationId: inventoryItem.externalId,
+                slideObjectId: objectId,
+                compiler: "@agent-native/creative-context:google-slides-native",
+            },
+            metadata: {
+                provider: "google-slides",
+                presentationTitle,
+                slideIndex: index,
+                slideObjectId: objectId,
+                locale: stringValue(presentation.locale),
+                revisionId,
+                speakerNotes: notes || null,
+                theme: inheritedSlideTheme(master, layout, slide),
+                nativeArtifact: compiled.nativeArtifact,
+            },
+            chunks: compiled.lexicalText
+                ? [
+                    {
+                        ordinal: 0,
+                        kind: "slides-native-lexical",
+                        text: [
+                            compiled.lexicalText,
+                            notes ? `Speaker notes ${notes}` : "",
+                        ]
+                            .filter(Boolean)
+                            .join("\n")
+                            .slice(0, 24_000),
+                        metadata: {
+                            artifactFormat: "slides-html",
+                            includesCodeTokens: true,
+                        },
+                    },
+                ]
+                : [],
+            media: compiled.media,
+            edges: [
+                {
+                    relation: "part-of-presentation",
+                    toExternalId: inventoryItem.externalId,
+                },
+                ...compiled.childArtifacts.map((child) => ({
+                    relation: "contains-native-child",
+                    toExternalId: child.externalId,
+                })),
+            ],
+        });
+        return [root, ...childItems];
+    });
+    const slideRoots = normalizedSlides.filter((item) => item.kind === "google-slides-slide");
+    const parentContent = slideRoots
+        .map((item, index) => {
+        const excerpt = item.summary?.slice(0, 2_000) ?? "";
+        return `Slide ${index + 1}: ${item.title}${excerpt ? `\n${excerpt}` : ""}`;
+    })
+        .join("\n\n")
+        .slice(0, 50_000);
+    const parent = normalizeContextItem({
+        externalId: inventoryItem.externalId,
+        kind: inventoryItem.kind,
+        title: presentationTitle,
+        canonicalUrl: inventoryItem.canonicalUrl ??
+            `https://docs.google.com/presentation/d/${encodeURIComponent(inventoryItem.externalId)}/edit`,
+        mimeType: inventoryItem.mimeType,
+        content: parentContent,
+        summary: `${slideRoots.length} indexed slide${slideRoots.length === 1 ? "" : "s"}.`,
+        sourceModifiedAt: inventoryItem.sourceModifiedAt,
+        sourceVersion,
+        parseStatus: "parsed",
+        upstreamAccess: inventoryItem.upstreamAccess ?? "unknown",
+        curationStatus: inventoryItem.upstreamAccess === "restricted" ? "review" : "included",
+        provenance: {
+            provider: "google-slides",
+            presentationId: inventoryItem.externalId,
+        },
+        metadata: {
+            provider: "google-slides",
+            presentationTitle,
+            slideCount: slideRoots.length,
+            locale: stringValue(presentation.locale),
+            revisionId,
+            childExternalIds: slideRoots.map((item) => item.externalId),
+        },
+        edges: slideRoots.map((item) => ({
+            relation: "contains-slide",
+            toExternalId: item.externalId,
+        })),
+    });
+    return [parent, ...normalizedSlides];
+}
+function mediaWithNativeUrl(media, source, revisionId) {
+    const id = `ccm_${createHash("sha256")
+        .update([
+        source.presentationId,
+        source.slideObjectId,
+        source.elementObjectId,
+        revisionId ?? "unversioned",
+        media.contentHash ?? "unhashed",
+    ].join(":"))
+        .digest("hex")
+        .slice(0, 28)}`;
+    return {
+        ...media,
+        id,
+        url: creativeContextMediaUrl({ mediaId: id }),
+    };
+}
+async function fetchTemporarySlideRender(input) {
+    const thumbnail = asRecord(await executeConnectorProviderRequest(input.context.providerApi, {
+        provider: "google_slides",
+        method: "GET",
+        path: `/presentations/${encodeURIComponent(input.presentationId)}/pages/${encodeURIComponent(input.slideObjectId)}/thumbnail`,
+        query: {
+            "thumbnailProperties.mimeType": "PNG",
+            "thumbnailProperties.thumbnailSize": "LARGE",
+        },
+        connectionId: input.connectionId,
+        accountId: stringValue(input.config.accountId),
+    }));
+    const contentUrl = stringValue(thumbnail?.contentUrl);
+    const width = finiteNumber(thumbnail?.width);
+    const height = finiteNumber(thumbnail?.height);
+    if (!contentUrl || !width || !height)
+        return null;
+    const remote = await fetchRemoteArtifact(contentUrl, input.context);
+    return { data: remote.data, width, height };
+}
+function thumbnailCropRegion(input) {
+    const left = Math.max(0, Math.min(input.imageWidth - 1, Math.floor((input.bounds.x / input.pageWidth) * input.imageWidth)));
+    const top = Math.max(0, Math.min(input.imageHeight - 1, Math.floor((input.bounds.y / input.pageHeight) * input.imageHeight)));
+    const right = Math.max(left + 1, Math.min(input.imageWidth, Math.ceil(((input.bounds.x + input.bounds.width) / input.pageWidth) *
+        input.imageWidth)));
+    const bottom = Math.max(top + 1, Math.min(input.imageHeight, Math.ceil(((input.bounds.y + input.bounds.height) / input.pageHeight) *
+        input.imageHeight)));
+    return { left, top, width: right - left, height: bottom - top };
+}
+function googleDimensionToPx(value) {
+    if (!value)
+        return 0;
+    const magnitude = Number(value.magnitude);
+    if (!Number.isFinite(magnitude))
+        return 0;
+    switch ((stringValue(value.unit) ?? "EMU").toUpperCase()) {
+        case "PT":
+            return (magnitude * 96) / 72;
+        case "PX":
+            return magnitude;
+        case "EMU":
+        default:
+            return (magnitude * 96) / 914_400;
+    }
+}
+async function hydrateSlideThumbnails(input) {
+    if (input.config.hydrateThumbnails === false)
+        return [];
+    const candidates = input.items.filter((item) => Boolean(stringValue(item.metadata?.slideObjectId)));
+    const limit = Math.min(candidates.length, positiveLimit(input.config.thumbnailLimit, 15, 50));
+    const warnings = [];
+    for (let index = 0; index < limit; index++) {
+        const item = candidates[index];
+        const slideObjectId = stringValue(item.metadata?.slideObjectId);
+        if (!slideObjectId)
+            continue;
+        try {
+            const thumbnail = asRecord(await executeConnectorProviderRequest(input.context.providerApi, {
+                provider: "google_slides",
+                method: "GET",
+                path: `/presentations/${encodeURIComponent(input.presentationId)}/pages/${encodeURIComponent(slideObjectId)}/thumbnail`,
+                query: {
+                    "thumbnailProperties.mimeType": "PNG",
+                    "thumbnailProperties.thumbnailSize": "SMALL",
+                },
+                connectionId: input.connectionId,
+                accountId: stringValue(input.config.accountId),
+            }));
+            const contentUrl = stringValue(thumbnail?.contentUrl);
+            if (!contentUrl) {
+                warnings.push(`Slide ${slideObjectId} returned no thumbnail URL.`);
+                continue;
+            }
+            const width = finiteNumber(thumbnail?.width);
+            const height = finiteNumber(thumbnail?.height);
+            if (!width || !height || width > 400 || height > 400) {
+                warnings.push(`Slide ${slideObjectId} UI thumbnail exceeded the 400px dimension limit.`);
+                continue;
+            }
+            const remote = await fetchRemoteArtifact(contentUrl, input.context);
+            if (remote.data.byteLength > 512 * 1024) {
+                warnings.push(`Slide ${slideObjectId} UI thumbnail exceeded the 512 KiB storage limit.`);
+                continue;
+            }
+            const stored = await storePrivateArtifact({
+                data: remote.data,
+                filename: `${safeFilePart(input.presentationId)}-${safeFilePart(slideObjectId)}-ui-thumbnail.png`,
+                mimeType: "image/png",
+                context: input.context,
+                metadata: {
+                    kind: "image",
+                    source: "google-slides-bounded-ui-thumbnail",
+                },
+            });
+            const media = {
+                kind: "image",
+                mimeType: "image/png",
+                accessMode: "private",
+                storageKey: stored.reference,
+                provenanceUrl: item.canonicalUrl,
+                contentHash: stored.contentHash,
+                ...(stored.palette.length ? { palette: stored.palette } : {}),
+                captionStatus: "pending",
+                width,
+                height,
+                metadata: {
+                    provider: "google-slides",
+                    presentationId: input.presentationId,
+                    slideObjectId,
+                    boundedUiThumbnail: true,
+                },
+            };
+            item.media = [...(item.media ?? []), media];
+            item.thumbnailBlobRef = media.storageKey;
+        }
+        catch (error) {
+            if (isContextConnectorQuotaError(error))
+                throw error;
+            warnings.push(`Slide ${slideObjectId} thumbnail was skipped: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return warnings;
+}
+function safeFilePart(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 100) || "slide";
+}
+function inheritedSlideTheme(master, layout, slide) {
+    const merged = deepMerge({}, asRecord(master?.pageProperties) ?? {}, asRecord(layout?.pageProperties) ?? {}, asRecord(slide.pageProperties) ?? {});
+    const resolvedTypography = resolveInheritedSlideTypography(master, layout, slide);
+    return {
+        ...(merged.pageBackgroundFill !== undefined
+            ? { pageBackgroundFill: merged.pageBackgroundFill }
+            : {}),
+        ...(merged.colorScheme !== undefined
+            ? { colorScheme: merged.colorScheme }
+            : {}),
+        masterObjectId: stringValue(master?.objectId) ?? null,
+        layoutObjectId: stringValue(layout?.objectId) ?? null,
+        fontFamilies: resolvedTypography.fontFamilies,
+        fontSizes: resolvedTypography.fontSizes,
+        colors: resolvedTypography.colors,
+        placeholders: resolvedTypography.placeholders,
+        resolvedTextStyles: resolvedTypography.resolvedTextStyles,
+    };
+}
+function resolveInheritedSlideTypography(master, layout, slide) {
+    const masterElements = pageElementMap(master?.pageElements);
+    const layoutElements = pageElementMap(layout?.pageElements);
+    const slideElements = pageElementMap(slide.pageElements);
+    const masterPlaceholders = placeholderElementMap(masterElements);
+    const layoutPlaceholders = placeholderElementMap(layoutElements);
+    const placeholders = [];
+    const resolvedTextStyles = [];
+    for (const element of [...slideElements.values()].slice(0, 200)) {
+        const slidePlaceholder = pageElementPlaceholder(element);
+        const layoutElement = resolvePlaceholderParent(slidePlaceholder, layoutElements, layoutPlaceholders);
+        const layoutPlaceholder = pageElementPlaceholder(layoutElement);
+        const masterElement = resolvePlaceholderParent(layoutPlaceholder, masterElements, masterPlaceholders);
+        const resolvedStyle = deepMerge({}, pageElementTextStyle(masterElement), pageElementTextStyle(layoutElement), pageElementTextStyle(element));
+        if (Object.keys(resolvedStyle).length > 0) {
+            resolvedTextStyles.push({
+                objectId: stringValue(element.objectId) ?? null,
+                placeholderType: stringValue(slidePlaceholder?.type) ?? null,
+                style: boundedThemeObject(resolvedStyle),
+            });
+        }
+        if (slidePlaceholder) {
+            placeholders.push({
+                objectId: stringValue(element.objectId) ?? null,
+                type: stringValue(slidePlaceholder.type) ?? null,
+                index: finiteNumber(slidePlaceholder.index) ?? null,
+                layoutObjectId: stringValue(layoutElement?.objectId) ?? null,
+                masterObjectId: stringValue(masterElement?.objectId) ?? null,
+                inheritedFrom: [
+                    ...(masterElement ? ["master"] : []),
+                    ...(layoutElement ? ["layout"] : []),
+                    "slide",
+                ],
+                resolvedTextStyle: boundedThemeObject(resolvedStyle),
+            });
+        }
+        if (resolvedTextStyles.length >= 100)
+            break;
+    }
+    const themeEvidence = {
+        placeholders,
+        resolvedTextStyles,
+        pageProperties: [
+            asRecord(master?.pageProperties) ?? {},
+            asRecord(layout?.pageProperties) ?? {},
+            asRecord(slide.pageProperties) ?? {},
+        ],
+    };
+    return {
+        fontFamilies: collectThemeStrings(themeEvidence, "fontFamily", 50),
+        fontSizes: collectThemeFontSizes(themeEvidence, 50),
+        colors: collectThemeColors(themeEvidence, 100),
+        placeholders: placeholders.slice(0, 100),
+        resolvedTextStyles: resolvedTextStyles.slice(0, 100),
+    };
+}
+function pageElementMap(value) {
+    const elements = new Map();
+    if (!Array.isArray(value))
+        return elements;
+    for (const entry of value.slice(0, 500)) {
+        const element = asRecord(entry);
+        const id = stringValue(element?.objectId);
+        if (element && id)
+            elements.set(id, element);
+    }
+    return elements;
+}
+function placeholderElementMap(elements) {
+    const result = new Map();
+    for (const element of elements.values()) {
+        const placeholder = pageElementPlaceholder(element);
+        const type = stringValue(placeholder?.type);
+        if (!type)
+            continue;
+        result.set(`${type}:${finiteNumber(placeholder?.index) ?? 0}`, element);
+    }
+    return result;
+}
+function resolvePlaceholderParent(placeholder, elements, placeholders) {
+    if (!placeholder)
+        return undefined;
+    const parentId = stringValue(placeholder.parentObjectId);
+    if (parentId && elements.has(parentId))
+        return elements.get(parentId);
+    const type = stringValue(placeholder.type);
+    return type
+        ? placeholders.get(`${type}:${finiteNumber(placeholder.index) ?? 0}`)
+        : undefined;
+}
+function pageElementPlaceholder(element) {
+    const shape = asRecord(element?.shape);
+    return asRecord(shape?.placeholder);
+}
+function pageElementTextStyle(element) {
+    const shape = asRecord(element?.shape);
+    const text = asRecord(shape?.text);
+    const style = deepMerge({}, asRecord(text?.textStyle) ?? {});
+    const textElements = Array.isArray(text?.textElements)
+        ? text.textElements.slice(0, 100)
+        : [];
+    for (const value of textElements) {
+        const textElement = asRecord(value);
+        const textRun = asRecord(textElement?.textRun);
+        const autoText = asRecord(textElement?.autoText);
+        const paragraphMarker = asRecord(textElement?.paragraphMarker);
+        deepMerge(style, asRecord(paragraphMarker?.style) ?? {}, asRecord(textRun?.style) ?? {}, asRecord(autoText?.style) ?? {});
+    }
+    return style;
+}
+function boundedThemeObject(value, depth = 0) {
+    if (depth >= 5)
+        return {};
+    return Object.fromEntries(Object.entries(value)
+        .slice(0, 100)
+        .map(([key, child]) => [
+        key,
+        Array.isArray(child)
+            ? child.slice(0, 100)
+            : asRecord(child)
+                ? boundedThemeObject(asRecord(child), depth + 1)
+                : typeof child === "string"
+                    ? child.slice(0, 500)
+                    : child,
+    ]));
+}
+function collectThemeStrings(value, key, limit) {
+    const values = new Set();
+    visitTheme(value, (currentKey, currentValue) => {
+        if (currentKey !== key)
+            return;
+        const text = stringValue(currentValue);
+        if (text && values.size < limit)
+            values.add(text);
+    });
+    return [...values];
+}
+function collectThemeFontSizes(value, limit) {
+    const values = new Set();
+    visitTheme(value, (key, currentValue) => {
+        if (key !== "fontSize" || values.size >= limit)
+            return;
+        const size = asRecord(currentValue);
+        const magnitude = finiteNumber(size?.magnitude);
+        if (magnitude === undefined)
+            return;
+        values.add(`${magnitude}${stringValue(size?.unit) ?? "PT"}`);
+    });
+    return [...values];
+}
+function collectThemeColors(value, limit) {
+    const values = new Set();
+    visitTheme(value, (key, currentValue) => {
+        if (values.size >= limit)
+            return;
+        if (key === "themeColor") {
+            const color = stringValue(currentValue);
+            if (color)
+                values.add(`theme:${color}`);
+        }
+        if (key !== "rgbColor")
+            return;
+        const rgb = asRecord(currentValue);
+        const channels = [rgb?.red, rgb?.green, rgb?.blue].map(Number);
+        if (channels.some((channel) => !Number.isFinite(channel)))
+            return;
+        values.add(`#${channels
+            .map((channel) => Math.round(Math.max(0, Math.min(1, channel)) * 255)
+            .toString(16)
+            .padStart(2, "0"))
+            .join("")}`);
+    });
+    return [...values];
+}
+function visitTheme(value, visit, depth = 0) {
+    if (depth >= 8 || !value)
+        return;
+    if (Array.isArray(value)) {
+        for (const child of value.slice(0, 200))
+            visitTheme(child, visit, depth + 1);
+        return;
+    }
+    const current = asRecord(value);
+    if (!current)
+        return;
+    for (const [key, child] of Object.entries(current).slice(0, 200)) {
+        visit(key, child);
+        visitTheme(child, visit, depth + 1);
+    }
+}
+function objectMap(value) {
+    const result = new Map();
+    if (!Array.isArray(value))
+        return result;
+    for (const item of value) {
+        const record = asRecord(item);
+        const id = stringValue(record?.objectId);
+        if (record && id)
+            result.set(id, record);
+    }
+    return result;
+}
+function deepMerge(target, ...sources) {
+    for (const source of sources) {
+        for (const [key, value] of Object.entries(source)) {
+            const current = asRecord(target[key]);
+            const child = asRecord(value);
+            target[key] = child ? deepMerge({ ...(current ?? {}) }, child) : value;
+        }
+    }
+    return target;
+}
+function escapeDriveQuery(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function finiteNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function googleDriveFileAccess(file) {
+    const capabilities = asRecord(file.capabilities);
+    const permissions = (Array.isArray(file.permissions) ? file.permissions : [])
+        .map(asRecord)
+        .filter((entry) => Boolean(entry));
+    if (file.copyRequiresWriterPermission === true ||
+        capabilities?.canCopy === false ||
+        capabilities?.canDownload === false ||
+        permissions.some((permission) => permission.deleted === true ||
+            permission.pendingOwner === true ||
+            permission.allowFileDiscovery === false)) {
+        return "restricted";
+    }
+    if (file.ownedByMe === true ||
+        file.shared === true ||
+        capabilities?.canCopy === true ||
+        capabilities?.canDownload === true) {
+        return "available";
+    }
+    return "unknown";
+}
+function googleDriveAccessSignals(file) {
+    return {
+        ownedByMe: typeof file.ownedByMe === "boolean" ? file.ownedByMe : null,
+        shared: typeof file.shared === "boolean" ? file.shared : null,
+        copyRequiresWriterPermission: typeof file.copyRequiresWriterPermission === "boolean"
+            ? file.copyRequiresWriterPermission
+            : null,
+        capabilities: asRecord(file.capabilities) ?? null,
+        permissions: Array.isArray(file.permissions) ? file.permissions : [],
+        driveId: stringValue(file.driveId) ?? null,
+    };
+}
+function googleDriveContainerIdFromUrl(value, label) {
+    const input = stringValue(value);
+    if (!input)
+        return undefined;
+    const url = new URL(input);
+    if (url.hostname !== "drive.google.com" &&
+        !url.hostname.endsWith(".drive.google.com")) {
+        throw new Error(`Google Drive ${label} URL must use drive.google.com.`);
+    }
+    const match = url.pathname.match(/\/(?:folders|shared-drives)\/([^/]+)/);
+    if (!match?.[1]) {
+        throw new Error(`Could not find a ${label} ID in ${input}.`);
+    }
+    return decodeURIComponent(match[1]);
+}
+//# sourceMappingURL=google-slides.js.map