@echofiles/echo-pdf 0.4.3 → 0.6.0

package/dist/auth.js

@@ -1,36 +0,0 @@
-export const checkHeaderAuth = (request, env, options) => {
-    const authHeader = typeof options.authHeader === "string" ? options.authHeader.trim() : "";
-    const authEnv = typeof options.authEnv === "string" ? options.authEnv.trim() : "";
-    const hasHeader = authHeader.length > 0;
-    const hasEnv = authEnv.length > 0;
-    if (!hasHeader && !hasEnv)
-        return { ok: true };
-    if (!hasHeader || !hasEnv) {
-        return {
-            ok: false,
-            status: 500,
-            code: options.misconfiguredCode,
-            message: `${options.contextName} auth must configure both authHeader and authEnv`,
-        };
-    }
-    const required = env[authEnv];
-    if (typeof required !== "string" || required.length === 0) {
-        if (options.allowMissingSecret === true)
-            return { ok: true };
-        return {
-            ok: false,
-            status: 500,
-            code: options.misconfiguredCode,
-            message: `${options.contextName} auth is configured but env "${authEnv}" is missing`,
-        };
-    }
-    if (request.headers.get(authHeader) !== required) {
-        return {
-            ok: false,
-            status: 401,
-            code: options.unauthorizedCode,
-            message: "Unauthorized",
-        };
-    }
-    return { ok: true };
-};

package/dist/core/index.d.ts

@@ -1,50 +0,0 @@
-export { callTool, listToolSchemas } from "../tool-registry.js";
-export type { ToolRuntimeContext } from "../tool-registry.js";
-export type { ToolSchema } from "../pdf-types.js";
-export type { Env, FileStore, JsonObject } from "../types.js";
-import type { ReturnMode } from "../types.js";
-export interface PdfExtractPagesArgs {
-    readonly fileId?: string;
-    readonly url?: string;
-    readonly base64?: string;
-    readonly filename?: string;
-    readonly pages: ReadonlyArray<number>;
-    readonly renderScale?: number;
-    readonly returnMode?: ReturnMode;
-}
-export interface PdfOcrPagesArgs {
-    readonly fileId?: string;
-    readonly url?: string;
-    readonly base64?: string;
-    readonly filename?: string;
-    readonly pages: ReadonlyArray<number>;
-    readonly renderScale?: number;
-    readonly provider?: string;
-    readonly model?: string;
-    readonly prompt?: string;
-}
-export interface PdfTablesToLatexArgs {
-    readonly fileId?: string;
-    readonly url?: string;
-    readonly base64?: string;
-    readonly filename?: string;
-    readonly pages: ReadonlyArray<number>;
-    readonly renderScale?: number;
-    readonly provider?: string;
-    readonly model?: string;
-    readonly prompt?: string;
-}
-export interface FileOpsArgs {
-    readonly op: "list" | "read" | "delete" | "put";
-    readonly fileId?: string;
-    readonly includeBase64?: boolean;
-    readonly text?: string;
-    readonly filename?: string;
-    readonly mimeType?: string;
-    readonly base64?: string;
-    readonly returnMode?: ReturnMode;
-}
-export declare const pdf_extract_pages: (args: PdfExtractPagesArgs, ctx: import("../tool-registry.js").ToolRuntimeContext) => Promise<unknown>;
-export declare const pdf_ocr_pages: (args: PdfOcrPagesArgs, ctx: import("../tool-registry.js").ToolRuntimeContext) => Promise<unknown>;
-export declare const pdf_tables_to_latex: (args: PdfTablesToLatexArgs, ctx: import("../tool-registry.js").ToolRuntimeContext) => Promise<unknown>;
-export declare const file_ops: (args: FileOpsArgs, ctx: import("../tool-registry.js").ToolRuntimeContext) => Promise<unknown>;

package/dist/core/index.js

@@ -1,7 +0,0 @@
-export { callTool, listToolSchemas } from "../tool-registry.js";
-import { callTool } from "../tool-registry.js";
-const asJsonObject = (value) => value;
-export const pdf_extract_pages = async (args, ctx) => callTool("pdf_extract_pages", asJsonObject(args), ctx);
-export const pdf_ocr_pages = async (args, ctx) => callTool("pdf_ocr_pages", asJsonObject(args), ctx);
-export const pdf_tables_to_latex = async (args, ctx) => callTool("pdf_tables_to_latex", asJsonObject(args), ctx);
-export const file_ops = async (args, ctx) => callTool("file_ops", asJsonObject(args), ctx);

