@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

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

@@ -1,250 +0,0 @@
-// Cloud clip records — DynamoDB single-table store for clip curation, mirroring
-// the serverless-records / serverless-jobs conventions (pk/sk + gsi1 overload,
-// entity_type tag, local-dynamo shim in `serve` mode). Same Clip shape as the
-// devcli SQLite store so users move between local and cloud without lock-in.
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DeleteCommand, DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
-import { config } from "../config.js";
-import { createLocalDynamoClient } from "./local-dynamo.js";
-import { BUILTIN_PRESETS } from "./clip-curation/index.js";
-// Same client construction as serverless-records.ts: disk shim locally, real
-// client when deployed. Call sites are identical either way.
-const dynamodb = config.RECORDS_DRIVER === "local"
-    ? createLocalDynamoClient()
-    : DynamoDBDocumentClient.from(new DynamoDBClient({}), {
-        marshallOptions: { removeUndefinedValues: true }
-    });
-function requireMainTableName() {
-    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("Clip record store requires VIDFARM_SERVERLESS_MAIN_TABLE_NAME.");
-    }
-    return config.VIDFARM_SERVERLESS_MAIN_TABLE_NAME;
-}
-const ENTITY_CLIP = "clip_curation_clip";
-const ENTITY_PRESET = "clip_curation_preset";
-const ENTITY_SOURCE = "clip_curation_source";
-const ENTITY_SCAN = "clip_curation_scan";
-// Key scheme (one owner partition, sk-prefixed by entity; gsi1 lists by recency).
-const clipPk = (owner) => `USER#${owner}`;
-const clipSk = (clipId) => `CLIP#${clipId}`;
-const clipListPk = (owner) => `USER#${owner}#CLIPS`;
-const clipSourceListPk = (owner, sourceId) => `USER#${owner}#CLIPS#SRC#${sourceId}`;
-const presetSk = (presetId) => `CLIPPRESET#${presetId}`;
-const presetListPk = (owner) => `USER#${owner}#CLIPPRESETS`;
-const sourceSk = (sourceId) => `CLIPSRC#${sourceId}`;
-const sourceListPk = (owner) => `USER#${owner}#CLIPSRCS`;
-const scanSk = (scanId) => `CLIPSCAN#${scanId}`;
-export class ClipRecordsService {
-    // ── Clips ────────────────────────────────────────────────────────────────
-    async putClip(clip) {
-        const owner = requireOwner(clip.owner_id);
-        await dynamodb.send(new PutCommand({
-            TableName: requireMainTableName(),
-            Item: {
-                pk: clipPk(owner),
-                sk: clipSk(clip.clip_id),
-                entity_type: ENTITY_CLIP,
-                gsi1pk: clipListPk(owner),
-                gsi1sk: `${clip.created_at}#${clip.clip_id}`,
-                gsi2pk: clipSourceListPk(owner, clip.source_video_id),
-                gsi2sk: `${clip.start_time_sec.toFixed(3)}#${clip.clip_id}`,
-                ...clip
-            }
-        }));
-    }
-    async getClip(owner, clipId) {
-        const res = await dynamodb.send(new GetCommand({ TableName: requireMainTableName(), Key: { pk: clipPk(owner), sk: clipSk(clipId) } }));
-        return res.Item ? stripKeys(res.Item) : null;
-    }
-    /** List a user's clips (newest first), optionally scoped to a source video. */
-    async listClips(owner, opts = {}) {
-        const limit = opts.limit ?? 200;
-        if (opts.sourceVideoId) {
-            const res = await dynamodb.send(new QueryCommand({
-                TableName: requireMainTableName(),
-                IndexName: "gsi2",
-                KeyConditionExpression: "gsi2pk = :pk",
-                ExpressionAttributeValues: { ":pk": clipSourceListPk(owner, opts.sourceVideoId) },
-                Limit: limit
-            }));
-            return (res.Items ?? []).map(stripKeys);
-        }
-        const res = await dynamodb.send(new QueryCommand({
-            TableName: requireMainTableName(),
-            IndexName: "gsi1",
-            KeyConditionExpression: "gsi1pk = :pk",
-            ExpressionAttributeValues: { ":pk": clipListPk(owner) },
-            ScanIndexForward: false,
-            Limit: limit
-        }));
-        return (res.Items ?? []).map(stripKeys);
-    }
-    /** All embeddings for a user's clips — feeds the brute-force vector search. */
-    async listClipsWithEmbeddings(owner) {
-        const clips = await this.listClips(owner, { limit: 5000 });
-        return clips.filter((c) => Array.isArray(c.embedding) && c.embedding.length > 0);
-    }
-    /**
-     * The embedding model the library was built with (from the newest embedded
-     * clip). A match query must be embedded with the SAME model to be comparable.
-     */
-    async getLibraryEmbeddingModel(owner) {
-        const clips = await this.listClips(owner, { limit: 20 });
-        for (const c of clips) {
-            if (c.embedding_model && Array.isArray(c.embedding) && c.embedding.length > 0)
-                return c.embedding_model;
-        }
-        return null;
-    }
-    async deleteClip(owner, clipId) {
-        await dynamodb.send(new DeleteCommand({ TableName: requireMainTableName(), Key: { pk: clipPk(owner), sk: clipSk(clipId) } }));
-    }
-    /**
-     * Move a clip between virtual Raws folders. Partial update (doesn't rewrite
-     * the embedding vector). `folderPath` is stored normalized; "" = raws root.
-     */
-    async updateClipFolder(owner, clipId, folderPath) {
-        await dynamodb.send(new UpdateCommand({
-            TableName: requireMainTableName(),
-            Key: { pk: clipPk(owner), sk: clipSk(clipId) },
-            UpdateExpression: "SET folder_path = :fp",
-            ConditionExpression: "attribute_exists(pk)",
-            ExpressionAttributeValues: { ":fp": folderPath }
-        }));
-    }
-    /**
-     * Rename/move a whole Raws folder: re-point every clip whose folder_path is
-     * `fromFolder` OR nested beneath it onto `toFolder` (prefix-preserving), so a
-     * folder rename carries its subfolders too. Returns the count moved.
-     * Paths are compared normalized (trimmed, no leading/trailing slashes).
-     */
-    async moveClipsFolder(owner, fromFolder, toFolder) {
-        const norm = (v) => String(v ?? "").split("/").map((s) => s.trim()).filter(Boolean).join("/");
-        const from = norm(fromFolder);
-        const to = norm(toFolder);
-        if (!from || from === to)
-            return 0;
-        const clips = await this.listClips(owner, { limit: 5000 });
-        let moved = 0;
-        for (const clip of clips) {
-            const fp = norm(clip.folder_path);
-            let next = null;
-            if (fp === from)
-                next = to;
-            else if (fp.startsWith(from + "/"))
-                next = to + fp.slice(from.length);
-            if (next != null) {
-                await this.updateClipFolder(owner, clip.clip_id, next);
-                moved += 1;
-            }
-        }
-        return moved;
-    }
-    // ── Presets ──────────────────────────────────────────────────────────────
-    async listPresets(owner) {
-        const res = await dynamodb.send(new QueryCommand({
-            TableName: requireMainTableName(),
-            KeyConditionExpression: "pk = :pk AND begins_with(sk, :sk)",
-            ExpressionAttributeValues: { ":pk": clipPk(owner), ":sk": "CLIPPRESET#" }
-        }));
-        const saved = (res.Items ?? []).map((i) => stripKeys(i));
-        return [...BUILTIN_PRESETS, ...saved];
-    }
-    async putPreset(owner, preset) {
-        await dynamodb.send(new PutCommand({
-            TableName: requireMainTableName(),
-            Item: {
-                pk: clipPk(owner),
-                sk: presetSk(preset.preset_id),
-                entity_type: ENTITY_PRESET,
-                gsi1pk: presetListPk(owner),
-                gsi1sk: preset.created_at,
-                ...preset,
-                owner_id: owner
-            }
-        }));
-    }
-    async deletePreset(owner, presetId) {
-        await dynamodb.send(new DeleteCommand({ TableName: requireMainTableName(), Key: { pk: clipPk(owner), sk: presetSk(presetId) } }));
-    }
-    // ── Source videos ──────────────────────────────────────────────────────────
-    async putSource(record) {
-        await dynamodb.send(new PutCommand({
-            TableName: requireMainTableName(),
-            Item: {
-                pk: clipPk(record.owner_id),
-                sk: sourceSk(record.source_video_id),
-                entity_type: ENTITY_SOURCE,
-                gsi1pk: sourceListPk(record.owner_id),
-                gsi1sk: record.created_at,
-                ...record
-            }
-        }));
-    }
-    async getSource(owner, sourceId) {
-        const res = await dynamodb.send(new GetCommand({ TableName: requireMainTableName(), Key: { pk: clipPk(owner), sk: sourceSk(sourceId) } }));
-        return res.Item ? stripKeys(res.Item) : null;
-    }
-    async listSources(owner) {
-        const res = await dynamodb.send(new QueryCommand({
-            TableName: requireMainTableName(),
-            IndexName: "gsi1",
-            KeyConditionExpression: "gsi1pk = :pk",
-            ExpressionAttributeValues: { ":pk": sourceListPk(owner) },
-            ScanIndexForward: false
-        }));
-        return (res.Items ?? []).map((i) => stripKeys(i));
-    }
-    // ── Scan jobs ──────────────────────────────────────────────────────────────
-    async putScan(record) {
-        await dynamodb.send(new PutCommand({
-            TableName: requireMainTableName(),
-            Item: {
-                pk: clipPk(record.owner_id),
-                sk: scanSk(record.scan_id),
-                entity_type: ENTITY_SCAN,
-                ...record
-            }
-        }));
-    }
-    async getScan(owner, scanId) {
-        const res = await dynamodb.send(new GetCommand({ TableName: requireMainTableName(), Key: { pk: clipPk(owner), sk: scanSk(scanId) } }));
-        return res.Item ? stripKeys(res.Item) : null;
-    }
-}
-export const clipRecords = new ClipRecordsService();
-/** Build a user-saved preset record from raw criteria. */
-export function makeUserPreset(input) {
-    return {
-        preset_id: `preset_${Date.now().toString(36)}_${Math.floor(Math.random() * 1e6).toString(36)}`,
-        name: input.name,
-        description: input.description,
-        criteria: input.criteria,
-        builtin: false,
-        owner_id: input.owner,
-        created_at: new Date().toISOString()
-    };
-}
-function requireOwner(owner) {
-    if (!owner)
-        throw new Error("Clip records require an owner_id.");
-    return owner;
-}
-// Drop the DynamoDB key/index attributes so callers get back a clean record.
-function stripKeys(item) {
-    const { pk, sk, entity_type, gsi1pk, gsi1sk, gsi2pk, gsi2sk, gsi3pk, gsi3sk, ...rest } = item;
-    void pk;
-    void sk;
-    void entity_type;
-    void gsi1pk;
-    void gsi1sk;
-    void gsi2pk;
-    void gsi2sk;
-    void gsi3pk;
-    void gsi3sk;
-    return rest;
-}
-//# sourceMappingURL=clip-records.js.map

