@vmz/vmz 0.1.12 → 0.1.13

package/dist/dev-watch-roots.js

@@ -1,245 +0,0 @@
-// @ts-nocheck
-/**
- * Dev watch helpers: coalesce multi-file bursts without dropping dirty set,
- * and derive extra watch roots from the compile graph (deployment unit sources).
- */
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
-import path from 'node:path';
-import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
-/**
- * @typedef {{ changed: string[], deleted: string[] }} DirtySet
- */
-/**
- * Merge dirty sets: later change cancels delete and vice versa.
- * @param {DirtySet} a
- * @param {DirtySet} b
- * @returns {DirtySet}
- */
-export function mergeDirtySets(a, b) {
-    const changed = new Set(a?.changed || []);
-    const deleted = new Set(a?.deleted || []);
-    for (const f of b?.changed || []) {
-        changed.add(f);
-        deleted.delete(f);
-    }
-    for (const f of b?.deleted || []) {
-        deleted.add(f);
-        changed.delete(f);
-    }
-    return { changed: [...changed], deleted: [...deleted] };
-}
-/**
- * Wait until `root` stops changing; return the **accumulated** dirty set since `initial`.
- * Updates `fingerprints` for `root` as it polls. Does **not** discard `initial`.
- *
- * @param {string} root
- * @param {Map<string, Map<string, string>>} fingerprints
- * @param {DirtySet} initial
- * @param {{ sleep?: (ms: number) => Promise<void>, maxRounds?: number, settleMs?: number }} [opts]
- * @returns {Promise<DirtySet>}
- */
-export async function coalesceRootBurst(root, fingerprints, initial, opts = {}) {
-    const sleepFn = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
-    const maxRounds = opts.maxRounds ?? 20;
-    const settleMs = opts.settleMs ?? 220;
-    let accumulated = {
-        changed: [...(initial?.changed || [])],
-        deleted: [...(initial?.deleted || [])],
-    };
-    let guard = 0;
-    while (guard++ < maxRounds) {
-        await sleepFn(settleMs);
-        const prev = fingerprints.get(root) || new Map();
-        const next = fileFingerprintMap(root);
-        const diff = diffFingerprints(prev, next);
-        fingerprints.set(root, next);
-        if (!diff.changed.length && !diff.deleted.length)
-            break;
-        accumulated = mergeDirtySets(accumulated, diff);
-    }
-    return accumulated;
-}
-/**
- * Walk up from a file to find a package.json directory.
- * @param {string} file
- * @returns {string | null}
- */
-export function findPackageRoot(file) {
-    let dir = path.dirname(path.resolve(file));
-    for (let i = 0; i < 24; i++) {
-        if (existsSync(path.join(dir, 'package.json')))
-            return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-}
-/**
- * Prefer package/src when present; otherwise the directory containing the source file.
- * @param {string} sourceFile
- * @returns {string | null}
- */
-export function watchRootForSourceFile(sourceFile) {
-    const abs = path.resolve(sourceFile);
-    if (!existsSync(abs))
-        return null;
-    const pkg = findPackageRoot(abs);
-    if (pkg) {
-        const src = path.join(pkg, 'src');
-        if (existsSync(src))
-            return src;
-        return pkg;
-    }
-    return path.dirname(abs);
-}
-/**
- * Absolute roots for workspace / file / link deps that have a src tree.
- * @param {string} project
- * @returns {string[]}
- */
-export function localLinkDependencyRoots(project) {
-    const pkgPath = path.join(path.resolve(project), 'package.json');
-    if (!existsSync(pkgPath))
-        return [];
-    /** @type {string[]} */
-    const roots = [];
-    try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-        for (const [name, spec] of Object.entries(deps)) {
-            if (typeof spec !== 'string')
-                continue;
-            let target = null;
-            if (spec.startsWith('workspace:')) {
-                // Resolve via node_modules (pnpm links workspace packages there).
-                const nm = path.join(path.resolve(project), 'node_modules', ...name.split('/'));
-                if (existsSync(path.join(nm, 'package.json')))
-                    target = nm;
-            }
-            else if (spec.startsWith('file:') || spec.startsWith('link:')) {
-                const rel = spec.replace(/^(file|link):/, '');
-                target = path.resolve(project, rel);
-            }
-            if (!target)
-                continue;
-            try {
-                target = realpathSync(target);
-            }
-            catch {
-                /* keep as-is */
-            }
-            const src = path.join(target, 'src');
-            if (existsSync(src))
-                roots.push(src);
-            else if (existsSync(target))
-                roots.push(target);
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    return roots;
-}
-/**
- * Collect watch roots: project src/locales/documents + compile-graph external sources
- * + local link/workspace package roots. Never adds a bare registry node_modules tree.
- *
- * @param {{ project: string, outDir: string }} opts
- * @returns {{ roots: string[], dependencyRoots: string[], applicationRoots: string[] }}
- */
-export function collectDevWatchRoots(opts) {
-    const project = path.resolve(opts.project);
-    const outDir = path.resolve(opts.outDir);
-    const src = path.join(project, 'src');
-    const docsRoot = path.join(project, 'documents');
-    const localesRoot = path.join(project, 'locales');
-    const designsRoot = path.join(project, 'designs');
-    /** @type {string[]} */
-    const applicationRoots = [];
-    if (existsSync(src))
-        applicationRoots.push(src);
-    if (existsSync(docsRoot))
-        applicationRoots.push(docsRoot);
-    if (existsSync(localesRoot))
-        applicationRoots.push(localesRoot);
-    if (existsSync(designsRoot))
-        applicationRoots.push(designsRoot);
-    /** @type {Set<string>} */
-    const depSet = new Set();
-    const depJson = path.join(outDir, 'vmz-deployment.json');
-    if (existsSync(depJson)) {
-        try {
-            const dep = JSON.parse(readFileSync(depJson, 'utf8'));
-            for (const unit of dep.units || []) {
-                const source = unit?.source;
-                if (typeof source !== 'string' || !source)
-                    continue;
-                let abs = path.resolve(source);
-                try {
-                    abs = realpathSync(abs);
-                }
-                catch {
-                    /* keep */
-                }
-                const underProject = abs === project || abs.startsWith(project + path.sep) || abs.startsWith(project + '/');
-                if (underProject)
-                    continue;
-                const root = watchRootForSourceFile(abs);
-                if (root)
-                    depSet.add(path.resolve(root));
-            }
-        }
-        catch {
-            /* ignore corrupt deployment */
-        }
-    }
-    for (const r of localLinkDependencyRoots(project)) {
-        depSet.add(path.resolve(r));
-    }
-    // Drop dependency roots that are already under an application root.
-    const dependencyRoots = [...depSet].filter((r) => {
-        return !applicationRoots.some((app) => r === app || r.startsWith(app + path.sep) || r.startsWith(app + '/'));
-    });
-    const roots = [...applicationRoots];
-    for (const r of dependencyRoots) {
-        if (!roots.includes(r))
-            roots.push(r);
-    }
-    return { roots, dependencyRoots, applicationRoots };
-}
-/**
- * Classify which watch bucket a root belongs to.
- * @param {string} root
- * @param {{
- *   src: string,
- *   docsRoot: string,
- *   localesRoot: string,
- *   designsRoot: string,
- *   dependencyRoots: string[],
- * }} ctx
- * @returns {'src' | 'locales' | 'docs' | 'designs' | 'dep' | 'other'}
- */
-export function classifyWatchRoot(root, ctx) {
-    if (root === ctx.src)
-        return 'src';
-    if (root === ctx.localesRoot)
-        return 'locales';
-    if (root === ctx.docsRoot)
-        return 'docs';
-    if (root === ctx.designsRoot)
-        return 'designs';
-    if ((ctx.dependencyRoots || []).includes(root))
-        return 'dep';
-    return 'other';
-}
-/**
- * Classify whether a changed file lives under a dependency watch root (not app src).
- * @param {string} file
- * @param {string[]} dependencyRoots
- */
-export function isDependencyPath(file, dependencyRoots) {
-    const abs = path.resolve(file);
-    return (dependencyRoots || []).some((r) => abs === r || abs.startsWith(r + path.sep) || abs.startsWith(r + '/'));
-}

package/dist/document-layout-render.d.ts

@@ -1,20 +0,0 @@
-/**
- * Integrated DocumentMount — compile host chrome via DocumentLayout + createRenderHost.
- * Replaces the removed regex template lowering in document-host-chrome.ts.
- */
-/** @param {string} distDir */
-export declare function resolveDocumentLayoutChunkId(distDir: any): string;
-/**
- * @param {string} distDir
- */
-export declare function assertIntegratedDistReady(distDir: any): string;
-/**
- * @param {string} html
- */
-export declare function assertCompiledShellHtml(html: any): void;
-/**
- * @param {string} distDir
- * @param {string} localeId
- * @param {string} slotHtml
- */
-export declare function renderCompiledDocumentLayout(distDir: any, localeId: any, slotHtml: any): Promise<any>;

package/dist/document-layout-render.js

@@ -1,87 +0,0 @@
-// @ts-nocheck
-/**
- * Integrated DocumentMount — compile host chrome via DocumentLayout + createRenderHost.
- * Replaces the removed regex template lowering in document-host-chrome.ts.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { createRenderHost } from '@vmz/core/render-host';
-/** @param {string} distDir */
-export function resolveDocumentLayoutChunkId(distDir) {
-    for (const chunkId of ['layouts/DocumentLayout', 'components/DocumentLayout']) {
-        if (fs.existsSync(path.join(distDir, `${chunkId}.client.js`)))
-            return chunkId;
-    }
-    return null;
-}
-/**
- * @param {string} distDir
- */
-export function assertIntegratedDistReady(distDir) {
-    const dom = path.join(distDir, 'vmz-dom.js');
-    if (!fs.existsSync(dom)) {
-        throw new Error('integrated document mount requires vmz build output (vmz-dom.js in app dist). Run `vmz build` before document emit.');
-    }
-    const chunkId = resolveDocumentLayoutChunkId(distDir);
-    if (!chunkId) {
-        throw new Error('integrated document mount requires compiled DocumentLayout (add src/layouts/DocumentLayout.vmz and rebuild)');
-    }
-    return chunkId;
-}
-/**
- * @param {string} html
- */
-export function assertCompiledShellHtml(html) {
-    const header = html.match(/<header[^>]*data-vmz-fixture="site-header"[\s\S]*?<\/header>/i)?.[0] ?? '';
-    const footer = html.match(/<footer[^>]*data-vmz-fixture="site-footer"[\s\S]*?<\/footer>/i)?.[0] ?? '';
-    for (const part of [header, footer]) {
-        const leak = part.match(/\{[A-Za-z][A-Za-z0-9]*\}/);
-        if (leak) {
-            throw new Error(`document layout SSR leaked binding placeholder ${leak[0]}`);
-        }
-        if (/<(?:Link|Button|Icon)\b/.test(part)) {
-            throw new Error('document layout SSR leaked uncompiled VMZ component tag in chrome');
-        }
-    }
-    if (!header || !footer) {
-        throw new Error('document layout SSR missing compiled SiteHeader/SiteFooter fixtures');
-    }
-}
-/**
- * @param {string} distDir
- * @param {string} chunkId
- */
-async function loadCtor(distDir, chunkId) {
-    const href = pathToFileURL(path.join(distDir, `${chunkId}.client.js`)).href;
-    const mod = await import(`${href}?t=${Date.now()}`);
-    return mod.default;
-}
-/**
- * @param {string} distDir
- * @param {string} localeId
- * @param {string} slotHtml
- */
-export async function renderCompiledDocumentLayout(distDir, localeId, slotHtml) {
-    const chunkId = assertIntegratedDistReady(distDir);
-    const prevHint = globalThis.__vmzLocaleIdHint;
-    globalThis.__vmzLocaleIdHint = localeId;
-    try {
-        if (typeof globalThis.document !== 'undefined' && globalThis.document?.documentElement) {
-            globalThis.document.documentElement.setAttribute('data-locale', localeId);
-            globalThis.document.documentElement.setAttribute('lang', localeId);
-        }
-        const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
-        await host.ensureComponents([chunkId]);
-        const Layout = await loadCtor(distDir, chunkId);
-        const html = await host.renderToString(Layout, {}, { slotHtml });
-        assertCompiledShellHtml(html);
-        return html;
-    }
-    finally {
-        if (prevHint === undefined)
-            delete globalThis.__vmzLocaleIdHint;
-        else
-            globalThis.__vmzLocaleIdHint = prevHint;
-    }
-}

package/dist/document-routing-config.d.ts

@@ -1,13 +0,0 @@
-/**
- * Project locale routing config for document mount (locales/locales.json5).
- */
-/**
- * @param {string} projectRoot
- * @returns {{ strategy?: string, defaultLocale?: string } | null}
- */
-export declare function loadLocalesRouting(projectRoot: any): any;
-/**
- * @param {string} routeBase
- * @param {string} pageKey
- */
-export declare function docsRouteNone(routeBase: any, pageKey: any): string;

package/dist/document-routing-config.js

@@ -1,40 +0,0 @@
-// @ts-nocheck
-/**
- * Project locale routing config for document mount (locales/locales.json5).
- */
-import fs from 'node:fs';
-import path from 'node:path';
-/**
- * @param {string} projectRoot
- * @returns {{ strategy?: string, defaultLocale?: string } | null}
- */
-export function loadLocalesRouting(projectRoot) {
-    const p = path.join(projectRoot, 'locales', 'locales.json5');
-    if (!fs.existsSync(p))
-        return null;
-    try {
-        const raw = fs.readFileSync(p, 'utf8');
-        let s = raw.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
-        const m = s.match(/routing\s*:\s*\{([\s\S]*?)\}/);
-        if (!m)
-            return null;
-        let block = `{${m[1]}}`;
-        block = block.replace(/([,{]\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g, '$1"$2":');
-        block = block.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, (_, inner) => JSON.stringify(inner));
-        block = block.replace(/,\s*([}\]])/g, '$1');
-        return JSON.parse(block);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * @param {string} routeBase
- * @param {string} pageKey
- */
-export function docsRouteNone(routeBase, pageKey) {
-    const base = String(routeBase || '/').replace(/\/$/, '') || '';
-    const key = pageKey === 'index' ? '' : pageKey.replace(/\\/g, '/');
-    const parts = [base.replace(/^\//, ''), key].filter((p) => p !== '');
-    return '/' + (parts.length ? parts.join('/') : '');
-}

package/dist/native-addon.d.ts

@@ -1,9 +0,0 @@
-/**
- * Load the N-API addon or throw (production printers must not fall back to TS).
- * @returns {any}
- */
-export declare function requireNativeAddon(): any;
-/**
- * @returns {any | null}
- */
-export declare function tryLoadNativeAddon(): any;

package/dist/native-addon.js

@@ -1,84 +0,0 @@
-// @ts-nocheck
-/**
- * Load the N-API `.node` addon without importing `index.js`
- * (avoids cycles with modules re-exported from the package entry).
- */
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const require = createRequire(import.meta.url);
-/** @type {any} */
-let cached;
-/**
- * Load the N-API addon or throw (production printers must not fall back to TS).
- * @returns {any}
- */
-export function requireNativeAddon() {
-    const native = tryLoadNativeAddon();
-    if (!native) {
-        throw new Error('vmz native addon missing — run `pnpm napi:build` (CodeGenerators live in vmz-generator via N-API)');
-    }
-    return native;
-}
-/**
- * @returns {any | null}
- */
-export function tryLoadNativeAddon() {
-    if (cached !== undefined)
-        return cached;
-    try {
-        const envPath = (typeof process.env.VMZ_NATIVE_NODE === 'string' && process.env.VMZ_NATIVE_NODE.trim()) || '';
-        if (envPath) {
-            cached = require(path.resolve(envPath));
-            return cached;
-        }
-        const { platform, arch } = process;
-        let triple = `${platform}-${arch}`;
-        if (platform === 'win32' && arch === 'x64')
-            triple = 'win32-x64-msvc';
-        else if (platform === 'win32' && arch === 'arm64')
-            triple = 'win32-arm64-msvc';
-        else if (platform === 'darwin' && arch === 'arm64')
-            triple = 'darwin-arm64';
-        else if (platform === 'darwin' && arch === 'x64')
-            triple = 'darwin-x64';
-        else if (platform === 'linux' && arch === 'x64')
-            triple = 'linux-x64-gnu';
-        else if (platform === 'linux' && arch === 'arm64')
-            triple = 'linux-arm64-gnu';
-        const short = triple === 'win32-x64-msvc'
-            ? 'win32-x64'
-            : triple === 'win32-arm64-msvc'
-                ? 'win32-arm64'
-                : triple === 'linux-x64-gnu'
-                    ? 'linux-x64'
-                    : triple === 'linux-arm64-gnu'
-                        ? 'linux-arm64'
-                        : triple;
-        const pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
-        const name = `@vmz/vmz-${short}`;
-        /** @type {string[]} */
-        const candidates = [];
-        try {
-            const resolved = require.resolve(`${name}/package.json`);
-            const dir = path.dirname(resolved);
-            candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
-        }
-        catch {
-            /* optional */
-        }
-        candidates.push(path.join(pkgRoot, 'node_modules', name, `vmz.${triple}.node`), path.join(pkgRoot, 'node_modules', name, 'vmz.node'));
-        for (const p of candidates) {
-            if (fs.existsSync(p)) {
-                cached = require(p);
-                return cached;
-            }
-        }
-        cached = null;
-    }
-    catch {
-        cached = null;
-    }
-    return cached;
-}

package/dist/pretty-json.d.ts

@@ -1,19 +0,0 @@
-/**
- * Pretty-print a value through `vmz-generator` (N-API).
- * @param {unknown} value
- * @returns {string} Pretty JSON without trailing newline.
- */
-export declare function generatePrettyJson(value: any): any;
-/**
- * Write a pretty JSON artifact with a trailing newline.
- * @param {string} filePath
- * @param {unknown} value
- */
-export declare function writePrettyJsonFile(filePath: any, value: any): void;
-/**
- * CLI `--json` helper: write to a path when `target` is a string, else stdout.
- * @param {string | boolean | undefined} target
- * @param {unknown} value
- * @param {{ logWrote?: (path: string) => void }} [opts]
- */
-export declare function emitPrettyJson(target: any, value: any, opts?: {}): void;

package/dist/pretty-json.js

@@ -1,43 +0,0 @@
-// @ts-nocheck
-/**
- * Production JSON artifact printer — always via N-API JsonCodeGenerator.
- * Do not use `JSON.stringify(x, null, 2)` for on-disk artifacts.
- */
-import fs from 'node:fs';
-import { requireNativeAddon } from './native-addon.js';
-/**
- * Pretty-print a value through `vmz-generator` (N-API).
- * @param {unknown} value
- * @returns {string} Pretty JSON without trailing newline.
- */
-export function generatePrettyJson(value) {
-    const native = requireNativeAddon();
-    if (typeof native.generatePrettyJson !== 'function') {
-        throw new Error('vmz native addon missing generatePrettyJson — rebuild with `pnpm napi:build`');
-    }
-    return native.generatePrettyJson(JSON.stringify(value));
-}
-/**
- * Write a pretty JSON artifact with a trailing newline.
- * @param {string} filePath
- * @param {unknown} value
- */
-export function writePrettyJsonFile(filePath, value) {
-    fs.writeFileSync(filePath, `${generatePrettyJson(value)}\n`, 'utf8');
-}
-/**
- * CLI `--json` helper: write to a path when `target` is a string, else stdout.
- * @param {string | boolean | undefined} target
- * @param {unknown} value
- * @param {{ logWrote?: (path: string) => void }} [opts]
- */
-export function emitPrettyJson(target, value, opts = {}) {
-    const text = generatePrettyJson(value);
-    if (typeof target === 'string') {
-        fs.writeFileSync(target, `${text}\n`, 'utf8');
-        if (typeof opts.logWrote === 'function')
-            opts.logWrote(target);
-        return;
-    }
-    console.log(text);
-}

package/dist/route-path.d.ts

@@ -1,35 +0,0 @@
-/**
- * Browser HTTP path projection from Route Graph / `vmz-deployment.json`.
- * Mini pack ignores this and lowers RouteId → chunk id → page stem.
- */
-export declare function isRouteBoundaryStem(stem: string): boolean;
-export declare function isRouteGroupDir(seg: string): boolean;
-/**
- * File-route fallback (`pages/home` → `/home`, `pages/index` → `/`).
- * Used only when a deployment unit has no `pathPattern`.
- */
-export declare function filePathPatternFromChunk(chunkId: string): string;
-export type DeploymentPageUnit = {
-    kind?: string;
-    chunkId?: string;
-    clientEntry?: string;
-    programIr?: string;
-    pathPattern?: string;
-    routeId?: string;
-};
-/** Canonical Browser HTTP pattern for a page unit. Mini must not read this. */
-export declare function unitBrowserPathPattern(unit: DeploymentPageUnit | null | undefined): string;
-export type PathSeg = {
-    kind: 'static';
-    value: string;
-} | {
-    kind: 'param';
-    name: string;
-} | {
-    kind: 'catch';
-    name: string;
-};
-export declare function parsePathPattern(pattern: string): PathSeg[];
-export declare function listPublicPageUnits(deployment: {
-    units?: DeploymentPageUnit[];
-} | null | undefined): DeploymentPageUnit[];

package/dist/route-path.js

@@ -1,77 +0,0 @@
-/**
- * Browser HTTP path projection from Route Graph / `vmz-deployment.json`.
- * Mini pack ignores this and lowers RouteId → chunk id → page stem.
- */
-export function isRouteBoundaryStem(stem) {
-    return stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound';
-}
-export function isRouteGroupDir(seg) {
-    return typeof seg === 'string' && seg.startsWith('(') && seg.endsWith(')') && seg.length > 2;
-}
-/**
- * File-route fallback (`pages/home` → `/home`, `pages/index` → `/`).
- * Used only when a deployment unit has no `pathPattern`.
- */
-export function filePathPatternFromChunk(chunkId) {
-    const rel = String(chunkId || '').replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    const segs = [];
-    for (let i = 0; i < parts.length; i++) {
-        const p = parts[i];
-        if (isRouteGroupDir(p))
-            continue;
-        if (p === 'index' && i === parts.length - 1)
-            continue;
-        if (isRouteBoundaryStem(p))
-            continue;
-        segs.push(p);
-    }
-    return segs.length ? `/${segs.join('/')}` : '/';
-}
-/** Canonical Browser HTTP pattern for a page unit. Mini must not read this. */
-export function unitBrowserPathPattern(unit) {
-    const explicit = String(unit?.pathPattern || '').trim();
-    if (explicit)
-        return explicit.startsWith('/') ? explicit : `/${explicit}`;
-    return filePathPatternFromChunk(String(unit?.chunkId || ''));
-}
-export function parsePathPattern(pattern) {
-    const raw = String(pattern || '').trim();
-    if (!raw || raw === '/')
-        return [];
-    const parts = raw.replace(/^\/+/, '').replace(/\/+$/, '').split('/').filter(Boolean);
-    const segs = [];
-    for (const p of parts) {
-        if (isRouteGroupDir(p))
-            continue;
-        segs.push(parsePathSegment(p));
-    }
-    return segs;
-}
-function parsePathSegment(p) {
-    const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(p);
-    const star = /^\*([A-Za-z_][\w]*)$/.exec(p);
-    const param = /^\[([^\]]+)\]$/.exec(p);
-    const colon = /^:([A-Za-z_][\w]*)$/.exec(p);
-    if (catchAll)
-        return { kind: 'catch', name: catchAll[1] };
-    if (star)
-        return { kind: 'catch', name: star[1] };
-    if (param)
-        return { kind: 'param', name: param[1] };
-    if (colon)
-        return { kind: 'param', name: colon[1] };
-    return { kind: 'static', value: p.toLowerCase() };
-}
-export function listPublicPageUnits(deployment) {
-    const units = Array.isArray(deployment?.units) ? deployment.units : [];
-    return units.filter((u) => {
-        if (u?.kind !== 'page')
-            return false;
-        const chunkId = String(u.chunkId || '').replace(/\\/g, '/');
-        if (!chunkId.startsWith('pages/'))
-            return false;
-        const stem = chunkId.split('/').pop() || '';
-        return !isRouteBoundaryStem(stem);
-    });
-}