@rynx-ai/daemon 0.1.0 → 0.1.10-beta.2

package/dist/session-resource-store.js

@@ -0,0 +1,700 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
+import { basename, join } from "node:path";
+import { rynxHome, } from "@rynx-ai/core";
+import { defaultSessionResourcePolicy, SESSION_RESOURCE_MAX_IMAGE_PIXELS, SESSION_RESOURCE_MAX_IMAGE_SIDE, SESSION_RESOURCE_MAX_MESSAGE_BYTES, SESSION_RESOURCE_TRANSFER_CHUNK_BYTES, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { MachineSessionServiceFailure, } from "@rynx-ai/server";
+import { db } from "./db.js";
+const MAX_STAGED_RESOURCES_PER_SESSION = 16;
+const STAGED_TTL_MS = 24 * 60 * 60 * 1_000;
+export class SqliteSessionResourceStore {
+    root;
+    constructor(root = join(rynxHome(), "resources")) {
+        this.root = root;
+        ensurePrivateDirectory(this.root);
+        this.sweepExpiredStagedResources();
+    }
+    policy(_sessionId) {
+        return defaultSessionResourcePolicy();
+    }
+    async beginUpload(input) {
+        this.sweepExpiredStagedResources();
+        const filename = safeFilename(input.filename);
+        const existing = db()
+            .prepare(`SELECT * FROM session_resources
+          WHERE session_id = ? AND client_upload_id = ?`)
+            .get(input.sessionId, input.clientUploadId);
+        if (existing) {
+            if (existing.filename !== filename ||
+                existing.media_type !== input.mediaType ||
+                existing.byte_length !== input.byteLength) {
+                throw conflict("clientUploadId was already used for different content");
+            }
+            if (existing.state === "uploading")
+                this.reconcileUploadOffset(existing);
+            const refreshed = this.rowByUpload(input.sessionId, existing.upload_id);
+            return {
+                uploadId: refreshed.upload_id,
+                resourceId: refreshed.id,
+                offset: refreshed.uploaded_bytes,
+                complete: refreshed.state !== "uploading",
+                ...(refreshed.state === "uploading"
+                    ? {}
+                    : { resource: toMetadata(refreshed) }),
+            };
+        }
+        const staged = db()
+            .prepare(`SELECT COUNT(*) AS count, COALESCE(SUM(byte_length), 0) AS bytes
+           FROM session_resources
+          WHERE session_id = ? AND state IN ('uploading', 'staged')`)
+            .get(input.sessionId);
+        if (staged.count >= MAX_STAGED_RESOURCES_PER_SESSION ||
+            staged.bytes + input.byteLength > SESSION_RESOURCE_MAX_MESSAGE_BYTES) {
+            throw unavailable("Session staged image quota exceeded");
+        }
+        const resourceId = `res_${randomUUID()}`;
+        const uploadId = `upl_${randomUUID()}`;
+        const createdAt = Date.now();
+        ensurePrivateDirectory(this.sessionDirectory(input.sessionId));
+        db().prepare(`INSERT INTO session_resources
+         (id, session_id, client_upload_id, upload_id, filename, media_type,
+          byte_length, uploaded_bytes, state, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 0, 'uploading', ?)`).run(resourceId, input.sessionId, input.clientUploadId, uploadId, filename, input.mediaType, input.byteLength, createdAt);
+        return { uploadId, resourceId, offset: 0, complete: false };
+    }
+    async writeUploadChunk(input) {
+        const row = this.requireUpload(input.sessionId, input.uploadId);
+        if (row.state !== "uploading")
+            return { offset: row.byte_length };
+        const bytes = decodeBase64(input.data);
+        if (bytes.byteLength === 0 || bytes.byteLength > SESSION_RESOURCE_TRANSFER_CHUNK_BYTES) {
+            throw invalid("Upload chunk length is invalid");
+        }
+        this.reconcileUploadOffset(row);
+        const current = this.requireUpload(input.sessionId, input.uploadId);
+        if (input.offset > current.uploaded_bytes) {
+            throw conflict("Upload chunk offset is ahead of the stored resource");
+        }
+        if (input.offset < current.uploaded_bytes) {
+            const end = input.offset + bytes.byteLength;
+            if (end > current.uploaded_bytes) {
+                throw conflict("Upload chunk overlaps the stored resource tail");
+            }
+            const existing = Buffer.alloc(bytes.byteLength);
+            const fd = openSync(this.partialPath(current), constants.O_RDONLY | noFollowFlag());
+            try {
+                readSync(fd, existing, 0, existing.length, input.offset);
+            }
+            finally {
+                closeSync(fd);
+            }
+            if (!existing.equals(bytes)) {
+                throw conflict("Upload chunk retry does not match stored bytes");
+            }
+            return { offset: current.uploaded_bytes };
+        }
+        if (current.uploaded_bytes + bytes.byteLength > current.byte_length) {
+            throw invalid("Upload exceeds its declared byteLength");
+        }
+        const file = this.partialPath(current);
+        const fd = openSync(file, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | noFollowFlag(), 0o600);
+        try {
+            writeSync(fd, bytes);
+        }
+        finally {
+            closeSync(fd);
+        }
+        const nextOffset = current.uploaded_bytes + bytes.byteLength;
+        db().prepare(`UPDATE session_resources
+          SET uploaded_bytes = ?
+        WHERE id = ? AND state = 'uploading'`).run(nextOffset, current.id);
+        return { offset: nextOffset };
+    }
+    async commitUpload(input) {
+        let row = this.requireUpload(input.sessionId, input.uploadId);
+        if (row.state !== "uploading")
+            return { resource: toMetadata(row) };
+        this.reconcileUploadOffset(row);
+        row = this.requireUpload(input.sessionId, input.uploadId);
+        if (row.uploaded_bytes !== row.byte_length) {
+            throw conflict("Upload is incomplete");
+        }
+        const partial = this.partialPath(row);
+        const final = this.finalPath(row);
+        if (!existsSync(partial) && existsSync(final)) {
+            const bytes = readFileSync(final);
+            return { resource: this.finalizeUpload(row, bytes) };
+        }
+        const bytes = readFileSync(partial);
+        const image = inspectImage(bytes, row.media_type);
+        if (image.width > SESSION_RESOURCE_MAX_IMAGE_SIDE ||
+            image.height > SESSION_RESOURCE_MAX_IMAGE_SIDE ||
+            image.width * image.height > SESSION_RESOURCE_MAX_IMAGE_PIXELS) {
+            throw invalid("Image dimensions exceed the Session resource policy");
+        }
+        renameSync(partial, final);
+        chmodSync(final, 0o600);
+        return { resource: this.finalizeUpload(row, bytes, image) };
+    }
+    async getResource(input) {
+        return { resource: toMetadata(this.requireResource(input.sessionId, input.resourceId)) };
+    }
+    async readResource(input) {
+        const row = this.requireResource(input.sessionId, input.resourceId);
+        if (row.state === "uploading")
+            throw unavailable("Resource upload is incomplete");
+        const length = Math.min(input.length, SESSION_RESOURCE_TRANSFER_CHUNK_BYTES);
+        const available = Math.max(0, row.byte_length - input.offset);
+        const readLength = Math.min(length, available);
+        const data = Buffer.alloc(readLength);
+        if (readLength > 0) {
+            const fd = openSync(this.finalPath(row), constants.O_RDONLY | noFollowFlag());
+            try {
+                readSync(fd, data, 0, readLength, input.offset);
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        const offset = input.offset + readLength;
+        return { data: data.toString("base64"), offset, eof: offset >= row.byte_length };
+    }
+    async deleteResource(input) {
+        const row = db()
+            .prepare("SELECT * FROM session_resources WHERE session_id = ? AND id = ?")
+            .get(input.sessionId, input.resourceId);
+        if (!row)
+            return { deleted: false };
+        if (row.state === "committed") {
+            throw conflict("Committed message resources cannot be deleted independently");
+        }
+        rmSync(this.partialPath(row), { force: true });
+        rmSync(this.finalPath(row), { force: true });
+        db().prepare("DELETE FROM session_resources WHERE id = ?").run(row.id);
+        return { deleted: true };
+    }
+    async prepareInput(sessionId, content, clientMessageId) {
+        const runtimeContent = [];
+        const canonicalContent = [];
+        const resourceIds = [];
+        let title = "";
+        let totalImageBytes = 0;
+        for (const part of content) {
+            if (part.type === "input_text") {
+                runtimeContent.push({ type: "text", text: part.text });
+                canonicalContent.push({ type: "input_text", text: part.text });
+                title ||= part.text.trim();
+                continue;
+            }
+            const row = this.requireResource(sessionId, part.resourceId);
+            if (row.state === "uploading")
+                throw unavailable("Image upload is incomplete");
+            const resource = toImagePart(row);
+            if (resource.mediaType !== part.mediaType ||
+                (part.byteLength !== undefined && part.byteLength !== resource.byteLength)) {
+                throw conflict("Image reference metadata does not match the stored resource");
+            }
+            totalImageBytes += row.byte_length;
+            resourceIds.push(row.id);
+            canonicalContent.push(resource);
+            runtimeContent.push({
+                type: "local_image",
+                path: this.finalPath(row),
+                resource,
+            });
+            title ||= row.filename;
+        }
+        if (runtimeContent.length === 0 || totalImageBytes > SESSION_RESOURCE_MAX_MESSAGE_BYTES) {
+            throw invalid("Message content is empty or exceeds the image byte limit");
+        }
+        if (!runtimeContent.some((part) => part.type === "local_image" || part.text.trim())) {
+            throw invalid("Message content must contain text or an image");
+        }
+        let operationState;
+        if (clientMessageId) {
+            const requestHash = hashMessageContent(canonicalContent);
+            operationState = this.prepareMessageOperation(sessionId, clientMessageId, requestHash, resourceIds);
+        }
+        return {
+            input: {
+                content: runtimeContent,
+                ...(clientMessageId ? { clientMessageId } : {}),
+            },
+            title: title || "Image",
+            ...(operationState ? { operationState } : {}),
+        };
+    }
+    markMessageInjecting(sessionId, clientMessageId) {
+        this.transitionOperation(sessionId, clientMessageId, ["prepared", "failed_not_started"], "injecting");
+    }
+    markMessageInjected(sessionId, clientMessageId) {
+        this.transitionOperation(sessionId, clientMessageId, ["injecting"], "injected");
+    }
+    markMessageOutcomeUnknown(sessionId, clientMessageId, reason) {
+        this.transitionOperation(sessionId, clientMessageId, ["injecting"], "outcome_unknown", reason);
+    }
+    markMessageFailedNotStarted(sessionId, clientMessageId, reason) {
+        this.transitionOperation(sessionId, clientMessageId, ["prepared", "injecting"], "failed_not_started", reason);
+    }
+    deleteSession(sessionId) {
+        const rows = db()
+            .prepare("SELECT * FROM session_resources WHERE session_id = ?")
+            .all(sessionId);
+        for (const row of rows) {
+            rmSync(this.partialPath(row), { force: true });
+            rmSync(this.finalPath(row), { force: true });
+        }
+        db().transaction(() => {
+            db().prepare("DELETE FROM session_message_operations WHERE session_id = ?").run(sessionId);
+            db().prepare("DELETE FROM session_resources WHERE session_id = ?").run(sessionId);
+        })();
+        rmSync(this.sessionDirectory(sessionId), { recursive: true, force: true });
+    }
+    prepareMessageOperation(sessionId, clientMessageId, requestHash, resourceIds) {
+        const conn = db();
+        return conn.transaction(() => {
+            const existing = conn.prepare(`SELECT request_hash, state
+           FROM session_message_operations
+          WHERE session_id = ? AND client_message_id = ?`).get(sessionId, clientMessageId);
+            if (existing) {
+                if (existing.request_hash !== requestHash) {
+                    throw conflict("clientMessageId was already used for different content");
+                }
+                if (existing.state === "failed_not_started") {
+                    this.bindOperationResources(conn, sessionId, clientMessageId, resourceIds);
+                    conn.prepare(`UPDATE session_message_operations
+                SET state = 'prepared', error = NULL, updated_at = ?
+              WHERE session_id = ? AND client_message_id = ?`).run(Date.now(), sessionId, clientMessageId);
+                    return "prepared";
+                }
+                return existing.state;
+            }
+            const now = Date.now();
+            conn.prepare(`INSERT INTO session_message_operations
+           (session_id, client_message_id, request_hash, state, created_at, updated_at)
+         VALUES (?, ?, ?, 'prepared', ?, ?)`).run(sessionId, clientMessageId, requestHash, now, now);
+            this.bindOperationResources(conn, sessionId, clientMessageId, resourceIds);
+            return "prepared";
+        })();
+    }
+    bindOperationResources(conn, sessionId, clientMessageId, resourceIds) {
+        conn.prepare(`DELETE FROM session_message_operation_resources
+        WHERE session_id = ? AND client_message_id = ?`).run(sessionId, clientMessageId);
+        const releaseFailed = conn.prepare(`DELETE FROM session_message_operation_resources
+        WHERE resource_id = ?
+          AND EXISTS (
+            SELECT 1
+              FROM session_message_operations operation
+             WHERE operation.session_id = session_message_operation_resources.session_id
+               AND operation.client_message_id =
+                   session_message_operation_resources.client_message_id
+               AND operation.state = 'failed_not_started'
+          )`);
+        const bind = conn.prepare(`INSERT INTO session_message_operation_resources
+         (session_id, client_message_id, resource_id)
+       VALUES (?, ?, ?)`);
+        try {
+            for (const resourceId of resourceIds) {
+                releaseFailed.run(resourceId);
+                bind.run(sessionId, clientMessageId, resourceId);
+            }
+        }
+        catch {
+            throw conflict("An image resource is already bound to another message");
+        }
+    }
+    transitionOperation(sessionId, clientMessageId, from, to, error) {
+        const placeholders = from.map(() => "?").join(", ");
+        const result = db().prepare(`UPDATE session_message_operations
+          SET state = ?, error = ?, updated_at = ?
+        WHERE session_id = ? AND client_message_id = ?
+          AND state IN (${placeholders})`).run(to, error ?? null, Date.now(), sessionId, clientMessageId, ...from);
+        if (result.changes === 0) {
+            const current = db().prepare(`SELECT state FROM session_message_operations
+          WHERE session_id = ? AND client_message_id = ?`).get(sessionId, clientMessageId);
+            if (current?.state === to || current?.state === "mirrored")
+                return;
+            throw conflict("Message operation state changed");
+        }
+    }
+    finalizeUpload(row, bytes, inspected = inspectImage(bytes, row.media_type)) {
+        const digest = createHash("sha256").update(bytes).digest("hex");
+        db().prepare(`UPDATE session_resources
+          SET state = 'staged', uploaded_bytes = byte_length, sha256 = ?,
+              width = ?, height = ?
+        WHERE id = ? AND state = 'uploading'`).run(digest, inspected.width, inspected.height, row.id);
+        return toMetadata(this.requireResource(row.session_id, row.id));
+    }
+    reconcileUploadOffset(row) {
+        const partial = this.partialPath(row);
+        const final = this.finalPath(row);
+        if (!existsSync(partial)) {
+            if (existsSync(final))
+                return;
+            const fd = openSync(partial, constants.O_WRONLY | constants.O_CREAT | noFollowFlag(), 0o600);
+            closeSync(fd);
+        }
+        const size = statSync(partial).size;
+        if (size > row.byte_length)
+            throw conflict("Stored upload exceeds its declared byteLength");
+        if (size !== row.uploaded_bytes) {
+            db().prepare("UPDATE session_resources SET uploaded_bytes = ? WHERE id = ? AND state = 'uploading'").run(size, row.id);
+        }
+    }
+    rowByUpload(sessionId, uploadId) {
+        return db()
+            .prepare("SELECT * FROM session_resources WHERE session_id = ? AND upload_id = ?")
+            .get(sessionId, uploadId);
+    }
+    requireUpload(sessionId, uploadId) {
+        const row = this.rowByUpload(sessionId, uploadId);
+        if (!row)
+            throw notFound();
+        return row;
+    }
+    requireResource(sessionId, resourceId) {
+        const row = db()
+            .prepare("SELECT * FROM session_resources WHERE session_id = ? AND id = ?")
+            .get(sessionId, resourceId);
+        if (!row)
+            throw notFound();
+        return row;
+    }
+    sessionDirectory(sessionId) {
+        const sessionKey = createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+        return join(this.root, sessionKey);
+    }
+    partialPath(row) {
+        return join(this.sessionDirectory(row.session_id), `${row.id}.part`);
+    }
+    finalPath(row) {
+        return join(this.sessionDirectory(row.session_id), `${row.id}.${extension(row.media_type)}`);
+    }
+    sweepExpiredStagedResources(now = Date.now()) {
+        const rows = db()
+            .prepare(`SELECT * FROM session_resources
+          WHERE state IN ('uploading', 'staged') AND created_at < ?`)
+            .all(now - STAGED_TTL_MS);
+        for (const row of rows) {
+            rmSync(this.partialPath(row), { force: true });
+            rmSync(this.finalPath(row), { force: true });
+            db().prepare("DELETE FROM session_resources WHERE id = ?").run(row.id);
+        }
+    }
+}
+function toImagePart(row) {
+    if (row.state === "uploading" ||
+        !row.sha256 ||
+        !row.width ||
+        !row.height) {
+        throw unavailable("Resource upload is incomplete");
+    }
+    return {
+        type: "input_image",
+        resourceId: row.id,
+        mediaType: row.media_type,
+        filename: row.filename,
+        byteLength: row.byte_length,
+        width: row.width,
+        height: row.height,
+    };
+}
+function toMetadata(row) {
+    const part = toImagePart(row);
+    if (row.state === "uploading")
+        throw unavailable("Resource upload is incomplete");
+    return {
+        ...part,
+        state: row.state,
+        sha256: row.sha256,
+        createdAt: row.created_at,
+    };
+}
+function hashMessageContent(content) {
+    return createHash("sha256")
+        .update(JSON.stringify(content.map((part) => part.type === "input_text"
+        ? { type: part.type, text: part.text }
+        : { type: part.type, resourceId: part.resourceId })))
+        .digest("hex");
+}
+function inspectImage(bytes, declared) {
+    const sniffed = sniffMediaType(bytes);
+    if (sniffed !== declared)
+        throw invalid("Image bytes do not match the declared media type");
+    const structurallyValid = sniffed === "image/png"
+        ? validatePngContainer(bytes)
+        : sniffed === "image/jpeg"
+            ? validateJpegContainer(bytes)
+            : validateWebpContainer(bytes);
+    if (!structurallyValid)
+        throw invalid("Image file is incomplete or malformed");
+    const dimensions = sniffed === "image/png"
+        ? pngDimensions(bytes)
+        : sniffed === "image/jpeg"
+            ? jpegDimensions(bytes)
+            : webpDimensions(bytes);
+    if (!dimensions || dimensions.width <= 0 || dimensions.height <= 0) {
+        throw invalid("Image dimensions could not be decoded");
+    }
+    return dimensions;
+}
+function validatePngContainer(bytes) {
+    let offset = 8;
+    let sawHeader = false;
+    let sawImageData = false;
+    while (offset + 12 <= bytes.length) {
+        const length = bytes.readUInt32BE(offset);
+        const typeStart = offset + 4;
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + length;
+        const chunkEnd = dataEnd + 4;
+        if (dataEnd < dataStart || chunkEnd > bytes.length)
+            return false;
+        const type = bytes.toString("ascii", typeStart, dataStart);
+        if (!sawHeader && (type !== "IHDR" || length !== 13))
+            return false;
+        const expectedCrc = bytes.readUInt32BE(dataEnd);
+        if (pngCrc32(bytes.subarray(typeStart, dataEnd)) !== expectedCrc)
+            return false;
+        if (type === "IHDR") {
+            if (sawHeader || length !== 13)
+                return false;
+            sawHeader = true;
+        }
+        else if (type === "IDAT") {
+            if (!sawHeader)
+                return false;
+            sawImageData = true;
+        }
+        else if (type === "IEND") {
+            return length === 0 && sawHeader && sawImageData && chunkEnd === bytes.length;
+        }
+        offset = chunkEnd;
+    }
+    return false;
+}
+const PNG_CRC_TABLE = Array.from({ length: 256 }, (_, index) => {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = (value & 1) !== 0 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    return value >>> 0;
+});
+function pngCrc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc = PNG_CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function validateJpegContainer(bytes) {
+    if (bytes.length < 8 || bytes[0] !== 0xff || bytes[1] !== 0xd8)
+        return false;
+    let offset = 2;
+    let sawFrame = false;
+    let sawScan = false;
+    let entropyBytes = 0;
+    while (offset < bytes.length) {
+        if (bytes[offset] !== 0xff)
+            return false;
+        while (offset < bytes.length && bytes[offset] === 0xff)
+            offset += 1;
+        if (offset >= bytes.length)
+            return false;
+        const marker = bytes[offset++];
+        if (marker === 0xd9) {
+            return sawFrame && sawScan && entropyBytes > 0 && offset === bytes.length;
+        }
+        if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            return false;
+        }
+        if (offset + 2 > bytes.length)
+            return false;
+        const length = bytes.readUInt16BE(offset);
+        if (length < 2 || offset + length > bytes.length)
+            return false;
+        const segmentEnd = offset + length;
+        if ((marker >= 0xc0 && marker <= 0xc3) ||
+            (marker >= 0xc5 && marker <= 0xc7) ||
+            (marker >= 0xc9 && marker <= 0xcb) ||
+            (marker >= 0xcd && marker <= 0xcf)) {
+            sawFrame = true;
+        }
+        offset = segmentEnd;
+        if (marker !== 0xda)
+            continue;
+        sawScan = true;
+        const scanStart = offset;
+        while (offset < bytes.length) {
+            if (bytes[offset] !== 0xff) {
+                offset += 1;
+                continue;
+            }
+            const markerStart = offset;
+            while (offset < bytes.length && bytes[offset] === 0xff)
+                offset += 1;
+            if (offset >= bytes.length)
+                return false;
+            const scanMarker = bytes[offset];
+            if (scanMarker === 0x00) {
+                offset += 1;
+                continue;
+            }
+            if (scanMarker >= 0xd0 && scanMarker <= 0xd7) {
+                offset += 1;
+                continue;
+            }
+            entropyBytes += markerStart - scanStart;
+            offset = markerStart;
+            break;
+        }
+    }
+    return false;
+}
+function validateWebpContainer(bytes) {
+    if (bytes.length < 20 ||
+        bytes.toString("ascii", 0, 4) !== "RIFF" ||
+        bytes.toString("ascii", 8, 12) !== "WEBP" ||
+        bytes.readUInt32LE(4) + 8 !== bytes.length)
+        return false;
+    let offset = 12;
+    let sawImage = false;
+    while (offset + 8 <= bytes.length) {
+        const type = bytes.toString("ascii", offset, offset + 4);
+        const size = bytes.readUInt32LE(offset + 4);
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + size;
+        const chunkEnd = dataEnd + (size & 1);
+        if (dataEnd < dataStart || chunkEnd > bytes.length)
+            return false;
+        if (type === "ANIM" || type === "ANMF")
+            return false;
+        if (type === "VP8X") {
+            if (size < 10 || (bytes[dataStart] & 0x02) !== 0)
+                return false;
+        }
+        else if (type === "VP8 " || type === "VP8L") {
+            sawImage = true;
+        }
+        offset = chunkEnd;
+    }
+    return sawImage && offset === bytes.length;
+}
+function sniffMediaType(bytes) {
+    if (bytes.length >= 24 &&
+        bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        return "image/png";
+    if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8)
+        return "image/jpeg";
+    if (bytes.length >= 30 &&
+        bytes.toString("ascii", 0, 4) === "RIFF" &&
+        bytes.toString("ascii", 8, 12) === "WEBP")
+        return "image/webp";
+    return undefined;
+}
+function pngDimensions(bytes) {
+    if (bytes.toString("ascii", 12, 16) !== "IHDR")
+        return undefined;
+    return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
+}
+function jpegDimensions(bytes) {
+    let offset = 2;
+    while (offset + 9 < bytes.length) {
+        if (bytes[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = bytes[offset + 1];
+        offset += 2;
+        if (marker === 0xd8 || marker === 0xd9)
+            continue;
+        if (offset + 2 > bytes.length)
+            return undefined;
+        const length = bytes.readUInt16BE(offset);
+        if (length < 2 || offset + length > bytes.length)
+            return undefined;
+        if ((marker >= 0xc0 && marker <= 0xc3) ||
+            (marker >= 0xc5 && marker <= 0xc7) ||
+            (marker >= 0xc9 && marker <= 0xcb) ||
+            (marker >= 0xcd && marker <= 0xcf)) {
+            return {
+                height: bytes.readUInt16BE(offset + 3),
+                width: bytes.readUInt16BE(offset + 5),
+            };
+        }
+        offset += length;
+    }
+    return undefined;
+}
+function webpDimensions(bytes) {
+    const chunk = bytes.toString("ascii", 12, 16);
+    if (chunk === "VP8X" && bytes.length >= 30) {
+        return {
+            width: 1 + readUInt24LE(bytes, 24),
+            height: 1 + readUInt24LE(bytes, 27),
+        };
+    }
+    if (chunk === "VP8L" && bytes.length >= 25 && bytes[20] === 0x2f) {
+        const b1 = bytes[21];
+        const b2 = bytes[22];
+        const b3 = bytes[23];
+        const b4 = bytes[24];
+        return {
+            width: 1 + (((b2 & 0x3f) << 8) | b1),
+            height: 1 + (((b4 & 0x0f) << 10) | (b3 << 2) | (b2 >> 6)),
+        };
+    }
+    if (chunk === "VP8 " &&
+        bytes.length >= 30 &&
+        bytes[23] === 0x9d &&
+        bytes[24] === 0x01 &&
+        bytes[25] === 0x2a) {
+        return {
+            width: bytes.readUInt16LE(26) & 0x3fff,
+            height: bytes.readUInt16LE(28) & 0x3fff,
+        };
+    }
+    return undefined;
+}
+function readUInt24LE(bytes, offset) {
+    return bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16);
+}
+function decodeBase64(value) {
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+        throw invalid("Upload chunk is not valid base64");
+    }
+    return Buffer.from(value, "base64");
+}
+function extension(mediaType) {
+    return mediaType === "image/png" ? "png" : mediaType === "image/jpeg" ? "jpg" : "webp";
+}
+function safeFilename(value) {
+    const name = basename(value).replace(/[\u0000-\u001f\u007f]/g, "").trim();
+    if (!name || name === "." || name === "..")
+        throw invalid("Image filename is invalid");
+    return name;
+}
+function ensurePrivateDirectory(path) {
+    if (existsSync(path) && lstatSync(path).isSymbolicLink()) {
+        throw new Error("Session resource directory must not be a symlink");
+    }
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    chmodSync(path, 0o700);
+}
+function noFollowFlag() {
+    return "O_NOFOLLOW" in constants
+        ? constants.O_NOFOLLOW
+        : 0;
+}
+function invalid(message) {
+    return new MachineSessionServiceFailure("failed_precondition", message);
+}
+function unavailable(message) {
+    return new MachineSessionServiceFailure("failed_precondition", message);
+}
+function conflict(message) {
+    return new MachineSessionServiceFailure("conflict", message);
+}
+function notFound() {
+    return new MachineSessionServiceFailure("not_found", "Session resource not found");
+}