package/dist/src/services/clip-search.js

@@ -1,77 +0,0 @@
-// Cloud clip search — the two-stage flow (structured filter → semantic re-rank)
-// wired over DynamoDB records + the configured vector index. Same result shape
-// as the devcli store so the API mirrors the CLI (success criterion #4).
-import { matchesCriteria, rankHits, scoreClip, searchClips } from "./clip-curation/index.js";
-import { clipRecords } from "./clip-records.js";
-import { resolveClipVectorIndex } from "./clip-vectors.js";
-const vectorIndex = resolveClipVectorIndex((owner) => clipRecords.listClipsWithEmbeddings(owner));
-export async function searchUserClips(owner, input) {
-    const limit = input.limit ?? 20;
-    const all = await clipRecords.listClips(owner, { limit: 5000 });
-    // ── No semantic signal → pure structured (hard) filter. ──────────────────
-    if (!input.queryEmbedding) {
-        const structured = all.filter((c) => matchesCriteria(c, input.criteria));
-        return rankHits(structured.map((c) => scoreClip(c, input.criteria, undefined, false)), limit);
-    }
-    // ── Semantic query → SEMANTIC-FIRST hybrid. ──────────────────────────────
-    // The old flow hard-AND-filtered by the (often auto-derived) categorical
-    // criteria BEFORE looking at embeddings, so the true nearest-neighbor clips
-    // were silently excluded whenever the NL→criteria step over-constrained —
-    // the "search doesn't work" symptom. Now: retrieve the nearest neighbors over
-    // the WHOLE library from the vector index, and only UNION in exact structured
-    // matches when the criteria actually constrains something. Everything is
-    // scored with the soft structured boost (`relaxed`), so an exact facet match
-    // floats a clip up without ever gating a strong semantic match out.
-    const knn = await vectorIndex.query(owner, input.queryEmbedding, Math.max(limit * 5, 50));
-    const byId = new Map(all.map((c) => [c.clip_id, c]));
-    const pool = new Map();
-    for (const h of knn) {
-        const c = byId.get(h.clip_id);
-        if (c)
-            pool.set(c.clip_id, c);
-    }
-    if (hasStructuredConstraints(input.criteria)) {
-        for (const c of all)
-            if (matchesCriteria(c, input.criteria))
-                pool.set(c.clip_id, c);
-    }
-    // Fallback: an empty vector index (e.g. clips scanned without an embedding
-    // provider) yields no neighbors — degrade to the whole library so keyword /
-    // structured scoring still returns something rather than nothing.
-    const candidates = pool.size > 0 ? [...pool.values()] : all;
-    const hits = candidates.map((c) => scoreClip(c, input.criteria, input.queryEmbedding, true));
-    return rankHits(hits, limit);
-}
-/** True when the criteria constrains any categorical/duration/boolean facet (not just free-text). */
-function hasStructuredConstraints(criteria) {
-    for (const [key, value] of Object.entries(criteria)) {
-        if (key === "semantic_text")
-            continue;
-        if (value == null)
-            continue;
-        if (Array.isArray(value) ? value.length > 0 : true)
-            return true;
-    }
-    return false;
-}
-export { vectorIndex };
-/**
- * Match many scene annotations against the owner's clip library at once. Loads
- * the library ONCE (embeddings ride on the records) and runs each scene's
- * structured filter + semantic re-rank in memory — so a whole decomposed video
- * costs one library read plus M cheap in-memory ranks.
- */
-export async function matchScenesToClips(owner, queries) {
-    const all = await clipRecords.listClips(owner, { limit: 5000 });
-    return queries.map((q) => ({
-        id: q.id,
-        meta: q.meta,
-        matches: searchClips(all, {
-            criteria: q.criteria,
-            queryEmbedding: q.queryEmbedding,
-            limit: q.limit ?? 5,
-            relaxWhenEmpty: true
-        })
-    }));
-}
-//# sourceMappingURL=clip-search.js.map

