@echofiles/echo-pdf 0.2.0

package/src/pdfium-engine.ts

@@ -0,0 +1,207 @@
+import { init } from "@embedpdf/pdfium"
+import { encode as encodePng } from "@cf-wasm/png/workerd"
+import type { WrappedPdfiumModule } from "@embedpdf/pdfium"
+import type { EchoPdfConfig } from "./pdf-types"
+import { toDataUrl } from "./file-utils"
+import compiledPdfiumModule from "@embedpdf/pdfium/dist/pdfium.wasm"
+
+let moduleInstance: WrappedPdfiumModule | null = null
+let libraryInitialized = false
+
+const toUint8 = (value: ArrayBuffer): Uint8Array => new Uint8Array(value)
+const textDecoder = new TextDecoder()
+
+const ensureWasmFunctionShim = (): void => {
+  const wasmApi = WebAssembly as unknown as {
+    Function?: unknown
+  }
+  if (typeof wasmApi.Function === "function") return
+  ;(wasmApi as { Function: (sig: unknown, fn: unknown) => unknown }).Function = (
+    _sig: unknown,
+    fn: unknown
+  ) => fn
+}
+
+const ensurePdfium = async (config: EchoPdfConfig): Promise<WrappedPdfiumModule> => {
+  ensureWasmFunctionShim()
+  if (!moduleInstance) {
+    const maybeModule = compiledPdfiumModule as unknown
+    if (maybeModule instanceof WebAssembly.Module) {
+      moduleInstance = await init({
+        instantiateWasm: (
+          imports: WebAssembly.Imports,
+          successCallback: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void
+        ): WebAssembly.Exports => {
+          const instance = new WebAssembly.Instance(maybeModule, imports)
+          successCallback(instance, maybeModule)
+          return instance.exports
+        },
+      })
+    } else {
+      const wasmBinary = await fetch(config.pdfium.wasmUrl).then((res) => res.arrayBuffer())
+      moduleInstance = await init({ wasmBinary })
+    }
+  }
+  if (!libraryInitialized) {
+    moduleInstance.FPDF_InitLibrary()
+    libraryInitialized = true
+  }
+  return moduleInstance
+}
+
+const makeDoc = (pdfium: WrappedPdfiumModule, bytes: Uint8Array): {
+  readonly doc: number
+  readonly memPtr: number
+} => {
+  const memPtr = pdfium.pdfium.wasmExports.malloc(bytes.length)
+  ;(pdfium.pdfium as unknown as { HEAPU8: Uint8Array }).HEAPU8.set(bytes, memPtr)
+  const doc = pdfium.FPDF_LoadMemDocument(memPtr, bytes.length, "")
+  if (!doc) {
+    pdfium.pdfium.wasmExports.free(memPtr)
+    throw new Error("Failed to load PDF document")
+  }
+  return { doc, memPtr }
+}
+
+const closeDoc = (pdfium: WrappedPdfiumModule, doc: number, memPtr: number): void => {
+  pdfium.FPDF_CloseDocument(doc)
+  pdfium.pdfium.wasmExports.free(memPtr)
+}
+
+const bgraToRgba = (bgra: Uint8Array): Uint8Array => {
+  const rgba = new Uint8Array(bgra.length)
+  for (let i = 0; i < bgra.length; i += 4) {
+    rgba[i] = bgra[i + 2] ?? 0
+    rgba[i + 1] = bgra[i + 1] ?? 0
+    rgba[i + 2] = bgra[i] ?? 0
+    rgba[i + 3] = bgra[i + 3] ?? 255
+  }
+  return rgba
+}
+
+const decodeUtf16Le = (buf: Uint8Array): string => {
+  const view = new Uint16Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 2))
+  const chars: number[] = []
+  for (const code of view) {
+    if (code === 0) break
+    chars.push(code)
+  }
+  return String.fromCharCode(...chars)
+}
+
+export const getPdfPageCount = async (config: EchoPdfConfig, bytes: Uint8Array): Promise<number> => {
+  const pdfium = await ensurePdfium(config)
+  const { doc, memPtr } = makeDoc(pdfium, bytes)
+  try {
+    return pdfium.FPDF_GetPageCount(doc)
+  } finally {
+    closeDoc(pdfium, doc, memPtr)
+  }
+}
+
+export const renderPdfPageToPng = async (
+  config: EchoPdfConfig,
+  bytes: Uint8Array,
+  pageIndex: number,
+  scale = config.service.defaultRenderScale
+): Promise<{
+  width: number
+  height: number
+  png: Uint8Array
+}> => {
+  const pdfium = await ensurePdfium(config)
+  const { doc, memPtr } = makeDoc(pdfium, bytes)
+  let page = 0
+  let bitmap = 0
+  try {
+    page = pdfium.FPDF_LoadPage(doc, pageIndex)
+    if (!page) {
+      throw new Error(`Failed to load page ${pageIndex}`)
+    }
+    const width = Math.max(1, Math.round(pdfium.FPDF_GetPageWidthF(page) * scale))
+    const height = Math.max(1, Math.round(pdfium.FPDF_GetPageHeightF(page) * scale))
+    bitmap = pdfium.FPDFBitmap_Create(width, height, 1)
+    if (!bitmap) {
+      throw new Error("Failed to create bitmap")
+    }
+    pdfium.FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xffffffff)
+    pdfium.FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0)
+
+    const stride = pdfium.FPDFBitmap_GetStride(bitmap)
+    const bufferPtr = pdfium.FPDFBitmap_GetBuffer(bitmap)
+    const heap = (pdfium.pdfium as unknown as { HEAPU8: Uint8Array }).HEAPU8
+    const bgra = heap.slice(bufferPtr, bufferPtr + stride * height)
+    const rgba = bgraToRgba(bgra)
+    const png = encodePng(rgba, width, height)
+    return { width, height, png }
+  } finally {
+    if (bitmap) pdfium.FPDFBitmap_Destroy(bitmap)
+    if (page) pdfium.FPDF_ClosePage(page)
+    closeDoc(pdfium, doc, memPtr)
+  }
+}
+
+export const extractPdfPageText = async (
+  config: EchoPdfConfig,
+  bytes: Uint8Array,
+  pageIndex: number
+): Promise<string> => {
+  const pdfium = await ensurePdfium(config)
+  const { doc, memPtr } = makeDoc(pdfium, bytes)
+  let page = 0
+  let textPage = 0
+  let outPtr = 0
+  try {
+    page = pdfium.FPDF_LoadPage(doc, pageIndex)
+    if (!page) {
+      throw new Error(`Failed to load page ${pageIndex}`)
+    }
+    textPage = pdfium.FPDFText_LoadPage(page)
+    if (!textPage) return ""
+    const chars = pdfium.FPDFText_CountChars(textPage)
+    if (chars <= 0) return ""
+    const bytesLen = (chars + 1) * 2
+    outPtr = pdfium.pdfium.wasmExports.malloc(bytesLen)
+    pdfium.FPDFText_GetText(textPage, 0, chars, outPtr)
+    const heap = (pdfium.pdfium as unknown as { HEAPU8: Uint8Array }).HEAPU8
+    const raw = heap.slice(outPtr, outPtr + bytesLen)
+    return decodeUtf16Le(raw).trim()
+  } finally {
+    if (outPtr) pdfium.pdfium.wasmExports.free(outPtr)
+    if (textPage) pdfium.FPDFText_ClosePage(textPage)
+    if (page) pdfium.FPDF_ClosePage(page)
+    closeDoc(pdfium, doc, memPtr)
+  }
+}
+
+export const toBytes = async (value: string): Promise<Uint8Array> => {
+  const response = await fetch(value)
+  if (!response.ok) {
+    throw new Error(`Failed to fetch source: HTTP ${response.status}`)
+  }
+  const contentType = (response.headers.get("content-type") ?? "").toLowerCase()
+  const bytes = toUint8(await response.arrayBuffer())
+  const signature = textDecoder.decode(bytes.subarray(0, Math.min(8, bytes.length)))
+
+  if (contentType.includes("application/pdf") || signature.startsWith("%PDF-")) {
+    return bytes
+  }
+
+  const html = textDecoder.decode(bytes)
+  const pdfMatch = html.match(/https?:\/\/[^"' )]+\.pdf[^"' )]*/i)
+  if (!pdfMatch || pdfMatch.length === 0) {
+    throw new Error("URL does not point to a PDF and no PDF link was found in the page")
+  }
+
+  const resolvedUrl = pdfMatch[0].replace(/&amp;/g, "&")
+  const pdfResponse = await fetch(resolvedUrl)
+  if (!pdfResponse.ok) {
+    throw new Error(`Failed to fetch resolved PDF url: HTTP ${pdfResponse.status}`)
+  }
+  const pdfBytes = toUint8(await pdfResponse.arrayBuffer())
+  const pdfSignature = textDecoder.decode(pdfBytes.subarray(0, Math.min(8, pdfBytes.length)))
+  if (!pdfSignature.startsWith("%PDF-")) {
+    throw new Error("Resolved file is not a valid PDF")
+  }
+  return pdfBytes
+}

package/src/provider-client.ts

@@ -0,0 +1,176 @@
+import type { Env } from "./types"
+import type { EchoPdfConfig, EchoPdfProviderConfig } from "./pdf-types"
+import { resolveProviderApiKey } from "./provider-keys"
+
+const defaultBaseUrl = (provider: EchoPdfProviderConfig): string => {
+  if (provider.baseUrl) return provider.baseUrl
+  switch (provider.type) {
+    case "openrouter":
+      return "https://openrouter.ai/api/v1"
+    case "vercel-ai-gateway":
+      return "https://ai-gateway.vercel.sh/v1"
+    case "openai":
+    default:
+      return "https://api.openai.com/v1"
+  }
+}
+
+const noTrailingSlash = (url: string): string => url.replace(/\/+$/, "")
+
+const resolveEndpoint = (
+  provider: EchoPdfProviderConfig,
+  kind: "chatCompletionsPath" | "modelsPath"
+): string => {
+  const configured = provider.endpoints?.[kind]
+  if (configured?.startsWith("http://") || configured?.startsWith("https://")) {
+    return configured
+  }
+  const fallback = kind === "chatCompletionsPath" ? "/chat/completions" : "/models"
+  const path = configured && configured.length > 0 ? configured : fallback
+  return `${noTrailingSlash(defaultBaseUrl(provider))}${path.startsWith("/") ? path : `/${path}`}`
+}
+
+const toAuthHeader = (
+  config: EchoPdfConfig,
+  providerAlias: string,
+  provider: EchoPdfProviderConfig,
+  env: Env,
+  runtimeApiKeys?: Record<string, string>
+): Record<string, string> => {
+  const token = resolveProviderApiKey({
+    config,
+    env,
+    providerAlias,
+    provider,
+    runtimeApiKeys,
+  })
+  return { Authorization: `Bearer ${token}` }
+}
+
+const withTimeout = async (
+  url: string,
+  init: RequestInit,
+  timeoutMs: number
+): Promise<Response> => {
+  const ctrl = new AbortController()
+  const timer = setTimeout(() => ctrl.abort("timeout"), timeoutMs)
+  try {
+    return await fetch(url, { ...init, signal: ctrl.signal })
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timeout after ${timeoutMs}ms for ${url}`)
+    }
+    throw error
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+const responseDetail = async (response: Response): Promise<string> => {
+  const contentType = response.headers.get("content-type") ?? ""
+  try {
+    if (contentType.includes("application/json")) {
+      return JSON.stringify(await response.json()).slice(0, 800)
+    }
+    return (await response.text()).slice(0, 800)
+  } catch {
+    return "<unable to parse response payload>"
+  }
+}
+
+const getProvider = (config: EchoPdfConfig, alias: string): EchoPdfProviderConfig => {
+  const provider = config.providers[alias]
+  if (!provider) {
+    throw new Error(`Provider "${alias}" not configured`)
+  }
+  return provider
+}
+
+export const listProviderModels = async (
+  config: EchoPdfConfig,
+  env: Env,
+  alias: string,
+  runtimeApiKeys?: Record<string, string>
+): Promise<ReadonlyArray<string>> => {
+  const provider = getProvider(config, alias)
+  const url = resolveEndpoint(provider, "modelsPath")
+  const response = await withTimeout(
+    url,
+    {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        ...toAuthHeader(config, alias, provider, env, runtimeApiKeys),
+        ...(provider.headers ?? {}),
+      },
+    },
+    provider.timeoutMs ?? 30000
+  )
+
+  if (!response.ok) {
+    throw new Error(`Model list request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`)
+  }
+
+  const payload = await response.json()
+  const data = (payload as { data?: unknown }).data
+  if (!Array.isArray(data)) return []
+  return data
+    .map((item) => item as { id?: unknown })
+    .map((item) => (typeof item.id === "string" ? item.id : ""))
+    .filter((id) => id.length > 0)
+}
+
+export const visionRecognize = async (input: {
+  config: EchoPdfConfig
+  env: Env
+  providerAlias: string
+  model: string
+  prompt: string
+  imageDataUrl: string
+  runtimeApiKeys?: Record<string, string>
+}): Promise<string> => {
+  const provider = getProvider(input.config, input.providerAlias)
+  const url = resolveEndpoint(provider, "chatCompletionsPath")
+  const response = await withTimeout(
+    url,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...toAuthHeader(input.config, input.providerAlias, provider, input.env, input.runtimeApiKeys),
+        ...(provider.headers ?? {}),
+      },
+      body: JSON.stringify({
+        model: input.model,
+        messages: [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: input.prompt },
+              { type: "image_url", image_url: { url: input.imageDataUrl } },
+            ],
+          },
+        ],
+      }),
+    },
+    provider.timeoutMs ?? 30000
+  )
+
+  if (!response.ok) {
+    throw new Error(`Vision request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`)
+  }
+
+  const payload = await response.json()
+  const message = (payload as { choices?: Array<{ message?: { content?: unknown } }> }).choices?.[0]?.message
+  if (!message) return ""
+  const content = message.content
+  if (typeof content === "string") return content
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => part as { type?: string; text?: string })
+      .filter((part) => part.type === "text" && typeof part.text === "string")
+      .map((part) => part.text ?? "")
+      .join("")
+  }
+  return ""
+}

package/src/provider-keys.ts

@@ -0,0 +1,44 @@
+import { readRequiredEnv } from "./pdf-config"
+import type { EchoPdfConfig, EchoPdfProviderConfig } from "./pdf-types"
+import type { Env } from "./types"
+
+const normalizeKey = (value: string): string => value.trim()
+
+const keyVariants = (value: string): string[] => {
+  const raw = normalizeKey(value)
+  if (raw.length === 0) return []
+  return Array.from(
+    new Set([
+      raw,
+      raw.replace(/-/g, "_"),
+      raw.replace(/_/g, "-"),
+    ])
+  )
+}
+
+export const runtimeProviderKeyCandidates = (
+  _config: EchoPdfConfig,
+  providerAlias: string,
+  provider: EchoPdfProviderConfig
+): string[] => {
+  const aliases = keyVariants(providerAlias)
+  const types = keyVariants(provider.type)
+  return Array.from(new Set([...aliases, ...types]))
+}
+
+export const resolveProviderApiKey = (input: {
+  config: EchoPdfConfig
+  env: Env
+  providerAlias: string
+  provider: EchoPdfProviderConfig
+  runtimeApiKeys?: Record<string, string>
+}): string => {
+  const candidates = runtimeProviderKeyCandidates(input.config, input.providerAlias, input.provider)
+  for (const candidate of candidates) {
+    const value = input.runtimeApiKeys?.[candidate]
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim()
+    }
+  }
+  return readRequiredEnv(input.env, input.provider.apiKeyEnv)
+}

package/src/tool-registry.ts

@@ -0,0 +1,203 @@
+import { normalizeReturnMode } from "./file-utils"
+import { runFileOp } from "./file-ops"
+import { runPdfAgent } from "./pdf-agent"
+import type { EchoPdfConfig, PdfOperationRequest, ToolSchema } from "./pdf-types"
+import type { Env, FileStore, JsonObject } from "./types"
+
+export interface ToolRuntimeContext {
+  readonly config: EchoPdfConfig
+  readonly env: Env
+  readonly fileStore: FileStore
+  readonly providerApiKeys?: Record<string, string>
+  readonly trace?: (event: { kind: "step"; phase: "start" | "end" | "log"; name: string; payload?: unknown }) => void
+}
+
+interface ToolDefinition {
+  readonly schema: ToolSchema
+  run: (ctx: ToolRuntimeContext, args: JsonObject) => Promise<unknown>
+}
+
+const asNumberArray = (value: unknown): number[] =>
+  Array.isArray(value) ? value.map((item) => Number(item)).filter((item) => Number.isInteger(item) && item > 0) : []
+
+const asObject = (value: unknown): JsonObject =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as JsonObject)
+    : {}
+
+const readString = (obj: JsonObject, key: string): string | undefined => {
+  const value = obj[key]
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
+}
+
+const toolDefinitions: ReadonlyArray<ToolDefinition> = [
+  {
+    schema: {
+      name: "pdf_extract_pages",
+      description: "Render specific PDF pages to image and return inline/file_id/url mode.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          fileId: { type: "string" },
+          url: { type: "string" },
+          base64: { type: "string" },
+          filename: { type: "string" },
+          pages: { type: "array", items: { type: "integer" } },
+          renderScale: { type: "number" },
+          returnMode: { type: "string", enum: ["inline", "file_id"] },
+        },
+        required: ["pages"],
+      },
+      source: { kind: "local", toolName: "pdf.extract_pages" },
+    },
+    run: async (ctx, args) => {
+      const req: PdfOperationRequest = {
+        operation: "extract_pages",
+        fileId: readString(args, "fileId"),
+        url: readString(args, "url"),
+        base64: readString(args, "base64"),
+        filename: readString(args, "filename"),
+        pages: asNumberArray(args.pages),
+        renderScale: typeof args.renderScale === "number" ? args.renderScale : undefined,
+        provider: undefined,
+        model: "not-required",
+        providerApiKeys: ctx.providerApiKeys,
+        returnMode: normalizeReturnMode(args.returnMode),
+      }
+      return runPdfAgent(ctx.config, ctx.env, req, {
+        fileStore: ctx.fileStore,
+        trace: ctx.trace,
+      })
+    },
+  },
+  {
+    schema: {
+      name: "pdf_ocr_pages",
+      description: "OCR specific PDF pages using configured multimodal model.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          fileId: { type: "string" },
+          url: { type: "string" },
+          base64: { type: "string" },
+          filename: { type: "string" },
+          pages: { type: "array", items: { type: "integer" } },
+          renderScale: { type: "number" },
+          provider: { type: "string" },
+          model: { type: "string" },
+          prompt: { type: "string" },
+        },
+        required: ["pages"],
+      },
+      source: { kind: "local", toolName: "pdf.ocr_pages" },
+    },
+    run: async (ctx, args) => {
+      const req: PdfOperationRequest = {
+        operation: "ocr_pages",
+        fileId: readString(args, "fileId"),
+        url: readString(args, "url"),
+        base64: readString(args, "base64"),
+        filename: readString(args, "filename"),
+        pages: asNumberArray(args.pages),
+        renderScale: typeof args.renderScale === "number" ? args.renderScale : undefined,
+        provider: readString(args, "provider"),
+        model: readString(args, "model") ?? "",
+        prompt: readString(args, "prompt"),
+        providerApiKeys: ctx.providerApiKeys,
+        returnMode: "inline",
+      }
+      return runPdfAgent(ctx.config, ctx.env, req, {
+        fileStore: ctx.fileStore,
+        trace: ctx.trace,
+      })
+    },
+  },
+  {
+    schema: {
+      name: "pdf_tables_to_latex",
+      description: "Recognize tables from pages and return LaTeX tabular output.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          fileId: { type: "string" },
+          url: { type: "string" },
+          base64: { type: "string" },
+          filename: { type: "string" },
+          pages: { type: "array", items: { type: "integer" } },
+          renderScale: { type: "number" },
+          provider: { type: "string" },
+          model: { type: "string" },
+          prompt: { type: "string" },
+        },
+        required: ["pages"],
+      },
+      source: { kind: "local", toolName: "pdf.tables_to_latex" },
+    },
+    run: async (ctx, args) => {
+      const req: PdfOperationRequest = {
+        operation: "tables_to_latex",
+        fileId: readString(args, "fileId"),
+        url: readString(args, "url"),
+        base64: readString(args, "base64"),
+        filename: readString(args, "filename"),
+        pages: asNumberArray(args.pages),
+        renderScale: typeof args.renderScale === "number" ? args.renderScale : undefined,
+        provider: readString(args, "provider"),
+        model: readString(args, "model") ?? "",
+        prompt: readString(args, "prompt"),
+        providerApiKeys: ctx.providerApiKeys,
+        returnMode: "inline",
+      }
+      return runPdfAgent(ctx.config, ctx.env, req, {
+        fileStore: ctx.fileStore,
+        trace: ctx.trace,
+      })
+    },
+  },
+  {
+    schema: {
+      name: "file_ops",
+      description: "Basic file operations: list/read/delete/put for runtime file store.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          op: { type: "string", enum: ["list", "read", "delete", "put"] },
+          fileId: { type: "string" },
+          includeBase64: { type: "boolean" },
+          text: { type: "string" },
+          filename: { type: "string" },
+          mimeType: { type: "string" },
+          base64: { type: "string" },
+          returnMode: { type: "string", enum: ["inline", "file_id"] },
+        },
+        required: ["op"],
+      },
+      source: { kind: "local", toolName: "file.ops" },
+    },
+    run: async (ctx, args) =>
+      runFileOp(ctx.fileStore, {
+        op: (readString(args, "op") as "list" | "read" | "delete" | "put") ?? "list",
+        fileId: readString(args, "fileId"),
+        includeBase64: Boolean(args.includeBase64),
+        text: readString(args, "text"),
+        filename: readString(args, "filename"),
+        mimeType: readString(args, "mimeType"),
+        base64: readString(args, "base64"),
+        returnMode: normalizeReturnMode(args.returnMode),
+      }),
+  },
+]
+
+export const listToolSchemas = (): ReadonlyArray<ToolSchema> => toolDefinitions.map((item) => item.schema)
+
+export const callTool = async (
+  name: string,
+  args: unknown,
+  ctx: ToolRuntimeContext
+): Promise<unknown> => {
+  const definition = toolDefinitions.find((item) => item.schema.name === name)
+  if (!definition) {
+    throw new Error(`Unknown tool: ${name}`)
+  }
+  return definition.run(ctx, asObject(args))
+}

package/src/types.ts

@@ -0,0 +1,39 @@
+export type JsonPrimitive = string | number | boolean | null
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray
+export type JsonArray = JsonValue[]
+export interface JsonObject {
+  [key: string]: JsonValue
+}
+
+export type ProviderType = "openai" | "openrouter" | "vercel-ai-gateway"
+export type ReturnMode = "inline" | "file_id" | "url"
+
+export interface Env {
+  readonly ECHO_PDF_CONFIG_JSON?: string
+  readonly ASSETS?: Fetcher
+  readonly FILE_STORE_DO?: DurableObjectNamespace
+  readonly [key: string]: string | Fetcher | DurableObjectNamespace | undefined
+}
+
+export interface StoredFileMeta {
+  readonly id: string
+  readonly filename: string
+  readonly mimeType: string
+  readonly sizeBytes: number
+  readonly createdAt: string
+}
+
+export interface StoredFileRecord extends StoredFileMeta {
+  readonly bytes: Uint8Array
+}
+
+export interface FileStore {
+  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>
+}

package/src/wasm.d.ts

@@ -0,0 +1,4 @@
+declare module "*.wasm" {
+  const wasmModule: WebAssembly.Module
+  export default wasmModule
+}

package/wrangler.toml

@@ -0,0 +1,15 @@
+name = "echo-pdf"
+main = "src/index.ts"
+compatibility_date = "2026-03-06"
+
+[assets]
+directory = "./assets"
+binding = "ASSETS"
+
+[[durable_objects.bindings]]
+name = "FILE_STORE_DO"
+class_name = "FileStoreDO"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["FileStoreDO"]