@echofiles/echo-pdf 0.4.1 → 0.4.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@echofiles/echo-pdf",
-  "description": "MCP-first PDF agent on Cloudflare Workers with CLI and web demo.",
-  "version": "0.4.1",
+  "description": "Local-first PDF document component core with CLI, workspace artifacts, and reusable page primitives.",
+  "version": "0.4.3",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -9,24 +9,53 @@
   "bin": {
     "echo-pdf": "./bin/echo-pdf.js"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
+    },
+    "./local": {
+      "types": "./dist/local/index.d.ts",
+      "import": "./dist/local/index.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js"
+    }
+  },
   "files": [
     "bin",
-    "src",
+    "dist",
     "scripts",
     "README.md",
     "wrangler.toml",
     "echo-pdf.config.json"
   ],
   "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "check:runtime": "bash ./scripts/check-runtime.sh",
     "dev": "wrangler dev",
     "deploy": "wrangler deploy",
+    "document:dev": "ECHO_PDF_SOURCE_DEV=1 bun ./bin/echo-pdf.js",
+    "eval": "node ./eval/run-local.mjs",
+    "eval:smoke": "node ./eval/run-local.mjs --suite smoke",
+    "eval:core": "node ./eval/run-local.mjs --suite core",
+    "eval:stress": "node ./eval/run-local.mjs --suite stress",
+    "eval:known-bad": "node ./eval/run-local.mjs --suite known-bad",
+    "eval:fetch-public-samples": "node ./eval/fetch-public-samples.mjs",
     "typecheck": "npm run check:runtime && tsc --noEmit",
     "test:unit": "npm run check:runtime && vitest run tests/unit",
-    "test:integration": "npm run check:runtime && vitest run tests/integration",
+    "test:import-smoke": "npm run check:runtime && npm run build && vitest run tests/integration/npm-pack-import.integration.test.ts tests/integration/ts-nodenext-consumer.integration.test.ts",
+    "test:integration": "npm run check:runtime && npm run build && vitest run tests/integration",
     "test": "npm run test:unit && npm run test:integration",
     "smoke": "bash ./scripts/smoke.sh",
