canopycms 0.0.68-int.102 → 0.0.68-int.104

package/README.md

@@ -637,7 +637,9 @@ media: { adapter: 's3', bucket: 'my-site-assets', region: 'us-east-1' }
 
   Passing an `image` field value applies its stored crop (`opts.crop` overrides it). Its `width`
   and `height` are the uncropped original's, so scale them by `crop.w` and `crop.h` for a cropped
-  value. SVGs and PDFs are served statically, with no transform.
+  value. SVGs and PDFs are served statically, with no transform. The package declares
+  `sideEffects`, so this import adds under 7 KB minified to a client bundle and none of the
+  config schemas.
 
 - **Where `/assets` is mounted** — the URLs above are root-relative, because that is what gets
   stored in content and content moves between branches and environments. If your renderer sees

package/dist/assets/asset-url.d.ts

@@ -41,6 +41,12 @@ export interface AssetUrlOptions {
      */
     baseUrl?: string;
 }
+/**
+ * Whether `src` is in canopycms's own `/assets` URL space - a transform or static asset src the
+ * asset store serves. Every other src (a site's own static file, an off-site URL, a `data:` URI)
+ * is the host's, and the asset store never serves it.
+ */
+export declare function isAssetStoreSrc(src: string): boolean;
 /**
  * Build a transform URL, merging `opts` and `ref.crop` over the directives already present
  * in `ref.src` (see `mergeDirectives` for precedence). For static srcs (svg/pdf under

package/dist/assets/asset-url.js

@@ -9,6 +9,15 @@ import { getPreviewAssetBase } from '../editor/preview-asset-base.js';
 import { ASSET_PREFIXES } from './asset-prefixes.js';
 import { formatDirectives, isAllowedTransformWidth, parseTransformPath, } from './transform-directives.js';
 const TRANSFORM_URL_PREFIX = `/${ASSET_PREFIXES.transform}/`;
+const ASSET_SPACE_PREFIX = `/${ASSET_PREFIXES.public}/`;
+/**
+ * Whether `src` is in canopycms's own `/assets` URL space - a transform or static asset src the
+ * asset store serves. Every other src (a site's own static file, an off-site URL, a `data:` URI)
+ * is the host's, and the asset store never serves it.
+ */
+export function isAssetStoreSrc(src) {
+    return src.startsWith(ASSET_SPACE_PREFIX);
+}
 /**
  * Test-only. A function stored on `globalThis` under this symbol is called with every URL
  * `assetUrl` returns; the dual-build fixture installs one during a static export to prove

package/dist/build/asset-refs.d.ts

@@ -63,9 +63,10 @@ declare const assetRefsFileSchema: z.ZodObject<{
     }[];
 }>;
 export type AssetRefsFile = z.infer<typeof assetRefsFileSchema>;
-/** A URL in the output that no stored object can answer. */
+/** A URL in the output that no stored object can answer, or an inline flight script that cannot be read. */
 export interface AssetRefProblem {
     file: string;
+    /** The URL, or the script's position when the problem is a script. */
     url: string;
     error: string;
 }

package/dist/build/asset-refs.js

@@ -12,6 +12,7 @@ import { z } from 'zod';
 import { ASSET_PREFIXES } from '../assets/asset-prefixes.js';
 import { canonicalizeTransformPath } from '../assets/transform-directives.js';
 import { atomicWriteFile } from '../utils/atomic-write.js';
+import { extractInlineFlight } from './inline-flight.js';
 /** @internal Written into the scanned directory, so a manifest the adopter builds afterwards covers it. */
 export const ASSET_REFS_FILENAME = 'canopy-asset-refs.json';
 /**
@@ -84,11 +85,12 @@ async function listScannedFiles(root) {
         .filter((rel) => rel !== ASSET_REFS_FILENAME)
         .sort();
 }
+const HTML_FILE_RE = /\.html?$/;
 /** The route a static-export HTML file serves (`about/index.html` and `about.html` are `/about`). */
 function routeForFile(file) {
-    if (!/\.html?$/.test(file))
+    if (!HTML_FILE_RE.test(file))
         return undefined;
-    const withoutExt = file.replace(/\.html?$/, '');
+    const withoutExt = file.replace(HTML_FILE_RE, '');
     const route = withoutExt === 'index' ? '' : withoutExt.replace(/\/index$/, '');
     return `/${route}`;
 }
