@mevdragon/vidfarm-devcli 0.5.3 → 0.7.0

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

@@ -0,0 +1,1385 @@
+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",
+    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 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: 1
+        }));
+        return response.Items?.[0] ?? null;
+    }
+    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",
+            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",
+            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);
+    }
+    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,
+            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;
+    }
+    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 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,
+            createdAt: input.createdAt ?? timestamp
+        });
+    }
+    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();
+        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: input.expiresAt ?? timestamp,
+            createdAt: input.createdAt ?? timestamp
+        });
+    }
+    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);
+    }
+    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}`,
+            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, "");
+}
+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