wiki-formant 0.49.0 → 0.50.0

package/README.md

@@ -649,7 +649,7 @@ export const POST = uploadHandler({
 });
 ```
 
-The bytes say what the file is, never the name or type, and SVG is refused. Every image is re-encoded, upright, so nothing from the source's metadata is kept, a phone's GPS position included; the bytes as sent are never stored. `encode` is the re-encode, the sniffed format by default; a wiki with an image standard resizes and converts there. Each uploader has a budget, keyed on `authorize`'s id and address. `maxBytes`, `maxPixels` and `rateLimit` take other limits, and `store` replaces Vercel Blob. `sharp` and `@vercel/blob` are optional peers.
+The bytes say what the file is, never the name or type, and SVG is refused. Every image is re-encoded, upright, so nothing from the source's metadata is kept, a phone's GPS position included; the bytes as sent are never stored. `encode` is the re-encode, the sniffed format by default; a wiki with an image standard resizes and converts there. Each uploader has a budget, keyed on `authorize`'s id and address. `maxBytes`, `maxPixels` and `rateLimit` take other limits, and `store` replaces Vercel Blob. `sharp` and `@vercel/blob` are optional peers. `normalizeImage(bytes, { maxPixels, encode })` is the same sniff, cap and re-encode without the route, for images that arrive another way – a server action, or a picture copied in from another site; it resolves to `{ buffer, format, contentType }` and throws a message fit to show the uploader.
 
 ## Editor nodes
 

package/dist/upload.d.ts

@@ -1,27 +1,40 @@
 import { type Sharp } from 'sharp';
 import { type RateLimitOptions } from './rate-limit.js';
 export type ImageFormat = 'jpg' | 'png' | 'gif' | 'webp' | 'avif';
-export interface UploadOptions {
-    /** The uploader's id, which keys the rate limit, or the response that turns them away. */
-    authorize: (request: Request) => Promise<string | Response>;
-    /** Default 4 MB. */
-    maxBytes?: number;
+type Encode = (image: Sharp, source: {
+    format: ImageFormat;
+    width: number;
+    height: number;
+}) => {
+    image: Sharp;
+    format: ImageFormat;
+};
+export interface NormalizeOptions {
     /** Decoded pixels, default 40 million: a phone camera's full resolution. */
     maxPixels?: number;
-    /** Default a burst of 20, then one every five seconds. */
-    rateLimit?: RateLimitOptions;
     /**
      * How the upright image is written. Default the format it arrived in. A wiki
      * with an image standard resizes and converts here.
      */
-    encode?: (image: Sharp, source: {
-        format: ImageFormat;
-        width: number;
-        height: number;
-    }) => {
-        image: Sharp;
-        format: ImageFormat;
-    };
+    encode?: Encode;
+}
+/**
+ * The image re-encoded upright with no metadata, in the format `encode` chose.
+ * Throws, with a message fit to show the uploader, for bytes that are not an
+ * accepted image or decode to more than `maxPixels`.
+ */
+export declare function normalizeImage(bytes: Buffer, { maxPixels, encode, }?: NormalizeOptions): Promise<{
+    buffer: Buffer;
+    format: ImageFormat;
+    contentType: string;
+}>;
+export interface UploadOptions extends NormalizeOptions {
+    /** The uploader's id, which keys the rate limit, or the response that turns them away. */
+    authorize: (request: Request) => Promise<string | Response>;
+    /** Default 4 MB. */
+    maxBytes?: number;
+    /** Default a burst of 20, then one every five seconds. */
+    rateLimit?: RateLimitOptions;
     /** Prepended to the stored name, e.g. `wiki/`. */
     prefix?: string;
     /** Stores the bytes and resolves to their public URL. Default Vercel Blob, public. */
@@ -29,3 +42,4 @@ export interface UploadOptions {
 }
 /** The POST handler: a multipart `file` in, `{ url }` out. */
 export declare function uploadHandler({ authorize, maxBytes, maxPixels, rateLimit, encode, prefix, store, }: UploadOptions): (request: Request) => Promise<Response>;
+export {};

package/dist/upload.js

@@ -15,6 +15,10 @@
 //   EXIF; the orientation that metadata carried is applied first.
 // - **Each uploader has a budget**, keyed on who they are and where from.
 //
+// `normalizeImage` is the sniff, the pixel cap and the re-encode without the
+// route, for an app whose images arrive another way: a server action, or a
+// picture copied in from another site.
+//
 // `sharp` and `@vercel/blob` are optional peers. Run the route on Node, never
 // the edge: sharp is native.
 import sharp, {} from 'sharp';
@@ -43,11 +47,39 @@ function sniffImage(buf) {
         return 'avif';
     return null;
 }
+/**
+ * The image re-encoded upright with no metadata, in the format `encode` chose.
+ * Throws, with a message fit to show the uploader, for bytes that are not an
+ * accepted image or decode to more than `maxPixels`.
+ */
+export async function normalizeImage(bytes, { maxPixels = 40_000_000, encode = (image, { format }) => ({ image: image.toFormat(format === 'jpg' ? 'jpeg' : format), format }), } = {}) {
+    const megapixels = Math.round(maxPixels / 1_000_000);
+    const format = sniffImage(bytes);
+    if (!format)
+        throw new Error('Invalid file. Allowed: JPEG, PNG, GIF, WebP, AVIF');
+    try {
+        const meta = await sharp(bytes, { limitInputPixels: maxPixels }).metadata();
+        const width = meta.width ?? 0;
+        const height = meta.pageHeight ?? meta.height ?? 0;
+        if (!width || !height)
+            throw new Error('no dimensions');
+        if (width * height > maxPixels)
+            throw new Error('pixel limit');
+        const upright = sharp(bytes, { animated: (meta.pages ?? 1) > 1, limitInputPixels: maxPixels }).rotate();
+        const encoded = encode(upright, { format, width, height });
+        return { buffer: await encoded.image.toBuffer(), format: encoded.format, contentType: CONTENT_TYPE[encoded.format] };
+    }
+    catch (e) {
+        // Never fall back to the bytes as sent: storing them is what leaks the location.
+        throw new Error(e instanceof Error && e.message.includes('pixel limit')
+            ? `Image too large (max ${megapixels} megapixels)`
+            : 'Could not read this image. Save it as PNG or JPEG and try again.');
+    }
+}
 const vercelBlob = async (path, body, contentType) => (await put(path, body, { access: 'public', addRandomSuffix: false, contentType })).url;
 /** The POST handler: a multipart `file` in, `{ url }` out. */
-export function uploadHandler({ authorize, maxBytes = 4 * 1024 * 1024, maxPixels = 40_000_000, rateLimit = { capacity: 20, refillPerSec: 0.2 }, encode = (image, { format }) => ({ image: image.toFormat(format === 'jpg' ? 'jpeg' : format), format }), prefix = '', store = vercelBlob, }) {
+export function uploadHandler({ authorize, maxBytes = 4 * 1024 * 1024, maxPixels, rateLimit = { capacity: 20, refillPerSec: 0.2 }, encode, prefix = '', store = vercelBlob, }) {
     const megabytes = Math.round((maxBytes / 1024 / 1024) * 10) / 10;
-    const megapixels = Math.round(maxPixels / 1_000_000);
     return request => handleRoute(async () => {
         const who = await authorize(request);
         if (who instanceof Response)
@@ -61,31 +93,14 @@ export function uploadHandler({ authorize, maxBytes = 4 * 1024 * 1024, maxPixels
             return errors.badRequest('No file provided');
         if (file.size > maxBytes)
             return errors.badRequest(`File too large (max ${megabytes}MB)`);
-        const bytes = Buffer.from(await file.arrayBuffer());
-        const format = sniffImage(bytes);
-        if (!format)
-            return errors.badRequest('Invalid file. Allowed: JPEG, PNG, GIF, WebP, AVIF');
         let out;
         try {
-            const meta = await sharp(bytes, { limitInputPixels: maxPixels }).metadata();
-            const width = meta.width ?? 0;
-            const height = meta.pageHeight ?? meta.height ?? 0;
-            if (!width || !height)
-                throw new Error('no dimensions');
-            if (width * height > maxPixels)
-                return errors.badRequest(`Image too large (max ${megapixels} megapixels)`);
-            const upright = sharp(bytes, { animated: (meta.pages ?? 1) > 1, limitInputPixels: maxPixels }).rotate();
-            const encoded = encode(upright, { format, width, height });
-            out = { buffer: await encoded.image.toBuffer(), format: encoded.format };
+            out = await normalizeImage(Buffer.from(await file.arrayBuffer()), { maxPixels, encode });
         }
         catch (e) {
-            // Never fall back to the bytes as sent: storing them is what leaks the location.
-            const tooBig = e instanceof Error && e.message.includes('pixel limit');
-            return errors.badRequest(tooBig
-                ? `Image too large (max ${megapixels} megapixels)`
-                : 'Could not read this image. Save it as PNG or JPEG and try again.');
+            return errors.badRequest(e.message);
         }
-        const url = await store(`${prefix}${crypto.randomUUID()}.${out.format}`, out.buffer, CONTENT_TYPE[out.format]);
+        const url = await store(`${prefix}${crypto.randomUUID()}.${out.format}`, out.buffer, out.contentType);
         return json({ url });
     }, 'Upload failed');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "description": "The portable half of a wiki: derived taxonomy and facet controls, a version-negotiating MCP transport, markdown twins, block rendering, a rich-text editor engine, conditional-GET plumbing, and the headers and CSP every origin sends.",
   "type": "module",
   "license": "MIT",