@officexapp/vidfarm-devcli 0.21.10

package/dist/src/lib/crypto.js

@@ -0,0 +1,45 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+function deriveKey(secret) {
+    return scryptSync(secret, "vidfarm", 32);
+}
+export function hashSecret(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function safeEqualHash(raw, hashed) {
+    const left = Buffer.from(hashSecret(raw), "hex");
+    const right = Buffer.from(hashed, "hex");
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+export function encryptString(value, secret) {
+    const iv = randomBytes(12);
+    const key = deriveKey(secret);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, tag, encrypted]).toString("base64");
+}
+export function decryptString(value, secret) {
+    const raw = Buffer.from(value, "base64");
+    const iv = raw.subarray(0, 12);
+    const tag = raw.subarray(12, 28);
+    const encrypted = raw.subarray(28);
+    const key = deriveKey(secret);
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
+}
+export function hashPassword(password) {
+    const salt = randomBytes(16).toString("hex");
+    const digest = scryptSync(password, salt, 32).toString("hex");
+    return `${salt}:${digest}`;
+}
+export function verifyPassword(password, storedHash) {
+    const [salt, digest] = storedHash.split(":");
+    if (!salt || !digest) {
+        return false;
+    }
+    const left = Buffer.from(scryptSync(password, salt, 32).toString("hex"), "hex");
+    const right = Buffer.from(digest, "hex");
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+//# sourceMappingURL=crypto.js.map

package/dist/src/lib/dev-log.js

@@ -0,0 +1,54 @@
+import { config } from "../config.js";
+const SECRET_KEY_PATTERN = /(secret|token|password|api[_-]?key|authorization|credential)/i;
+export function devLog(event, fields = {}, level = "info") {
+    if (!config.debugLogs) {
+        return;
+    }
+    const entry = {
+        level,
+        event,
+        time: new Date().toISOString(),
+        deployment_target: config.VIDFARM_DEPLOYMENT_TARGET ?? null,
+        runtime_backend: config.VIDFARM_RUNTIME_BACKEND,
+        ...sanitizeLogFields(fields)
+    };
+    const line = JSON.stringify(entry);
+    if (level === "error") {
+        console.error(line);
+    }
+    else if (level === "warn") {
+        console.warn(line);
+    }
+    else {
+        console.log(line);
+    }
+}
+export function devErrorFields(error) {
+    if (error instanceof Error) {
+        return {
+            error_name: error.name,
+            error_message: error.message,
+            error_stack: error.stack?.split("\n").slice(0, 8).join("\n") ?? null
+        };
+    }
+    return {
+        error_message: String(error)
+    };
+}
+function sanitizeLogValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sanitizeLogValue);
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const output = {};
+    for (const [key, child] of Object.entries(value)) {
+        output[key] = SECRET_KEY_PATTERN.test(key) ? "[redacted]" : sanitizeLogValue(child);
+    }
+    return output;
+}
+function sanitizeLogFields(fields) {
+    return sanitizeLogValue(fields);
+}
+//# sourceMappingURL=dev-log.js.map

package/dist/src/lib/display-name.js

@@ -0,0 +1,11 @@
+export function displayNameFromEmail(email) {
+    const normalized = email.trim().toLowerCase();
+    const localPart = normalized.split("@", 1)[0] || normalized;
+    const words = localPart
+        .split(/[^a-z0-9]+/i)
+        .map((word) => word.trim())
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+    return words.join(" ") || normalized;
+}
+//# sourceMappingURL=display-name.js.map

package/dist/src/lib/ids.js

