smoodly 0.0.51 → 0.0.52

package/dist/index.js

@@ -3,7 +3,6 @@ import { collection } from "./collections.js";
 import { toolset } from "./toolset.js";
 import { globalItem } from "./global.js";
 import { marks } from "./marks.js";
-export { createSupabaseStores, siteOptions } from "./bind.js";
 export { schemaOf } from "./registration.js";
 export { EMPTY_PAGE_CONTEXT } from "./page-context.js";
 export { fixedSlug } from "./page.js";
@@ -19,27 +18,14 @@ export { DEFAULT_ADMIN_PATH } from "./admin-path.js";
 export { ASSET_COLLECTION, DEFAULT_MEDIA, MEDIA_TYPES, FULL_CROP, CENTER_HOTSPOT, parseAspect, cropAspect, clamp01, isMediaValue, collectAssetIds, applyAssets, } from "./media.js";
 export { z } from "./zones.js";
 export { defineConfig } from "./config.js";
-export { collectionSQL, coreTablesSQL } from "./sql.js";
-export { SCHEMA_VERSION, SCHEMA_VERSION_KEY, schemaVersionSQL, coreFileVersion, schemaBehind, schemaBehindMessage } from "./schema-version.js";
 export { draftToken, sameToken, isDraftToken, assertFresh, StaleDraftError } from "./draft-token.js";
-export { MemoryPageStore } from "./store.js";
-export { MemoryAssetStore, assetErrors, kindOf, extensionFor, objectPath, withDownload, PAGE_SIZE as ASSET_PAGE_SIZE } from "./asset-store.js";
+export { assetErrors, kindOf, extensionFor, objectPath, PAGE_SIZE as ASSET_PAGE_SIZE } from "./asset-store.js";
 export { imageDimensions } from "./image-dimensions.js";
-export { SupabasePageStore } from "./supabase-store.js";
-export { SupabaseAssetStore } from "./supabase-asset-store.js";
-export { MemoryMemberStore, sortMembers, memberErrors } from "./member-store.js";
-export { SupabaseMemberStore } from "./supabase-member-store.js";
+export { sortMembers, memberErrors } from "./member-store.js";
 export { MEMBER_ROLES, can, normalizeRole, isMemberRole } from "./permissions.js";
 export { collectEntryRefs, collectTreeRefs } from "./refs.js";
 export { richtextBlocks, elementSchemas, IMAGE_NODE, ELEMENT_NODE } from "./richtext-walk.js";
-export { MemoryRefIndex } from "./ref-index.js";
-export { MemoryPathIndex } from "./path-index.js";
-export { MemoryEntryStore } from "./entry-store.js";
-export { SupabaseEntryStore } from "./supabase-entry-store.js";
-export { SupabasePathIndex } from "./supabase-path-index.js";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.js";
-export { MemoryPublishedStore } from "./published.js";
-export { SupabasePublishedStore } from "./supabase-published-store.js";
 export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.js";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.js";
 export { SEGMENT_RE, isSegment, assertSegment, slugify, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.js";
@@ -54,10 +40,11 @@ export { GLOBAL_NODE_TYPE, SETTINGS_KEY, STYLES_KEY, CSS_KEY, globalLink } from
 export { SMD_KEY } from "./smd-key.js";
 export { CSS_MAX, cssProblem, safeCss, scopedCss } from "./css.js";
 export { globalEntryId } from "./global-id.js";
-export { DEFAULT_SPACE_ID } from "./sql-space.js";
+export { DEFAULT_SPACE_ID } from "./global-id.js";
 /** The registration namespace: schemas and their parts. The React pairing (`smoodly.section`, `<smoodly.Section>`) is smoodly/react's. */
 export const smoodly = { schema, collection, toolset, global: globalItem, marks };
 export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, BLANK_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.js";
-export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig, siteUrl } from "./env.js";
-export { clientOptions, createSmoodlyClient } from "./client.js";
-export { createSmoodlySite, pageContextOf } from "./site.js";
+export { apiEnv, resolveSmoodlyEnv, smoodlyEnv, presenceConfig, siteUrl } from "./env.js";
+export { createSmoodlyApi, SmoodlyApiError } from "./api-client.js";
+export { MESSAGE_MAX_AGE_MS, signMessage, verifyMessage } from "./signed-message.js";
+export { pageContextOf, siteStatics } from "./site.js";

package/dist/media-cut.d.ts