package/dist/src/services/clip-vectors.js

@@ -1,125 +0,0 @@
-// Vector index abstraction for cloud clip search. Two backends behind one
-// interface so the pipeline is portable and cloud infra cost stays deferrable:
-//
-//  • "dynamo" (default) — embeddings live on the clip records in DynamoDB;
-//    search brute-forces cosine in memory. Zero extra infra, works with the
-//    local-dynamo shim in `serve` mode. Fine to thousands of clips per user.
-//  • "s3vectors" — Amazon S3 Vectors index (handoff target). Best-effort:
-//    dynamically imports @aws-sdk/client-s3vectors and errors clearly if the
-//    dep/config is absent, so selecting it is opt-in.
-//
-// Both return the same {clip_id, similarity} shape; the caller applies the
-// structured filter + final scoring with the shared query builder.
-import { cosineSimilarity } from "./clip-curation/index.js";
-import { config } from "../config.js";
-/** Default backend: brute-force cosine over the owner's clip embeddings in DynamoDB. */
-export class DynamoVectorIndex {
-    loadEmbeddings;
-    backend = "dynamo";
-    constructor(loadEmbeddings) {
-        this.loadEmbeddings = loadEmbeddings;
-    }
-    async upsert() {
-        /* embedding is stored on the clip record itself */
-    }
-    async delete() {
-        /* removed with the clip record */
-    }
-    async query(owner, queryEmbedding, k) {
-        const clips = await this.loadEmbeddings(owner);
-        return clips
-            .map((c) => ({ clip_id: c.clip_id, similarity: cosineSimilarity(c.embedding, queryEmbedding) }))
-            .sort((a, b) => b.similarity - a.similarity)
-            .slice(0, k);
-    }
-}
-/**
- * Amazon S3 Vectors backend. Vectors are keyed by clip_id within a per-owner
- * partition; metadata carries source_video_id for filtering. Requires
- * VIDFARM_CLIP_VECTORS_BUCKET + VIDFARM_CLIP_VECTORS_INDEX and the
- * @aws-sdk/client-s3vectors package.
- */
-export class S3VectorsIndex {
-    bucket;
-    indexName;
-    backend = "s3vectors";
-    clientPromise = null;
-    constructor(bucket, indexName) {
-        this.bucket = bucket;
-        this.indexName = indexName;
-    }
-    async client() {
-        if (!this.clientPromise) {
-            this.clientPromise = import("@aws-sdk/client-s3vectors").catch(() => {
-                throw new Error("S3 Vectors backend selected but @aws-sdk/client-s3vectors is not installed. `npm i @aws-sdk/client-s3vectors` or set VIDFARM_CLIP_VECTOR_BACKEND=dynamo.");
-            });
-        }
-        const mod = await this.clientPromise;
-        return { mod, client: new mod.S3VectorsClient({}) };
-    }
-    async upsert(owner, clip) {
-        if (!clip.embedding?.length)
-            return;
-        const { mod, client } = await this.client();
-        await client.send(new mod.PutVectorsCommand({
-            vectorBucketName: this.bucket,
-            indexName: this.indexName,
-            vectors: [
-                {
-                    key: vectorKey(owner, clip.clip_id),
-                    data: { float32: clip.embedding },
-                    metadata: { owner, source_video_id: clip.source_video_id, clip_id: clip.clip_id }
-                }
-            ]
-        }));
-    }
-    async delete(owner, clipId) {
-        const { mod, client } = await this.client();
-        await client.send(new mod.DeleteVectorsCommand({ vectorBucketName: this.bucket, indexName: this.indexName, keys: [vectorKey(owner, clipId)] }));
-    }
-    async query(owner, queryEmbedding, k) {
-        const { mod, client } = await this.client();
-        const res = await client.send(new mod.QueryVectorsCommand({
-            vectorBucketName: this.bucket,
-            indexName: this.indexName,
-            topK: k,
-            queryVector: { float32: queryEmbedding },
-            filter: { owner },
-            returnMetadata: true,
-            returnDistance: true
-        }));
-        const vectors = res.vectors ?? [];
-        return vectors.map((v) => ({
-            clip_id: v.metadata?.clip_id ?? stripVectorKey(v.key),
-            // S3 Vectors returns cosine DISTANCE (0..2); convert to similarity.
-            similarity: 1 - Number(v.distance ?? 0)
-        }));
-    }
-}
-function vectorKey(owner, clipId) {
-    return `${owner}/${clipId}`;
-}
-function stripVectorKey(key) {
-    const idx = key.lastIndexOf("/");
-    return idx >= 0 ? key.slice(idx + 1) : key;
-}
-let cached = null;
-/** Resolve the configured vector index (default: dynamo brute-force). */
-export function resolveClipVectorIndex(loadEmbeddings) {
-    if (cached)
-        return cached;
-    const backend = (process.env.VIDFARM_CLIP_VECTOR_BACKEND ?? "dynamo").toLowerCase();
-    if (backend === "s3vectors") {
-        const bucket = process.env.VIDFARM_CLIP_VECTORS_BUCKET;
-        const index = process.env.VIDFARM_CLIP_VECTORS_INDEX;
-        if (bucket && index) {
-            cached = new S3VectorsIndex(bucket, index);
-            return cached;
-        }
-        // Missing config → fall back to the always-available dynamo backend.
-    }
-    cached = new DynamoVectorIndex(loadEmbeddings);
-    void config; // config imported for parity with sibling services / future use
-    return cached;
-}
-//# sourceMappingURL=clip-vectors.js.map