@@ -191,13 +193,8 @@ export async function collectAssetRefs(outDir) {
     const transforms = new RefCollector();
     const statics = new RefCollector();
     const problems = [];
-    let scannedFiles = 0;
-    for (const file of files) {
-        const filePath = path.join(root, file);
-        if (path.extname(file) === '' && (await startsBinary(filePath)))
-            continue;
-        scannedFiles++;
-        const text = decodeUrlEscapes(await fs.readFile(filePath, 'utf-8'));
+    const scan = (file, raw) => {
+        const text = decodeUrlEscapes(raw);
         for (const match of text.matchAll(TRANSFORM_URL_RE)) {
             const [url, filename] = trimTrailingPunctuation(match[0], match[3]);
             const [, encodedDirectives, hash32] = match;
@@ -228,6 +225,25 @@ export async function collectAssetRefs(outDir) {
                 statics.add(`${ASSET_PREFIXES.public}/${hash32}/${filename}`, file);
             }
         }
+    };
+    let scannedFiles = 0;
+    for (const file of files) {
+        const filePath = path.join(root, file);
+        if (path.extname(file) === '' && (await startsBinary(filePath)))
+            continue;
+        scannedFiles++;
+        const text = await fs.readFile(filePath, 'utf-8');
+        if (!HTML_FILE_RE.test(file)) {
+            scan(file, text);
+            continue;
+        }
+        // A page's inline RSC payload is split across scripts at arbitrary bytes (inline-flight.ts).
+        const page = extractInlineFlight(text);
+        scan(file, page.markup);
+        for (const flight of page.texts)
+            scan(file, flight);
+        for (const { script, error } of page.problems)
+            problems.push({ file, url: script, error });
     }
     if (problems.length > 0)
         throw new AssetRefsError(problems);

package/dist/build/inline-flight.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reassemble the RSC (flight) stream Next's App Router inlines into a page, so a URL the stream
+ * splits across two scripts is scanned whole.
+ *
+ * Next writes each chunk of the stream as its own `<script>`, and React Flight cuts chunks at
+ * arbitrary bytes (it fills fixed-size views and enqueues the partial one at every flush), so a URL
+ * can straddle two scripts and the page text holds only its fragments. The format is the same in Next 15.5.21 and 16.1.7
+ * (`createInlinedDataReadableStream` in `dist/server/app-render/use-flight-response.js`, read back
+ * by `nextServerDataCallback` in `dist/client/app-index.js`):
+ *
+ * - `(self.__next_f=self.__next_f||[]).push([0])` starts the stream, followed in the same script by
+ *   `;self.__next_f.push([2,formState])` when there is form state;
+ * - each chunk is then `self.__next_f.push([1,text])`, or `[3,base64]` for a chunk that is not
+ *   valid UTF-8, whose bytes join the same stream;
+ * - every argument is `JSON.stringify` output passed through `htmlEscapeJsonString`, which only
+ *   rewrites `& < > U+2028 U+2029` as `\uXXXX` escapes, so it parses as JSON and never holds
+ *   `</script`.
+ *
+ * Every push on a page joins one stream: Next inlines one flight stream per page.
+ */
+export interface InlineFlight {
+    /** The page with each parsed flight script replaced by a space, so no fragment is scanned. */
+    markup: string;
+    /** The stream's text, joined in document order, then each form state as JSON. */
+    texts: string[];
+    /** Scripts that name `__next_f` but are not flight pushes; their data cannot be scanned. */
+    problems: {
+        script: string;
+        error: string;
+    }[];
+}
+/**
+ * Split `html` into its markup and its inline flight stream. Only a script whose body names
+ * `__next_f` is flight; one that does but does not parse stays in the markup and is reported,
+ * because skipping it could drop a reference.
+ */
+export declare function extractInlineFlight(html: string): InlineFlight;

package/dist/build/inline-flight.js

@@ -0,0 +1,142 @@
+/**
+ * Reassemble the RSC (flight) stream Next's App Router inlines into a page, so a URL the stream
+ * splits across two scripts is scanned whole.
+ *
+ * Next writes each chunk of the stream as its own `<script>`, and React Flight cuts chunks at
+ * arbitrary bytes (it fills fixed-size views and enqueues the partial one at every flush), so a URL
+ * can straddle two scripts and the page text holds only its fragments. The format is the same in Next 15.5.21 and 16.1.7
+ * (`createInlinedDataReadableStream` in `dist/server/app-render/use-flight-response.js`, read back
+ * by `nextServerDataCallback` in `dist/client/app-index.js`):
+ *
+ * - `(self.__next_f=self.__next_f||[]).push([0])` starts the stream, followed in the same script by
+ *   `;self.__next_f.push([2,formState])` when there is form state;
+ * - each chunk is then `self.__next_f.push([1,text])`, or `[3,base64]` for a chunk that is not
+ *   valid UTF-8, whose bytes join the same stream;
+ * - every argument is `JSON.stringify` output passed through `htmlEscapeJsonString`, which only
+ *   rewrites `& < > U+2028 U+2029` as `\uXXXX` escapes, so it parses as JSON and never holds
+ *   `</script`.
+ *
+ * Every push on a page joins one stream: Next inlines one flight stream per page.
+ */
+import { getErrorMessage } from '../utils/error.js';
+const PUSH_CALL_RE = /(?:\(self\.__next_f=self\.__next_f\|\|\[\]\)|self\.__next_f)\.push\(/y;
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/** The index just past the JSON array that opens at `start`; `JSON.parse` checks the rest. */
+function jsonArrayEnd(body, start) {
+    if (body[start] !== '[')
+        throw new Error(`expected a JSON array at ${start}`);
+    let depth = 0;
+    let inString = false;
+    for (let i = start; i < body.length; i++) {
+        const c = body[i];
+        if (inString) {
+            if (c === '\\')
+                i++;
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"') {
+            inString = true;
+        }
+        else if (c === '[' || c === '{') {
+            depth++;
+        }
+        else if (c === ']' || c === '}') {
+            depth--;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    throw new Error('unterminated JSON array');
+}
+/** The arguments of a script body that is nothing but `;`-joined `self.__next_f.push(...)` calls. */
+function parsePushArguments(body) {
+    const args = [];
+    let pos = 0;
+    for (;;) {
+        PUSH_CALL_RE.lastIndex = pos;
+        if (!PUSH_CALL_RE.test(body))
+            throw new Error(`expected self.__next_f.push( at ${pos}`);
+        const end = jsonArrayEnd(body, PUSH_CALL_RE.lastIndex);
+        args.push(JSON.parse(body.slice(PUSH_CALL_RE.lastIndex, end)));
+        if (body[end] !== ')')
+            throw new Error(`expected ) at ${end}`);
+        pos = end + 1;
+        if (pos === body.length)
+            return args;
+        if (body[pos] !== ';')
+            throw new Error(`expected ; or the end of the script at ${pos}`);
+        pos++;
+    }
+}
+/** A push's contribution: bytes of the stream, form state as JSON, or nothing (the bootstrap). */
+function readSegment(arg) {
+    if (!Array.isArray(arg))
+        throw new Error('argument is not an array');
+    const [kind, payload] = arg;
+    if (kind === 0 && arg.length === 1)
+        return {};
+    if (kind === 1 && arg.length === 2 && typeof payload === 'string') {
+        return { bytes: Buffer.from(payload, 'utf8') };
+    }
+    if (kind === 2 && arg.length === 2)
+        return { formState: JSON.stringify(payload) };
+    if (kind === 3 && arg.length === 2 && typeof payload === 'string' && BASE64_RE.test(payload)) {
+        return { bytes: Buffer.from(payload, 'base64') };
+    }
+    throw new Error(`unknown segment ${JSON.stringify(arg).slice(0, 40)}`);
+}
+/** Each script element's span and body, in document order; one pass, however the page ends. */
+function* scriptElements(html) {
+    const openRe = /<script\b[^<>]*>/gi;
+    const closeRe = /<\/script\s*>/gi;
+    for (let open = openRe.exec(html); open; open = openRe.exec(html)) {
+        closeRe.lastIndex = openRe.lastIndex;
+        const close = closeRe.exec(html);
+        if (!close)
+            return;
+        yield {
+            start: open.index,
+            end: closeRe.lastIndex,
+            body: html.slice(openRe.lastIndex, close.index),
+        };
+        openRe.lastIndex = closeRe.lastIndex;
+    }
+}
+/**
+ * Split `html` into its markup and its inline flight stream. Only a script whose body names
+ * `__next_f` is flight; one that does but does not parse stays in the markup and is reported,
+ * because skipping it could drop a reference.
+ */
+export function extractInlineFlight(html) {
+    const stream = [];
+    const formStates = [];
+    const problems = [];
+    let markup = '';
+    let last = 0;
+    for (const { start, end, body } of scriptElements(html)) {
+        if (!body.includes('__next_f'))
+            continue;
+        let segments;
+        try {
+            segments = parsePushArguments(body).map(readSegment);
+        }
+        catch (err) {
+            problems.push({
+                script: `<script> at offset ${start}`,
+                error: `Not a Next inline flight script (${getErrorMessage(err)}); its RSC payload cannot be scanned`,
+            });
+            continue;
+        }
+        for (const { bytes, formState } of segments) {
+            if (bytes)
+                stream.push(bytes);
+            if (formState !== undefined)
+                formStates.push(formState);
+        }
+        markup += `${html.slice(last, start)} `;
+        last = end;
+    }
+    const texts = stream.length > 0 ? [Buffer.concat(stream).toString('utf8'), ...formStates] : formStates;
+    return { markup: markup + html.slice(last), texts, problems };
+}