@@ -0,0 +1,44 @@
+import type { Crop, Hotspot } from "./media.ts";
+export type PixelRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/** The qualities a cut is made at: unsigned in the address like the width, so a list bounds what Images is asked to
+ *  make (spec 2026-10-18 image quality and max width §2). 75 matched Vercel's optimizer in step 6's speed round. */
+export declare const IMAGE_QUALITIES: readonly [50, 60, 75, 85, 95, 100];
+export type ImageQuality = (typeof IMAGE_QUALITIES)[number];
+export declare const DEFAULT_QUALITY: ImageQuality;
+export declare const isImageQuality: (n: unknown) => n is ImageQuality;
+/** The refusal of a quality off the list; `label` names where it was given (`media.quality`, `f.image quality`). */
+export declare const qualityError: (n: unknown, label?: string) => string;
+/** A cap on a srcset's widths: a positive whole number of pixels. */
+export declare const isMaxWidth: (n: unknown) => n is number;
+/** Signs a rectangle of the file at `path` (`<space>/<asset>.<ext>`) and answers the cut's base address; the service
+ *  makes one from its media secret, a site never holds it. */
+export type CutSigner = (path: string, rect: PixelRect) => Promise<string>;
+/** A crop's fractions as whole pixels inside the image: edges rounded, never past the image, at least one pixel. */
+export declare function rectOf(crop: Crop, imageWidth: number, imageHeight: number): PixelRect;
+/** The largest rectangle at `aspect` (width / height) inside the image, centred on the hotspot (the centre without
+ *  one) and shifted to stay inside: what a crop nobody framed shows (spec §6). */
+export declare function hotspotRect(aspect: number, hotspot: Hotspot | undefined, imageWidth: number, imageHeight: number): PixelRect;
+/** The listed widths under the cut's own, then its own: a 200-pixel logo is `[200]`. A `maxWidth` keeps those at or
+ *  under it and adds none; under them all it keeps the smallest, so a srcset is never empty. */
+export declare function cutWidths(rectWidth: number, maxWidth?: number): number[];
+export declare const cutSegment: (rect: PixelRect, sig: string) => string;
+/** `<left>.<top>.<width>.<height>.<sig>`, or null: whole numbers written one way only (no sign, no leading zero), a
+ *  width and a height of at least one, and a signature's shape. */
+export declare function parseCutSegment(segment: string): {
+    rect: PixelRect;
+    sig: string;
+} | null;
+/** What the signature covers: the file and the rectangle, never the width or the quality (the route checks both
+ *  against their lists). */
+export declare const cutPayload: (path: string, rect: PixelRect) => string;
+export declare const cutUrl: (cut: string, width: number, quality: ImageQuality) => string;
+/** `<width>q<quality>`, or null: whole numbers written one way only. Whether both are listed is the route's check. */
+export declare function parseCutSize(segment: string): {
+    width: number;
+    quality: number;
+} | null;

package/dist/media-cut.js

