@mevdragon/vidfarm-devcli 0.20.6 → 0.20.9

package/dist/src/services/serverless-records.js

@@ -1,1515 +0,0 @@
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DeleteCommand, DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, ScanCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
-import { config } from "../config.js";
-import { devLog } from "../lib/dev-log.js";
-import { displayNameFromEmail } from "../lib/display-name.js";
-import { createId, createIdV7 } from "../lib/ids.js";
-import { nowIso } from "../lib/time.js";
-import { ServerlessAuthService } from "./serverless-auth.js";
-import { createLocalDynamoClient } from "./local-dynamo.js";
-// In local (`vidfarm serve`) mode every DynamoDB call is serviced from disk by
-// the shim; deployed environments keep the real client. Call sites are
-// identical either way — only this construction switches.
-const dynamodb = config.RECORDS_DRIVER === "local"
-    ? createLocalDynamoClient()
-    : DynamoDBDocumentClient.from(new DynamoDBClient({}), {
-        marshallOptions: {
-            removeUndefinedValues: true
-        }
-    });
-const METHOD_COLLECTIONS = {
-    archiveReadyPost: "ready_post",
-    createCompositionFork: "composition_fork",
-    deleteCompositionFork: "composition_fork",
-    getCompositionFork: "composition_fork",
-    listCompositionForksForCustomer: "composition_fork",
-    listCompositionForksForTemplate: "composition_fork",
-    updateCompositionFork: "composition_fork",
-    createInspiration: "inspiration",
-    getInspiration: "inspiration",
-    findInspirationByOriginalUrl: "inspiration",
-    updateInspiration: "inspiration",
-    listInspirationsForCustomer: "inspiration",
-    listInspirationsFeed: "inspiration",
-    createTemplate: "template",
-    getTemplate: "template",
-    updateTemplate: "template",
-    deleteTemplate: "template",
-    deleteInspiration: "inspiration",
-    listTemplatesFeed: "template",
-    listTemplatesForCustomer: "template",
-    createEmailChannel: "email_channel",
-    createPostSchedule: "post_schedule",
-    createReadyPost: "ready_post",
-    createTemplateRelease: "template_release",
-    createTemplateSource: "template_source",
-    createUserAttachment: "user_attachment",
-    updateUserAttachmentNotes: "user_attachment",
-    createUserFileFolder: "user_file_folder",
-    createUserTemporaryFile: "user_temporary_file",
-    deleteEmailChannel: "email_channel",
-    deleteReadyPost: "ready_post",
-    deleteUserAttachment: "user_attachment",
-    deleteUserFileFolder: "user_file_folder",
-    deleteUserTemporaryFile: "user_temporary_file",
-    getEmailChannel: "email_channel",
-    getEmailChannelByEmail: "email_channel",
-    getPostSchedule: "post_schedule",
-    getReadyPost: "ready_post",
-    getTemplateRelease: "template_release",
-    getTemplateSource: "template_source",
-    getTemplateSourceByLocation: "template_source",
-    getTemplateSourceBySlugId: "template_source",
-    getTemplateSourceByTemplateId: "template_source",
-    getUserAttachment: "user_attachment",
-    getUserTemporaryFile: "user_temporary_file",
-    listEmailChannels: "email_channel",
-    listPostSchedulesForCalendar: "post_schedule",
-    listPostSchedulesForPost: "post_schedule",
-    listReadyPosts: "ready_post",
-    listTemplateReleases: "template_release",
-    listTemplateSources: "template_source",
-    listUserAttachments: "user_attachment",
-    listUserFileFolders: "user_file_folder",
-    listUserTemporaryFiles: "user_temporary_file",
-    markPostScheduleCancelled: "post_schedule",
-    markPostScheduleFailed: "post_schedule",
-    moveUserAttachmentFolder: "user_attachment",
-    moveUserFileFolder: "user_file_folder",
-    moveUserTemporaryFolder: "user_temporary_file",
-    queueWebhookDelivery: "webhook_delivery",
-    setReadyPostZip: "ready_post",
-    updateEmailChannel: "email_channel",
-    updateEmailChannelAvatar: "email_channel",
-    updateEmailChannelVerification: "email_channel",
-    updatePostScheduleProvider: "post_schedule",
-    updateTemplateSource: "template_source",
-    upsertExternalPostSchedule: "post_schedule"
-};
-class ServerlessRecordsServiceImpl {
-    auth = new ServerlessAuthService();
-    async getCustomerById(customerId) {
-        return this.auth.getCustomerById(customerId);
-    }
-    async getCustomerByEmail(email) {
-        return this.auth.getCustomerByEmailPublic(email);
-    }
-    async upsertCustomer(input) {
-        return this.auth.upsertCustomer(input);
-    }
-    async insertApiKey(input) {
-        return this.auth.insertApiKey(input);
-    }
-    async getFirstPaidCustomer() {
-        const response = await dynamodb.send(new ScanCommand({
-            TableName: requireMainTableName(),
-            FilterExpression: "entity_type = :type AND is_paid_plan = :paid",
-            ExpressionAttributeValues: {
-                ":type": "Customer",
-                ":paid": true
-            },
-            Limit: 1
-        }));
-        return response.Items?.[0] ? itemToCustomer(response.Items[0]) : null;
-    }
-    async setCustomerAccessByEmail(input) {
-        const normalizedEmail = input.email.trim().toLowerCase();
-        const existing = await this.auth.getCustomerByEmailPublic(normalizedEmail);
-        return this.auth.upsertCustomer({
-            id: existing?.id ?? createId("cus"),
-            email: normalizedEmail,
-            name: input.name?.trim() || existing?.name || displayNameFromEmail(normalizedEmail),
-            defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
-            isDeveloper: input.isDeveloper ?? existing?.isDeveloper ?? false,
-            isAgency: input.isAgency ?? existing?.isAgency ?? false,
-            isPaidPlan: input.isPaidPlan ?? existing?.isPaidPlan ?? false,
-            planTier: input.planTier ?? existing?.planTier ?? "client"
-        });
-    }
-    async updateCustomerPaidPlan(customerId, isPaidPlan, planTier = "client") {
-        const existing = await this.auth.getCustomerById(customerId);
-        if (!existing)
-            return null;
-        return this.auth.upsertCustomer({ ...existing, isPaidPlan, planTier });
-    }
-    async updateCustomerAgencyStatus(customerId, isAgency) {
-        const existing = await this.auth.getCustomerById(customerId);
-        if (!existing)
-            return null;
-        return this.auth.upsertCustomer({ ...existing, isAgency, planTier: isAgency ? "agency" : existing.planTier });
-    }
-    async updateCustomerProfile(input) {
-        const existing = await this.auth.getCustomerById(input.customerId);
-        if (!existing)
-            return null;
-        return this.auth.upsertCustomer({
-            ...existing,
-            name: input.name === undefined ? existing.name : input.name,
-            about: input.about === undefined ? existing.about : input.about,
-            defaultWebhookUrl: input.defaultWebhookUrl === undefined ? existing.defaultWebhookUrl : input.defaultWebhookUrl,
-            groupchatUrl: input.groupchatUrl === undefined ? existing.groupchatUrl : input.groupchatUrl,
-            flockposterApiKey: input.flockposterApiKey === undefined ? existing.flockposterApiKey : input.flockposterApiKey
-        });
-    }
-    async getLatestApiKeyForCustomer(customerId) {
-        const keys = await this.listActiveApiKeysForCustomer(customerId, 1);
-        return keys[0] ?? null;
-    }
-    // Newest-first active API key records. Callers that hand a key to a client
-    // (boot configs, Settings) should pick one the CURRENT server can validate —
-    // after an API_KEY_SALT rotation the shared table holds keys hashed under
-    // different salts (deployed stage vs local dev boxes).
-    async listActiveApiKeysForCustomer(customerId, limit = 25) {
-        const response = await dynamodb.send(new QueryCommand({
-            TableName: requireMainTableName(),
-            IndexName: "gsi1",
-            KeyConditionExpression: "gsi1pk = :pk",
-            FilterExpression: "#status = :status",
-            ExpressionAttributeNames: {
-                "#status": "status"
-            },
-            ExpressionAttributeValues: {
-                ":pk": `CUSTOMER#${customerId}#APIKEYS`,
-                ":status": "active"
-            },
-            ScanIndexForward: false,
-            Limit: limit
-        }));
-        return response.Items ?? [];
-    }
-    async hasCustomerCreditGrant(customerId, grantType) {
-        return Boolean(await this.getById("credit_grant", `${customerId}:${grantType}`));
-    }
-    async insertCustomerCreditGrant(input) {
-        await this.putRecord("credit_grant", {
-            ...input,
-            id: `${input.customerId}:${input.grantType}`,
-            customerId: input.customerId
-        });
-    }
-    async grantAgencyClientAccess(input) {
-        return this.putRecord("agency_access", {
-            id: `${input.agencyCustomerId}:${input.clientCustomerId}`,
-            customerId: input.agencyCustomerId,
-            agencyCustomerId: input.agencyCustomerId,
-            clientCustomerId: input.clientCustomerId
-        });
-    }
-    async revokeAgencyClientAccess(input) {
-        const record = await this.getById("agency_access", `${input.agencyCustomerId}:${input.clientCustomerId}`);
-        await this.deleteById("agency_access", `${input.agencyCustomerId}:${input.clientCustomerId}`);
-        return record;
-    }
-    async listAgencyClients(input) {
-        const links = await this.listByCustomer("agency_access", input.agencyCustomerId);
-        const clients = [];
-        for (const link of links) {
-            const clientId = String(link.clientCustomerId ?? "");
-            const customer = clientId ? await this.auth.getCustomerById(clientId) : null;
-            if (customer)
-                clients.push({ ...link, customer });
-        }
-        return clients;
-    }
-    async getAgencyClient(agencyCustomerId, clientCustomerId) {
-        return this.getById("agency_access", `${agencyCustomerId}:${clientCustomerId}`);
-    }
-    async createCompositionFork(input) {
-        const timestamp = nowIso();
-        return this.putRecord("composition_fork", {
-            id: input.id ?? createIdV7("fork"),
-            customerId: input.customerId,
-            templateId: input.templateId,
-            parentForkId: input.parentForkId ?? null,
-            parentVersion: input.parentVersion ?? null,
-            title: input.title ?? null,
-            visibility: input.visibility ?? "private",
-            latestVersion: 0,
-            currentRenderJobId: null,
-            deletedAt: null,
-            createdAt: timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async getCompositionFork(forkId) {
-        const fork = await this.getById("composition_fork", forkId);
-        if (!fork)
-            return null;
-        return {
-            ...fork,
-            parentForkId: fork.parentForkId ?? null,
-            parentVersion: fork.parentVersion ?? null,
-            visibility: fork.visibility ?? "private",
-            latestVersion: fork.latestVersion ?? 0
-        };
-    }
-    async listCompositionForksForTemplate(input) {
-        const owned = await this.listByCustomer("composition_fork", input.customerId);
-        return owned.filter((fork) => fork.templateId === input.templateId && !fork.deletedAt);
-    }
-    async listCompositionForksForCustomer(customerId) {
-        return this.listByCustomer("composition_fork", customerId);
-    }
-    async listPublicCompositionForks() {
-        return (await this.scanCollection("composition_fork"))
-            .filter((fork) => !fork.deletedAt && fork.visibility === "public");
-    }
-    async updateCompositionFork(input) {
-        const existing = await this.getCompositionFork(input.forkId);
-        if (!existing)
-            return null;
-        return this.putRecord("composition_fork", {
-            ...existing,
-            ...input.patch,
-            id: existing.id,
-            customerId: existing.customerId,
-            updatedAt: nowIso()
-        });
-    }
-    async deleteCompositionFork(input) {
-        const existing = await this.getCompositionFork(input.forkId);
-        if (!existing || existing.customerId !== input.customerId)
-            return null;
-        return this.putRecord("composition_fork", {
-            ...existing,
-            deletedAt: nowIso(),
-            updatedAt: nowIso()
-        });
-    }
-    async grantForkPermission(input) {
-        const existing = (await this.listForkPermissions(input.forkId))
-            .find((perm) => perm.granteeType === input.granteeType && perm.granteeId === input.granteeId);
-        const timestamp = nowIso();
-        const id = existing?.id ?? createId("perm");
-        return this.putRecord("fork_permission", {
-            id,
-            forkId: input.forkId,
-            ownerCustomerId: input.ownerCustomerId,
-            granteeType: input.granteeType,
-            granteeId: input.granteeId,
-            role: input.role,
-            grantedBy: input.grantedBy,
-            expiresAt: input.expiresAt ?? null,
-            createdAt: existing?.createdAt ?? timestamp,
-            updatedAt: timestamp
-        }, { partitionKey: forkPartitionPk("fork_permission", input.forkId) });
-    }
-    async listForkPermissions(forkId) {
-        return this.listByPartition("fork_permission", forkPartitionPk("fork_permission", forkId));
-    }
-    async listForkPermissionsForGrantee(customerId) {
-        return (await this.scanCollection("fork_permission"))
-            .filter((perm) => perm.granteeType === "customer" && perm.granteeId === customerId);
-    }
-    async deleteForkPermission(input) {
-        const existing = (await this.listForkPermissions(input.forkId)).find((perm) => perm.id === input.permissionId);
-        if (!existing)
-            return null;
-        await this.deleteById("fork_permission", input.permissionId);
-        return existing;
-    }
-    async createForkShareLink(input) {
-        const timestamp = nowIso();
-        return this.putRecord("fork_share_link", {
-            id: input.token,
-            forkId: input.forkId,
-            ownerCustomerId: input.ownerCustomerId,
-            token: input.token,
-            role: input.role,
-            createdBy: input.createdBy,
-            expiresAt: input.expiresAt ?? null,
-            revokedAt: null,
-            createdAt: timestamp,
-            updatedAt: timestamp
-        }, { partitionKey: forkPartitionPk("fork_share_link", input.forkId) });
-    }
-    async getForkShareLinkByToken(token) {
-        return this.getById("fork_share_link", token);
-    }
-    async listForkShareLinks(forkId) {
-        return this.listByPartition("fork_share_link", forkPartitionPk("fork_share_link", forkId));
-    }
-    async revokeForkShareLink(input) {
-        const existing = await this.getForkShareLinkByToken(input.token);
-        if (!existing || existing.forkId !== input.forkId)
-            return null;
-        return this.putRecord("fork_share_link", {
-            ...existing,
-            revokedAt: nowIso(),
-            updatedAt: nowIso()
-        }, { partitionKey: forkPartitionPk("fork_share_link", input.forkId) });
-    }
-    async createForkVersion(input) {
-        const timestamp = nowIso();
-        return this.putRecord("fork_version", {
-            id: `${input.forkId}:${input.version}`,
-            forkId: input.forkId,
-            ownerCustomerId: input.ownerCustomerId,
-            version: input.version,
-            reason: input.reason,
-            message: input.message ?? null,
-            createdBy: input.createdBy,
-            storagePrefix: input.storagePrefix,
-            renderJobId: input.renderJobId ?? null,
-            createdAt: timestamp,
-            updatedAt: timestamp
-        }, { partitionKey: forkPartitionPk("fork_version", input.forkId) });
-    }
-    async getForkVersion(forkId, version) {
-        return this.getById("fork_version", `${forkId}:${version}`);
-    }
-    async listForkVersions(input) {
-        const limit = Math.max(1, Math.min(input.limit ?? 25, 200));
-        let ExclusiveStartKey = decodeDynamoCursor(input.cursor);
-        const items = [];
-        do {
-            const response = await dynamodb.send(new QueryCommand({
-                TableName: requireMainTableName(),
-                IndexName: "gsi1",
-                KeyConditionExpression: "gsi1pk = :pk",
-                ExpressionAttributeValues: {
-                    ":pk": forkPartitionPk("fork_version", input.forkId)
-                },
-                ScanIndexForward: false,
-                Limit: Math.max(1, limit - items.length),
-                ExclusiveStartKey
-            }));
-            items.push(...(response.Items ?? []).map((item) => item.data));
-            ExclusiveStartKey = response.LastEvaluatedKey;
-        } while (ExclusiveStartKey && items.length < limit);
-        return { items, nextCursor: encodeDynamoCursor(ExclusiveStartKey) };
-    }
-    async createInspiration(input) {
-        const timestamp = nowIso();
-        return this.putRecord("inspiration", {
-            id: input.id ?? createIdV7("inspiration"),
-            customerId: input.customerId,
-            sourceUrl: input.sourceUrl,
-            originalUrl: input.originalUrl,
-            sourceHost: input.sourceHost,
-            status: "downloading",
-            downloadJobId: input.downloadJobId ?? null,
-            videoStorageKey: null,
-            videoUrl: null,
-            thumbnailUrl: null,
-            title: null,
-            durationSeconds: null,
-            songName: null,
-            songUrl: null,
-            templateId: null,
-            trendTagline: input.trendTagline ?? null,
-            visibility: input.visibility ?? "public",
-            origin: input.origin ?? "inspiration",
-            notes: input.notes ?? null,
-            errorMessage: null,
-            createdAt: timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async getInspiration(inspirationId) {
-        const record = await this.getById("inspiration", inspirationId);
-        return record ? normalizeInspirationVisibility(record) : null;
-    }
-    async findInspirationByOriginalUrl(originalUrl) {
-        const record = await this.findByScan("inspiration", (item) => item.originalUrl === originalUrl || item.sourceUrl === originalUrl);
-        return record ? normalizeInspirationVisibility(record) : null;
-    }
-    async updateInspiration(input) {
-        const existing = await this.getInspiration(input.inspirationId);
-        if (!existing)
-            return null;
-        return this.putRecord("inspiration", {
-            ...existing,
-            ...input.patch,
-            id: existing.id,
-            customerId: existing.customerId,
-            updatedAt: nowIso()
-        });
-    }
-    async listInspirationsForCustomer(customerId) {
-        const records = await this.listByCustomer("inspiration", customerId);
-        return records.map(normalizeInspirationVisibility);
-    }
-    async listInspirationsFeed(input = {}) {
-        const limit = Math.max(1, Math.min(input.limit ?? 50, 200));
-        const all = (await this.scanCollection("inspiration"))
-            .filter((video) => video.status === "ready" && video.visibility !== "private");
-        const ranked = all
-            .map(normalizeInspirationVisibility)
-            .sort((a, b) => String(b.createdAt ?? "").localeCompare(String(a.createdAt ?? "")));
-        return filterAndRankBySearch(ranked, input.query).slice(0, limit);
-    }
-    async createTemplate(input) {
-        const timestamp = nowIso();
-        return this.putRecord("template", {
-            id: input.id ?? createIdV7("template"),
-            inspirationId: input.inspirationId,
-            customerId: input.customerId,
-            originalUrl: input.originalUrl,
-            sourceHost: input.sourceHost,
-            title: input.title ?? null,
-            thumbnailUrl: input.thumbnailUrl ?? null,
-            videoUrl: input.videoUrl ?? null,
-            durationSeconds: input.durationSeconds ?? null,
-            songName: input.songName ?? null,
-            songUrl: input.songUrl ?? null,
-            viralDna: input.viralDna ?? null,
-            defaultForkId: input.defaultForkId ?? null,
-            visibility: input.visibility ?? "public",
-            origin: input.origin ?? "inspiration",
-            notes: input.notes ?? null,
-            createdAt: timestamp,
-            updatedAt: timestamp
-        }).then((record) => {
-            this.bustTemplatesFeedCache();
-            return record;
-        });
-    }
-    async getTemplate(templateId) {
-        const record = await this.getById("template", templateId);
-        return record ? normalizeTemplateVisibility(record) : null;
-    }
-    async listTemplatesForCustomer(customerId) {
-        const records = await this.listByCustomer("template", customerId);
-        return records.map(normalizeTemplateVisibility);
-    }
-    async deleteTemplate(templateId) {
-        await this.deleteById("template", templateId);
-        this.bustTemplatesFeedCache();
-    }
-    async deleteInspiration(inspirationId) {
-        await this.deleteById("inspiration", inspirationId);
-    }
-    async updateTemplate(input) {
-        const existing = await this.getTemplate(input.templateId);
-        if (!existing)
-            return null;
-        return this.putRecord("template", {
-            ...existing,
-            ...input.patch,
-            id: existing.id,
-            customerId: existing.customerId,
-            updatedAt: nowIso()
-        }).then((record) => {
-            this.bustTemplatesFeedCache();
-            return record;
-        });
-    }
-    // Atomically claim this template's default fork for the FIRST decompose only.
-    // Uses a conditional DynamoDB UpdateCommand (attribute_not_exists / == null)
-    // so concurrent first-decomposes can't both win — the loser's write is
-    // rejected at the storage layer and it re-reads the winner. A plain
-    // read-check-then-updateTemplate() is racy (both callers pass the JS guard,
-    // the later putRecord clobbers the earlier) AND clobbers concurrent edits to
-    // other template fields; this touches only defaultForkId + the derived index
-    // keys (gsi1sk recency, gsi2sk feed tier — decomposed templates promote from
-    // tier "0" to "1"). Returns whether THIS call became the default and the
-    // resulting template (the winner's, if we lost the race).
-    async stampDefaultForkIfUnset(input) {
-        const existing = await this.getTemplate(input.templateId);
-        if (!existing)
-            return { template: null, becameDefault: false };
-        if (existing.defaultForkId)
-            return { template: existing, becameDefault: false };
-        const now = nowIso();
-        const names = {
-            "#data": "data",
-            "#dfk": "defaultForkId",
-            "#updatedAt": "updatedAt"
-        };
-        const values = {
-            ":forkId": input.forkId,
-            ":now": now,
-            ":gsi1sk": `${now}#${existing.id}`,
-            ":null": null
-        };
-        const setClauses = ["#data.#dfk = :forkId", "#data.#updatedAt = :now", "gsi1sk = :gsi1sk"];
-        // Only public/unlisted templates carry the sparse gsi2 feed keys; a private
-        // template has no gsi2pk, so writing a bare gsi2sk would be inconsistent.
-        if (existing.visibility !== "private") {
-            values[":gsi2sk"] = templateFeedSortKey({ defaultForkId: input.forkId, createdAt: existing.createdAt, id: existing.id });
-            setClauses.push("gsi2sk = :gsi2sk");
-        }
-        try {
-            await dynamodb.send(new UpdateCommand({
-                TableName: requireMainTableName(),
-                Key: recordKey("template", existing.id),
-                UpdateExpression: `SET ${setClauses.join(", ")}`,
-                ConditionExpression: "attribute_not_exists(#data.#dfk) OR #data.#dfk = :null",
-                ExpressionAttributeNames: names,
-                ExpressionAttributeValues: values
-            }));
-            this.bustTemplatesFeedCache();
-            return { template: { ...existing, defaultForkId: input.forkId, updatedAt: now }, becameDefault: true };
-        }
-        catch (error) {
-            // Lost the race: another decompose already stamped a default fork. Not an
-            // error — re-read so callers see the winning fork id.
-            if (error?.name === "ConditionalCheckFailedException") {
-                const winner = await this.getTemplate(input.templateId);
-                return { template: winner, becameDefault: false };
-            }
-            throw error;
-        }
-    }
-    // The discover feed is global (identical for every caller) and read on every
-    // homepage load, but templates live in per-customer gsi1 partitions — so
-    // template items also carry a FEED#template gsi2 partition whose sort key
-    // tiers decomposed templates above undecomposed ingests, each newest-first
-    // under one descending Query. The 60s per-container cache keeps warm hits at
-    // zero DynamoDB reads; template writes bust it so new content shows up
-    // immediately on the container that wrote it.
-    templatesFeedCache = null;
-    static TEMPLATES_FEED_TTL_MS = 60_000;
-    static TEMPLATES_FEED_MAX = 200;
-    bustTemplatesFeedCache() {
-        this.templatesFeedCache = null;
-    }
-    async listTemplatesFeed(input = {}) {
-        const limit = Math.max(1, Math.min(input.limit ?? 50, ServerlessRecordsServiceImpl.TEMPLATES_FEED_MAX));
-        const now = Date.now();
-        if (!this.templatesFeedCache || now - this.templatesFeedCache.fetchedAt > ServerlessRecordsServiceImpl.TEMPLATES_FEED_TTL_MS) {
-            let records = await this.queryTemplatesFeed();
-            if (records.length === 0) {
-                // Feed partition empty — either no templates exist or the gsi2
-                // attributes have not been backfilled yet (scripts/
-                // backfill-template-feed-gsi.ts). Fall back to the legacy scan with
-                // the same tiered ordering so the homepage never goes blank.
-                devLog("serverless_records.templates_feed_fallback_scan", {}, "warn");
-                records = (await this.scanCollection("template"))
-                    .sort((a, b) => templateFeedSortKey(b).localeCompare(templateFeedSortKey(a)));
-            }
-            // Private templates are excluded from the FEED partition at write time,
-            // but filter here too so the scan fallback (and any legacy feed items)
-            // never leak customer-scoped templates into the public feed.
-            records = records
-                .filter((record) => record.visibility !== "private")
-                .map(normalizeTemplateVisibility);
-            this.templatesFeedCache = { records, fetchedAt: now };
-        }
-        // Search is applied over the cached full feed (not baked into the cache key)
-        // so the coarse keyword filter never fights the TTL cache.
-        return filterAndRankBySearch(this.templatesFeedCache.records, input.query).slice(0, limit);
-    }
-    // Curated "Popular" picks: the handful of public templates flagged with a
-    // popularGroup. Drawn from the same cached feed as listTemplatesFeed (the set
-    // is tiny), ordered by popularRank so the editorial sequence is preserved.
-    async listPopularTemplates() {
-        const feed = await this.listTemplatesFeed({ limit: ServerlessRecordsServiceImpl.TEMPLATES_FEED_MAX });
-        return feed
-            .filter((record) => typeof record.popularGroup === "string" && record.popularGroup.trim().length > 0)
-            .sort((a, b) => (a.popularRank ?? 0) - (b.popularRank ?? 0));
-    }
-    async queryTemplatesFeed() {
-        const response = await dynamodb.send(new QueryCommand({
-            TableName: requireMainTableName(),
-            IndexName: "gsi2",
-            KeyConditionExpression: "gsi2pk = :pk",
-            ExpressionAttributeValues: {
-                ":pk": TEMPLATE_FEED_PARTITION
-            },
-            ScanIndexForward: false,
-            Limit: ServerlessRecordsServiceImpl.TEMPLATES_FEED_MAX
-        }));
-        return (response.Items ?? []).map((item) => item.data);
-    }
-    async createReadyPost(input) {
-        const timestamp = nowIso();
-        return this.putRecord("ready_post", {
-            id: input.id ?? createId("post"),
-            customerId: input.customerId,
-            status: input.status ?? "ready",
-            source: input.source ?? "hyperframes",
-            compositionId: input.compositionId ?? null,
-            tracer: input.tracer ?? null,
-            title: input.title ?? null,
-            caption: input.caption ?? "",
-            pinnedComment: input.pinnedComment ?? null,
-            // Self-file into a tracer-derived Approved subfolder (canonical
-            // `/approved/<slug>`), mirroring how raws default into a source folder. An
-            // explicit folderPath (incl. "" for the root) always wins.
-            folderPath: input.folderPath !== undefined
-                ? normalizeFolder(input.folderPath ?? "")
-                : (input.tracer ? slugFolderSegment(input.tracer) : ""),
-            mediaAssets: input.mediaAssets ?? [],
-            sharePasswordHash: input.sharePasswordHash ?? null,
-            zipStorageKey: input.zipStorageKey ?? null,
-            zipPublicUrl: input.zipPublicUrl ?? null,
-            archivedAt: input.archivedAt ?? null,
-            deletedAt: input.deletedAt ?? null,
-            createdAt: input.createdAt ?? timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async getReadyPost(postId) {
-        return this.getById("ready_post", postId);
-    }
-    async listReadyPosts(customerId) {
-        return this.listByCustomer("ready_post", customerId);
-    }
-    async archiveReadyPost(customerId, postId) {
-        const post = await this.getReadyPost(postId);
-        if (!post || post.customerId !== customerId)
-            return null;
-        return this.putRecord("ready_post", { ...post, status: "archived", archivedAt: nowIso(), updatedAt: nowIso() });
-    }
-    async deleteReadyPost(customerId, postId) {
-        const post = await this.getReadyPost(postId);
-        if (!post || post.customerId !== customerId)
-            return null;
-        const updated = await this.putRecord("ready_post", { ...post, status: "deleted", deletedAt: nowIso(), updatedAt: nowIso() });
-        return updated;
-    }
-    // Move one approved post into a folder (canonical /approved/<folderPath>); ""
-    // returns it to the root. Mirrors updateClipFolder for raws.
-    async setReadyPostFolder(customerId, postId, folderPath) {
-        const post = await this.getReadyPost(postId);
-        if (!post || post.customerId !== customerId)
-            return null;
-        return this.putRecord("ready_post", {
-            ...post,
-            folderPath: normalizeFolder(folderPath),
-            updatedAt: nowIso()
-        });
-    }
-    // Rename an approved folder by re-pointing every post inside it (the folder-rename
-    // primitive for the /approved directory root).
-    async moveReadyPostFolder(customerId, fromFolder, toFolder) {
-        await this.moveCollectionFolder("ready_post", customerId, fromFolder, toFolder);
-    }
-    async setReadyPostMedia(input) {
-        const post = await this.getReadyPost(input.postId);
-        if (!post || post.customerId !== input.customerId)
-            return null;
-        return this.putRecord("ready_post", {
-            ...post,
-            mediaAssets: input.mediaAssets,
-            updatedAt: nowIso()
-        });
-    }
-    async setReadyPostZip(input) {
-        const post = await this.getReadyPost(input.postId);
-        if (!post || post.customerId !== input.customerId)
-            return null;
-        return this.putRecord("ready_post", {
-            ...post,
-            zipStorageKey: input.zipStorageKey,
-            zipPublicUrl: input.zipPublicUrl,
-            updatedAt: nowIso()
-        });
-    }
-    async createSwipeCustomization(input) {
-        const timestamp = nowIso();
-        return this.putRecord("swipe_customization", {
-            id: input.id ?? createIdV7("swipe"),
-            customerId: input.customerId,
-            templateId: input.templateId,
-            forkId: input.forkId ?? null,
-            sourceTitle: input.sourceTitle ?? null,
-            status: input.status ?? "customizing",
-            pipelineVersion: input.pipelineVersion ?? null,
-            tailoredTitle: input.tailoredTitle ?? null,
-            tailoredCaption: input.tailoredCaption ?? "",
-            tailoredPinnedComment: input.tailoredPinnedComment ?? null,
-            captionStyleId: input.captionStyleId ?? null,
-            previewSourceUrl: input.previewSourceUrl ?? null,
-            durationSeconds: input.durationSeconds ?? null,
-            aspect: input.aspect ?? null,
-            jobId: input.jobId ?? null,
-            renderJobId: input.renderJobId ?? null,
-            readyPostId: input.readyPostId ?? null,
-            error: input.error ?? null,
-            decidedAt: input.decidedAt ?? null,
-            createdAt: input.createdAt ?? timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async getSwipeCustomization(id) {
-        return this.getById("swipe_customization", id);
-    }
-    async listSwipeCustomizationsForCustomer(customerId) {
-        return this.listByCustomer("swipe_customization", customerId);
-    }
-    async updateSwipeCustomization(input) {
-        const existing = await this.getSwipeCustomization(input.id);
-        if (!existing || existing.customerId !== input.customerId)
-            return null;
-        return this.putRecord("swipe_customization", {
-            ...existing,
-            ...input.patch,
-            id: existing.id,
-            customerId: existing.customerId,
-            updatedAt: nowIso()
-        });
-    }
-    async createPostSchedule(input) {
-        const timestamp = nowIso();
-        return this.putRecord("post_schedule", {
-            id: input.id ?? createId("sched"),
-            customerId: input.customerId,
-            readyPostId: input.readyPostId ?? null,
-            managedBy: input.managedBy ?? "vidfarm",
-            provider: input.provider ?? "flockposter",
-            destinationType: input.destinationType ?? "flockposter",
-            destinationId: input.destinationId ?? "",
-            scheduledAt: input.scheduledAt ?? timestamp,
-            timezone: input.timezone ?? null,
-            status: input.status ?? "scheduled",
-            providerStatus: input.providerStatus ?? null,
-            providerScheduleId: input.providerScheduleId ?? null,
-            title: input.title ?? null,
-            summary: input.summary ?? null,
-            url: input.url ?? null,
-            additionalNotes: input.additionalNotes ?? null,
-            providerPayload: input.providerPayload ?? {},
-            providerResponse: input.providerResponse ?? {},
-            lastSyncedAt: input.lastSyncedAt ?? null,
-            lastError: input.lastError ?? null,
-            cancelledAt: input.cancelledAt ?? null,
-            sentAt: input.sentAt ?? null,
-            createdAt: input.createdAt ?? timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async getPostSchedule(customerId, scheduleId) {
-        const schedule = await this.getById("post_schedule", scheduleId);
-        return schedule?.customerId === customerId ? schedule : null;
-    }
-    async listPostSchedulesForPost(customerId, readyPostId) {
-        return (await this.listByCustomer("post_schedule", customerId)).filter((schedule) => schedule.readyPostId === readyPostId);
-    }
-    async listPostSchedulesForCalendar(input) {
-        return (await this.listByCustomer("post_schedule", input.customerId)).filter((schedule) => {
-            const scheduledAt = String(schedule.scheduledAt ?? "");
-            if (input.startTime && scheduledAt < input.startTime)
-                return false;
-            if (input.endTime && scheduledAt > input.endTime)
-                return false;
-            return true;
-        });
-    }
-    async updatePostScheduleProvider(input) {
-        return this.mergeByIdForCustomer("post_schedule", input.customerId, input.scheduleId, input);
-    }
-    async markPostScheduleCancelled(input) {
-        return this.mergeByIdForCustomer("post_schedule", input.customerId, input.scheduleId, {
-            ...input,
-            status: "cancelled",
-            cancelledAt: nowIso()
-        });
-    }
-    async markPostScheduleFailed(input) {
-        return this.mergeByIdForCustomer("post_schedule", input.customerId, input.scheduleId, {
-            ...input,
-            status: "failed",
-            lastError: input.lastError ?? "Schedule failed"
-        });
-    }
-    async upsertExternalPostSchedule(input) {
-        const existing = (await this.listByCustomer("post_schedule", input.customerId))
-            .find((schedule) => schedule.providerScheduleId === input.providerScheduleId);
-        return this.createPostSchedule({ ...existing, ...input, managedBy: "external" });
-    }
-    async createEmailChannel(input) {
-        const timestamp = nowIso();
-        return this.putRecord("email_channel", {
-            id: input.id ?? createId("email"),
-            customerId: input.customerId,
-            title: input.title ?? input.email,
-            email: input.email,
-            note: input.note ?? null,
-            avatarUrl: input.avatarUrl ?? null,
-            avatarStorageKey: input.avatarStorageKey ?? null,
-            status: input.status ?? "unverified",
-            verificationTokenHash: input.verificationTokenHash ?? null,
-            verificationSentAt: input.verificationSentAt ?? null,
-            verifiedAt: input.verifiedAt ?? null,
-            createdAt: input.createdAt ?? timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async listEmailChannels(customerId) {
-        return this.listByCustomer("email_channel", customerId);
-    }
-    async getEmailChannel(customerId, channelId) {
-        const channel = await this.getById("email_channel", channelId);
-        return channel?.customerId === customerId ? channel : null;
-    }
-    async getEmailChannelByEmail(customerId, email) {
-        return (await this.listEmailChannels(customerId)).find((channel) => channel.email.toLowerCase() === email.toLowerCase()) ?? null;
-    }
-    async updateEmailChannel(input) {
-        return this.mergeByIdForCustomer("email_channel", input.customerId, input.channelId, input);
-    }
-    async updateEmailChannelAvatar(input) {
-        await this.updateEmailChannel(input);
-    }
-    async updateEmailChannelVerification(input) {
-        return this.updateEmailChannel(input);
-    }
-    async verifyEmailChannelByTokenHash(tokenHash) {
-        const response = await dynamodb.send(new ScanCommand({
-            TableName: requireMainTableName(),
-            FilterExpression: "entity_type = :type AND verificationTokenHash = :token",
-            ExpressionAttributeValues: {
-                ":type": "serverless_record#email_channel",
-                ":token": tokenHash
-            },
-            Limit: 1
-        }));
-        const channel = response.Items?.[0]?.data;
-        if (!channel)
-            return null;
-        return this.putRecord("email_channel", {
-            ...channel,
-            status: "verified",
-            verifiedAt: nowIso(),
-            verificationTokenHash: null,
-            updatedAt: nowIso()
-        });
-    }
-    async deleteEmailChannel(customerId, channelId) {
-        const existing = await this.getEmailChannel(customerId, channelId);
-        if (existing)
-            await this.deleteById("email_channel", channelId);
-    }
-    async createUserAttachment(input) {
-        const timestamp = nowIso();
-        return this.putRecord("user_attachment", {
-            id: input.id ?? createId("att"),
-            customerId: input.customerId,
-            fileName: input.fileName,
-            contentType: input.contentType ?? "application/octet-stream",
-            sizeBytes: input.sizeBytes ?? 0,
-            storageKey: input.storageKey,
-            folderPath: normalizeFolder(input.folderPath),
-            publicUrl: input.publicUrl ?? null,
-            thumbnailStorageKey: input.thumbnailStorageKey ?? null,
-            thumbnailUrl: input.thumbnailUrl ?? null,
-            notes: input.notes ?? null,
-            notesEmbedding: input.notesEmbedding ?? null,
-            notesEmbeddingModel: input.notesEmbeddingModel ?? null,
-            createdAt: input.createdAt ?? timestamp
-        });
-    }
-    async updateUserAttachmentNotes(customerId, attachmentId, patch) {
-        return this.mergeByIdForCustomer("user_attachment", customerId, attachmentId, patch);
-    }
-    // Rename a My Files entry. Only the record's display name changes — the S3
-    // storageKey (and therefore the durable view URL) is untouched, so this is a
-    // cheap metadata-only rename that keeps every existing link working.
-    async renameUserAttachment(customerId, attachmentId, fileName) {
-        return this.mergeByIdForCustomer("user_attachment", customerId, attachmentId, { fileName });
-    }
-    async listUserAttachments(customerId) {
-        return this.listByCustomer("user_attachment", customerId);
-    }
-    async getUserAttachment(customerId, attachmentId) {
-        const attachment = await this.getById("user_attachment", attachmentId);
-        return attachment?.customerId === customerId ? attachment : null;
-    }
-    async deleteUserAttachment(customerId, attachmentId) {
-        const existing = await this.getUserAttachment(customerId, attachmentId);
-        if (existing)
-            await this.deleteById("user_attachment", attachmentId);
-    }
-    async createUserTemporaryFile(input) {
-        const timestamp = nowIso();
-        const expiresAt = input.expiresAt ?? timestamp;
-        // Native DynamoDB TTL (top-level expires_at_epoch_seconds) so temp-file
-        // records auto-expire even if no list sweep ever runs; the S3 object is
-        // separately expired by the tag-scoped bucket lifecycle rule.
-        const expiresAtEpochSeconds = Math.floor(Date.parse(expiresAt) / 1000);
-        return this.putRecord("user_temporary_file", {
-            id: input.id ?? createId("tmp"),
-            customerId: input.customerId,
-            fileName: input.fileName,
-            contentType: input.contentType ?? "application/octet-stream",
-            sizeBytes: input.sizeBytes ?? 0,
-            storageKey: input.storageKey,
-            folderPath: normalizeFolder(input.folderPath),
-            expiresAt,
-            createdAt: input.createdAt ?? timestamp
-        }, Number.isFinite(expiresAtEpochSeconds) ? { expiresAtEpochSeconds } : undefined);
-    }
-    async listUserTemporaryFiles(customerId) {
-        return this.listByCustomer("user_temporary_file", customerId);
-    }
-    async getUserTemporaryFile(customerId, fileId) {
-        const file = await this.getById("user_temporary_file", fileId);
-        return file?.customerId === customerId ? file : null;
-    }
-    async deleteUserTemporaryFile(customerId, fileId) {
-        const existing = await this.getUserTemporaryFile(customerId, fileId);
-        if (existing)
-            await this.deleteById("user_temporary_file", fileId);
-    }
-    // Rename a temp file (display name only; storageKey/view URL untouched).
-    async renameUserTemporaryFile(customerId, fileId, fileName) {
-        return this.mergeByIdForCustomer("user_temporary_file", customerId, fileId, { fileName });
-    }
-    async deleteExpiredUserTemporaryFiles() {
-        const now = nowIso();
-        const files = (await this.scanCollection("user_temporary_file"))
-            .filter(isExpiredUserTemporaryFileRecord);
-        const expired = files.filter((file) => file.expiresAt <= now);
-        for (const file of expired)
-            await this.deleteById("user_temporary_file", file.id);
-        return expired;
-    }
-    async createUserFileFolder(customerId, scope, folderPath) {
-        const normalized = normalizeFolder(folderPath);
-        await this.putRecord("user_file_folder", {
-            id: `${customerId}:${scope}:${normalized}`,
-            customerId,
-            scope,
-            folderPath: normalized
-        });
-    }
-    async listUserFileFolders(customerId, scope) {
-        return (await this.listByCustomer("user_file_folder", customerId))
-            .filter((folder) => folder.scope === scope)
-            .map((folder) => String(folder.folderPath));
-    }
-    async moveUserFileFolder(customerId, scope, fromFolder, toFolder) {
-        await this.deleteUserFileFolder(customerId, scope, fromFolder);
-        await this.createUserFileFolder(customerId, scope, toFolder);
-    }
-    async deleteUserFileFolder(customerId, scope, folderPath) {
-        await this.deleteById("user_file_folder", `${customerId}:${scope}:${normalizeFolder(folderPath)}`);
-    }
-    async moveUserAttachmentFolder(customerId, fromFolder, toFolder) {
-        await this.moveCollectionFolder("user_attachment", customerId, fromFolder, toFolder);
-    }
-    async deleteUserAttachmentFolder(customerId, folderPath) {
-        return this.deleteCollectionFolder("user_attachment", customerId, folderPath);
-    }
-    async moveUserTemporaryFolder(customerId, fromFolder, toFolder) {
-        await this.moveCollectionFolder("user_temporary_file", customerId, fromFolder, toFolder);
-    }
-    async deleteUserTemporaryFolder(customerId, folderPath) {
-        return this.deleteCollectionFolder("user_temporary_file", customerId, folderPath);
-    }
-    async queueWebhookDelivery(input) {
-        const timestamp = nowIso();
-        await this.putRecord("webhook_delivery", {
-            id: typeof input.id === "string" ? input.id : createId("webhook"),
-            customerId: typeof input.customerId === "string" ? input.customerId : undefined,
-            jobId: input.jobId,
-            destinationUrl: input.destinationUrl,
-            destination_url: input.destinationUrl,
-            eventType: input.eventType,
-            event_type: input.eventType,
-            payload: input.payload,
-            payload_json: JSON.stringify(input.payload ?? {}),
-            status: "pending",
-            attemptCount: 0,
-            attempt_count: 0,
-            nextAttemptAt: timestamp,
-            next_attempt_at: timestamp,
-            createdAt: timestamp,
-            updatedAt: timestamp
-        });
-    }
-    async listPendingWebhookDeliveries(limit = 100) {
-        const response = await dynamodb.send(new ScanCommand({
-            TableName: requireMainTableName(),
-            FilterExpression: "entity_type = :type AND #data.#status = :status",
-            ExpressionAttributeNames: { "#data": "data", "#status": "status" },
-            ExpressionAttributeValues: {
-                ":type": "serverless_record#webhook_delivery",
-                ":status": "pending"
-            },
-            Limit: limit
-        }));
-        return (response.Items ?? []).map((item) => item.data);
-    }
-    async markWebhookDelivery(input) {
-        const existing = await this.getById("webhook_delivery", input.id);
-        if (!existing)
-            return;
-        await this.putRecord("webhook_delivery", {
-            ...existing,
-            ...input,
-            attempt_count: input.attemptCount ?? input.attempt_count ?? existing.attempt_count,
-            next_attempt_at: input.nextAttemptAt ?? input.next_attempt_at ?? existing.next_attempt_at,
-            updatedAt: nowIso()
-        });
-    }
-    async listChatThreadMetas(input) {
-        const limit = Math.max(1, Math.min(input.limit ?? 100, 500));
-        return (await this.listByCustomer("chat_thread", input.customerId))
-            .filter((thread) => !input.templateId || thread.templateId === input.templateId)
-            .sort((a, b) => String(b.updatedAt ?? "").localeCompare(String(a.updatedAt ?? "")))
-            .slice(0, limit);
-    }
-    async getChatThreadMeta(customerId, threadId) {
-        const thread = await this.getById("chat_thread", threadId);
-        return thread?.customerId === customerId ? thread : null;
-    }
-    async appendChatThreadMessages(input) {
-        const existing = await this.getChatThreadMeta(input.customerId, input.threadId);
-        const timestamp = nowIso();
-        const thread = {
-            id: input.threadId,
-            customerId: input.customerId,
-            templateId: input.templateId,
-            title: input.title,
-            storagePrefix: input.storagePrefix,
-            tracers: input.tracers,
-            messageCount: (existing?.messageCount ?? 0) + input.messageCountDelta,
-            lastMessageAt: input.lastMessageAt,
-            hiddenFromView: existing?.hiddenFromView ?? false,
-            archivedAt: existing?.archivedAt ?? null,
-            createdAt: existing?.createdAt ?? timestamp,
-            updatedAt: timestamp,
-            messages: []
-        };
-        return this.putRecord("chat_thread", thread);
-    }
-    async updateChatThreadState(input) {
-        const existing = await this.getChatThreadMeta(input.customerId, input.threadId);
-        if (!existing)
-            return null;
-        return this.putRecord("chat_thread", {
-            ...existing,
-            title: input.title ?? existing.title,
-            tracers: input.tracers ?? existing.tracers,
-            hiddenFromView: input.hiddenFromView ?? existing.hiddenFromView,
-            archivedAt: input.archivedAt === undefined ? existing.archivedAt : input.archivedAt,
-            updatedAt: nowIso()
-        });
-    }
-    async deleteChatThread(customerId, threadId) {
-        const existing = await this.getChatThreadMeta(customerId, threadId);
-        if (!existing)
-            return null;
-        await this.deleteById("chat_thread", threadId);
-        return existing;
-    }
-    async createTemplateSource(input) {
-        return this.putRecord("template_source", { id: input.id ?? createId("tsrc"), ...input });
-    }
-    async updateTemplateSource(input) {
-        const existing = await this.getById("template_source", String(input.id));
-        return this.putRecord("template_source", { ...existing, ...input, updatedAt: nowIso() });
-    }
-    async getTemplateSource(sourceId) {
-        return this.getById("template_source", sourceId);
-    }
-    async getTemplateSourceByTemplateId(templateId) {
-        return this.findByScan("template_source", (item) => item.templateId === templateId);
-    }
-    async getTemplateSourceBySlugId(slugId) {
-        return this.findByScan("template_source", (item) => item.slugId === slugId);
-    }
-    async getTemplateSourceByLocation(repoUrl, branch, templateModulePath) {
-        return this.findByScan("template_source", (item) => item.repoUrl === repoUrl && item.branch === branch && item.templateModulePath === templateModulePath);
-    }
-    async listTemplateSources() {
-        return this.scanCollection("template_source");
-    }
-    async createTemplateRelease(input) {
-        return this.putRecord("template_release", { id: input.id ?? createId("trel"), ...input });
-    }
-    async getTemplateRelease(releaseId) {
-        return this.getById("template_release", releaseId);
-    }
-    async getTemplateReleaseBySourceAndCommit(sourceId, commitSha) {
-        return this.findByScan("template_release", (item) => item.sourceId === sourceId && item.commitSha === commitSha);
-    }
-    async getLatestTemplateReleaseForSource(sourceId) {
-        return (await this.scanCollection("template_release"))
-            .filter((release) => release.sourceId === sourceId)
-            .sort((a, b) => String(b.createdAt ?? "").localeCompare(String(a.createdAt ?? "")))[0] ?? null;
-    }
-    async listTemplateReleases() {
-        return this.scanCollection("template_release");
-    }
-    async listActiveTemplateReleases() {
-        const releases = [];
-        let cursor = null;
-        do {
-            const page = await this.listActiveTemplateReleasePage({ cursor, limit: 500 });
-            releases.push(...page.items);
-            cursor = page.nextCursor;
-        } while (cursor);
-        return releases;
-    }
-    async listActiveTemplateReleasePage(input = {}) {
-        const limit = Math.max(1, Math.min(input.limit ?? 100, 500));
-        const releases = [];
-        let ExclusiveStartKey = decodeDynamoCursor(input.cursor);
-        do {
-            const response = await dynamodb.send(new QueryCommand({
-                TableName: requireMainTableName(),
-                IndexName: "gsi1",
-                KeyConditionExpression: "gsi1pk = :pk",
-                FilterExpression: "#data.#record_kind = :kind",
-                ExpressionAttributeNames: {
-                    "#data": "data",
-                    "#record_kind": "recordKind"
-                },
-                ExpressionAttributeValues: {
-                    ":pk": collectionPk("active_template"),
-                    ":kind": "active_template_release"
-                },
-                ScanIndexForward: false,
-                Limit: Math.max(1, limit - releases.length),
-                ExclusiveStartKey
-            }));
-            releases.push(...(response.Items ?? []).map((item) => item.data));
-            ExclusiveStartKey = response.LastEvaluatedKey;
-        } while (ExclusiveStartKey && releases.length < limit);
-        return {
-            items: releases,
-            nextCursor: encodeDynamoCursor(ExclusiveStartKey)
-        };
-    }
-    async getActiveTemplateReleaseByTemplateId(templateId) {
-        const direct = await this.getById("active_template", templateId);
-        if (direct?.recordKind === "active_template_release") {
-            return direct;
-        }
-        const alias = await this.getById("active_template", activeTemplateSlugAliasId(templateId));
-        if (alias?.recordKind === "active_template_slug_alias" && typeof alias.templateId === "string") {
-            const release = await this.getById("active_template", alias.templateId);
-            return release?.recordKind === "active_template_release"
-                ? release
-                : null;
-        }
-        return null;
-    }
-    async putActiveTemplateRelease(release) {
-        const slugId = release.templateSnapshot?.slugId;
-        const data = await this.putRecord("active_template", {
-            ...release,
-            id: release.templateId,
-            recordKind: "active_template_release",
-            updatedAt: release.activatedAt ?? release.updatedAt ?? nowIso()
-        });
-        if (slugId) {
-            await this.putRecord("active_template", {
-                id: activeTemplateSlugAliasId(slugId),
-                recordKind: "active_template_slug_alias",
-                templateId: release.templateId,
-                slugId,
-                releaseId: release.id,
-                updatedAt: release.activatedAt ?? release.updatedAt ?? nowIso()
-            });
-        }
-        return data;
-    }
-    async updateTemplateReleaseStatus(input) {
-        const existing = await this.getById("template_release", input.releaseId);
-        if (existing)
-            await this.putRecord("template_release", { ...existing, ...input, id: input.releaseId, updatedAt: nowIso() });
-    }
-    async clearActiveTemplateReleases(templateId) {
-        const active = await this.getActiveTemplateReleaseByTemplateId(templateId);
-        if (active) {
-            await this.putRecord("template_release", { ...active, id: String(active.id), status: "approved", activatedAt: null, updatedAt: nowIso() });
-            await this.deleteById("active_template", active.templateId);
-            if (active.templateSnapshot?.slugId) {
-                await this.deleteById("active_template", activeTemplateSlugAliasId(active.templateSnapshot.slugId));
-            }
-        }
-    }
-    async call(method, args) {
-        const collection = METHOD_COLLECTIONS[method];
-        if (!collection) {
-            throw new Error(`Serverless record method ${method} is not implemented.`);
-        }
-        devLog("serverless_records.dynamic_call", { method, collection });
-        throw new Error(`Serverless record method ${method} requires a typed implementation.`);
-    }
-    async mergeByIdForCustomer(collection, customerId, id, patch) {
-        const existing = await this.getById(collection, id);
-        if (!existing || existing.customerId !== customerId)
-            return null;
-        return this.putRecord(collection, { ...existing, ...patch, id, customerId, updatedAt: nowIso() });
-    }
-    async moveCollectionFolder(collection, customerId, fromFolder, toFolder) {
-        for (const record of await this.listByCustomer(collection, customerId)) {
-            if (normalizeFolder(String(record.folderPath ?? "")) === normalizeFolder(fromFolder)) {
-                await this.putRecord(collection, { ...record, folderPath: normalizeFolder(toFolder), updatedAt: nowIso() });
-            }
-        }
-    }
-    async deleteCollectionFolder(collection, customerId, folderPath) {
-        const deleted = [];
-        for (const record of await this.listByCustomer(collection, customerId)) {
-            if (normalizeFolder(String(record.folderPath ?? "")) === normalizeFolder(folderPath)) {
-                await this.deleteById(collection, String(record.id));
-                deleted.push(record);
-            }
-        }
-        return deleted;
-    }
-    async findByScan(collection, predicate) {
-        return (await this.scanCollection(collection)).find(predicate) ?? null;
-    }
-    async scanCollection(collection) {
-        const results = [];
-        let exclusiveStartKey;
-        // DDB Scan with FilterExpression only reads one page at a time; matching
-        // items later in the table are silently dropped unless you follow
-        // LastEvaluatedKey. Paginate until DDB stops returning a cursor.
-        do {
-            const response = await dynamodb.send(new ScanCommand({
-                TableName: requireMainTableName(),
-                FilterExpression: "entity_type = :type",
-                ExpressionAttributeValues: {
-                    ":type": entityType(collection)
-                },
-                ExclusiveStartKey: exclusiveStartKey
-            }));
-            for (const item of response.Items ?? []) {
-                results.push(item.data);
-            }
-            exclusiveStartKey = response.LastEvaluatedKey;
-        } while (exclusiveStartKey);
-        return results;
-    }
-    async listByCustomer(collection, customerId) {
-        return this.listByPartition(collection, customerCollectionPk(collection, customerId));
-    }
-    async listByPartition(_collection, partitionKey) {
-        const response = await dynamodb.send(new QueryCommand({
-            TableName: requireMainTableName(),
-            IndexName: "gsi1",
-            KeyConditionExpression: "gsi1pk = :pk",
-            ExpressionAttributeValues: {
-                ":pk": partitionKey
-            },
-            ScanIndexForward: false
-        }));
-        return (response.Items ?? []).map((item) => item.data);
-    }
-    async getById(collection, id) {
-        const response = await dynamodb.send(new GetCommand({
-            TableName: requireMainTableName(),
-            Key: recordKey(collection, id)
-        }));
-        return response.Item?.data ?? null;
-    }
-    async deleteById(collection, id) {
-        await dynamodb.send(new DeleteCommand({
-            TableName: requireMainTableName(),
-            Key: recordKey(collection, id)
-        }));
-        devLog("serverless_records.deleted", { collection, id });
-    }
-    async putRecord(collection, record, options) {
-        const timestamp = nowIso();
-        const id = typeof record.id === "string" && record.id ? record.id : createId("rec");
-        const data = {
-            ...record,
-            id,
-            createdAt: record.createdAt ?? timestamp,
-            updatedAt: record.updatedAt ?? timestamp
-        };
-        const gsi1pk = options?.partitionKey
-            ?? (data.customerId ? customerCollectionPk(collection, String(data.customerId)) : collectionPk(collection));
-        const item = {
-            ...recordKey(collection, id),
-            entity_type: entityType(collection),
-            gsi1pk,
-            gsi1sk: `${String(data.updatedAt)}#${id}`,
-            // Top-level so the table's native TTL (timeToLiveAttribute) can act on it.
-            ...(options?.expiresAtEpochSeconds ? { expires_at_epoch_seconds: options.expiresAtEpochSeconds } : {}),
-            data
-        };
-        // Private templates stay out of the global FEED partition (sparse gsi2):
-        // they are only reachable via their owner's gsi1 customer partition.
-        if (collection === "template" && data.visibility !== "private") {
-            item.gsi2pk = TEMPLATE_FEED_PARTITION;
-            item.gsi2sk = templateFeedSortKey(data);
-        }
-        await dynamodb.send(new PutCommand({
-            TableName: requireMainTableName(),
-            Item: item
-        }));
-        devLog("serverless_records.put", {
-            collection,
-            id,
-            customer_id: data.customerId ?? null,
-            partition_key: gsi1pk
-        });
-        return data;
-    }
-}
-function forkPartitionPk(collection, forkId) {
-    return `FORK#${forkId}#${collection}`;
-}
-// Records written before the visibility/notes fields existed have no such
-// attributes — they are all the seeded public catalog, so default to public.
-function normalizeTemplateVisibility(record) {
-    return {
-        ...record,
-        visibility: record.visibility ?? "public",
-        notes: record.notes ?? null
-    };
-}
-function normalizeInspirationVisibility(record) {
-    return {
-        ...record,
-        visibility: record.visibility ?? "public",
-        notes: record.notes ?? null
-    };
-}
-function contentSearchHaystack(record) {
-    const parts = [];
-    const push = (value) => {
-        if (typeof value === "string") {
-            if (value.trim())
-                parts.push(value.toLowerCase());
-        }
-        else if (Array.isArray(value)) {
-            for (const item of value) {
-                if (typeof item === "string" && item.trim())
-                    parts.push(item.toLowerCase());
-            }
-        }
-    };
-    push(record.title);
-    push(record.trendTagline);
-    push(record.notes);
-    push(record.viralDna);
-    push(record.searchSummary);
-    push(record.promotions);
-    push(record.keywords);
-    return parts.join(" 
 ");
-}
-export function tokenizeSearchQuery(query) {
-    if (!query)
-        return [];
-    return Array.from(new Set(query
-        .toLowerCase()
-        .split(/[^a-z0-9]+/i)
-        .map((token) => token.trim())
-        .filter((token) => token.length >= 2)));
-}
-// Exported predicate for callers that interleave records outside the feed
-// methods (e.g. a logged-in user's own templates) and want them filtered by the
-// same coarse keyword rule. An empty/whitespace query matches everything.
-export function recordMatchesSearchQuery(record, query) {
-    const tokens = tokenizeSearchQuery(query);
-    return tokens.length === 0 || scoreContentMatch(record, tokens) > 0;
-}
-function scoreContentMatch(record, tokens) {
-    if (tokens.length === 0)
-        return 1;
-    const haystack = contentSearchHaystack(record);
-    let score = 0;
-    for (const token of tokens) {
-        if (haystack.includes(token))
-            score += 1;
-    }
-    return score;
-}
-// Filter to records matching at least one query token, ranked by token-hit
-// count (descending), preserving the caller's incoming order on ties. Returns
-// the input unchanged when the query is empty.
-function filterAndRankBySearch(records, query) {
-    const tokens = tokenizeSearchQuery(query);
-    if (tokens.length === 0)
-        return records;
-    return records
-        .map((record, index) => ({ record, index, score: scoreContentMatch(record, tokens) }))
-        .filter((entry) => entry.score > 0)
-        .sort((a, b) => (b.score - a.score) || (a.index - b.index))
-        .map((entry) => entry.record);
-}
-// Global discover-feed partition on gsi2 (job records use gsi2 under
-// CUSTOMER#... partitions — no overlap). The sort key tiers the feed:
-// "1#createdAt#id" (decomposed, has defaultForkId) sorts above
-// "0#createdAt#id" (undecomposed ingest) in a descending query, giving
-// decomposed templates newest-first, then fresh ingests newest-first.
-export const TEMPLATE_FEED_PARTITION = "FEED#template";
-export function templateFeedSortKey(record) {
-    const tier = record.defaultForkId ? "1" : "0";
-    return `${tier}#${String(record.createdAt ?? "")}#${String(record.id ?? "")}`;
-}
-function requireMainTableName() {
-    // In local mode the shim keys files by this name only, so a fixed default is
-    // fine and the env var is not required.
-    if (config.RECORDS_DRIVER === "local") {
-        return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME || "vidfarm-local-main";
-    }
-    if (!config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME) {
-        throw new Error("Serverless record store requires VIDFARM_SERVERLESS_MAIN_TABLE_NAME.");
-    }
-    return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME;
-}
-function recordKey(collection, id) {
-    return {
-        pk: `${collectionPk(collection)}#${id}`,
-        sk: "META"
-    };
-}
-function collectionPk(collection) {
-    return `SERVERLESS_RECORD#${collection}`;
-}
-function activeTemplateSlugAliasId(slugId) {
-    return `slug#${slugId}`;
-}
-function encodeDynamoCursor(value) {
-    return value ? Buffer.from(JSON.stringify(value), "utf8").toString("base64url") : null;
-}
-function decodeDynamoCursor(raw) {
-    if (!raw) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
-        return parsed && typeof parsed === "object" ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function customerCollectionPk(collection, customerId) {
-    return `CUSTOMER#${customerId}#${collection}`;
-}
-function entityType(collection) {
-    return `serverless_record#${collection}`;
-}
-function normalizeFolder(value) {
-    if (typeof value !== "string")
-        return "";
-    return value.trim().replace(/^\/+|\/+$/g, "");
-}
-// Slugify a single folder-name segment (e.g. a tracer → an /approved subfolder).
-function slugFolderSegment(value) {
-    return String(value ?? "")
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 60);
-}
-function isExpiredUserTemporaryFileRecord(record) {
-    return typeof record.id === "string"
-        && record.id.length > 0
-        && typeof record.expiresAt === "string"
-        && record.expiresAt.length > 0;
-}
-function itemToCustomer(item) {
-    return {
-        id: String(item.customer_id),
-        email: String(item.email),
-        name: typeof item.name === "string" ? item.name : null,
-        defaultWebhookUrl: typeof item.default_webhook_url === "string" ? item.default_webhook_url : null,
-        isDeveloper: Boolean(item.is_developer),
-        isAgency: Boolean(item.is_agency),
-        isPaidPlan: Boolean(item.is_paid_plan),
-        planTier: item.plan_tier === "standalone" || item.plan_tier === "agency" ? item.plan_tier : "client",
-        about: typeof item.about === "string" ? item.about : null,
-        groupchatUrl: typeof item.groupchat_url === "string" ? item.groupchat_url : null,
-        flockposterApiKey: typeof item.flockposter_api_key === "string" ? item.flockposter_api_key : null,
-        createdAt: typeof item.created_at === "string" ? item.created_at : nowIso(),
-        updatedAt: typeof item.updated_at === "string" ? item.updated_at : nowIso()
-    };
-}
-export const serverlessRecords = new ServerlessRecordsServiceImpl();
-//# sourceMappingURL=serverless-records.js.map