package/dist/file-ops.d.ts

@@ -1,11 +0,0 @@
-import type { FileStore, ReturnMode } from "./types.js";
-export declare const runFileOp: (fileStore: FileStore, input: {
-    readonly op: "list" | "read" | "delete" | "put";
-    readonly fileId?: string;
-    readonly includeBase64?: boolean;
-    readonly text?: string;
-    readonly filename?: string;
-    readonly mimeType?: string;
-    readonly base64?: string;
-    readonly returnMode?: ReturnMode;
-}) => Promise<unknown>;

package/dist/file-ops.js

@@ -1,36 +0,0 @@
-import { fromBase64, normalizeReturnMode, toInlineFilePayload } from "./file-utils.js";
-export const runFileOp = async (fileStore, input) => {
-    if (input.op === "list") {
-        return { files: await fileStore.list() };
-    }
-    if (input.op === "put") {
-        const bytes = input.base64 ? fromBase64(input.base64) : new TextEncoder().encode(input.text ?? "");
-        const meta = await fileStore.put({
-            filename: input.filename ?? `file-${Date.now()}.txt`,
-            mimeType: input.mimeType ?? "text/plain; charset=utf-8",
-            bytes,
-        });
-        const returnMode = normalizeReturnMode(input.returnMode);
-        if (returnMode === "file_id")
-            return { returnMode, file: meta };
-        if (returnMode === "url")
-            return { returnMode, file: meta, url: `/api/files/get?fileId=${encodeURIComponent(meta.id)}` };
-        const stored = await fileStore.get(meta.id);
-        if (!stored)
-            throw new Error(`File not found after put: ${meta.id}`);
-        return {
-            returnMode,
-            ...toInlineFilePayload(stored, true),
-        };
-    }
-    if (!input.fileId) {
-        throw new Error("fileId is required");
-    }
-    if (input.op === "delete") {
-        return { deleted: await fileStore.delete(input.fileId), fileId: input.fileId };
-    }
-    const file = await fileStore.get(input.fileId);
-    if (!file)
-        throw new Error(`File not found: ${input.fileId}`);
-    return toInlineFilePayload(file, Boolean(input.includeBase64));
-};

package/dist/file-store-do.d.ts

@@ -1,36 +0,0 @@
-import type { StoragePolicy } from "./pdf-types.js";
-import type { DurableObjectNamespace, DurableObjectState, StoredFileMeta, StoredFileRecord } from "./types.js";
-interface StoreStats {
-    readonly fileCount: number;
-    readonly totalBytes: number;
-}
-export declare class FileStoreDO {
-    private readonly state;
-    constructor(state: DurableObjectState);
-    fetch(request: Request): Promise<Response>;
-}
-export declare class DurableObjectFileStore {
-    private readonly namespace;
-    private readonly policy;
-    constructor(namespace: DurableObjectNamespace, policy: StoragePolicy);
-    private stub;
-    put(input: {
-        readonly filename: string;
-        readonly mimeType: string;
-        readonly bytes: Uint8Array;
-    }): Promise<StoredFileMeta>;
-    get(fileId: string): Promise<StoredFileRecord | null>;
-    list(): Promise<ReadonlyArray<StoredFileMeta>>;
-    delete(fileId: string): Promise<boolean>;
-    stats(): Promise<{
-        policy: StoragePolicy;
-        stats: StoreStats;
-    }>;
-    cleanup(): Promise<{
-        policy: StoragePolicy;
-        deletedExpired: number;
-        deletedEvicted: number;
-        stats: StoreStats;
-    }>;
-}
-export {};

package/dist/file-store-do.js

