@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/files/media/cache.js

@@ -0,0 +1,620 @@
+import * as fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import lockfile from 'proper-lockfile';
+import { remuxRange } from './encoding.js';
+const hex64 = /^[a-f0-9]{64}$/;
+const hex32 = /^[a-f0-9]{32}$/;
+const MAX_META = 4 * 1024 * 1024;
+// Reclaim old seek windows eagerly, but advertised windows must survive until
+// their leases expire. Byte/metadata budgets remain the admission limits.
+const GENERATION_RECLAIM_TARGET = 64;
+const MAX_GENERATIONS = 6000;
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const stampOf = (s) => [s.dev, s.ino, s.size, s.mtimeNs, s.ctimeNs].join(':');
+/** Private immutable objects; per-resource pins and file locks protect concurrent readers/writers. */
+export class MediaCache {
+    directory;
+    policy;
+    versions = new Map();
+    claims = new Map();
+    pins = new Map();
+    retainedUntil = new Map();
+    activeReads = new Map();
+    readerId = randomUUID();
+    queue = Promise.resolve();
+    constructor(directory, policy) {
+        this.directory = directory;
+        this.policy = policy;
+    }
+    static async open(directory, policy) {
+        await safeDirectory(directory);
+        return new MediaCache(directory, policy);
+    }
+    serial(run) {
+        const result = this.queue.then(async () => {
+            const release = await lockfile.lock(this.directory, { lockfilePath: path.join(this.directory, '.cache.guard'), stale: 60_000, update: 10_000, retries: { retries: 120, minTimeout: 25, maxTimeout: 250 } });
+            try {
+                return await run();
+            }
+            finally {
+                await release();
+            }
+        });
+        this.queue = result.catch(() => { });
+        return result;
+    }
+    versionPath(key) {
+        if (!hex64.test(key.version))
+            throw new Error('Invalid media version');
+        return path.join(this.directory, `v3-${key.version}`);
+    }
+    async createGeneration(key, generationId) {
+        if (!hex32.test(generationId))
+            throw new Error('Invalid generation identity');
+        const directory = this.versionPath(key);
+        await safeDirectory(directory);
+        const output = path.join(directory, generationId);
+        await safeDirectory(output);
+        return output;
+    }
+    async claimWriter(key) {
+        const directory = this.versionPath(key);
+        await safeDirectory(directory);
+        if (this.claims.has(key.version))
+            throw new Error('Media cache writer is busy');
+        const lockPath = `${directory}.lock`;
+        try {
+            const s = await fs.lstat(lockPath);
+            if (!s.isDirectory() || s.isSymbolicLink() || (process.getuid && s.uid !== process.getuid()))
+                throw new Error('Unsafe cache writer lock');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const claim = { valid: true, release: async () => { } };
+        try {
+            claim.release = await lockfile.lock(directory, { stale: 60_000, update: 10_000, retries: 0, onCompromised: () => { claim.valid = false; } });
+        }
+        catch {
+            throw new Error('Media cache writer is busy');
+        }
+        this.claims.set(key.version, claim);
+        return { release: async () => {
+                if (this.claims.get(key.version) !== claim)
+                    return;
+                this.claims.delete(key.version);
+                claim.valid = false;
+                await claim.release();
+            } };
+    }
+    requireWriter(key) { if (!this.claims.get(key.version)?.valid)
+        throw new Error('Media cache writer lease was lost'); }
+    objectPath(key, generationId, object) {
+        if (!hex32.test(generationId) || !hex32.test(object.id) || !['ts', 'mp3', 'mp4', 'png'].includes(object.extension))
+            throw new Error('Invalid media object');
+        return path.join(this.versionPath(key), generationId, `${object.id}.${object.extension}`);
+    }
+    async load(key) {
+        const memory = this.versions.get(key.version);
+        if (memory && this.claims.has(key.version))
+            return same(memory.key, key) ? memory : null;
+        try {
+            const directory = this.versionPath(key);
+            const s = await fs.lstat(directory);
+            if (!s.isDirectory() || s.isSymbolicLink())
+                return null;
+            const handle = await fs.open(path.join(directory, 'index.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
+            let data;
+            try {
+                const stat = await handle.stat();
+                if (!stat.isFile() || stat.size > MAX_META)
+                    return null;
+                data = JSON.parse(await handle.readFile('utf8'));
+            }
+            finally {
+                await handle.close();
+            }
+            if (!data || !same(data.key, key) || !Array.isArray(data.generations) || data.generations.length > MAX_GENERATIONS)
+                return null;
+            for (const g of data.generations) {
+                if (!hex32.test(g.id) || !Array.isArray(g.objects) || g.objects.length > 6000)
+                    return null;
+                for (const o of g.objects) {
+                    this.objectPath(key, g.id, o);
+                    if (!Number.isSafeInteger(o.size) || o.size <= 0 || o.size > this.policy.maxVersionBytes || !hex64.test(o.etag) || typeof o.stamp !== 'string' || !Number.isFinite(o.accessedAtMs))
+                        return null;
+                    if (!Number.isSafeInteger(o.startMs) || !Number.isSafeInteger(o.endMs) || o.startMs < 0 || o.endMs < o.startMs || o.endMs > 21_600_001)
+                        return null;
+                }
+            }
+            this.versions.set(key.version, data);
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(version) {
+        this.requireWriter(version.key);
+        const directory = this.versionPath(version.key);
+        const temp = path.join(directory, `index-${randomUUID()}.tmp`);
+        const text = JSON.stringify(version);
+        if (Buffer.byteLength(text) > MAX_META)
+            throw new Error('Media cache metadata exceeds budget');
+        try {
+            await fs.writeFile(temp, text, { mode: 0o600, flag: 'wx' });
+            this.requireWriter(version.key);
+            await fs.rename(temp, path.join(directory, 'index.json'));
+        }
+        finally {
+            await fs.unlink(temp).catch(() => { });
+        }
+        this.versions.set(version.key.version, version);
+    }
+    async lookup(key) {
+        return this.serial(async () => {
+            const state = await this.load(key);
+            if (!state)
+                return [];
+            return state.generations.map(g => ({ ...g, objects: g.objects.map(({ stamp, accessedAtMs, ...o }) => ({ ...o, file: this.objectPath(key, g.id, o) })) }));
+        });
+    }
+    async publish(key, generation, object) {
+        return this.serial(async () => {
+            this.requireWriter(key);
+            const file = this.objectPath(key, generation.id, object);
+            if (path.resolve(object.file) !== file)
+                throw new Error('Media object escaped cache generation');
+            const stat = await fs.lstat(file, { bigint: true });
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size !== BigInt(object.size) || object.size > this.policy.maxVersionBytes)
+                throw new Error('Invalid cached media object size');
+            const state = await this.load(key) ?? { key, generations: [] };
+            let stored = state.generations.find(g => g.id === generation.id);
+            if (!stored) {
+                if (state.generations.length >= GENERATION_RECLAIM_TARGET) {
+                    const foreignPins = await this.foreignProtection(Date.now());
+                    const victim = state.generations.find(g => g.objects.every(o => !this.protected(o.id, Date.now()) && !foreignPins.has(o.id)));
+                    if (victim) {
+                        for (const o of victim.objects)
+                            await fs.unlink(this.objectPath(key, victim.id, o)).catch(e => { if (e.code !== 'ENOENT')
+                                throw e; });
+                        state.generations = state.generations.filter(g => g !== victim);
+                    }
+                }
+                if (state.generations.length >= MAX_GENERATIONS)
+                    throw new Error('Media cache pressure: generation metadata budget exceeded');
+                stored = { ...generation, objects: [] };
+                state.generations.push(stored);
+            }
+            if (stored.objects.some(o => o.id === object.id))
+                throw new Error('Media objects are immutable');
+            const { file: ignored, ...wire } = object;
+            stored.objects.push({ ...wire, stamp: stampOf(stat), accessedAtMs: Date.now() });
+            this.versions.set(key.version, state);
+            this.activeReads.set(object.id, (this.activeReads.get(object.id) ?? 0) + 1);
+            try {
+                await this.trimInternal(Date.now());
+                await this.save(state);
+            }
+            catch (error) {
+                stored.objects = stored.objects.filter(o => o.id !== object.id);
+                await fs.unlink(file).catch(() => { });
+                await this.save(state);
+                throw error;
+            }
+            finally {
+                this.activeReads.delete(object.id);
+            }
+        });
+    }
+    async finishGeneration(key, generation) {
+        return this.serial(async () => {
+            const state = await this.load(key);
+            const stored = state?.generations.find(g => g.id === generation.id);
+            if (!state || !stored)
+                return;
+            stored.complete = generation.complete;
+            stored.sourceComplete = generation.sourceComplete;
+            await this.save(state);
+        });
+    }
+    async read(key, objectId, offset, length) {
+        if (!hex32.test(objectId) || !Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length < 1 || length > 256 * 1024)
+            throw new Error('Invalid media object read');
+        return this.serial(async () => {
+            const state = await this.load(key);
+            const generation = state?.generations.find(g => g.objects.some(o => o.id === objectId));
+            const object = generation?.objects.find(o => o.id === objectId);
+            if (!object || !generation)
+                throw new Error('Media cache interval is unavailable');
+            const file = this.objectPath(key, generation.id, object);
+            this.activeReads.set(objectId, (this.activeReads.get(objectId) ?? 0) + 1);
+            let handle;
+            try {
+                handle = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+                const stat = await handle.stat({ bigint: true });
+                if (!stat.isFile() || stampOf(stat) !== object.stamp)
+                    throw new Error('Media preview cache changed');
+                const bytes = Buffer.alloc(Math.min(length, Math.max(0, object.size - offset)));
+                const { bytesRead } = await handle.read(bytes, 0, bytes.length, offset);
+                if (stampOf(await handle.stat({ bigint: true })) !== object.stamp)
+                    throw new Error('Media preview cache changed');
+                object.accessedAtMs = Date.now();
+                return bytes.subarray(0, bytesRead);
+            }
+            finally {
+                if (handle)
+                    await handle.close();
+                const count = (this.activeReads.get(objectId) ?? 1) - 1;
+                if (count)
+                    this.activeReads.set(objectId, count);
+                else
+                    this.activeReads.delete(objectId);
+            }
+        });
+    }
+    async pin(consumerId, objectIds, retainUntilMs) {
+        if (objectIds.some(id => !hex32.test(id)) || !Number.isFinite(retainUntilMs))
+            throw new Error('Invalid cache retention');
+        return this.serial(async () => {
+            this.pins.set(consumerId, new Set(objectIds));
+            for (const id of objectIds)
+                this.retainedUntil.set(id, Math.max(this.retainedUntil.get(id) ?? 0, retainUntilMs));
+            await this.saveReader();
+        });
+    }
+    async unpin(consumerId) { return this.serial(async () => { this.pins.delete(consumerId); await this.saveReader(); }); }
+    async saveReader() {
+        const now = Date.now();
+        for (const [id, deadline] of this.retainedUntil)
+            if (deadline <= now)
+                this.retainedUntil.delete(id);
+        const file = path.join(this.directory, `reader-${this.readerId}.json`);
+        const data = { pid: process.pid, expires: now + this.policy.consumerLeaseMs + 5000, pins: [...this.pins.values()].flatMap(ids => [...ids]), retained: [...this.retainedUntil] };
+        const temp = file + '.tmp';
+        await fs.writeFile(temp, JSON.stringify(data), { mode: 0o600 });
+        await fs.rename(temp, file);
+    }
+    async foreignProtection(now) {
+        const protectedIds = new Set();
+        for (const name of await fs.readdir(this.directory)) {
+            if (!/^reader-[a-f0-9-]{36}\.json$/.test(name))
+                continue;
+            const file = path.join(this.directory, name);
+            const handle = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const stat = await handle.stat();
+                if (!stat.isFile() || stat.size > MAX_META || (process.getuid && stat.uid !== process.getuid()))
+                    throw new Error('Unsafe cache reader lease');
+                const data = JSON.parse(await handle.readFile('utf8'));
+                if (!Array.isArray(data.pins) || !Array.isArray(data.retained) || !Number.isFinite(data.expires))
+                    throw new Error('Invalid cache reader lease');
+                let live = false;
+                try {
+                    if (Number.isSafeInteger(data.pid) && data.pid > 0) {
+                        process.kill(data.pid, 0);
+                        live = true;
+                    }
+                }
+                catch { }
+                if (live && data.expires > now)
+                    for (const id of data.pins)
+                        if (hex32.test(id))
+                            protectedIds.add(id);
+                for (const [id, deadline] of data.retained)
+                    if (hex32.test(id) && Number.isFinite(deadline) && deadline > now)
+                        protectedIds.add(id);
+                if ((!live || data.expires <= now) && !data.retained.some((r) => r[1] > now))
+                    await fs.unlink(file);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        return protectedIds;
+    }
+    /** Reserve legacy encoder headroom in the same physical quota used by v3 publishers. */
+    async reserveLegacy(output, bytes) {
+        const name = path.basename(output);
+        if (path.dirname(output) !== this.directory || !/^\.part-[a-f0-9-]{36}\.(mp3|mp4|png)$/.test(name) || !Number.isSafeInteger(bytes) || bytes < 1)
+            throw new Error('Invalid legacy reservation');
+        const file = path.join(this.directory, `reservation-${randomUUID()}.json`);
+        await this.serial(async () => {
+            await fs.writeFile(file, JSON.stringify({ pid: process.pid, output: name, bytes }), { mode: 0o600, flag: 'wx' });
+            try {
+                await this.trimInternal(Date.now());
+            }
+            catch (error) {
+                await fs.unlink(file);
+                throw error;
+            }
+        });
+        return () => this.serial(async () => { await fs.unlink(file).catch(e => { if (e.code !== 'ENOENT')
+            throw e; }); await this.trimInternal(Date.now()); });
+    }
+    async reservedBytes() {
+        let reserved = 0;
+        for (const name of await fs.readdir(this.directory)) {
+            if (!/^reservation-[a-f0-9-]{36}\.json$/.test(name))
+                continue;
+            const file = path.join(this.directory, name);
+            const handle = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                if ((await handle.stat()).size > 4096)
+                    throw new Error('Invalid cache reservation');
+                const r = JSON.parse(await handle.readFile('utf8'));
+                if (!Number.isSafeInteger(r.pid) || r.pid < 1 || !Number.isSafeInteger(r.bytes) || r.bytes < 1 || !/^\.part-[a-f0-9-]{36}\.(mp3|mp4|png)$/.test(r.output))
+                    throw new Error('Invalid cache reservation');
+                try {
+                    process.kill(r.pid, 0);
+                }
+                catch {
+                    await fs.unlink(file);
+                    continue;
+                }
+                const size = await fs.lstat(path.join(this.directory, r.output)).then(s => s.isFile() ? s.size : 0).catch(() => 0);
+                reserved += Math.max(0, r.bytes - size);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        return reserved;
+    }
+    protected(id, now) {
+        return this.activeReads.has(id) || [...this.pins.values()].some(ids => ids.has(id)) || (this.retainedUntil.get(id) ?? 0) > now;
+    }
+    async trim(nowMs) { return this.serial(() => this.trimInternal(nowMs)); }
+    async trimInternal(now) {
+        for (const [id, expiry] of this.retainedUntil)
+            if (expiry <= now)
+                this.retainedUntil.delete(id);
+        const foreignPins = await this.foreignProtection(now);
+        await this.reclaimOrphans(now);
+        for (const name of await fs.readdir(this.directory))
+            if (/^\.part-[a-f0-9-]{36}\.(mp3|mp4|png|json)$/.test(name)) {
+                const file = path.join(this.directory, name);
+                const stat = await fs.lstat(file);
+                if (stat.isFile() && stat.mtimeMs < now - this.policy.ttlMs)
+                    await fs.unlink(file);
+            }
+        for (const name of await fs.readdir(this.directory))
+            if (/^v3-[a-f0-9]{64}$/.test(name)) {
+                const version = name.slice(3);
+                if (this.claims.has(version))
+                    continue;
+                try {
+                    const handle = await fs.open(path.join(this.directory, name, 'index.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
+                    let key;
+                    try {
+                        if ((await handle.stat()).size <= MAX_META)
+                            key = JSON.parse(await handle.readFile('utf8')).key;
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                    if (key?.version === version)
+                        await this.load(key);
+                }
+                catch { /* An unpublished or corrupt directory is not a ready cache entry. */ }
+            }
+        const records = [];
+        for (const state of this.versions.values()) {
+            const foreign = !this.claims.has(state.key.version) && await lockfile.check(this.versionPath(state.key)).catch(() => true);
+            for (const generation of state.generations)
+                for (const object of generation.objects)
+                    records.push({ state, generation, object, foreign });
+        }
+        const usage = new Map();
+        let total = (await this.diskUsage()).total + await this.reservedBytes();
+        for (const { state, object } of records) {
+            usage.set(state.key.version, (usage.get(state.key.version) ?? 0) + object.size);
+        }
+        // Legacy derivatives participate in the same quota and reader protection.
+        const legacy = [];
+        for (const name of await fs.readdir(this.directory))
+            if (/^[a-f0-9]{64}\.(mp3|mp4|png|json)$/.test(name)) {
+                const stat = await fs.lstat(path.join(this.directory, name));
+                if (stat.isFile())
+                    legacy.push({ name, size: stat.size, time: stat.mtimeMs });
+            }
+        for (const entry of legacy.sort((a, b) => a.time - b.time)) {
+            const id = entry.name.slice(0, 32);
+            if (this.protected(id, now) || foreignPins.has(id))
+                continue;
+            if (total <= this.policy.maxCacheBytes && now - entry.time <= this.policy.ttlMs)
+                continue;
+            await fs.unlink(path.join(this.directory, entry.name)).catch(e => { if (e.code !== 'ENOENT')
+                throw e; });
+            total -= entry.size;
+        }
+        const changed = new Set();
+        for (const record of records.sort((a, b) => a.object.accessedAtMs - b.object.accessedAtMs || a.object.sequence - b.object.sequence)) {
+            const { state, generation, object, foreign } = record;
+            if (foreign || this.protected(object.id, now) || foreignPins.has(object.id))
+                continue;
+            if (total <= this.policy.maxCacheBytes && (usage.get(state.key.version) ?? 0) <= this.policy.maxVersionBytes && now - object.accessedAtMs <= this.policy.ttlMs)
+                continue;
+            // A read-only cache instance never edits another keeper's index.
+            let release;
+            if (!this.claims.has(state.key.version)) {
+                try {
+                    release = (await this.claimWriter(state.key)).release;
+                }
+                catch {
+                    continue;
+                }
+            }
+            try {
+                await fs.unlink(this.objectPath(state.key, generation.id, object)).catch(e => { if (e.code !== 'ENOENT')
+                    throw e; });
+                generation.objects = generation.objects.filter(o => o.id !== object.id);
+                total -= object.size;
+                usage.set(state.key.version, (usage.get(state.key.version) ?? 0) - object.size);
+                changed.add(state);
+                if (release) {
+                    await this.save(state);
+                    changed.delete(state);
+                }
+            }
+            finally {
+                if (release)
+                    await release();
+            }
+        }
+        for (const state of changed)
+            await this.save(state);
+        total = (await this.diskUsage()).total + await this.reservedBytes();
+        if (total > this.policy.maxCacheBytes || [...usage.values()].some(bytes => bytes > this.policy.maxVersionBytes))
+            throw new Error('Media cache pressure: protected data fills the budget');
+    }
+    async reclaimOrphans(now) {
+        for (const name of await fs.readdir(this.directory)) {
+            if (!/^v3-[a-f0-9]{64}$/.test(name) || this.claims.has(name.slice(3)))
+                continue;
+            const directory = path.join(this.directory, name);
+            const stat = await fs.lstat(directory);
+            if (!stat.isDirectory() || stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()))
+                continue;
+            let release;
+            try {
+                release = await lockfile.lock(directory, { stale: 60_000, update: 10_000, retries: 0 });
+            }
+            catch {
+                continue;
+            } // Never collect a fresh keeper's unpublished output.
+            try {
+                const indexed = new Set();
+                let readable = true;
+                try {
+                    const handle = await fs.open(path.join(directory, 'index.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
+                    try {
+                        const info = await handle.stat();
+                        if (!info.isFile() || info.size > MAX_META)
+                            throw new Error('Invalid cache metadata');
+                        const data = JSON.parse(await handle.readFile('utf8'));
+                        if (!Array.isArray(data.generations))
+                            throw new Error('Invalid cache metadata');
+                        for (const g of data.generations)
+                            if (hex32.test(g.id) && Array.isArray(g.objects))
+                                for (const o of g.objects) {
+                                    if (hex32.test(o.id) && ['ts', 'mp3', 'mp4', 'png'].includes(o.extension))
+                                        indexed.add(`${g.id}/${o.id}.${o.extension}`);
+                                }
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        readable = false;
+                }
+                // Corrupt metadata cannot prove that a file is unreferenced.
+                if (!readable)
+                    continue;
+                for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+                    const file = path.join(directory, entry.name);
+                    if (entry.isFile() && /^index-[a-f0-9-]{36}\.tmp$/.test(entry.name)) {
+                        if ((await fs.lstat(file)).mtimeMs < now - this.policy.ttlMs)
+                            await fs.unlink(file);
+                    }
+                    else if (entry.isDirectory() && hex32.test(entry.name)) {
+                        for (const leaf of await fs.readdir(file, { withFileTypes: true })) {
+                            if (!leaf.isFile() || indexed.has(`${entry.name}/${leaf.name}`))
+                                continue;
+                            if (!/^([a-f0-9]{32}\.(ts|mp3|mp4|png)(\.[a-f0-9]{32})?(\.tmp)?|[a-f0-9]{32}\.ffconcat|raw_\d{6}\.(ts|mp3)(\.tmp)?|encoder\.(csv|m3u8)(\.tmp)?)$/.test(leaf.name))
+                                continue;
+                            const orphan = path.join(file, leaf.name);
+                            if ((await fs.lstat(orphan)).mtimeMs < now - this.policy.ttlMs)
+                                await fs.unlink(orphan);
+                        }
+                        await fs.rmdir(file).catch(error => { if (!['ENOTEMPTY', 'ENOENT'].includes(error.code))
+                            throw error; });
+                    }
+                }
+            }
+            finally {
+                await release();
+            }
+        }
+    }
+    async diskUsage() {
+        let total = 0;
+        const visit = async (directory, depth) => {
+            for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+                if (entry.isSymbolicLink())
+                    continue;
+                const file = path.join(directory, entry.name);
+                if (entry.isFile()) {
+                    try {
+                        total += (await fs.lstat(file)).size;
+                    }
+                    catch (e) {
+                        if (e.code !== 'ENOENT')
+                            throw e;
+                    }
+                }
+                else if (entry.isDirectory() && ((depth === 0 && /^v3-[a-f0-9]{64}$/.test(entry.name)) || (depth === 1 && hex32.test(entry.name))))
+                    await visit(file, depth + 1);
+            }
+        };
+        await visit(this.directory, 0);
+        return { total };
+    }
+    async finalizeRange(key, generationId, signal = new AbortController().signal) {
+        const generations = await this.lookup(key);
+        const g = generations.find(g => g.id === generationId);
+        if (!g?.complete || !g.sourceComplete || g.sourceOffsetMs !== 0 || !g.objects.length || g.objects[0].sequence !== 0)
+            return null;
+        if (g.objects.some((o, i) => o.type !== 'segment' || (i > 0 && (o.sequence !== g.objects[i - 1].sequence + 1 || o.startMs !== g.objects[i - 1].endMs))))
+            return null;
+        const bytes = g.objects.reduce((n, o) => n + o.size, 0);
+        if (bytes * 2 > this.policy.maxVersionBytes || (await this.diskUsage()).total + bytes > this.policy.maxCacheBytes)
+            return null;
+        const id = randomUUID().replaceAll('-', '');
+        const extension = g.objects[0].extension === 'ts' ? 'mp4' : 'mp3';
+        const file = path.join(await this.createGeneration(key, g.id), `${id}.${extension}`);
+        const object = { ...await remuxRange(g, file, signal), id };
+        await this.publish(key, g, object);
+        return object;
+    }
+    async lookupLegacy(version) {
+        if (!hex64.test(version))
+            return null;
+        try {
+            const meta = await fs.open(path.join(this.directory, `${version}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
+            let data;
+            try {
+                const s = await meta.stat();
+                if (!s.isFile() || s.size > 4096)
+                    return null;
+                data = JSON.parse(await meta.readFile('utf8'));
+            }
+            finally {
+                await meta.close();
+            }
+            if (data.version !== version || data.state !== 'ready' || !['mp3', 'mp4', 'png'].includes(data.extension) || !['audio', 'video', 'image'].includes(data.kind) || !Number.isSafeInteger(data.size) || data.size <= 0 || data.size > this.policy.maxVersionBytes || !Number.isFinite(data.durationSeconds) || data.durationSeconds < 0 || data.durationSeconds > 21600)
+                return null;
+            const file = path.join(this.directory, `${version}.${data.extension}`);
+            const s = await fs.lstat(file);
+            if (!s.isFile() || s.isSymbolicLink() || s.size !== data.size)
+                return null;
+            const durationMs = Math.round(data.durationSeconds * 1000);
+            return { kind: data.kind, durationMs, object: { id: version.slice(0, 32), type: data.kind === 'image' ? 'image' : 'range', extension: data.extension, mimeType: data.mimeType, size: data.size, etag: version, startMs: 0, endMs: durationMs, sequence: 0, timestamp90k: 0, file } };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+async function safeDirectory(directory) {
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    const stat = await fs.lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()))
+        throw new Error('Unsafe media cache directory');
+    await fs.chmod(directory, 0o700);
+}