@@ -0,0 +1,70 @@
+/** The widths a cut is served at, plus the cut's own width; a wider one is never served (upscaling sells nothing).
+ *  From 640 to 1080 they are Next's device sizes, so a phone gets what `next/image` gave it (a 412-pixel screen at 1.75
+ *  finds 750, not 960; step 6 plan (d)'s speed round); 1536 spares a 1366- or 1440-wide laptop the 1920 (spec 2026-10-18
+ *  image quality and max width §5). */
+const CUT_WIDTHS = [320, 640, 750, 828, 1080, 1280, 1536, 1920, 2560];
+/** The qualities a cut is made at: unsigned in the address like the width, so a list bounds what Images is asked to
+ *  make (spec 2026-10-18 image quality and max width §2). 75 matched Vercel's optimizer in step 6's speed round. */
+export const IMAGE_QUALITIES = [50, 60, 75, 85, 95, 100];
+export const DEFAULT_QUALITY = 75;
+export const isImageQuality = (n) => IMAGE_QUALITIES.includes(n);
+/** The refusal of a quality off the list; `label` names where it was given (`media.quality`, `f.image quality`). */
+export const qualityError = (n, label = "quality") => `smoodly: ${label} ${String(n)} is not one of ${IMAGE_QUALITIES.join(", ")}.`;
+/** A cap on a srcset's widths: a positive whole number of pixels. */
+export const isMaxWidth = (n) => typeof n === "number" && Number.isInteger(n) && n > 0;
+const clampInt = (n, min, max) => Math.min(max, Math.max(min, n));
+/** A crop's fractions as whole pixels inside the image: edges rounded, never past the image, at least one pixel. */
+export function rectOf(crop, imageWidth, imageHeight) {
+    const left = clampInt(Math.round(crop.left * imageWidth), 0, imageWidth - 1);
+    const top = clampInt(Math.round(crop.top * imageHeight), 0, imageHeight - 1);
+    const right = clampInt(Math.round((crop.left + crop.width) * imageWidth), left + 1, imageWidth);
+    const bottom = clampInt(Math.round((crop.top + crop.height) * imageHeight), top + 1, imageHeight);
+    return { left, top, width: right - left, height: bottom - top };
+}
+/** The largest rectangle at `aspect` (width / height) inside the image, centred on the hotspot (the centre without
+ *  one) and shifted to stay inside: what a crop nobody framed shows (spec §6). */
+export function hotspotRect(aspect, hotspot, imageWidth, imageHeight) {
+    const spot = hotspot ?? { x: 0.5, y: 0.5 };
+    const wide = imageWidth / imageHeight > aspect;
+    const width = wide ? clampInt(Math.round(imageHeight * aspect), 1, imageWidth) : imageWidth;
+    const height = wide ? imageHeight : clampInt(Math.round(imageWidth / aspect), 1, imageHeight);
+    const left = clampInt(Math.round(spot.x * imageWidth - width / 2), 0, imageWidth - width);
+    const top = clampInt(Math.round(spot.y * imageHeight - height / 2), 0, imageHeight - height);
+    return { left, top, width, height };
+}
+/** The listed widths under the cut's own, then its own: a 200-pixel logo is `[200]`. A `maxWidth` keeps those at or
+ *  under it and adds none; under them all it keeps the smallest, so a srcset is never empty. */
+export function cutWidths(rectWidth, maxWidth) {
+    const all = [...CUT_WIDTHS.filter((w) => w < rectWidth), rectWidth];
+    if (maxWidth === undefined)
+        return all;
+    const kept = all.filter((w) => w <= maxWidth);
+    return kept.length > 0 ? kept : [all[0]];
+}
+export const cutSegment = (rect, sig) => `${rect.left}.${rect.top}.${rect.width}.${rect.height}.${sig}`;
+const INT = /^(0|[1-9]\d{0,8})$/;
+/** A signature: 16 bytes, base64url without padding, written one way: the 22nd character carries two bits and four
+ *  zero bits of padding, so it is one of A, Q, g, w (else 16 spellings of one signature would be 16 cuts to cache). */
+const SIG = /^[A-Za-z0-9_-]{21}[AQgw]$/;
+/** `<left>.<top>.<width>.<height>.<sig>`, or null: whole numbers written one way only (no sign, no leading zero), a
+ *  width and a height of at least one, and a signature's shape. */
+export function parseCutSegment(segment) {
+    const parts = segment.split(".");
+    if (parts.length !== 5)
+        return null;
+    const [l, t, w, h, sig] = parts;
+    if (![l, t, w, h].every((p) => INT.test(p)) || !SIG.test(sig))
+        return null;
+    const rect = { left: Number(l), top: Number(t), width: Number(w), height: Number(h) };
+    return rect.width >= 1 && rect.height >= 1 ? { rect, sig } : null;
+}
+/** What the signature covers: the file and the rectangle, never the width or the quality (the route checks both
+ *  against their lists). */
+export const cutPayload = (path, rect) => `${path}:${rect.left}.${rect.top}.${rect.width}.${rect.height}`;
+export const cutUrl = (cut, width, quality) => `${cut}/${width}q${quality}`;
+const SIZE = /^([1-9]\d{0,8})q([1-9]\d{0,2})$/;
+/** `<width>q<quality>`, or null: whole numbers written one way only. Whether both are listed is the route's check. */
+export function parseCutSize(segment) {
+    const m = SIZE.exec(segment);
+    return m ? { width: Number(m[1]), quality: Number(m[2]) } : null;
+}

package/dist/media.d.ts

@@ -1,4 +1,5 @@
 import type { Descriptor } from "./fields.ts";