package/dist/src/services/composition-sanitize.js

@@ -1,124 +0,0 @@
-// Sanitizes composition.html before it is stored in a fork's S3 namespace.
-//
-// Fork content lives under a public-read S3 prefix and is rendered SAME-ORIGIN
-// inside the editor iframe (the editor needs same-origin DOM access to morph the
-// timeline). That means any <script> or inline handler an author embeds would
-// execute in a *viewer's* vidfarm.cc origin when a fork is shared — a stored-XSS
-// vector against other users. Compositions are declarative (data-* attributes
-// drive the injected runtime), so scripts are never needed in stored content:
-// the trusted runtime is (re)injected at serve time by
-// rewriteHyperframesDraftCompositionHtml. We therefore strip all author scripts,
-// inline on*= handlers, and javascript:/vbscript: URLs.
-//
-// This is a pragmatic regex sanitizer (the Lambda has no DOM). It errs toward
-// removing anything script-like; it is a hardening layer, not the only defense.
-const SCRIPT_TAG_RE = /<script\b[^>]*>[\s\S]*?<\/script\s*>/gi;
-// Void/self-closed or unterminated <script ...> with no closing tag.
-const LONE_SCRIPT_OPEN_RE = /<script\b[^>]*\/?>/gi;
-// Inline event handlers: on-word = "..." | '...' | bare token. Requires a
-// preceding whitespace so we don't match attributes like `data-on=""`.
-const INLINE_HANDLER_RE = /\son[a-z]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi;
-// Dangerous URL schemes in a navigable attribute value. Matches the whole
-// value — quoted (single/double) or bare — so the closing quote is consumed and
-// the replacement stays well-formed.
-const DANGEROUS_SCHEME = String.raw `(?:javascript\s*:|vbscript\s*:|data\s*:\s*text\/html)`;
-const DANGEROUS_URL_RE = new RegExp(String.raw `((?:href|src|xlink:href|action|formaction)\s*=\s*)` +
-    String.raw `(?:"\s*${DANGEROUS_SCHEME}[^"]*"|'\s*${DANGEROUS_SCHEME}[^']*'|${DANGEROUS_SCHEME}[^\s>]*)`, "gi");
-export function sanitizeCompositionHtml(html) {
-    let scripts = 0;
-    let handlers = 0;
-    let urls = 0;
-    let out = html.replace(SCRIPT_TAG_RE, () => {
-        scripts += 1;
-        return "";
-    });
-    out = out.replace(LONE_SCRIPT_OPEN_RE, () => {
-        scripts += 1;
-        return "";
-    });
-    out = out.replace(INLINE_HANDLER_RE, () => {
-        handlers += 1;
-        return "";
-    });
-    out = out.replace(DANGEROUS_URL_RE, (_match, prefix) => {
-        urls += 1;
-        // Neutralize to a harmless anchor while preserving the attribute shape.
-        return `${prefix}"#"`;
-    });
-    const changed = scripts > 0 || handlers > 0 || urls > 0;
-    return { html: out, changed, removed: { scripts, handlers, urls } };
-}
-// Re-derives inline z-index from data-track-index on every open tag carrying
-// the attribute. The render pipeline (normalizePublishHtml) enforces
-// z-index = track — higher track draws in front — but the preview runtime
-// trusts whatever inline z is stored, so any stored html with stale or missing
-// z previews with the wrong stacking. Applying this at serve time keeps the
-// preview identical to the render for every composition, including ones never
-// touched by the current editor. String-only pass for the same reason as the
-// sanitizer above (no DOM in the Lambda; and DOM serialization re-quotes
-// font-family values, breaking the render's font resolver).
-const OPEN_TAG_RE = /<([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'`=<>]+))?)*)\s*(\/?)>/g;
-// Walks real attribute boundaries. A flat regex over the attr blob can match
-// `style=` or `data-track-index` text INSIDE another attribute's value
-// (e.g. a data-label containing markup), corrupting user content.
-const ATTR_RE = /\s+([^\s"'>/=]+)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'`=<>]+))?/g;
-// KEEP IN SYNC with normalizeCompositionZIndex in
-// demo/src/HyperframesStudioEditor.tsx (client editor copy).
-export function normalizeCompositionZIndexHtml(html) {
-    if (!html || !html.includes("data-track-index"))
-        return html;
-    return html.replace(OPEN_TAG_RE, (match, tag, rawAttrs, selfClose) => {
-        let track = null;
-        let styleQuote = '"';
-        let styleValue = null;
-        let styleStart = -1;
-        let styleEnd = -1;
-        ATTR_RE.lastIndex = 0;
-        let attr;
-        while ((attr = ATTR_RE.exec(rawAttrs))) {
-            const name = attr[1].toLowerCase();
-            const rawValue = attr[2];
-            if (rawValue === undefined)
-                continue;
-            const quoted = rawValue.startsWith('"') || rawValue.startsWith("'");
-            const value = quoted ? rawValue.slice(1, -1) : rawValue;
-            if (name === "data-track-index") {
-                const parsed = Number.parseInt(value, 10);
-                if (Number.isFinite(parsed))
-                    track = parsed;
-            }
-            else if (name === "style") {
-                styleQuote = quoted ? rawValue[0] : '"';
-                styleValue = value;
-                styleStart = attr.index;
-                styleEnd = attr.index + attr[0].length;
-            }
-        }
-        if (track === null)
-            return match;
-        const desired = String(track);
-        if (styleValue !== null) {
-            let nextStyle;
-            if (/(^|;)\s*z-index\s*:/i.test(styleValue)) {
-                if (new RegExp(`(^|;)\\s*z-index\\s*:\\s*${desired}\\s*(;|$)`, "i").test(styleValue)) {
-                    return match;
-                }
-                // Replacer function: a plain replacement string would interpret $-
-                // sequences inside the surrounding style (e.g. content:'20$') as
-                // substitution metacharacters and corrupt the attribute.
-                nextStyle = styleValue.replace(/(^|;)\s*z-index\s*:\s*[^;]*/i, (_zMatch, lead) => `${lead}z-index:${desired}`);
-            }
-            else {
-                nextStyle = styleValue.endsWith(";") || styleValue.length === 0
-                    ? `${styleValue}z-index:${desired}`
-                    : `${styleValue};z-index:${desired}`;
-            }
-            // Rebuild by slicing around the style attribute — never String.replace
-            // with user-controlled content.
-            const rebuiltAttrs = `${rawAttrs.slice(0, styleStart)} style=${styleQuote}${nextStyle}${styleQuote}${rawAttrs.slice(styleEnd)}`;
-            return `<${tag}${rebuiltAttrs}${selfClose ? "/" : ""}>`;
-        }
-        return `<${tag}${rawAttrs} style="z-index:${desired}"${selfClose ? "/" : ""}>`;
-    });
-}
-//# sourceMappingURL=composition-sanitize.js.map

package/dist/src/services/composition-watch.js

@@ -1,79 +0,0 @@
-import { mkdirSync, watch } from "node:fs";
-import path from "node:path";
-import { config } from "../config.js";
-// fs.watch on macOS emits 1–3 events per save; coalesce a burst into one
-// broadcast. Also drop events for a fork the server itself just wrote (the
-// editor's own PUT) so a save doesn't echo back as a reload.
-const COALESCE_MS = 80;
-const SELF_WRITE_SUPPRESS_MS = 500;
-class CompositionWatch {
-    listeners = new Set();
-    suppressUntil = new Map();
-    started = false;
-    pending = null;
-    timer = null;
-    forksDir() {
-        return path.join(config.VIDFARM_DATA_DIR, "storage", "compositions", "forks");
-    }
-    start() {
-        if (this.started || config.STORAGE_DRIVER !== "local")
-            return;
-        this.started = true;
-        const dir = this.forksDir();
-        mkdirSync(dir, { recursive: true });
-        try {
-            watch(dir, { recursive: true }, (_event, filename) => {
-                if (filename)
-                    this.onFsEvent(String(filename));
-            });
-            console.log(`[vidfarm] live-reload watching ${dir}`);
-        }
-        catch (error) {
-            console.warn(`[vidfarm] live-reload watch failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    // Call right before the server writes a working composition file so the
-    // editor's own save doesn't bounce back as an external reload.
-    suppressFork(forkId) {
-        this.suppressUntil.set(forkId, Date.now() + SELF_WRITE_SUPPRESS_MS);
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    onFsEvent(filename) {
-        // filename is relative to forksDir, e.g. "<forkId>/working/composition.html".
-        const parts = filename.split(/[\\/]/).filter(Boolean);
-        if (parts.length < 3 || parts[1] !== "working")
-            return;
-        const file = parts[2];
-        if (file !== "composition.html" && file !== "composition.json")
-            return;
-        const forkId = parts[0];
-        const until = this.suppressUntil.get(forkId);
-        if (until && Date.now() < until)
-            return;
-        this.pending = { forkId, file, at: Date.now() };
-        if (this.timer)
-            clearTimeout(this.timer);
-        this.timer = setTimeout(() => {
-            this.timer = null;
-            const change = this.pending;
-            this.pending = null;
-            if (change)
-                this.broadcast(change);
-        }, COALESCE_MS);
-    }
-    broadcast(change) {
-        for (const listener of [...this.listeners]) {
-            try {
-                listener(change);
-            }
-            catch {
-                // A dead SSE writer is dropped on its own onAbort; ignore here.
-            }
-        }
-    }
-}
-export const compositionWatch = new CompositionWatch();
-//# sourceMappingURL=composition-watch.js.map