@@ -0,0 +1,24 @@
+import { randomBytes, randomUUID } from "node:crypto";
+export function createId(prefix) {
+    return `${prefix}_${randomUUID().replace(/-/g, "")}`;
+}
+// UUIDv7: time-ordered 128-bit id. First 48 bits are Unix millis, next 4 bits
+// are the version (7), next 12 bits are random, next 2 bits are the variant
+// (0b10), and the rest is random. Chronologically sortable — good for DDB
+// keys and for humans skimming a list of forks.
+export function uuidv7() {
+    const timestampMs = BigInt(Date.now());
+    const rand = randomBytes(10);
+    const bytes = Buffer.alloc(16);
+    bytes.writeUIntBE(Number((timestampMs >> 16n) & 0xffffffffn), 0, 4);
+    bytes.writeUIntBE(Number(timestampMs & 0xffffn), 4, 2);
+    rand.copy(bytes, 6);
+    bytes[6] = (bytes[6] & 0x0f) | 0x70; // version 7
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant RFC 4122
+    const hex = bytes.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export function createIdV7(prefix) {
+    return `${prefix}_${uuidv7().replace(/-/g, "")}`;
+}
+//# sourceMappingURL=ids.js.map

package/dist/src/lib/images.js

@@ -0,0 +1,19 @@
+import sharp from "sharp";
+export async function normalizeToPortraitFrame(input, target = { width: 1080, height: 1920 }) {
+    const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+    const output = await sharp(buffer, { density: 144 })
+        .rotate()
+        .resize(target.width, target.height, {
+        fit: "cover",
+        position: sharp.strategy.attention
+    })
+        .png()
+        .toBuffer();
+    return {
+        bytes: output,
+        contentType: "image/png",
+        width: target.width,
+        height: target.height
+    };
+}
+//# sourceMappingURL=images.js.map

package/dist/src/lib/json.js

@@ -0,0 +1,15 @@
+export function parseJson(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function stringifyJson(value) {
+    return JSON.stringify(value ?? null);
+}
+//# sourceMappingURL=json.js.map

package/dist/src/lib/package-root.js

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Server asset files (the hyperframes editor bundle, public/assets JS bundles,
+// SKILL.*.md, src/assets binaries) are laid out relative to the PACKAGE root:
+// the repo checkout in dev, /app–/var/task in Docker/Lambda, or
+// node_modules/@officexapp/vidfarm-devcli when `vidfarm serve` runs from the
+// published npm package. cwd-relative reads only cover the first two, so every
+// root-file read should try cwd first (preserves the existing dev/Docker
+// behavior) and then fall back to this package root.
+function findPackageRoot() {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 6; depth += 1) {
+        const manifest = path.join(current, "package.json");
+        if (existsSync(manifest)) {
+            try {
+                const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+                if (parsed.name === "@officexapp/vidfarm-devcli") {
+                    return current;
+                }
+            }
+            catch {
+                // Unreadable manifest — keep walking up.
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+export const packageRoot = findPackageRoot();
+// All plausible absolute paths for a package-root-relative file, ordered
+// cwd-first so a dev checkout (or Docker task root) always wins over the
+// installed package copy.
+export function resolveRootFileCandidates(relativePath) {
+    const candidates = [path.resolve(relativePath)];
+    if (packageRoot) {
+        const packaged = path.resolve(packageRoot, relativePath);
+        if (!candidates.includes(packaged)) {
+            candidates.push(packaged);
+        }
+    }
+    return candidates;
+}
+//# sourceMappingURL=package-root.js.map

package/dist/src/lib/render-media-prep.js

@@ -0,0 +1,293 @@
+// Render media prep — "download once, cut from it".
+//
+// A composition that drops N short windows of the same long source video onto
+// the timeline (e.g. "insert a 5s clip of my Dubai raw every 10 seconds")
+// naively makes the renderer load the ENTIRE long source once per <video>
+// element. Headless Chrome buffers each element independently, so a 12-minute
+// source referenced five times stalls the media-ready phase for minutes (or
+// forever on slow links) to ultimately show 25 seconds of footage.
+//
+// This pass runs at project-staging time, before any renderer sees the HTML:
+//   1. group <video>/<audio> clips by remote source URL,
+//   2. probe the source's duration (ffprobe reads headers over HTTP — cheap),
+//   3. when the composition only plays small windows of a big source (or plays
+//      the same source from several elements), download the source ONCE to a
+//      temp dir, ffmpeg-cut each element's exact window into a small local
+//      segment file inside the project dir, and rewrite the element to play
+//      that segment from 0,
+//   4. when cutting isn't safe (looping layers, alpha/webm containers) but the
+//      source is still referenced multiple times, download it once into the
+//      project dir and point every element at the single local copy.
+//
+// The module is dependency-light on purpose (node builtins + linkedom +
+// bundled ffmpeg/ffprobe statics) so the PUBLIC devcli package can ship it for
+// free local renders; the backend render paths (in-process + Lambda staging)
+// call the same function.
+import { spawn } from "node:child_process";
+import { createWriteStream, existsSync } from "node:fs";
+import { mkdir, mkdtemp, rm, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { parseHTML } from "linkedom";
+// Trailing pad added to every cut so the renderer never runs out of media on
+// the final frame of a clip (frame quantization + audio priming).
+const SEGMENT_PAD_SECONDS = 0.5;
+// A single-reference source is only worth cutting when the unused tail is
+// substantial — the download itself is the expensive part we're amortizing.
+const SINGLE_REF_MIN_WASTE_SECONDS = 60;
+const SINGLE_REF_MIN_RATIO = 3;
+const CUTTABLE_VIDEO = /\.(mp4|m4v)(\?|#|$)/i;
+const CUTTABLE_AUDIO = /\.(mp3|m4a|aac|wav|mp4)(\?|#|$)/i;
+function numAttr(node, name) {
+    const raw = Number.parseFloat(node?.getAttribute?.(name) ?? "");
+    return Number.isFinite(raw) ? raw : NaN;
+}
+function readMediaRef(node, kind) {
+    const playbackStart = numAttr(node, "data-playback-start");
+    const mediaStart = numAttr(node, "data-media-start");
+    const duration = numAttr(node, "data-duration");
+    return {
+        node,
+        kind,
+        mediaStart: Number.isFinite(playbackStart) ? playbackStart : (Number.isFinite(mediaStart) ? mediaStart : 0),
+        duration: Number.isFinite(duration) && duration > 0 ? duration : null,
+        loops: node.hasAttribute("loop") || node.getAttribute("data-loop") === "true"
+    };
+}
+async function resolveFfmpegPath() {
+    const env = process.env.HYPERFRAMES_FFMPEG_PATH?.trim();
+    if (env && existsSync(env))
+        return env;
+    try {
+        const mod = (await import("ffmpeg-static"));
+        const resolved = typeof mod === "string" ? mod : mod.default;
+        if (typeof resolved === "string" && resolved && existsSync(resolved))
+            return resolved;
+    }
+    catch { /* PATH fallback */ }
+    return "ffmpeg";
+}
+async function resolveFfprobePath() {
+    const env = process.env.HYPERFRAMES_FFPROBE_PATH?.trim();
+    if (env && existsSync(env))
+        return env;
+    try {
+        const mod = (await import("ffprobe-static"));
+        const resolved = (mod.path ?? mod.default?.path);
+        if (typeof resolved === "string" && resolved && existsSync(resolved))
+            return resolved;
+    }
+    catch { /* PATH fallback */ }
+    return "ffprobe";
+}
+function runCommand(bin, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            proc.kill("SIGKILL");
+            reject(new Error(`${path.basename(bin)} timed out after ${Math.round(timeoutMs / 1000)}s`));
+        }, timeoutMs);
+        proc.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+        proc.stderr.on("data", (chunk) => { stderr = (stderr + chunk.toString()).slice(-8192); });
+        proc.on("error", (error) => { clearTimeout(timer); reject(error); });
+        proc.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 1, stdout, stderr }); });
+    });
+}
+/** Probe a (remote or local) media file's duration in seconds, or null. */
+export async function probeMediaDurationSeconds(source, timeoutMs = 30_000) {
+    const ffprobe = await resolveFfprobePath();
+    try {
+        const result = await runCommand(ffprobe, [
+            "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "json",
+            source
+        ], timeoutMs);
+        if (result.code !== 0)
+            return null;
+        const parsed = JSON.parse(result.stdout || "{}");
+        const duration = Number.parseFloat(parsed.format?.duration ?? "");
+        return Number.isFinite(duration) && duration > 0 ? duration : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function downloadToFile(url, filePath, maxBytes) {
+    const response = await fetch(url, { redirect: "follow" });
+    if (!response.ok || !response.body) {
+        throw new Error(`download failed with HTTP ${response.status}`);
+    }
+    const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+        throw new Error(`source is ${Math.round(contentLength / 1e6)} MB (cap ${Math.round(maxBytes / 1e6)} MB)`);
+    }
+    // Streamed byte cap — aborts mid-download instead of filling the disk when
+    // content-length lied or was absent.
+    let received = 0;
+    const cap = new Transform({
+        transform(chunk, _enc, callback) {
+            received += chunk.length;
+            if (received > maxBytes) {
+                callback(new Error(`download exceeded ${Math.round(maxBytes / 1e6)} MB cap`));
+                return;
+            }
+            callback(null, chunk);
+        }
+    });
+    await pipeline(Readable.fromWeb(response.body), cap, createWriteStream(filePath));
+    return received;
+}
+function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 10);
+}
+function urlExtension(url, fallback) {
+    const match = url.match(/\.([a-z0-9]{2,5})(\?|#|$)/i);
+    return match ? match[1].toLowerCase() : fallback;
+}
+/**
+ * Rewrite the composition so no remote source is loaded more times (or longer)
+ * than the timeline actually needs. Returns the (possibly rewritten) HTML plus
+ * a note per touched source; on any per-source failure that source is left
+ * untouched, so the pass can only improve the render, never break it.
+ */
+export async function prepareProjectMediaForRender(options) {
+    const log = options.log ?? (() => { });
+    const maxSourceBytes = options.maxSourceBytes ?? 1.5e9;
+    const localizeMaxBytes = options.localizeMaxBytes ?? 512e6;
+    const deadline = Date.now() + (options.budgetMs ?? 4 * 60_000);
+    const notes = [];
+    const { document } = parseHTML(options.html);
+    const groups = new Map();
+    for (const tag of ["video", "audio"]) {
+        for (const node of Array.from(document.querySelectorAll(`${tag}[src]`))) {
+            const src = String(node.getAttribute("src") ?? "").trim();
+            if (!/^https?:\/\//i.test(src))
+                continue;
+            const list = groups.get(src) ?? [];
+            list.push(readMediaRef(node, tag));
+            groups.set(src, list);
+        }
+    }
+    if (groups.size === 0)
+        return { html: options.html, changed: false, notes };
+    const mediaDir = path.join(options.projectDir, "media");
+    let changed = false;
+    let ffmpegPath = null;
+    for (const [url, refs] of groups) {
+        if (Date.now() > deadline) {
+            notes.push({ url, action: "skipped", refs: refs.length, reason: "media-prep time budget exhausted" });
+            continue;
+        }
+        const isVideoGroup = refs.some((ref) => ref.kind === "video");
+        const cuttable = isVideoGroup ? CUTTABLE_VIDEO.test(url) : CUTTABLE_AUDIO.test(url);
+        const cutRefs = refs.filter((ref) => ref.duration !== null && !ref.loops);
+        const multiRef = refs.length >= 2;
+        // Probe duration first — it's cheap and it decides everything else.
+        const sourceDuration = await probeMediaDurationSeconds(url);
+        const totalWindow = cutRefs.reduce((sum, ref) => sum + (ref.duration ?? 0) + SEGMENT_PAD_SECONDS, 0);
+        const singleRefWorthCutting = sourceDuration !== null && cutRefs.length === refs.length && refs.length === 1
+            && (sourceDuration - totalWindow) >= SINGLE_REF_MIN_WASTE_SECONDS
+            && sourceDuration >= totalWindow * SINGLE_REF_MIN_RATIO;
+        const shouldCut = cuttable && cutRefs.length > 0 && (multiRef || singleRefWorthCutting);
+        const shouldLocalize = !shouldCut && multiRef;
+        if (!shouldCut && !shouldLocalize)
+            continue;
+        log("render_media_prep.source", {
+            url,
+            refs: refs.length,
+            source_duration_s: sourceDuration,
+            mode: shouldCut ? "cut" : "localize"
+        });
+        let tempDir = null;
+        try {
+            if (shouldCut) {
+                tempDir = await mkdtemp(path.join(os.tmpdir(), "vf-media-prep-"));
+                const sourceFile = path.join(tempDir, `source.${urlExtension(url, isVideoGroup ? "mp4" : "m4a")}`);
+                await downloadToFile(url, sourceFile, maxSourceBytes);
+                ffmpegPath = ffmpegPath ?? await resolveFfmpegPath();
+                await mkdir(mediaDir, { recursive: true });
+                const segments = [];
+                for (const [index, ref] of cutRefs.entries()) {
+                    const duration = (ref.duration ?? 0) + SEGMENT_PAD_SECONDS;
+                    const ext = ref.kind === "video" ? "mp4" : "m4a";
+                    const segmentName = `vfprep-${shortHash(url)}-${index}.${ext}`;
+                    const segmentPath = path.join(mediaDir, segmentName);
+                    // -ss before -i + re-encode = frame-accurate fast seek. veryfast/crf18
+                    // is visually lossless for a short segment and keeps prep quick.
+                    const args = ref.kind === "video"
+                        ? [
+                            "-y", "-ss", String(Math.max(0, ref.mediaStart)), "-i", sourceFile, "-t", String(duration),
+                            "-c:v", "libx264", "-preset", "veryfast", "-crf", "18", "-pix_fmt", "yuv420p",
+                            "-c:a", "aac", "-movflags", "+faststart", segmentPath
+                        ]
+                        : [
+                            "-y", "-ss", String(Math.max(0, ref.mediaStart)), "-i", sourceFile, "-t", String(duration),
+                            "-vn", "-c:a", "aac", segmentPath
+                        ];
+                    const cut = await runCommand(ffmpegPath, args, 5 * 60_000);
+                    if (cut.code !== 0)
+                        throw new Error(`ffmpeg segment cut failed: ${cut.stderr.slice(-400)}`);
+                    ref.node.setAttribute("src", `media/${segmentName}`);
+                    ref.node.setAttribute("data-media-start", "0");
+                    ref.node.setAttribute("data-playback-start", "0");
+                    segments.push(`media/${segmentName}`);
+                    changed = true;
+                }
+                // Refs we couldn't cut (loops / no duration) keep the remote URL — the
+                // group note records the split so render logs explain the leftovers.
+                notes.push({
+                    url,
+                    action: "cut-segments",
+                    refs: refs.length,
+                    segments,
+                    sourceDurationSeconds: sourceDuration,
+                    reason: cutRefs.length < refs.length ? `${refs.length - cutRefs.length} looping/unbounded ref(s) kept the remote URL` : undefined
+                });
+            }
+            else {
+                // Localize: one shared local copy for every reference.
+                await mkdir(mediaDir, { recursive: true });
+                const localName = `vfprep-${shortHash(url)}-full.${urlExtension(url, isVideoGroup ? "mp4" : "m4a")}`;
+                const localPath = path.join(mediaDir, localName);
+                if (!existsSync(localPath)) {
+                    await downloadToFile(url, localPath, localizeMaxBytes);
+                }
+                const size = (await stat(localPath)).size;
+                for (const ref of refs) {
+                    ref.node.setAttribute("src", `media/${localName}`);
+                    changed = true;
+                }
+                notes.push({ url, action: "localized", refs: refs.length, segments: [`media/${localName}`], sourceDurationSeconds: sourceDuration, reason: `${Math.round(size / 1e6)} MB single copy` });
+            }
+        }
+        catch (error) {
+            // Best-effort: leave this source untouched and let the renderer handle
+            // the original URL. Remove any partial local files so a broken segment
+            // can never shadow the remote source.
+            notes.push({
+                url,
+                action: "skipped",
+                refs: refs.length,
+                sourceDurationSeconds: sourceDuration,
+                reason: error instanceof Error ? error.message : String(error)
+            });
+            log("render_media_prep.source_failed", { url, error: error instanceof Error ? error.message : String(error) });
+        }
+        finally {
+            if (tempDir)
+                await rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    if (!changed)
+        return { html: options.html, changed: false, notes };
+    const html = `<!doctype html>\n${document.documentElement.outerHTML}`;
+    log("render_media_prep.done", { sources: notes.length, changed });
+    return { html, changed, notes };
+}
+//# sourceMappingURL=render-media-prep.js.map

package/dist/src/lib/template-paths.js

@@ -0,0 +1,28 @@
+import path from "node:path";
+export const TEMPLATE_FOLDER_PREFIX = "vidfarm_template_";
+export const LEGACY_TEMPLATE_FOLDER_PREFIX = "template_";
+export function assertTemplateFolderNameHasPrefix(folderName) {
+    if (!folderName.startsWith(TEMPLATE_FOLDER_PREFIX) && !folderName.startsWith(LEGACY_TEMPLATE_FOLDER_PREFIX)) {
+        throw new Error(`Template folder name must start with ${TEMPLATE_FOLDER_PREFIX} or ${LEGACY_TEMPLATE_FOLDER_PREFIX}. Received: ${folderName}`);
+    }
+}
+export function deriveTemplateRootDirFromModulePath(templateModulePath) {
+    const normalizedModulePath = templateModulePath.replace(/\\/g, "/");
+    const templateSourceDir = path.posix.dirname(normalizedModulePath);
+    const templateRootDir = path.posix.dirname(templateSourceDir);
+    const sourceDirName = path.posix.basename(templateSourceDir);
+    if (sourceDirName !== "src") {
+        throw new Error("template_module_path must point at a TypeScript entrypoint inside a src/ folder, such as src/template.ts or templates/vidfarm_template_example/src/template.ts.");
+    }
+    if (templateRootDir === "." || templateRootDir === "") {
+        return "";
+    }
+    const folderName = path.posix.basename(templateRootDir);
+    assertTemplateFolderNameHasPrefix(folderName);
+    return templateRootDir;
+}
+export function defaultSkillPathForTemplateModule(templateModulePath) {
+    const templateRootDir = deriveTemplateRootDirFromModulePath(templateModulePath);
+    return templateRootDir ? path.posix.join(templateRootDir, "SKILL.md") : "SKILL.md";
+}
+//# sourceMappingURL=template-paths.js.map

package/dist/src/lib/time.js

@@ -0,0 +1,7 @@
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function addSeconds(date, seconds) {
+    return new Date(date.getTime() + seconds * 1000).toISOString();
+}
+//# sourceMappingURL=time.js.map

package/dist/src/lib/url-clean.js

@@ -0,0 +1,85 @@
+const TRACKING_PARAM_PREFIXES = ["utm_", "mc_", "ic_"];
+const TRACKING_PARAMS = new Set([
+    "si",
+    "share_link_id",
+    "share_app_id",
+    "share_iid",
+    "shareid",
+    "sender_device",
+    "sender_web_id",
+    "source",
+    "timestamp",
+    "user_id",
+    "sec_uid",
+    "t",
+    "feature",
+    "app",
+    "referer",
+    "referrer",
+    "ref",
+    "ref_src",
+    "ref_url",
+    "fbclid",
+    "gclid",
+    "igshid",
+    "igsh",
+    "mibextid",
+    "twclid",
+    "twsrc",
+    "trk",
+    "hl",
+    "context",
+    "checksum",
+    "_r",
+    "_t",
+    "_d",
+    "_i",
+    "_hsenc",
+    "_hsmi"
+]);
+function shouldStrip(param) {
+    const lower = param.toLowerCase();
+    if (TRACKING_PARAMS.has(lower))
+        return true;
+    return TRACKING_PARAM_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+export function stripTrackingParams(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return trimmed;
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+    const kept = [];
+    url.searchParams.forEach((value, key) => {
+        if (!shouldStrip(key))
+            kept.push([key, value]);
+    });
+    const params = new URLSearchParams(kept);
+    const search = params.toString();
+    url.search = search ? `?${search}` : "";
+    url.hash = "";
+    return url.toString();
+}
+export function detectSourceHost(rawUrl) {
+    try {
+        const host = new URL(rawUrl).hostname.toLowerCase().replace(/^www\./, "");
+        if (host.endsWith("tiktok.com"))
+            return "tiktok";
+        if (host === "instagram.com" || host.endsWith(".instagram.com"))
+            return "instagram";
+        if (host === "youtube.com" || host.endsWith(".youtube.com") || host === "youtu.be")
+            return "youtube";
+        if (host === "twitter.com" || host === "x.com" || host.endsWith(".twitter.com") || host.endsWith(".x.com"))
+            return "twitter";
+        return "other";
+    }
+    catch {
+        return "other";
+    }
+}
+//# sourceMappingURL=url-clean.js.map