@@ -1,298 +0,0 @@
-import { fromBase64, toBase64 } from "./file-utils.js";
-const json = (data, status = 200) => new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json; charset=utf-8" },
-});
-const readJson = async (request) => {
-    try {
-        const body = await request.json();
-        if (typeof body === "object" && body !== null && !Array.isArray(body)) {
-            return body;
-        }
-        return {};
-    }
-    catch {
-        return {};
-    }
-};
-const defaultPolicy = () => ({
-    maxFileBytes: 1_200_000,
-    maxTotalBytes: 52_428_800,
-    ttlHours: 24,
-    cleanupBatchSize: 50,
-});
-const parsePolicy = (input) => {
-    const raw = typeof input === "object" && input !== null && !Array.isArray(input)
-        ? input
-        : {};
-    const fallback = defaultPolicy();
-    const maxFileBytes = Number(raw.maxFileBytes ?? fallback.maxFileBytes);
-    const maxTotalBytes = Number(raw.maxTotalBytes ?? fallback.maxTotalBytes);
-    const ttlHours = Number(raw.ttlHours ?? fallback.ttlHours);
-    const cleanupBatchSize = Number(raw.cleanupBatchSize ?? fallback.cleanupBatchSize);
-    return {
-        maxFileBytes: Number.isFinite(maxFileBytes) && maxFileBytes > 0 ? Math.floor(maxFileBytes) : fallback.maxFileBytes,
-        maxTotalBytes: Number.isFinite(maxTotalBytes) && maxTotalBytes > 0 ? Math.floor(maxTotalBytes) : fallback.maxTotalBytes,
-        ttlHours: Number.isFinite(ttlHours) && ttlHours > 0 ? ttlHours : fallback.ttlHours,
-        cleanupBatchSize: Number.isFinite(cleanupBatchSize) && cleanupBatchSize > 0 ? Math.floor(cleanupBatchSize) : fallback.cleanupBatchSize,
-    };
-};
-const toMeta = (value) => ({
-    id: value.id,
-    filename: value.filename,
-    mimeType: value.mimeType,
-    sizeBytes: value.sizeBytes,
-    createdAt: value.createdAt,
-});
-const listStoredValues = async (state) => {
-    const listed = await state.storage.list({ prefix: "file:" });
-    return [...listed.values()];
-};
-const computeStats = (files) => ({
-    fileCount: files.length,
-    totalBytes: files.reduce((sum, file) => sum + file.sizeBytes, 0),
-});
-const isExpired = (createdAt, ttlHours) => {
-    const createdMs = Date.parse(createdAt);
-    if (!Number.isFinite(createdMs))
-        return false;
-    return Date.now() - createdMs > ttlHours * 60 * 60 * 1000;
-};
-const deleteFiles = async (state, files) => {
-    let deleted = 0;
-    for (const file of files) {
-        const ok = await state.storage.delete(`file:${file.id}`);
-        if (ok)
-            deleted += 1;
-    }
-    return deleted;
-};
-export class FileStoreDO {
-    state;
-    constructor(state) {
-        this.state = state;
-    }
-    async fetch(request) {
-        const url = new URL(request.url);
-        if (request.method === "POST" && url.pathname === "/put") {
-            const body = await readJson(request);
-            const policy = parsePolicy(body.policy);
-            const filename = typeof body.filename === "string" ? body.filename : `file-${Date.now()}`;
-            const mimeType = typeof body.mimeType === "string" ? body.mimeType : "application/octet-stream";
-            const bytesBase64 = typeof body.bytesBase64 === "string" ? body.bytesBase64 : "";
-            const bytes = fromBase64(bytesBase64);
-            if (bytes.byteLength > policy.maxFileBytes) {
-                return json({
-                    error: `file too large: ${bytes.byteLength} bytes exceeds maxFileBytes ${policy.maxFileBytes}`,
-                    code: "FILE_TOO_LARGE",
-                    policy,
-                }, 413);
-            }
-            let files = await listStoredValues(this.state);
-            const expired = files.filter((file) => isExpired(file.createdAt, policy.ttlHours));
-            if (expired.length > 0) {
-                await deleteFiles(this.state, expired);
-                files = await listStoredValues(this.state);
-            }
-            let stats = computeStats(files);
-            const projected = stats.totalBytes + bytes.byteLength;
-            if (projected > policy.maxTotalBytes) {
-                const needFree = projected - policy.maxTotalBytes;
-                const candidates = [...files]
-                    .sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt))
-                    .slice(0, policy.cleanupBatchSize);
-                let freed = 0;
-                const evictList = [];
-                for (const file of candidates) {
-                    evictList.push(file);
-                    freed += file.sizeBytes;
-                    if (freed >= needFree)
-                        break;
-                }
-                if (evictList.length > 0) {
-                    await deleteFiles(this.state, evictList);
-                    files = await listStoredValues(this.state);
-                    stats = computeStats(files);
-                }
-            }
-            if (stats.totalBytes + bytes.byteLength > policy.maxTotalBytes) {
-                return json({
-                    error: `storage quota exceeded: total ${stats.totalBytes} + incoming ${bytes.byteLength} > maxTotalBytes ${policy.maxTotalBytes}`,
-                    code: "STORAGE_QUOTA_EXCEEDED",
-                    policy,
-                    stats,
-                }, 507);
-            }
-            const id = crypto.randomUUID();
-            const value = {
-                id,
-                filename,
-                mimeType,
-                sizeBytes: bytes.byteLength,
-                createdAt: new Date().toISOString(),
-                bytesBase64,
-            };
-            await this.state.storage.put(`file:${id}`, value);
-            return json({ file: toMeta(value), policy });
-        }
-        if (request.method === "GET" && url.pathname === "/get") {
-            const fileId = url.searchParams.get("fileId");
-            if (!fileId)
-                return json({ error: "Missing fileId" }, 400);
-            const value = await this.state.storage.get(`file:${fileId}`);
-            if (!value)
-                return json({ file: null });
-            return json({ file: value });
-        }
-        if (request.method === "GET" && url.pathname === "/list") {
-            const listed = await this.state.storage.list({ prefix: "file:" });
-            const files = [...listed.values()].map(toMeta);
-            return json({ files });
-        }
-        if (request.method === "POST" && url.pathname === "/delete") {
-            const body = await readJson(request);
-            const fileId = typeof body.fileId === "string" ? body.fileId : "";
-            if (!fileId)
-                return json({ error: "Missing fileId" }, 400);
-            const key = `file:${fileId}`;
-            const existing = await this.state.storage.get(key);
-            if (!existing)
-                return json({ deleted: false });
-            await this.state.storage.delete(key);
-            return json({ deleted: true });
-        }
-        if (request.method === "GET" && url.pathname === "/stats") {
-            let policyInput;
-            const encoded = url.searchParams.get("policy");
-            if (encoded) {
-                try {
-                    policyInput = JSON.parse(encoded);
-                }
-                catch {
-                    policyInput = undefined;
-                }
-            }
-            const policy = parsePolicy(policyInput);
-            const files = await listStoredValues(this.state);
-            const stats = computeStats(files);
-            return json({ policy, stats });
-        }
-        if (request.method === "POST" && url.pathname === "/cleanup") {
-            const body = await readJson(request);
-            const policy = parsePolicy(body.policy);
-            const files = await listStoredValues(this.state);
-            const expired = files.filter((file) => isExpired(file.createdAt, policy.ttlHours));
-            const deletedExpired = await deleteFiles(this.state, expired);
-            const afterExpired = await listStoredValues(this.state);
-            let stats = computeStats(afterExpired);
-            let deletedEvicted = 0;
-            if (stats.totalBytes > policy.maxTotalBytes) {
-                const sorted = [...afterExpired].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
-                const evictList = [];
-                for (const file of sorted) {
-                    evictList.push(file);
-                    const projected = stats.totalBytes - evictList.reduce((sum, item) => sum + item.sizeBytes, 0);
-                    if (projected <= policy.maxTotalBytes)
-                        break;
-                    if (evictList.length >= policy.cleanupBatchSize)
-                        break;
-                }
-                deletedEvicted = await deleteFiles(this.state, evictList);
-                stats = computeStats(await listStoredValues(this.state));
-            }
-            return json({
-                policy,
-                deletedExpired,
-                deletedEvicted,
-                stats,
-            });
-        }
-        return json({ error: "Not found" }, 404);
-    }
-}
-export class DurableObjectFileStore {
-    namespace;
-    policy;
-    constructor(namespace, policy) {
-        this.namespace = namespace;
-        this.policy = policy;
-    }
-    stub() {
-        return this.namespace.get(this.namespace.idFromName("echo-pdf-file-store"));
-    }
-    async put(input) {
-        const response = await this.stub().fetch("https://do/put", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                filename: input.filename,
-                mimeType: input.mimeType,
-                bytesBase64: toBase64(input.bytes),
-                policy: this.policy,
-            }),
-        });
-        const payload = (await response.json());
-        if (!response.ok || !payload.file) {
-            const details = payload;
-            const error = new Error(payload.error ?? "DO put failed");
-            error.status = response.status;
-            error.code = typeof details.code === "string" ? details.code : undefined;
-            error.details = { policy: details.policy, stats: details.stats };
-            throw error;
-        }
-        return payload.file;
-    }
-    async get(fileId) {
-        const response = await this.stub().fetch(`https://do/get?fileId=${encodeURIComponent(fileId)}`);
-        const payload = (await response.json());
-        if (!response.ok)
-            throw new Error("DO get failed");
-        if (!payload.file)
-            return null;
-        return {
-            id: payload.file.id,
-            filename: payload.file.filename,
-            mimeType: payload.file.mimeType,
-            sizeBytes: payload.file.sizeBytes,
-            createdAt: payload.file.createdAt,
-            bytes: fromBase64(payload.file.bytesBase64),
-        };
-    }
-    async list() {
-        const response = await this.stub().fetch("https://do/list");
-        const payload = (await response.json());
-        if (!response.ok)
-            throw new Error("DO list failed");
-        return payload.files ?? [];
-    }
-    async delete(fileId) {
-        const response = await this.stub().fetch("https://do/delete", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ fileId }),
-        });
-        const payload = (await response.json());
-        if (!response.ok)
-            throw new Error("DO delete failed");
-        return payload.deleted === true;
-    }
-    async stats() {
-        const policyEncoded = encodeURIComponent(JSON.stringify(this.policy));
-        const response = await this.stub().fetch(`https://do/stats?policy=${policyEncoded}`);
-        const payload = (await response.json());
-        if (!response.ok)
-            throw new Error("DO stats failed");
-        return payload;
-    }
-    async cleanup() {
-        const response = await this.stub().fetch("https://do/cleanup", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ policy: this.policy }),
-        });
-        const payload = (await response.json());
-        if (!response.ok)
-            throw new Error("DO cleanup failed");
-        return payload;
-    }
-}