-    "prepublishOnly": "npm run typecheck && npm run test"
+    "prepublishOnly": "npm run build && npm run typecheck && npm run test"
   },
   "engines": {
     "node": ">=20.0.0"

package/wrangler.toml

@@ -1,5 +1,5 @@
 name = "echo-pdf"
-main = "src/index.ts"
+main = "src/worker.ts"
 compatibility_date = "2026-03-06"
 
 [assets]

package/src/agent-defaults.ts

@@ -1,25 +0,0 @@
-import type { EchoPdfConfig } from "./pdf-types"
-
-const normalize = (value: string): string => value.trim()
-
-export const resolveProviderAlias = (
-  config: EchoPdfConfig,
-  requestedProvider?: string
-): string => {
-  const raw = normalize(requestedProvider ?? "")
-  if (raw.length === 0) return config.agent.defaultProvider
-  if (config.providers[raw]) return raw
-  const fromType = Object.entries(config.providers).find(([, provider]) => provider.type === raw)?.[0]
-  if (fromType) return fromType
-  throw new Error(`Provider "${raw}" not configured`)
-}
-
-export const resolveModelForProvider = (
-  config: EchoPdfConfig,
-  _providerAlias: string,
-  requestedModel?: string
-): string => {
-  const explicit = normalize(requestedModel ?? "")
-  if (explicit.length > 0) return explicit
-  return normalize(config.agent.defaultModel ?? "")
-}

package/src/file-ops.ts

@@ -1,50 +0,0 @@
-import { fromBase64, normalizeReturnMode, toInlineFilePayload } from "./file-utils"
-import type { FileStore, ReturnMode } from "./types"
-
-export const runFileOp = async (
-  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> => {
-  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/src/file-store-do.ts

@@ -1,349 +0,0 @@
-import { fromBase64, toBase64 } from "./file-utils"
-import type { StoragePolicy } from "./pdf-types"
-import type { StoredFileMeta, StoredFileRecord } from "./types"
-
-interface StoredValue {
-  readonly id: string
-  readonly filename: string
-  readonly mimeType: string
-  readonly sizeBytes: number
-  readonly createdAt: string
-  readonly bytesBase64: string
-}
-
-interface StoreStats {
-  readonly fileCount: number
-  readonly totalBytes: number
-}
-
-const json = (data: unknown, status = 200): Response =>
-  new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json; charset=utf-8" },
-  })
-
-const readJson = async (request: Request): Promise<Record<string, unknown>> => {
-  try {
-    const body = await request.json()
-    if (typeof body === "object" && body !== null && !Array.isArray(body)) {
-      return body as Record<string, unknown>
-    }
-    return {}
-  } catch {
-    return {}
-  }
-}
-
-const defaultPolicy = (): StoragePolicy => ({
-  maxFileBytes: 1_200_000,
-  maxTotalBytes: 52_428_800,
-  ttlHours: 24,
-  cleanupBatchSize: 50,
-})
-
-const parsePolicy = (input: unknown): StoragePolicy => {
-  const raw = typeof input === "object" && input !== null && !Array.isArray(input)
-    ? (input as Record<string, unknown>)
-    : {}
-  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: StoredValue): StoredFileMeta => ({
-  id: value.id,
-  filename: value.filename,
-  mimeType: value.mimeType,
-  sizeBytes: value.sizeBytes,
-  createdAt: value.createdAt,
-})
-
-const listStoredValues = async (state: DurableObjectState): Promise<StoredValue[]> => {
-  const listed = await state.storage.list<StoredValue>({ prefix: "file:" })
-  return [...listed.values()]
-}
-
-const computeStats = (files: ReadonlyArray<StoredValue>): StoreStats => ({
-  fileCount: files.length,
-  totalBytes: files.reduce((sum, file) => sum + file.sizeBytes, 0),
-})
-
-const isExpired = (createdAt: string, ttlHours: number): boolean => {
-  const createdMs = Date.parse(createdAt)
-  if (!Number.isFinite(createdMs)) return false
-  return Date.now() - createdMs > ttlHours * 60 * 60 * 1000
-}
-
-const deleteFiles = async (state: DurableObjectState, files: ReadonlyArray<StoredValue>): Promise<number> => {
-  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 {
-  constructor(private readonly state: DurableObjectState) {}
-
-  async fetch(request: Request): Promise<Response> {
-    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: StoredValue[] = []
-        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: StoredValue = {
-        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<StoredValue>(`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<StoredValue>({ 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: unknown
-      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: StoredValue[] = []
-        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 {
-  constructor(
-    private readonly namespace: DurableObjectNamespace,
-    private readonly policy: StoragePolicy
-  ) {}
-
-  private stub(): DurableObjectStub {
-    return this.namespace.get(this.namespace.idFromName("echo-pdf-file-store"))
-  }
-
-  async put(input: {
-    readonly filename: string
-    readonly mimeType: string
-    readonly bytes: Uint8Array
-  }): Promise<StoredFileMeta> {
-    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()) as { file?: StoredFileMeta; error?: string }
-    if (!response.ok || !payload.file) {
-      const details = payload as { error?: string; code?: string; policy?: unknown; stats?: unknown }
-      const error = new Error(payload.error ?? "DO put failed") as Error & {
-        status?: number
-        code?: string
-        details?: unknown
-      }
-      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: string): Promise<StoredFileRecord | null> {
-    const response = await this.stub().fetch(`https://do/get?fileId=${encodeURIComponent(fileId)}`)
-    const payload = (await response.json()) as { file?: StoredValue | null }
-    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(): Promise<ReadonlyArray<StoredFileMeta>> {
-    const response = await this.stub().fetch("https://do/list")
-    const payload = (await response.json()) as { files?: StoredFileMeta[] }
-    if (!response.ok) throw new Error("DO list failed")
-    return payload.files ?? []
-  }
-
-  async delete(fileId: string): Promise<boolean> {
-    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()) as { deleted?: boolean }
-    if (!response.ok) throw new Error("DO delete failed")
-    return payload.deleted === true
-  }
-
-  async stats(): Promise<{ policy: StoragePolicy; stats: StoreStats }> {
-    const policyEncoded = encodeURIComponent(JSON.stringify(this.policy))
-    const response = await this.stub().fetch(`https://do/stats?policy=${policyEncoded}`)
-    const payload = (await response.json()) as { policy: StoragePolicy; stats: StoreStats }
-    if (!response.ok) throw new Error("DO stats failed")
-    return payload
-  }
-
-  async cleanup(): Promise<{ policy: StoragePolicy; deletedExpired: number; deletedEvicted: number; stats: StoreStats }> {
-    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()) as {
-      policy: StoragePolicy
-      deletedExpired: number
-      deletedEvicted: number
-      stats: StoreStats
-    }
-    if (!response.ok) throw new Error("DO cleanup failed")
-    return payload
-  }
-}

package/src/file-utils.ts

@@ -1,43 +0,0 @@
-import type { ReturnMode, StoredFileRecord } from "./types"
-
-export const fromBase64 = (value: string): Uint8Array => {
-  const raw = atob(value.replace(/^data:.*;base64,/, ""))
-  const out = new Uint8Array(raw.length)
-  for (let i = 0; i < raw.length; i++) {
-    out[i] = raw.charCodeAt(i)
-  }
-  return out
-}
-
-export const toBase64 = (bytes: Uint8Array): string => {
-  let binary = ""
-  const chunkSize = 0x8000
-  for (let i = 0; i < bytes.length; i += chunkSize) {
-    const chunk = bytes.subarray(i, i + chunkSize)
-    binary += String.fromCharCode(...chunk)
-  }
-  return btoa(binary)
-}
-
-export const toDataUrl = (bytes: Uint8Array, mimeType: string): string =>
-  `data:${mimeType};base64,${toBase64(bytes)}`
-
-export const normalizeReturnMode = (value: unknown): ReturnMode => {
-  if (value === "file_id" || value === "url" || value === "inline") {
-    return value
-  }
-  return "inline"
-}
-
-export const toInlineFilePayload = (file: StoredFileRecord, includeBase64: boolean): Record<string, unknown> => ({
-  file: {
-    id: file.id,
-    filename: file.filename,
-    mimeType: file.mimeType,
-    sizeBytes: file.sizeBytes,
-    createdAt: file.createdAt,
-  },
-  dataUrl: file.mimeType.startsWith("image/") ? toDataUrl(file.bytes, file.mimeType) : undefined,
-  base64: includeBase64 ? toBase64(file.bytes) : undefined,
-  text: file.mimeType.startsWith("text/") ? new TextDecoder().decode(file.bytes) : undefined,
-})

package/src/http-error.ts

@@ -1,21 +0,0 @@
-export class HttpError extends Error {
-  readonly status: number
-  readonly code: string
-  readonly details?: unknown
-
-  constructor(status: number, code: string, message: string, details?: unknown) {
-    super(message)
-    this.status = status
-    this.code = code
-    this.details = details
-  }
-}
-
-export const badRequest = (code: string, message: string, details?: unknown): HttpError =>
-  new HttpError(400, code, message, details)
-
-export const notFound = (code: string, message: string, details?: unknown): HttpError =>
-  new HttpError(404, code, message, details)
-
-export const unprocessable = (code: string, message: string, details?: unknown): HttpError =>
-  new HttpError(422, code, message, details)