+import { type CutSigner, type ImageQuality, type PixelRect } from "./media-cut.ts";
 import { type ElementSchemas } from "./richtext-walk.ts";
 export type Crop = {
     left: number;
@@ -11,10 +12,13 @@ export type Hotspot = {
     y: number;
 };
 export type AssetKind = "image" | "video" | "file";
+/** `crops`: the named crops the editor framed (spec 2026-10-18 media on R2 and Images §6); a name absent follows the
+ *  hotspot. `crop`: the one free or `aspect` crop. */
 export type ImageValue = {
     asset: string;
     alt?: string;
     crop?: Crop;
+    crops?: Record<string, Crop>;
     hotspot?: Hotspot;
     aspect?: string;
 };
@@ -51,10 +55,22 @@ export type AssetRecord = {
     credit: string | null;
     /** Derived by the store from the bucket's public URL, never stored. */
     url: string;
+    /** The whole image's cut where the service cuts (spec 2026-10-18 media on R2 and Images §9): the admin appends a
+     *  small width. Absent locally and on anything but a raster image. */
+    thumb?: string;
     createdAt: number;
     updatedAt: number;
 };
-export type ResolvedImage = {
+/** One named crop as a view receives it: the fractions (framed, or following the hotspot), the ratio, the cut's pixel
+ *  size (the `<source>`'s width and height) and its signed cut. */
+export type ResolvedCrop = {
+    cut?: string;
+    crop: Crop;
+    aspect: string;
+    width: number;
+    height: number;
+};
+export type ResolvedImage<C extends string = string> = {
     url: string;
     width: number;
     height: number;
@@ -63,6 +79,20 @@ export type ResolvedImage = {
     crop?: Crop;
     hotspot?: Hotspot;
     aspect?: string;
+    /** A field with named crops: every one, in the schema's order; the first is also `crop`, `aspect` and `cut`. */
+    crops?: Record<C, ResolvedCrop>;
+    /** The signed cut of what the stored value gives, widths appended by the component (spec 2026-10-18 media on R2 and
+     *  Images §5); absent where the service cuts nothing (locally, an SVG), and the component crops the original in CSS. */
+    cut?: string;
+    /** The field's quality and srcset cap, else the project's; absent where neither is set (spec 2026-10-18 image quality
+     *  and max width §6). The component's props win over both. */
+    quality?: ImageQuality;
+    maxWidth?: number;
+};
+/** The project's image quality and srcset cap (`defineConfig({ media })`), which a field's own options override. */
+export type ImageDefaults = {
+    quality?: ImageQuality;
+    maxWidth?: number;
 };
 export type ResolvedVideo = {
     url: string;
@@ -87,6 +117,12 @@ export declare const MEDIA_TYPES: ReadonlySet<string>;
  *  immutable (no upsert; Replace picks a new id), so the CDN, the browser
  *  and next/image may keep one for as long as they like. */
 export declare const MEDIA_CACHE_SECONDS = 31536000;
+/** The largest file a space may accept (spec 2026-10-18 media on R2 and Images §4): Cloudflare's request body limit on
+ *  Free and Pro, since every upload streams through the Worker; a pushed `media.maxSize` over it is refused. */
+export declare const MEDIA_SIZE_CEILING = 104857600;
+/** The raster types the service cuts (spec 2026-10-18 media on R2 and Images §5): Images takes them as input. An SVG,
+ *  a video and a file are served as their original. */
+export declare const CUT_TYPES: ReadonlySet<string>;
 export declare const DEFAULT_MEDIA: {
     readonly maxSize: number;
     readonly accept: readonly ["image/jpeg", "image/png", "image/webp", "image/avif", "image/gif", "image/svg+xml", "video/mp4", "video/webm", "application/pdf"];
@@ -104,6 +140,24 @@ export declare const isMediaValue: (v: unknown) => v is {
 /** Every asset id a value set references, walking lists and objects —
  *  unlike refs, media may sit inside a container (spec §8). */
 export declare function collectAssetIds(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, out: Set<string>, elements?: ElementSchemas): void;
+/** One image a read wants cut: the file, the rectangle its stored value gives, and where the signed address goes. */
+export type CutRequest = {
+    path: string;
+    rect: PixelRect;
+    set(cut: string): void;
+};
+/** A stored crop the resolver may use: four fractions inside the image. */
+export declare function isCrop(c: unknown): c is Crop;
+/** A named crop's framed rectangle, or undefined when it follows the hotspot: its stored entry, or for the first crop a
+ *  `crop` saved under `aspect`, at the crop's ratio (spec §6; the resolver and the crop window agree). */
+export declare function framedCrop(value: Pick<ImageValue, "crop" | "crops">, names: string[], name: string, ratio: string, imageAspect: number): Crop | undefined;
+/** What a crop nobody framed shows: the largest rectangle at its ratio around the hotspot, as fractions. */
+export declare function followingCrop(ratio: string, hotspot: Hotspot | undefined, width: number, height: number): Crop;
 /** Replace every media value in place with its resolved object — or delete
- *  it when the asset is missing or pending, so `image?.url` guards hold. */
-export declare function applyAssets(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, assets: Map<string, AssetRecord>, elements?: ElementSchemas): void;
+ *  it when the asset is missing or pending, so `image?.url` guards hold. With
+ *  `cuts`, every raster image resolved pushes its cut request (signCuts fills them); `defaults` are the project's
+ *  image quality and cap, under a field's own. */
+export declare function applyAssets(values: Record<string, unknown> | undefined, descriptors: Record<string, Descriptor>, assets: Map<string, AssetRecord>, elements?: ElementSchemas, cuts?: CutRequest[], defaults?: ImageDefaults): void;
+/** Signs each distinct rectangle once and fills every request for it: two fields framing one photo the same way share a
+ *  signature, an address and a cache entry. */
+export declare function signCuts(requests: CutRequest[], signer: CutSigner): Promise<void>;

package/dist/media.js

@@ -1,3 +1,4 @@
+import { hotspotRect, rectOf } from "./media-cut.js";
 import { ELEMENT_NODE, IMAGE_NODE, elementOf, elementSets, richtextBlocks } from "./richtext-walk.js";
 /** The refs target collection of every asset edge — a reserved registered name. */
 export const ASSET_COLLECTION = "asset";
@@ -6,6 +7,12 @@ export const MEDIA_TYPES = new Set(["image", "video", "file"]);
  *  immutable (no upsert; Replace picks a new id), so the CDN, the browser
  *  and next/image may keep one for as long as they like. */
 export const MEDIA_CACHE_SECONDS = 31536000;
+/** The largest file a space may accept (spec 2026-10-18 media on R2 and Images §4): Cloudflare's request body limit on
+ *  Free and Pro, since every upload streams through the Worker; a pushed `media.maxSize` over it is refused. */
+export const MEDIA_SIZE_CEILING = 104857600;
+/** The raster types the service cuts (spec 2026-10-18 media on R2 and Images §5): Images takes them as input. An SVG,
+ *  a video and a file are served as their original. */
+export const CUT_TYPES = new Set(["image/jpeg", "image/png", "image/webp", "image/avif", "image/gif"]);
 export const DEFAULT_MEDIA = {
     maxSize: 25 * 1024 * 1024,
     accept: [
@@ -78,31 +85,120 @@ export function collectAssetIds(values, descriptors, out, elements = {}) {
         }
     }
 }
-function resolvedImage(asset, value, d) {
+/** The rectangle the server cuts (spec §5): the saved crop; with none on a field with a ratio, the largest rectangle at
+ *  that ratio around the hotspot; with neither, the whole image. */
+function cutRect(image) {
+    if (image.crop)
+        return rectOf(image.crop, image.width, image.height);
+    if (image.aspect)
+        return hotspotRect(parseAspect(image.aspect), image.hotspot, image.width, image.height);
+    return { left: 0, top: 0, width: image.width, height: image.height };
+}
+/** A stored crop the resolver may use: four fractions inside the image. */
+export function isCrop(c) {
+    if (!c || typeof c !== "object")
+        return false;
+    const { left, top, width, height } = c;
+    const fractions = [left, top, width, height];
+    // A float's hair past an edge is the crop window's arithmetic, not a crop outside the image (rectOf clamps it).
+    const EPS = 1e-6;
+    if (!fractions.every((n) => typeof n === "number" && Number.isFinite(n) && n >= -EPS && n <= 1 + EPS))
+        return false;
+    const [l, t, w, h] = fractions;
+    return w > 0 && h > 0 && l + w <= 1 + EPS && t + h <= 1 + EPS;
+}
+/** A field's named crops (`f.image({ crops })`), or undefined. */
+const namedCropsOf = (d) => d.crops && typeof d.crops === "object" && Object.keys(d.crops).length > 0 ? d.crops : undefined;
+/** Every named crop of a use (spec §6): the framed rectangle, else the largest one at its ratio around the hotspot. A
+ *  `crop` saved before the field declared crops (under `aspect`) is the first crop's when its ratio is the first's
+ *  within 1%, else ignored. The first crop's cut is the image's. */
+/** A stored crop counts only at the ratio its field declares now, within 1%: a ratio changed in code makes it follow
+ *  the hotspot at the new one, so the box, the cut and the crop window agree (the final review of plan (c)). */
+const atRatio = (crop, ratio, imageAspect) => Math.abs(cropAspect(crop, imageAspect) / parseAspect(ratio) - 1) <= 0.01;
+/** A named crop's framed rectangle, or undefined when it follows the hotspot: its stored entry, or for the first crop a
+ *  `crop` saved under `aspect`, at the crop's ratio (spec §6; the resolver and the crop window agree). */
+export function framedCrop(value, names, name, ratio, imageAspect) {
+    const stored = value.crops?.[name];
+    if (isCrop(stored) && atRatio(stored, ratio, imageAspect))
+        return stored;
+    if (name === names[0] && isCrop(value.crop) && atRatio(value.crop, ratio, imageAspect))
+        return value.crop;
+    return undefined;
+}
+/** What a crop nobody framed shows: the largest rectangle at its ratio around the hotspot, as fractions. */
+export function followingCrop(ratio, hotspot, width, height) {
+    const rect = hotspotRect(parseAspect(ratio), hotspot, width, height);
+    return { left: rect.left / width, top: rect.top / height, width: rect.width / width, height: rect.height / height };
+}
+function resolveCrops(image, asset, value, named, cuts) {
+    const { width: W, height: H } = image;
+    const out = {};
+    const names = Object.keys(named);
+    Object.entries(named).forEach(([name, ratio], i) => {
+        const crop = framedCrop(value, names, name, ratio, W / H);
+        const rect = crop ? rectOf(crop, W, H) : hotspotRect(parseAspect(ratio), value.hotspot, W, H);
+        const resolved = {
+            crop: crop ?? { left: rect.left / W, top: rect.top / H, width: rect.width / W, height: rect.height / H },
+            aspect: ratio, width: rect.width, height: rect.height,
+        };
+        out[name] = resolved;
+        if (i === 0) {
+            image.crop = resolved.crop;
+            image.aspect = ratio;
+        }
+        if (cuts && CUT_TYPES.has(asset.mime))
+            cuts.push({ path: asset.path, rect, set: (cut) => { resolved.cut = cut; if (i === 0)
+                    image.cut = cut; } });
+    });
+    image.crops = out;
+}
+/** The field's quality and cap, else the project's: only the ones set, so an unconfigured site's output is unchanged. */
+function delivery(d, defaults) {
+    const quality = d.quality ?? defaults?.quality;
+    const maxWidth = d.maxWidth ?? defaults?.maxWidth;
+    return { ...(quality !== undefined ? { quality } : {}), ...(maxWidth !== undefined ? { maxWidth } : {}) };
+}
+function resolvedImage(asset, value, d, cuts, defaults) {
     if (asset.width === null || asset.height === null)
         return undefined;
+    const named = namedCropsOf(d);
+    if (named) {
+        const image = {
+            url: asset.url, width: asset.width, height: asset.height, mime: asset.mime, alt: value.alt ?? asset.alt ?? "",
+            ...(value.hotspot ? { hotspot: value.hotspot } : {}),
+            ...delivery(d, defaults),
+        };
+        resolveCrops(image, asset, value, named, cuts);
+        return image;
+    }
     const declared = d.aspect;
     const aspect = value.aspect ?? (typeof declared === "string" ? declared : undefined);
-    return {
+    // A crop saved at another ratio than the field's now is dropped: the hotspot frames the declared one.
+    const crop = value.crop && (!aspect || (isCrop(value.crop) && atRatio(value.crop, aspect, asset.width / asset.height))) ? value.crop : undefined;
+    const image = {
         url: asset.url, width: asset.width, height: asset.height, mime: asset.mime,
         alt: value.alt ?? asset.alt ?? "",
-        ...(value.crop ? { crop: value.crop } : {}),
+        ...(crop ? { crop } : {}),
         ...(value.hotspot ? { hotspot: value.hotspot } : {}),
         ...(aspect ? { aspect } : {}),
+        ...delivery(d, defaults),
     };
+    if (cuts && CUT_TYPES.has(asset.mime))
+        cuts.push({ path: asset.path, rect: cutRect(image), set: (cut) => { image.cut = cut; } });
+    return image;
 }
-function resolveOne(value, d, assets) {
+function resolveOne(value, d, assets, cuts, defaults) {
     if (!isMediaValue(value))
         return undefined;
     const asset = assets.get(value.asset);
     if (!asset || asset.status !== "ready")
         return undefined;
     if (d.type === "image")
-        return resolvedImage(asset, value, d);
+        return resolvedImage(asset, value, d, cuts, defaults);
     if (d.type === "video") {
         const v = value;
         const poster = asset.posterId ? assets.get(asset.posterId) : undefined;
-        const posterResolved = poster ? resolvedImage(poster, { asset: poster.id }, { type: "image" }) : undefined;
+        const posterResolved = poster ? resolvedImage(poster, { asset: poster.id }, { type: "image" }, cuts, defaults) : undefined;
         return {
             url: asset.url, mime: asset.mime,
             ...(asset.width !== null ? { width: asset.width } : {}),
@@ -116,8 +212,10 @@ function resolveOne(value, d, assets) {
     return { url: asset.url, mime: asset.mime, size: asset.size, filename: asset.filename, ...(f.title ? { title: f.title } : {}) };
 }
 /** Replace every media value in place with its resolved object — or delete
- *  it when the asset is missing or pending, so `image?.url` guards hold. */
-export function applyAssets(values, descriptors, assets, elements = {}) {
+ *  it when the asset is missing or pending, so `image?.url` guards hold. With
+ *  `cuts`, every raster image resolved pushes its cut request (signCuts fills them); `defaults` are the project's
+ *  image quality and cap, under a field's own. */
+export function applyAssets(values, descriptors, assets, elements = {}, cuts, defaults) {
     if (!values)
         return;
     for (const [key, d] of Object.entries(descriptors)) {
@@ -125,7 +223,7 @@ export function applyAssets(values, descriptors, assets, elements = {}) {
         if (value == null)
             continue;
         if (MEDIA_TYPES.has(d.type)) {
-            const resolved = resolveOne(value, d, assets);
+            const resolved = resolveOne(value, d, assets, cuts, defaults);
             if (resolved === undefined)
                 delete values[key];
             else
@@ -134,7 +232,7 @@ export function applyAssets(values, descriptors, assets, elements = {}) {
         else if (d.type === "richtext") {
             for (const node of richtextBlocks(value)) {
                 if (node.type === IMAGE_NODE) {
-                    const resolved = resolveOne(node.attrs.image, { type: "image" }, assets);
+                    const resolved = resolveOne(node.attrs.image, { type: "image" }, assets, cuts, defaults);
                     if (resolved === undefined)
                         delete node.attrs.image;
                     else
@@ -144,28 +242,40 @@ export function applyAssets(values, descriptors, assets, elements = {}) {
                     const schema = elementOf(node, elements);
                     if (schema)
                         for (const set of elementSets(node, schema))
-                            applyAssets(set.values, set.descriptors, assets, elements);
+                            applyAssets(set.values, set.descriptors, assets, elements, cuts, defaults);
                 }
             }
         }
         else if (d.type === "object" && typeof value === "object" && !Array.isArray(value)) {
-            applyAssets(value, d.fields, assets, elements);
+            applyAssets(value, d.fields, assets, elements, cuts, defaults);
         }
         else if (d.type === "list" && Array.isArray(value)) {
             const item = d.item;
             if (MEDIA_TYPES.has(item.type)) {
-                values[key] = value.map((v) => resolveOne(v, item, assets)).filter((v) => v !== undefined);
+                values[key] = value.map((v) => resolveOne(v, item, assets, cuts, defaults)).filter((v) => v !== undefined);
             }
             else if (item.type === "object") {
                 for (const v of value)
                     if (v && typeof v === "object")
-                        applyAssets(v, item.fields, assets, elements);
+                        applyAssets(v, item.fields, assets, elements, cuts, defaults);
             }
             else if (item.type === "richtext") {
                 // Resolves in place inside the document object `v`; the wrapper is throwaway.
                 for (const v of value)
-                    applyAssets({ v }, { v: item }, assets, elements);
+                    applyAssets({ v }, { v: item }, assets, elements, cuts, defaults);
             }
         }
     }
 }
+/** Signs each distinct rectangle once and fills every request for it: two fields framing one photo the same way share a
+ *  signature, an address and a cache entry. */
+export async function signCuts(requests, signer) {
+    const signed = new Map();
+    await Promise.all(requests.map(async (r) => {
+        const key = `${r.path}:${r.rect.left}.${r.rect.top}.${r.rect.width}.${r.rect.height}`;
+        let cut = signed.get(key);
+        if (!cut)
+            signed.set(key, (cut = signer(r.path, r.rect)));
+        r.set(await cut);
+    }));
+}

package/dist/member-store.d.ts

@@ -31,31 +31,12 @@ export interface MemberStore {
     setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
     /** Deletes the member row only; the Auth account stays. */
     remove(userId: string): Promise<void>;
+    /** The whole list at once, as the management API sets it (spec 2026-10-16 the control plane §3). */
+    replaceAll(members: MemberRecord[]): Promise<void>;
 }
 export declare const memberErrors: {
     notFound: (userId: string) => Error;
-    noAccount: (email: string) => Error;
+    managed: () => Error;
 };
 /** Email first (case-insensitive), rows without one last, ties by user id. */
 export declare function sortMembers(rows: MemberRecord[]): MemberRecord[];
-export declare class MemoryMemberStore implements MemberStore {
-    private rows;
-    private url;
-    /** Auth accounts that exist without a member row: email → user id. */
-    private accounts;
-    /** Emails an invite was "sent" to, in order — what a test asserts. */
-    readonly sent: string[];
-    constructor(rows?: MemberRecord[], url?: string | null, 
-    /** Auth accounts that exist without a member row: email → user id. */
-    accounts?: Record<string, string>);
-    list(): Promise<MemberRecord[]>;
-    consoleUrl(): Promise<string | null>;
-    invite(input: InviteInput): Promise<InviteResult>;
-    createAccount(input: {
-        email: string;
-        password: string;
-        role: MemberRole;
-    }): Promise<MemberRecord>;
-    setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
-    remove(userId: string): Promise<void>;
-}

package/dist/member-store.js

@@ -1,6 +1,6 @@
 export const memberErrors = {
     notFound: (userId) => new Error(`smoodly: no member "${userId}".`),
-    noAccount: (email) => new Error(`smoodly: no Auth account for "${email}" although the invite said it exists.`),
+    managed: () => new Error("smoodly: members are managed at smoodly.io."),
 };
 /** Email first (case-insensitive), rows without one last, ties by user id. */
 export function sortMembers(rows) {
@@ -14,55 +14,3 @@ export function sortMembers(rows) {
         return a.email.localeCompare(b.email, undefined, { sensitivity: "base" }) || a.userId.localeCompare(b.userId);
     });
 }
-export class MemoryMemberStore {
-    constructor(rows = [], url = null, 
-    /** Auth accounts that exist without a member row: email → user id. */
-    accounts = {}) {
-        this.rows = rows;
-        this.url = url;
-        this.accounts = accounts;
-        /** Emails an invite was "sent" to, in order — what a test asserts. */
-        this.sent = [];
-    }
-    async list() {
-        return sortMembers(this.rows);
-    }
-    async consoleUrl() {
-        return this.url;
-    }
-    async invite(input) {
-        const key = input.email.toLowerCase();
-        let userId = this.accounts[key] ?? this.rows.find((r) => r.email?.toLowerCase() === key)?.userId;
-        let invited = false;
-        if (!userId) {
-            userId = crypto.randomUUID();
-            this.accounts[key] = userId;
-            this.sent.push(input.email);
-            invited = true;
-        }
-        const member = { userId, email: input.email, role: input.role };
-        this.rows = [...this.rows.filter((r) => r.userId !== userId), member];
-        return { member, invited };
-    }
-    async createAccount(input) {
-        const key = input.email.toLowerCase();
-        const userId = this.accounts[key] ?? this.rows.find((r) => r.email?.toLowerCase() === key)?.userId ?? crypto.randomUUID();
-        this.accounts[key] = userId;
-        const member = { userId, email: input.email, role: input.role };
-        this.rows = [...this.rows.filter((r) => r.userId !== userId), member];
-        return member;
-    }
-    async setRole(userId, role) {
-        const row = this.rows.find((r) => r.userId === userId);
-        if (!row)
-            throw memberErrors.notFound(userId);
-        const next = { ...row, role };
-        this.rows = this.rows.map((r) => (r.userId === userId ? next : r));
-        return next;
-    }
-    async remove(userId) {
-        if (!this.rows.some((r) => r.userId === userId))
-            throw memberErrors.notFound(userId);
-        this.rows = this.rows.filter((r) => r.userId !== userId);
-    }
-}

package/dist/next/admin-route.d.ts

@@ -1,5 +1,5 @@
 import { type AdminHandlerDeps } from "../admin/handler.ts";
-export type AdminRouteDeps = Omit<AdminHandlerDeps, "effects">;
+export type AdminRouteDeps = Omit<AdminHandlerDeps, "effects" | "canvasMarks">;
 /** `deps` is read per request: the app's glue reads the environment there, so `next build` needs no keys. */
 export declare function createAdminRoute(deps: () => AdminRouteDeps): {
     GET: (request: Request) => Promise<Response>;

package/dist/next/admin-route.js

@@ -1,7 +1,8 @@
 // packages/smoodly/src/next/admin-route.ts
 // The admin in a Next app (spec 2026-10-02 astro cloud fit §4): one route handler file exports GET and
-// POST from here, and that is the whole mount — the page, the package's files and the operations
-// endpoint (admin/handler.ts). This file adds only what is Next's: the cache and draft mode.
+// POST from here, and that is the whole mount — the page, the package's files, the revalidate route the
+// service calls and the preview route (admin/handler.ts). This file adds only what is Next's: the cache
+// and draft mode.
 import { revalidateTag } from "next/cache";
 import { draftMode } from "next/headers";
 import { connection } from "next/server";
@@ -17,7 +18,8 @@ const effects = {
 };
 /** `deps` is read per request: the app's glue reads the environment there, so `next build` needs no keys. */
 export function createAdminRoute(deps) {
-    const handle = createAdminHandler(() => ({ ...deps(), effects }));
+    // The canvas marks the path: Vercel keeps only a prerendered route's own params in the query, draft mode included.
+    const handle = createAdminHandler(() => ({ ...deps(), effects, canvasMarks: "path" }));
     // A request first: the handler catches every error to answer with a named one, and Next's own
     // "this route is dynamic" signal must not be among them.
     const route = async (request) => {

package/dist/next/meta.js

@@ -1,4 +1,3 @@
-import { imageUrl } from "../image/loaders.js";
 import { pageSeo } from "../seo.js";
 /** Maps the effective SEO values onto Next metadata (spec 2026-09-10 page
  * fields §4, 2026-09-29 content API contract §7). Absent values leave the
@@ -16,8 +15,8 @@ export function metadataFromSeo(seo) {
     if (description)
         og.description = description;
     if (image) {
-        // The delivery seam decides the URL; the cloud's transform loader (OQ 28) can serve a real 1200-wide render.
-        og.images = [{ url: imageUrl(image, { width: 1200 }), width: image.width, height: image.height, ...(image.alt ? { alt: image.alt } : {}) }];
+        // The original, not a cut: a scraper asks no AVIF and some read neither AVIF nor WebP (spec 2026-10-18 media §7).
+        og.images = [{ url: image.url, width: image.width, height: image.height, ...(image.alt ? { alt: image.alt } : {}) }];
     }
     if (Object.keys(og).length > 0)
         out.openGraph = og;