package/dist/http-error.d.ts

@@ -1,9 +0,0 @@
-export declare class HttpError extends Error {
-    readonly status: number;
-    readonly code: string;
-    readonly details?: unknown;
-    constructor(status: number, code: string, message: string, details?: unknown);
-}
-export declare const badRequest: (code: string, message: string, details?: unknown) => HttpError;
-export declare const notFound: (code: string, message: string, details?: unknown) => HttpError;
-export declare const unprocessable: (code: string, message: string, details?: unknown) => HttpError;

package/dist/http-error.js

@@ -1,14 +0,0 @@
-export class HttpError extends Error {
-    status;
-    code;
-    details;
-    constructor(status, code, message, details) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.details = details;
-    }
-}
-export const badRequest = (code, message, details) => new HttpError(400, code, message, details);
-export const notFound = (code, message, details) => new HttpError(404, code, message, details);
-export const unprocessable = (code, message, details) => new HttpError(422, code, message, details);

package/dist/index.d.ts

@@ -1 +0,0 @@
-export * from "./core/index.js";

package/dist/index.js

@@ -1 +0,0 @@
-export * from "./core/index.js";

package/dist/mcp-server.d.ts

@@ -1,3 +0,0 @@
-import type { Env, FileStore } from "./types.js";
-import type { EchoPdfConfig } from "./pdf-types.js";
-export declare const handleMcpRequest: (request: Request, env: Env, config: EchoPdfConfig, fileStore: FileStore) => Promise<Response>;

