cursedbelt-server 3.0.1 → 4.0.0

package/src/server/storage/index.ts

@@ -69,9 +69,6 @@ export {
   type MintChunkUpload,
   type MountFileRoutesOptions,
   mountFileRoutes,
-  type PrivateFileCatalogue,
-  type PrivateFileItem,
-  type PrivateKeyMode,
   type SqliteFileCatalogueOptions,
   type StorageAction,
   type StorageOpRow,
@@ -112,7 +109,6 @@ export {
   type MediaSource,
   type MediaStore,
   type PhotoSource,
-  privateFsKey,
 } from './types';
 export {
   type ProcessOptions,

package/src/server/storage/mountMediaRoutes.ts

@@ -16,7 +16,7 @@ import {
 
 // Mounts the byte-serving media routes. These live OUTSIDE an app's guarded API (a <video>/
 // hls.js request can't send the platform Bearer) and authorize each request with a path-embedded
-// stream token instead. Optionally hooks decryption for private (pfs/…) bytes (private-media).
+// stream token instead.
 //
 // `basePath` is the on-server MOUNT path (always path-only, e.g. '/_media'). It is separate from
 // the PUBLIC url base passed to `createMediaUrls` (which may be an absolute API-origin URL for a
@@ -48,12 +48,6 @@ export type MountMediaOptions = {
   /** Authorizes an upload request (it CAN send the Bearer, unlike a media element). Return a
    * MediaCtx to allow, or null to reject. Omit ⇒ uploads are disabled on this mount. */
   authorizeUpload?: (c: Context) => Promise<MediaCtx | null> | MediaCtx | null;
-  /** Optional hook to decrypt bytes for the private (pfs/…) keyspace before serving. Wired by
-   * the private-media layer; omitted ⇒ all bytes served as stored. */
-  decryptStream?: (
-    stream: ReadableStream<Uint8Array>,
-    grant: StreamGrant,
-  ) => ReadableStream<Uint8Array>;
 };
 
 const EXPOSE_HEADERS = 'Content-Range, Content-Length, Accept-Ranges';

package/src/server/storage/types.ts

@@ -217,14 +217,5 @@ export const fsPosterKey = (owner: string, id: string) => `fs/${owner}/${id}-pos
 export const fsDisplayKey = (owner: string, id: string) => `fs/${owner}/${id}-display.jpg`;
 export const fsSpriteKey = (owner: string, id: string) => `fs/${owner}/${id}-sprites.jpg`;
 export const fsVttKey = (owner: string, id: string) => `fs/${owner}/${id}-sprites.vtt`;
-/** Private (encrypted) namespace — the private-media layer stores ciphertext here. The HLS
- * segments under it are AES-128-encrypted at rest (the player fetches the content key via the
- * gated key route and decrypts); a distinct keyspace from public `hls/` so the two never collide. */
-export const privateFsKey = (owner: string, id: string) => `pfs/${owner}/${id}`;
-export const privateHlsPrefix = (owner: string, id: string) => `pfs/${owner}/${id}/hls`;
-export const privateHlsMasterKey = (owner: string, id: string) =>
-  `pfs/${owner}/${id}/hls/master.m3u8`;
-export const privateHlsFileKey = (owner: string, id: string, rel: string) =>
-  `pfs/${owner}/${id}/hls/${rel}`;
-export const privatePosterKey = (owner: string, id: string) => `pfs/${owner}/${id}/poster.enc`;
-export const privateSourceKey = (owner: string, id: string) => `pfs/${owner}/${id}/source.enc`;
+// The `pfs/` (ciphertext) keyspace was deleted with private media on 2026-09-17 — nothing ever
+// wrote a byte to it on this fleet, and binary-server stores objects unencrypted regardless.

package/src/shippedFilesAreTracked.spec.ts

@@ -60,9 +60,10 @@ describe('every file inside the published surface is tracked', () => {
 		const untracked = out === '' ? [] : out.split('\n');
 		expect(
 			untracked,
-			'these would be PUBLISHED but exist in no commit — `bun publish` packs the working directory, not the index,\n' +
+			'these would be PUBLISHED but git does not know them — `bun publish` packs the working directory,\n' +
 				'so the registry would carry code nobody can review, diff or revert, and npm versions are immutable.\n' +
-				'Commit them (or add them to .gitignore if they genuinely must not ship):\n  ' +
+				'`git add <path>` alone clears this (--others skips the INDEX, not just HEAD), which is what a\n' +
+				'session forbidden from committing must do; otherwise commit them, or .gitignore them:\n  ' +
 				untracked.join('\n  '),
 		).toEqual([]);
 	});

package/dist/server/private-media/crypto.d.ts

@@ -1,37 +0,0 @@
-export type KeyMode = 'standard' | 'deniable';
-/** A random per-user salt (non-secret, stored plaintext, stable once created). Domain-separates
- * a user's password-derived keys so the same password yields different keys across users. */
-export declare const generateUserSalt: () => string;
-/** Zero-knowledge set key: scrypt(password, per-user salt). The server never stores this (or a
- * hash of it); it exists only transiently after an unlock. Different passwords → disjoint sets. */
-export declare const derivePasswordSetKey: (password: string, userSalt: string) => Buffer;
-/** Recoverable set key: scrypt(serverSecret, userId). The server can always derive it, so
- * `standard`-mode media is decryptable once private is unlocked (session-gated) — protects a
- * stolen disk / Finder / backups, but a compromised running server can decrypt. */
-export declare const deriveServerSetKey: (serverSecret: string, userId: string) => Buffer;
-export declare const sealMeta: (setKey: Buffer, meta: unknown) => string;
-/** Open a sealed envelope, or null if this key doesn't own it (wrong password / mode key).
- * The null return IS the membership signal — no stored set identifier is needed. */
-export declare function openMeta<T = unknown>(setKey: Buffer, sealed: string): T | null;
-export type ContentKey = {
-    key: Buffer;
-    iv: Buffer;
-};
-export declare const generateContentKey: () => ContentKey;
-export declare const wrapContentKey: (setKey: Buffer, content: ContentKey) => string;
-/** Unwrap a content key, or null if the set key can't open it (wrong password / mode key). */
-export declare function unwrapContentKey(setKey: Buffer, wrapped: string): ContentKey | null;
-/** Pipe a byte stream through the item's AES-128-CTR keystream. Symmetric: pass ciphertext to
- * decrypt, plaintext to encrypt. */
-/** Big-endian increment of a 16-byte CTR IV by `blocks` — the counter arithmetic that lets a
- * decryptor start mid-stream (genapp-100: Range/seek on private blobs). */
-export declare function incrementIv(iv: Buffer, blocks: number): Buffer;
-/**
- * Decrypt a CTR ciphertext stream that starts at the BLOCK-ALIGNED offset covering plaintext
- * byte `startOffset`, dropping the intra-block lead-in — the seek half of {@link cryptBlobStream}.
- * CTR is length-preserving and positionally keyed, so byte N of plaintext only needs ciphertext
- * from block ⌊N/16⌋ onward with the IV counter advanced by that many blocks (genapp-100: this is
- * what makes big private videos scrub on a remote-store host with no local derivatives).
- */
-export declare function cryptBlobRangeStream(content: ContentKey, stream: ReadableStream<Uint8Array>, startOffset: number): ReadableStream<Uint8Array>;
-export declare function cryptBlobStream(content: ContentKey, stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;

package/dist/server/private-media/crypto.js

@@ -1,111 +0,0 @@
-import { createCipheriv, randomBytes } from 'node:crypto';
-import { decryptSecret, deriveKey, encryptSecret } from 'cwip/node';
-/** A random per-user salt (non-secret, stored plaintext, stable once created). Domain-separates
- * a user's password-derived keys so the same password yields different keys across users. */
-export const generateUserSalt = () => randomBytes(16).toString('base64url');
-/** Zero-knowledge set key: scrypt(password, per-user salt). The server never stores this (or a
- * hash of it); it exists only transiently after an unlock. Different passwords → disjoint sets. */
-export const derivePasswordSetKey = (password, userSalt) => deriveKey(password, `pmedia:${userSalt}`);
-/** Recoverable set key: scrypt(serverSecret, userId). The server can always derive it, so
- * `standard`-mode media is decryptable once private is unlocked (session-gated) — protects a
- * stolen disk / Finder / backups, but a compromised running server can decrypt. */
-export const deriveServerSetKey = (serverSecret, userId) => deriveKey(serverSecret, `pmedia-srv:${userId}`);
-// ── Sealed metadata envelope (title / thumbnail key / notes / tags) ──────────────
-// Encrypted under the set key; NEVER stored in the plaintext index. A successful decrypt is
-// also the deniable MEMBERSHIP TEST — trying a password reveals only the items it opens.
-export const sealMeta = (setKey, meta) => encryptSecret(JSON.stringify(meta), setKey);
-/** Open a sealed envelope, or null if this key doesn't own it (wrong password / mode key).
- * The null return IS the membership signal — no stored set identifier is needed. */
-export function openMeta(setKey, sealed) {
-    try {
-        return JSON.parse(decryptSecret(sealed, setKey));
-    }
-    catch {
-        return null;
-    }
-}
-export const generateContentKey = () => ({
-    key: randomBytes(16), // AES-128
-    iv: randomBytes(16),
-});
-export const wrapContentKey = (setKey, content) => encryptSecret(`${content.key.toString('base64')}.${content.iv.toString('base64')}`, setKey);
-/** Unwrap a content key, or null if the set key can't open it (wrong password / mode key). */
-export function unwrapContentKey(setKey, wrapped) {
-    try {
-        const [k, iv] = decryptSecret(wrapped, setKey).split('.');
-        if (!k || !iv)
-            return null;
-        return { key: Buffer.from(k, 'base64'), iv: Buffer.from(iv, 'base64') };
-    }
-    catch {
-        return null;
-    }
-}
-// ── Whole-file blob cipher (non-video private files: photos, docs) ────────────────
-// AES-128-CTR under the item's content key — the same key/IV material the HLS path wraps, so
-// wrap/unwrap is shared. CTR is length-preserving and streaming (no padding, no buffering), and
-// encrypt/decrypt are the same operation. Tamper-evidence comes from the GCM-sealed descriptor +
-// the gated serve route (parity with the encrypted-HLS segments, which are CBC-without-MAC too).
-/** Pipe a byte stream through the item's AES-128-CTR keystream. Symmetric: pass ciphertext to
- * decrypt, plaintext to encrypt. */
-/** Big-endian increment of a 16-byte CTR IV by `blocks` — the counter arithmetic that lets a
- * decryptor start mid-stream (genapp-100: Range/seek on private blobs). */
-export function incrementIv(iv, blocks) {
-    const out = Buffer.from(iv);
-    let carry = BigInt(blocks);
-    for (let i = out.length - 1; i >= 0 && carry > 0n; i--) {
-        const sum = BigInt(out[i]) + (carry & 0xffn);
-        out[i] = Number(sum & 0xffn);
-        carry = (carry >> 8n) + (sum >> 8n);
-    }
-    return out;
-}
-/**
- * Decrypt a CTR ciphertext stream that starts at the BLOCK-ALIGNED offset covering plaintext
- * byte `startOffset`, dropping the intra-block lead-in — the seek half of {@link cryptBlobStream}.
- * CTR is length-preserving and positionally keyed, so byte N of plaintext only needs ciphertext
- * from block ⌊N/16⌋ onward with the IV counter advanced by that many blocks (genapp-100: this is
- * what makes big private videos scrub on a remote-store host with no local derivatives).
- */
-export function cryptBlobRangeStream(content, stream, startOffset) {
-    const BLOCK = 16;
-    const blocks = Math.floor(startOffset / BLOCK);
-    let drop = startOffset % BLOCK;
-    const cipher = createCipheriv('aes-128-ctr', content.key, incrementIv(content.iv, blocks));
-    return stream.pipeThrough(new TransformStream({
-        transform(chunk, controller) {
-            let out = cipher.update(chunk);
-            if (drop > 0) {
-                const skip = Math.min(drop, out.byteLength);
-                out = out.subarray(skip);
-                drop -= skip;
-            }
-            if (out.byteLength > 0) {
-                controller.enqueue(new Uint8Array(out.buffer, out.byteOffset, out.byteLength));
-            }
-        },
-        flush(controller) {
-            const out = cipher.final(); // empty for CTR — kept for cipher-contract completeness
-            if (out.byteLength > 0) {
-                controller.enqueue(new Uint8Array(out.buffer, out.byteOffset, out.byteLength));
-            }
-        },
-    }));
-}
-export function cryptBlobStream(content, stream) {
-    const cipher = createCipheriv('aes-128-ctr', content.key, content.iv);
-    return stream.pipeThrough(new TransformStream({
-        transform(chunk, controller) {
-            const out = cipher.update(chunk);
-            if (out.byteLength > 0) {
-                controller.enqueue(new Uint8Array(out.buffer, out.byteOffset, out.byteLength));
-            }
-        },
-        flush(controller) {
-            const out = cipher.final(); // empty for CTR — kept for cipher-contract completeness
-            if (out.byteLength > 0) {
-                controller.enqueue(new Uint8Array(out.buffer, out.byteOffset, out.byteLength));
-            }
-        },
-    }));
-}

package/dist/server/private-media/index-store.d.ts

@@ -1,31 +0,0 @@
-import type { ProcessingStatus } from 'cursedbelt-core/media';
-import type { KeyMode } from './crypto';
-export type PrivateItem = {
-    id: string;
-    owner: string;
-    sizeBytes: number;
-    createdAt: number;
-    status: ProcessingStatus;
-    keyMode: KeyMode;
-    /** AES-128 content key + IV, wrapped under the item's set key. */
-    wrappedContentKey: string;
-    /** AES-GCM envelope of { title, notes, tags, durationSeconds, … } under the item's set key. */
-    sealedMeta: string;
-};
-/** What the index endpoint exposes — clear, non-sensitive facts only. No title/thumb/notes/tags,
- * no key mode, no wrapped key. */
-export type PrivateIndexRow = {
-    id: string;
-    sizeBytes: number;
-    createdAt: number;
-    status: ProcessingStatus;
-};
-export declare const toPublic: (item: PrivateItem) => PrivateIndexRow;
-export interface PrivateIndex {
-    add(item: PrivateItem): Promise<void>;
-    get(owner: string, id: string): Promise<PrivateItem | null>;
-    list(owner: string): Promise<PrivateItem[]>;
-    update(owner: string, id: string, patch: Partial<Omit<PrivateItem, 'id' | 'owner'>>): Promise<void>;
-    remove(owner: string, id: string): Promise<void>;
-}
-export declare function createMemoryPrivateIndex(): PrivateIndex;

package/dist/server/private-media/index-store.js

@@ -1,36 +0,0 @@
-export const toPublic = (item) => ({
-    id: item.id,
-    sizeBytes: item.sizeBytes,
-    createdAt: item.createdAt,
-    status: item.status,
-});
-export function createMemoryPrivateIndex() {
-    const byOwner = new Map();
-    const bucket = (owner) => {
-        let m = byOwner.get(owner);
-        if (!m) {
-            m = new Map();
-            byOwner.set(owner, m);
-        }
-        return m;
-    };
-    return {
-        async add(item) {
-            bucket(item.owner).set(item.id, item);
-        },
-        async get(owner, id) {
-            return bucket(owner).get(id) ?? null;
-        },
-        async list(owner) {
-            return [...bucket(owner).values()].sort((a, b) => b.createdAt - a.createdAt);
-        },
-        async update(owner, id, patch) {
-            const item = bucket(owner).get(id);
-            if (item)
-                bucket(owner).set(id, { ...item, ...patch });
-        },
-        async remove(owner, id) {
-            bucket(owner).delete(id);
-        },
-    };
-}

package/dist/server/private-media/mountPrivateRoutes.d.ts

@@ -1,26 +0,0 @@
-import type { Context, Hono } from 'hono';
-import { type MediaStore } from '../storage/types';
-import type { PrivateIndex } from './index-store';
-import type { UnlockPasswordPolicy, UnlockService } from './unlock';
-/** Access-Control-Allow-Origin resolver for split-origin private streaming (media on another
- * origin than the SPA). Same shape as the storage layer's. */
-export type CorsResolver = string | string[] | ((requestOrigin: string | undefined) => string | null | undefined);
-export type MountPrivateOptions = {
-    store: MediaStore;
-    index: PrivateIndex;
-    unlock: UnlockService;
-    /** Path prefix (default '/_private'). */
-    basePath?: string;
-    /** App session auth → the caller's id + their per-user salt (created lazily, stable). Return
-     * null to reject. Gates unlock/index/reveal (the byte routes use the path token instead). */
-    authorize: (c: Context) => Promise<{
-        userId: string;
-        userSalt: string;
-    } | null>;
-    /** What a supplied password means (default: derive — deniable sets). `gate` verifies it
-     * against the app's accounts and mints the recoverable server-key grant instead. */
-    passwordPolicy?: UnlockPasswordPolicy;
-    /** Cross-origin access for split-origin deploys. */
-    cors?: CorsResolver;
-};
-export declare function mountPrivateRoutes(app: Hono, opts: MountPrivateOptions): void;

package/dist/server/private-media/mountPrivateRoutes.js

@@ -1,219 +0,0 @@
-import { decodeRange, serveRange } from '../storage/streamRange';
-import { privateHlsFileKey, privateSourceKey } from '../storage/types';
-import { cryptBlobRangeStream, cryptBlobStream, openMeta, unwrapContentKey } from './crypto';
-import { toPublic } from './index-store';
-function resolveAcao(cors, reqOrigin) {
-    if (!cors)
-        return null;
-    if (typeof cors === 'string')
-        return cors;
-    if (Array.isArray(cors))
-        return reqOrigin && cors.includes(reqOrigin) ? reqOrigin : null;
-    return cors(reqOrigin) ?? null;
-}
-export function mountPrivateRoutes(app, opts) {
-    const base = opts.basePath ?? '/_private';
-    const { store, index, unlock } = opts;
-    const cors = (c, res) => {
-        const acao = resolveAcao(opts.cors, c.req.header('origin'));
-        if (acao) {
-            res.headers.set('Access-Control-Allow-Origin', acao);
-            res.headers.set('Access-Control-Expose-Headers', 'Content-Range, Content-Length, Accept-Ranges');
-            res.headers.append('Vary', 'Origin');
-        }
-        return res;
-    };
-    const policy = opts.passwordPolicy ?? { mode: 'derive' };
-    /** Resolve what the supplied password contributes under the active policy:
-     * derive ⇒ it feeds key derivation (may be undefined ⇒ standard set);
-     * gate ⇒ it must be present AND verify against the app's accounts, then the
-     * set key is the recoverable server one (password never feeds derivation).
-     * Returns an error Response to short-circuit with, or the derivation input. */
-    const resolvePassword = async (c, who, password) => {
-        if (policy.mode === 'derive')
-            return { derivePassword: password };
-        if (!password)
-            return { error: c.json({ error: 'password required' }, 401) };
-        if (!(await policy.verifyPassword(who, password))) {
-            return { error: c.json({ error: 'invalid password' }, 401) };
-        }
-        return {}; // verified — standard (server-key) set
-    };
-    // POST /unlock { password? } → a token sealing the set key (deniable w/ password, else
-    // standard; under the gate policy the password is verified and the set is always standard).
-    app.post(`${base}/unlock`, async (c) => {
-        const who = await opts.authorize(c);
-        if (!who)
-            return c.json({ error: 'unauthorized' }, 401);
-        const body = (await c.req.json().catch(() => ({})));
-        const resolved = await resolvePassword(c, who, body.password || undefined);
-        if ('error' in resolved)
-            return resolved.error;
-        const { token, mode } = await unlock.unlock({
-            userId: who.userId,
-            userSalt: who.userSalt,
-            password: resolved.derivePassword,
-        });
-        return c.json({ token, mode });
-    });
-    // GET /index → clear, non-sensitive rows only (size + createdAt + status). Never title/thumb/mode.
-    app.get(`${base}/index`, async (c) => {
-        const who = await opts.authorize(c);
-        if (!who)
-            return c.json({ error: 'unauthorized' }, 401);
-        return c.json({ items: (await index.list(who.userId)).map(toPublic) });
-    });
-    // Decrypt every descriptor a set key opens, silently skipping the rest (decrypt-success IS the
-    // membership test — deniability). Shared by the password and token reveal routes.
-    const revealWithKey = async (userId, setKey) => {
-        const revealed = [];
-        for (const item of await index.list(userId)) {
-            const meta = openMeta(setKey, item.sealedMeta);
-            if (meta !== null)
-                revealed.push({ id: item.id, meta });
-        }
-        return revealed;
-    };
-    // POST /reveal { password } → which items that password unlocks (GCM decrypt-success), with
-    // their now-decrypted metadata. Others stay opaque. This is the "try a password" cleanup UX.
-    // Under the gate policy the password must verify first and the standard set is revealed.
-    app.post(`${base}/reveal`, async (c) => {
-        const who = await opts.authorize(c);
-        if (!who)
-            return c.json({ error: 'unauthorized' }, 401);
-        const body = (await c.req.json().catch(() => ({})));
-        const resolved = await resolvePassword(c, who, body.password || undefined);
-        if ('error' in resolved)
-            return resolved.error;
-        const setKey = unlock.deriveSetKey({
-            userId: who.userId,
-            userSalt: who.userSalt,
-            password: resolved.derivePassword,
-        });
-        return c.json({ items: await revealWithKey(who.userId, setKey) });
-    });
-    // POST /reveal-unlocked { token } → the same reveal, keyed by an UNLOCK TOKEN instead of the
-    // password (the token seals the set key — same mechanism the content-key route uses). Lets an
-    // already-unlocked session list its items without re-typing the password. The token must belong
-    // to the session caller.
-    app.post(`${base}/reveal-unlocked`, async (c) => {
-        const who = await opts.authorize(c);
-        if (!who)
-            return c.json({ error: 'unauthorized' }, 401);
-        const body = (await c.req.json().catch(() => ({})));
-        if (!body.token)
-            return c.json({ error: 'token required' }, 400);
-        const grant = await unlock.verify(body.token);
-        if (!grant || grant.userId !== who.userId)
-            return c.json({ error: 'invalid token' }, 401);
-        return c.json({ items: await revealWithKey(who.userId, grant.setKey) });
-    });
-    // GET /u/:token/hls/:source/:video/* → the encrypted HLS tree. The `enc.key` sub-path returns
-    // the unwrapped AES-128 content key (gated, no-store); every other path serves the encrypted
-    // segment/playlist (edge-cacheable — hls.js decrypts with the key).
-    app.get(`${base}/u/:token/hls/:source/:video/*`, async (c) => {
-        const raw = c.req.param('token');
-        if (!raw)
-            return c.body(null, 401);
-        const grant = await unlock.verify(raw);
-        if (!grant)
-            return c.body(null, 401);
-        const video = c.req.param('video');
-        const prefix = `${base}/u/${raw}/hls/${c.req.param('source')}/${video}/`;
-        const rel = c.req.path.slice(prefix.length);
-        if (!rel || rel.includes('..'))
-            return c.body(null, 400);
-        if (rel.endsWith('enc.key')) {
-            const item = await index.get(grant.userId, video);
-            if (!item)
-                return c.body(null, 404);
-            const content = unwrapContentKey(grant.setKey, item.wrappedContentKey);
-            // null ⇒ this token's set key doesn't own the item (wrong password / wrong mode).
-            if (!content)
-                return c.body(null, 403);
-            // A fresh, tightly-sized ArrayBuffer copy of the 16-byte key — an unambiguous BodyInit
-            // (wrapping the Node Buffer directly can mis-size the response).
-            const keyBytes = Uint8Array.from(content.key);
-            return cors(c, new Response(keyBytes.buffer, {
-                status: 200,
-                headers: { 'Content-Type': 'application/octet-stream', 'Cache-Control': 'no-store' },
-            }));
-        }
-        const mime = rel.endsWith('.m3u8') ? 'application/vnd.apple.mpegurl' : 'video/mp2t';
-        return cors(c, await serveRange(store, privateHlsFileKey(grant.userId, video, rel), mime, c.req.header('range')));
-    });
-    // GET /u/:token/file/:id → a private file stored as one AES-128-CTR ciphertext blob at
-    // privateSourceKey. Decrypted server-side per request under the token's set key; the mime
-    // comes from the sealed descriptor, so a token whose set key can't open the item (wrong
-    // password / wrong mode) gets a 403 and never any bytes.
-    //
-    // RANGE SUPPORT (genapp-100): CTR is positionally keyed, so a byte range decrypts from the
-    // block-aligned ciphertext offset with the IV counter advanced (`cryptBlobRangeStream`). This
-    // is what makes a big private VIDEO scrub on a remote-store host, where no local ffmpeg means
-    // no HLS derivatives and the blob route is the only byte path. Plaintext is never stored.
-    app.get(`${base}/u/:token/file/:id`, async (c) => {
-        const raw = c.req.param('token');
-        if (!raw)
-            return c.body(null, 401);
-        const grant = await unlock.verify(raw);
-        if (!grant)
-            return c.body(null, 401);
-        const id = c.req.param('id');
-        const item = await index.get(grant.userId, id);
-        if (!item)
-            return c.body(null, 404);
-        const content = unwrapContentKey(grant.setKey, item.wrappedContentKey);
-        if (!content)
-            return c.body(null, 403);
-        const meta = openMeta(grant.setKey, item.sealedMeta);
-        const baseHeaders = {
-            'Content-Type': meta?.mime || 'application/octet-stream',
-            'Cache-Control': 'no-store',
-            'Accept-Ranges': 'bytes',
-        };
-        const key = privateSourceKey(grant.userId, id);
-        const range = item.sizeBytes > 0 ? decodeRange(c.req.header('range'), item.sizeBytes) : { kind: 'full' };
-        if (range.kind === 'unsatisfiable') {
-            return cors(c, new Response(null, { status: 416, headers: { 'Content-Range': `bytes */${item.sizeBytes}` } }));
-        }
-        if (range.kind === 'partial') {
-            // Fetch ciphertext from the BLOCK-ALIGNED start (CTR block = 16 bytes); the range
-            // stream drops the intra-block lead-in so the client sees exactly [start, end].
-            const alignedStart = range.start - (range.start % 16);
-            const stored = await store.getRange(key, { start: alignedStart, end: range.end });
-            if (!stored)
-                return c.body(null, 404);
-            return cors(c, new Response(cryptBlobRangeStream(content, stored.stream, range.start), {
-                status: 206,
-                headers: {
-                    ...baseHeaders,
-                    'Content-Range': `bytes ${range.start}-${range.end}/${item.sizeBytes}`,
-                    'Content-Length': String(range.end - range.start + 1),
-                },
-            }));
-        }
-        const stored = await store.getRange(key);
-        if (!stored)
-            return c.body(null, 404);
-        const headers = { ...baseHeaders };
-        if (item.sizeBytes > 0)
-            headers['Content-Length'] = String(item.sizeBytes);
-        return cors(c, new Response(cryptBlobStream(content, stored.stream), { status: 200, headers }));
-    });
-    // Preflight for the cross-origin byte routes.
-    if (opts.cors) {
-        app.options(`${base}/u/*`, (c) => {
-            const acao = resolveAcao(opts.cors, c.req.header('origin'));
-            const headers = {
-                'Access-Control-Allow-Methods': 'GET, OPTIONS',
-                'Access-Control-Allow-Headers': 'Range',
-                'Access-Control-Max-Age': '86400',
-            };
-            if (acao) {
-                headers['Access-Control-Allow-Origin'] = acao;
-                headers.Vary = 'Origin';
-            }
-            return c.body(null, 204, headers);
-        });
-    }
-}

package/dist/server/private-media/pipeline.d.ts

@@ -1,37 +0,0 @@
-import type { ProcessingStatus } from 'cursedbelt-core/media';
-import { type MediaStore } from '../storage/types';
-export type PrivateProcessResult = {
-    status: ProcessingStatus;
-    durationSeconds: number;
-    hasHls: boolean;
-    /** The AES-128 content key + IV, wrapped under the caller's set key. Null if processing failed. */
-    wrappedContentKey: string | null;
-};
-export type PrivateProcessOptions = {
-    store: MediaStore;
-    /** Scratch dir for ffmpeg I/O + the transient key file (cleaned up afterwards). */
-    workDir: string;
-    owner: string;
-    id: string;
-    /** Local PLAINTEXT source, staged by the caller; never persisted (deleted with the job dir). */
-    sourcePath: string;
-    /** The mode key (server-held or password-derived) the content key is wrapped under. */
-    setKey: Buffer;
-    ladderHeights?: number[];
-    onProgress?: (status: ProcessingStatus, pct: number) => void;
-};
-export declare function processPrivateVideo(opts: PrivateProcessOptions): Promise<PrivateProcessResult>;
-export type PrivateBlobResult = {
-    status: ProcessingStatus;
-    sizeBytes: number;
-    /** The content key + IV, wrapped under the caller's set key. Null if processing failed. */
-    wrappedContentKey: string | null;
-};
-export declare function processPrivateBlob(opts: {
-    store: MediaStore;
-    owner: string;
-    id: string;
-    /** Local PLAINTEXT source, staged by the caller; never persisted (caller deletes it). */
-    sourcePath: string;
-    setKey: Buffer;
-}): Promise<PrivateBlobResult>;