package/dist/mcp-server.js

@@ -1,124 +0,0 @@
-import { checkHeaderAuth } from "./auth.js";
-import { buildMcpContent, buildToolOutputEnvelope } from "./response-schema.js";
-import { callTool, listToolSchemas } from "./tool-registry.js";
-const ok = (id, result) => new Response(JSON.stringify({
-    jsonrpc: "2.0",
-    id: id ?? null,
-    result,
-}), { headers: { "Content-Type": "application/json" } });
-const err = (id, code, message, data, httpStatus = 400) => new Response(JSON.stringify({
-    jsonrpc: "2.0",
-    id: id ?? null,
-    error: data ? { code, message, data } : { code, message },
-}), { status: httpStatus, headers: { "Content-Type": "application/json" } });
-const asObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
-const resolvePublicBaseUrl = (request, configured) => typeof configured === "string" && configured.length > 0 ? configured : request.url;
-const prepareMcpToolArgs = (toolName, args) => {
-    if (toolName === "pdf_extract_pages") {
-        const mode = typeof args.returnMode === "string" ? args.returnMode : "";
-        if (!mode) {
-            return { ...args, returnMode: "url" };
-        }
-    }
-    return args;
-};
-export const handleMcpRequest = async (request, env, config, fileStore) => {
-    const auth = checkHeaderAuth(request, env, {
-        authHeader: config.mcp.authHeader,
-        authEnv: config.mcp.authEnv,
-        allowMissingSecret: env.ECHO_PDF_ALLOW_MISSING_AUTH_SECRET === "1",
-        misconfiguredCode: "AUTH_MISCONFIGURED",
-        unauthorizedCode: "UNAUTHORIZED",
-        contextName: "MCP",
-    });
-    if (!auth.ok) {
-        return err(null, -32001, auth.message, { status: auth.status, code: auth.code }, 200);
-    }
-    let body;
-    try {
-        body = (await request.json());
-    }
-    catch {
-        return err(null, -32700, "Parse error");
-    }
-    if (typeof body !== "object" || body === null) {
-        return err(null, -32600, "Invalid Request");
-    }
-    if (body.jsonrpc !== "2.0") {
-        return err(body.id ?? null, -32600, "Invalid Request: jsonrpc must be '2.0'");
-    }
-    const method = body.method ?? "";
-    const id = body.id ?? null;
-    if (typeof method !== "string" || method.length === 0) {
-        return err(id, -32600, "Invalid Request: method is required");
-    }
-    if (method.startsWith("notifications/")) {
-        return new Response(null, { status: 204 });
-    }
-    const params = asObj(body.params);
-    if (method === "initialize") {
-        return ok(id, {
-            protocolVersion: "2024-11-05",
-            serverInfo: {
-                name: config.mcp.serverName,
-                version: config.mcp.version,
-            },
-            capabilities: {
-                tools: {},
-            },
-        });
-    }
-    if (method === "tools/list") {
-        return ok(id, { tools: listToolSchemas().map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                inputSchema: tool.inputSchema,
-            })) });
-    }
-    if (method !== "tools/call") {
-        return err(id, -32601, `Unsupported method: ${method}`);
-    }
-    const toolName = typeof params.name === "string" ? params.name : "";
-    const args = prepareMcpToolArgs(toolName, asObj(params.arguments));
-    if (!toolName) {
-        return err(id, -32602, "Invalid params: name is required", {
-            code: "INVALID_PARAMS",
-            status: 400,
-        });
-    }
-    try {
-        const result = await callTool(toolName, args, {
-            config,
-            env,
-            fileStore,
-        });
-        const envelope = buildToolOutputEnvelope(result, resolvePublicBaseUrl(request, config.service.publicBaseUrl));
-        return ok(id, { content: buildMcpContent(envelope) });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const status = error?.status;
-        const stableStatus = typeof status === "number" && Number.isFinite(status) ? status : 500;
-        const code = error?.code;
-        const details = error?.details;
-        if (message.startsWith("Unknown tool:")) {
-            return err(id, -32601, message, {
-                code: typeof code === "string" ? code : "TOOL_NOT_FOUND",
-                status: 404,
-                details,
-            });
-        }
-        if (stableStatus >= 400 && stableStatus < 500) {
-            return err(id, -32602, message, {
-                code: typeof code === "string" ? code : "INVALID_PARAMS",
-                status: stableStatus,
-                details,
-            });
-        }
-        return err(id, -32000, message, {
-            code: typeof code === "string" ? code : "INTERNAL_ERROR",
-            status: stableStatus,
-            details,
-        });
-    }
-};

package/dist/node/semantic-local.d.ts

@@ -1,16 +0,0 @@
-export interface SemanticPageInput {
-    readonly pageNumber: number;
-    readonly text: string;
-    readonly artifactPath: string;
-}
-export interface SemanticSectionNode {
-    readonly id: string;
-    readonly type: "section";
-    readonly title: string;
-    readonly level: number;
-    readonly pageNumber: number;
-    readonly pageArtifactPath: string;
-    readonly excerpt: string;
-    readonly children: ReadonlyArray<SemanticSectionNode>;
-}
-export declare const buildSemanticSectionTree: (pages: ReadonlyArray<SemanticPageInput>) => ReadonlyArray<SemanticSectionNode>;