@vmz/vmz 0.1.12 → 0.1.13

package/dist/server-artifact.js

@@ -4,10 +4,9 @@
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { SERVER_RUNTIMES } from './delivery-profile.js';
-import { writePrettyJsonFile } from './pretty-json.js';
 export const SERVER_ARTIFACT_SCHEMA = 'vmz.server.artifact.v0';
 export const HTTP_CONTRACT_SCHEMA = 'vmz.http.contract.v0';
 export const SERVER_RUNTIME_ADAPTER_SCHEMA = 'vmz.server.runtime_adapter.v0';
@@ -117,14 +116,14 @@ export function emitServerArtifact(outDir, opts = {}) {
     const vmzDir = path.join(outDir, '_vmz');
     mkdirSync(vmzDir, { recursive: true });
     const file = path.join(vmzDir, 'server-artifact.json');
-    writePrettyJsonFile(file, artifact);
+    writeFileSync(file, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
     const adapterDir = path.join(vmzDir, 'adapters');
     mkdirSync(adapterDir, { recursive: true });
     for (const adapterId of ['worker', 'rust-host']) {
         const projection = projectServerRuntimeAdapter(artifact, adapterId);
         const dir = path.join(adapterDir, adapterId);
         mkdirSync(dir, { recursive: true });
-        writePrettyJsonFile(path.join(dir, 'adapter.json'), projection);
+        writeFileSync(path.join(dir, 'adapter.json'), `${JSON.stringify(projection, null, 2)}\n`, 'utf8');
     }
     return { artifact, path: file, httpContractDigest };
 }

package/dist/site-delivery.js

@@ -6,7 +6,6 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { writePrettyJsonFile } from './pretty-json.js';
 export const SITE_DELIVERY_CONTRACT_SCHEMA = 'vmz.site.delivery_contract.v0';
 export const SITE_DELIVERY_RESOLUTION_SCHEMA = 'vmz.site.delivery_resolution.v0';
 /**
@@ -136,7 +135,7 @@ export function normalizeSiteDelivery(raw, opts = {}) {
         artifact: String(d.artifact),
         expectedCompatibility: d.expectedCompatibility || {
             runtime: 'vmz',
-            deliveryProfiles: ['static', 'filesystem'],
+            deliveryProfiles: ['web-static', 'filesystem'],
         },
         sources,
         resolutionPolicy: {
@@ -319,11 +318,11 @@ export function emitSiteDelivery(outDir, deliveryRaw, opts = {}) {
     }
     const vmzDir = path.join(outDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
-    writePrettyJsonFile(path.join(vmzDir, 'site-delivery-contract.json'), norm.contract);
+    fs.writeFileSync(path.join(vmzDir, 'site-delivery-contract.json'), `${JSON.stringify(norm.contract, null, 2)}\n`, 'utf8');
     let resolution = null;
     if (opts.probes) {
         resolution = resolveSiteRelease(norm.contract, opts.probes);
-        writePrettyJsonFile(path.join(vmzDir, 'site-delivery-resolution.json'), resolution);
+        fs.writeFileSync(path.join(vmzDir, 'site-delivery-resolution.json'), `${JSON.stringify(resolution, null, 2)}\n`, 'utf8');
     }
     return { contract: norm.contract, resolution };
 }

package/dist/static-emit.js

@@ -7,15 +7,9 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { createRenderHost } from '@vmz/core/render-host';
-import { resolveRouteLayoutChain } from '@vmz/core/route-layout-chain';
-import { listClientComponentsSync } from '@vmz/core/component-registry';
 import { emitCdnPolicy } from './cdn-policy.js';
 import { emitContentAddressedAssets } from './content-addressed-assets.js';
 import { absoluteUrl, buildLocalePageMeta, localizeBodyLinks } from './locale-router.js';
-import { requireNativeAddon } from './native-addon.js';
-import { writePrettyJsonFile } from './pretty-json.js';
-import { filePathPatternFromChunk, isRouteBoundaryStem, listPublicPageUnits, parsePathPattern, unitBrowserPathPattern } from './route-path.js';
 export const STATIC_DELIVERY_MANIFEST_SCHEMA = 'vmz.static.delivery_manifest.v0';
 /**
  * @param {string} distDir
@@ -32,8 +26,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     if (!fs.existsSync(domPath)) {
         throw new Error(`emitWebStatic: missing ${domPath} — run vmz build first`);
     }
-    const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
-    const { renderToString, renderToStream } = host;
+    const { renderToString, renderToStream } = await import(pathToFileURL(domPath).href);
     const pageCatalog = listPageClientFiles(distDir);
     /** @type {Array<{
      *   routeId: string,
@@ -50,7 +43,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     /** @type {Array<{ routeId: string, path: string, chunkId: string, classification: string, reason: string }>} */
     const skipped = [];
     for (const page of pageCatalog) {
-        const pattern = page.pathPattern || patternFromSegs(page.segs);
+        const pattern = patternFromSegs(page.segs);
         const routeId = guessRouteId(distDir, page.chunkId);
         if (page.segs.some((s) => s.kind === 'param' || s.kind === 'catch')) {
             skipped.push({
@@ -101,8 +94,7 @@ export async function emitWebStatic(distDir, opts = {}) {
             }
         }
         const meta = await resolvePageMeta(Page, { params, props, pathname: pattern, origin });
-        const layoutChain = resolveRouteLayoutChain(distDir, page.chunkId);
-        await host.ensureComponents([page.chunkId, ...layoutChain]);
+        const layoutChain = resolveLayoutChain(distDir, page.chunkId);
         let bodyHtml = '';
         for await (const chunk of renderToStream(Page, props, {})) {
             bodyHtml += chunk;
@@ -170,11 +162,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     fs.writeFileSync(path.join(distDir, '404.html'), notFoundHtml, 'utf8');
     const sitemap = buildSitemap(origin, generations);
     fs.writeFileSync(path.join(distDir, 'sitemap.xml'), sitemap, 'utf8');
-    const nativeRobots = requireNativeAddon();
-    if (typeof nativeRobots.generateRobotsTxt !== 'function') {
-        throw new Error('vmz native addon missing generateRobotsTxt — rebuild with `pnpm napi:build`');
-    }
-    const robots = nativeRobots.generateRobotsTxt(`${origin}/sitemap.xml`);
+    const robots = `User-agent: *\nAllow: /\nDisallow: /404\nSitemap: ${origin}/sitemap.xml\n`;
     fs.writeFileSync(path.join(distDir, 'robots.txt'), robots, 'utf8');
     // Hard rule: no SPA fallback shim in artifact.
     for (const bad of ['_redirects', 'vercel.json', 'netlify.toml']) {
@@ -191,7 +179,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     const manifest = {
         schema: STATIC_DELIVERY_MANIFEST_SCHEMA,
         applicationId,
-        deliveryProfile: 'static',
+        deliveryProfile: 'web-static',
         origin,
         generatedAt: new Date().toISOString(),
         spaFallback: false,
@@ -219,8 +207,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     };
     const digest = sha256Hex(canonicalJson(manifest));
     manifest.manifestDigest = digest;
-    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
-    emitStaticClientEntries(distDir, pageCatalog);
+    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
     const assets = emitContentAddressedAssets(distDir);
     manifest.contentAddressedAssets = {
         schema: assets.manifest.schema,
@@ -231,7 +218,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     // Re-stamp static manifest after linking asset digest (HTML already rewritten on disk).
     delete manifest.manifestDigest;
     manifest.manifestDigest = sha256Hex(canonicalJson(manifest));
-    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
+    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
     const cdn = emitCdnPolicy(distDir, manifest);
     return {
         manifest,
@@ -271,11 +258,8 @@ function sortKeys(value) {
  * @param {string} distDir
  */
 function listPageClientFiles(distDir) {
-    const fromDep = listPagesFromDeployment(distDir);
-    if (fromDep.length)
-        return fromDep;
     const root = path.join(distDir, 'pages');
-    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parsePathPattern>, pathPattern: string }>} */
+    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parseChunkSegments> }>} */
     const out = [];
     function walk(abs, relParts) {
         let ents;
@@ -290,11 +274,10 @@ function listPageClientFiles(distDir) {
                 walk(path.join(abs, e.name), [...relParts, e.name]);
             else if (e.isFile() && e.name.endsWith('.client.js')) {
                 const stem = e.name.replace(/\.client\.js$/, '');
-                if (isRouteBoundaryStem(stem))
+                if (stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound')
                     continue;
                 const chunkId = ['pages', ...relParts, stem].join('/');
-                const pathPattern = filePathPatternFromChunk(chunkId);
-                out.push({ chunkId, pathPattern, segs: parsePathPattern(pathPattern) });
+                out.push({ chunkId, segs: parseChunkSegments(chunkId) });
             }
         }
     }
@@ -302,26 +285,32 @@ function listPageClientFiles(distDir) {
     return out;
 }
 /**
- * @param {string} distDir
+ * @param {string} chunkId
  */
-function listPagesFromDeployment(distDir) {
-    const deploymentPath = path.join(distDir, 'vmz-deployment.json');
-    if (!fs.existsSync(deploymentPath))
-        return [];
-    try {
-        const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
-        return listPublicPageUnits(deployment).map((u) => {
-            const chunkId = String(u.chunkId || '').replace(/\\/g, '/');
-            const pathPattern = unitBrowserPathPattern(u);
-            return { chunkId, pathPattern, segs: parsePathPattern(pathPattern) };
-        });
-    }
-    catch {
-        return [];
+function parseChunkSegments(chunkId) {
+    const rel = chunkId.replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    /** @type {Array<{ kind: 'static' | 'param' | 'catch', value?: string, name?: string }>} */
+    const segs = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p.startsWith('(') && p.endsWith(')') && p.length > 2)
+            continue;
+        if (p === 'index' && i === parts.length - 1)
+            continue;
+        const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(p);
+        const param = /^\[([^\]]+)\]$/.exec(p);
+        if (catchAll)
+            segs.push({ kind: 'catch', name: catchAll[1] });
+        else if (param)
+            segs.push({ kind: 'param', name: param[1] });
+        else
+            segs.push({ kind: 'static', value: p.toLowerCase() });
     }
+    return segs;
 }
 /**
- * @param {ReturnType<typeof parsePathPattern>} segs
+ * @param {ReturnType<typeof parseChunkSegments>} segs
  */
 function patternFromSegs(segs) {
     if (!segs.length)
@@ -354,6 +343,24 @@ async function loadCtor(distDir, chunkId) {
     const mod = await import(`${href}?t=${Date.now()}`);
     return mod.default;
 }
+/**
+ * @param {string} distDir
+ * @param {string} pageChunkId
+ */
+function resolveLayoutChain(distDir, pageChunkId) {
+    const rel = pageChunkId.replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    parts.pop();
+    /** @type {string[]} */
+    const chain = [];
+    for (let i = parts.length; i >= 0; i--) {
+        const dirParts = parts.slice(0, i);
+        const layoutChunk = ['pages', ...dirParts, 'Layout'].join('/');
+        if (fs.existsSync(path.join(distDir, `${layoutChunk}.client.js`)))
+            chain.unshift(layoutChunk);
+    }
+    return chain;
+}
 /**
  * @param {string} distDir
  * @param {string} chunkId
@@ -382,8 +389,8 @@ async function resolvePageMeta(Page, ctx) {
     else if (Page.meta && typeof Page.meta === 'object') {
         raw = Page.meta;
     }
-    const title = String(raw.title || guessTitle(ctx.pathname) || 'App');
-    const description = String(raw.description || '');
+    const title = String(raw.title || `${guessTitle(ctx.pathname)} · VMZ`);
+    const description = String(raw.description || `VMZ page ${ctx.pathname}`);
     const canonical = String(raw.canonical || `${ctx.origin}${ctx.pathname === '/' ? '/' : ctx.pathname}`);
     const robots = String(raw.robots || 'index,follow');
     const lang = String(raw.lang || 'en');
@@ -507,87 +514,59 @@ function readCssEntry(distDir) {
  */
 function wrapDocument(input) {
     const propsJson = JSON.stringify(input.props ?? {});
+    const layoutAttr = input.layoutChain.length ? ` data-vmz-layout="${escapeAttr(input.layoutChain.join(','))}"` : '';
+    const pageAttr = input.chunkId ? ` data-vmz-page="${escapeAttr(input.chunkId)}"` : '';
     const localeId = input.meta.lang || 'en';
     const dir = input.meta.dir || 'ltr';
-    const native = requireNativeAddon();
-    if (typeof native.generatePageShell !== 'function') {
-        throw new Error('vmz native addon missing generatePageShell — rebuild with `pnpm napi:build`');
-    }
-    return native.generatePageShell({
-        bodyHtml: input.bodyHtml,
-        chunkId: input.chunkId || '',
-        layoutChain: input.layoutChain || [],
-        propsJson,
-        meta: {
-            title: input.meta.title,
-            description: input.meta.description,
-            canonical: input.meta.canonical,
-            robots: input.meta.robots,
-            lang: localeId,
-            dir,
-            alternates: input.meta.alternates || [],
-        },
-        // napi Option<String>: omit/undefined = None; null is rejected as String
-        ...(input.cssEntry ? { cssEntry: String(input.cssEntry) } : {}),
-        isErrorDocument: !!input.isErrorDocument,
-    });
+    const localeAttr = ` data-vmz-locale="${escapeAttr(localeId)}" data-vmz-dir="${escapeAttr(dir)}"`;
+    const cssLink = input.cssEntry ? `  <link rel="stylesheet" href="/${String(input.cssEntry).replace(/^\/+/, '')}" />\n` : '';
+    const entry = input.isErrorDocument ? '' : `  <script type="module" src="/entry-client.js"></script>\n`;
+    const hreflang = (input.meta.alternates || [])
+        .map((a) => `  <link rel="alternate" hreflang="${escapeAttr(a.hreflang)}" href="${escapeAttr(a.href)}" />`)
+        .join('\n');
+    const hreflangBlock = hreflang ? `${hreflang}\n` : '';
+    return `<!DOCTYPE html>
+<html lang="${escapeAttr(localeId)}" data-locale="${escapeAttr(localeId)}" dir="${escapeAttr(dir)}">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(input.meta.title)}</title>
+  <meta name="description" content="${escapeAttr(input.meta.description)}" />
+  <meta name="robots" content="${escapeAttr(input.meta.robots)}" />
+  <link rel="canonical" href="${escapeAttr(input.meta.canonical)}" />
+${hreflangBlock}  <meta property="og:title" content="${escapeAttr(input.meta.title)}" />
+  <meta property="og:description" content="${escapeAttr(input.meta.description)}" />
+  <meta property="og:url" content="${escapeAttr(input.meta.canonical)}" />
+${cssLink}</head>
+<body>
+  <div id="app"${pageAttr}${layoutAttr}${localeAttr} data-vmz-props="${escapeAttr(propsJson)}">${input.bodyHtml}</div>
+${entry}</body>
+</html>
+`;
 }
 /**
  * @param {string} origin
  * @param {Array<{ canonical: string, robots: string }>} generations
  */
-function buildSitemap(_origin, generations) {
-    const urls = generations.filter((g) => !String(g.robots).includes('noindex')).map((g) => ({ loc: g.canonical }));
-    const native = requireNativeAddon();
-    if (typeof native.generateSitemapXml !== 'function') {
-        throw new Error('vmz native addon missing generateSitemapXml — rebuild with `pnpm napi:build`');
-    }
-    return native.generateSitemapXml(urls);
+function buildSitemap(origin, generations) {
+    const urls = generations
+        .filter((g) => !String(g.robots).includes('noindex'))
+        .map((g) => `  <url>
+    <loc>${escapeXml(g.canonical)}</loc>
+  </url>`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
 }
-/**
- * Static CDN must ship entry-client/event like serve-host (content-addressed + HTML rewrite).
- * @param {string} distDir
- * @param {Array<{ chunkId: string }>} pageCatalog
- */
-function emitStaticClientEntries(distDir, pageCatalog) {
-    const componentEntries = listClientComponentsSync(distDir, { strict: true });
-    const indexChunk = pageCatalog.find((p) => p.chunkId === 'pages/index')?.chunkId || pageCatalog[0]?.chunkId || 'pages/index';
-    const resumeEntries = loadPageResumeEntriesSync(distDir, indexChunk);
-    const lazySet = new Set(resumeEntries
-        .filter((e) => isEventResumeStrategy(e.strategy))
-        .map((e) => e.component)
-        .filter(Boolean));
-    const eager = componentEntries.filter((e) => !lazySet.has(e.name));
-    const lazy = componentEntries.filter((e) => lazySet.has(e.name));
-    const native = requireNativeAddon();
-    if (typeof native.generateServeEntryClient !== 'function') {
-        throw new Error('vmz native addon missing generateServeEntryClient — rebuild with `pnpm napi:build`');
-    }
-    fs.writeFileSync(path.join(distDir, 'entry-client.js'), native.generateServeEntryClient(eager, lazy, ''), 'utf8');
-    if (typeof native.generateServeEntryEvent === 'function') {
-        fs.writeFileSync(path.join(distDir, 'entry-event.js'), native.generateServeEntryEvent(''), 'utf8');
-    }
+function escapeHtml(s) {
+    return String(s).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 }
-/**
- * @param {string} distDir
- * @param {string} chunkId
- */
-function loadPageResumeEntriesSync(distDir, chunkId) {
-    try {
-        const dep = JSON.parse(fs.readFileSync(path.join(distDir, 'vmz-deployment.json'), 'utf8'));
-        const units = Array.isArray(dep.units) ? dep.units : [];
-        const page = units.find((u) => u.chunkId === chunkId) || units.find((u) => u.chunkId === 'pages/index') || units.find((u) => u.kind === 'page');
-        const entries = Array.isArray(page?.resumeEntries) ? page.resumeEntries : [];
-        return entries.map((e) => ({
-            component: String(e.component || ''),
-            strategy: String(e.strategy || ''),
-        }));
-    }
-    catch {
-        return [];
-    }
+function escapeAttr(s) {
+    return escapeHtml(s).replaceAll('"', '&quot;');
 }
-/** @param {string} strategy */
-function isEventResumeStrategy(strategy) {
-    return strategy === 'event' || strategy === 'click' || String(strategy).startsWith('event:');
+function escapeXml(s) {
+    return escapeAttr(s).replaceAll("'", '&apos;');
 }

package/dist/test-cmd.js

@@ -6,7 +6,6 @@
 import path from 'node:path';
 import { createWorkspace } from './index.js';
 import { log } from './log.js';
-import { generatePrettyJson } from './pretty-json.js';
 /**
  * @returns {Promise<typeof import('@vmz/test')>}
  */
@@ -318,7 +317,7 @@ export async function cmdTest(args) {
         return errors.length ? 2 : 0;
     }
     if (wantJson) {
-        const text = `${generatePrettyJson(report)}\n`;
+        const text = `${JSON.stringify(report, null, 2)}\n`;
         if (typeof args.json === 'string' && args.json !== 'true') {
             const { writeFileSync } = await import('node:fs');
             writeFileSync(path.resolve(String(args.json)), text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "type": "module",
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "license": "MIT",
@@ -48,15 +48,15 @@
     }
   },
   "dependencies": {
-    "@vmz/core": "0.1.12",
-    "@vmz/plugin": "0.1.12",
-    "@vmz/protocol": "0.1.12",
+    "@vmz/core": "0.1.13",
+    "@vmz/plugin": "0.1.13",
+    "@vmz/protocol": "0.1.13",
     "jiti": "^2.6.1",
     "json5": "^2.2.3"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.1.12",
-    "@vmz/test": "0.1.12",
+    "@vmz/plugin-markdown-it": "0.1.13",
+    "@vmz/test": "0.1.13",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -90,12 +90,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.1.12",
-    "@vmz/vmz-win32-arm64": "0.1.12",
-    "@vmz/vmz-darwin-x64": "0.1.12",
-    "@vmz/vmz-darwin-arm64": "0.1.12",
-    "@vmz/vmz-linux-x64": "0.1.12",
-    "@vmz/vmz-linux-arm64": "0.1.12"
+    "@vmz/vmz-win32-x64": "0.1.13",
+    "@vmz/vmz-win32-arm64": "0.1.13",
+    "@vmz/vmz-darwin-x64": "0.1.13",
+    "@vmz/vmz-darwin-arm64": "0.1.13",
+    "@vmz/vmz-linux-x64": "0.1.13",
+    "@vmz/vmz-linux-arm64": "0.1.13"
   },
   "publishConfig": {
     "access": "public"

package/dist/dev-watch-roots.d.ts

@@ -1,80 +0,0 @@
-/**
- * Dev watch helpers: coalesce multi-file bursts without dropping dirty set,
- * and derive extra watch roots from the compile graph (deployment unit sources).
- */
-/**
- * @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 declare function mergeDirtySets(a: any, b: any): {
-    changed: unknown[];
-    deleted: unknown[];
-};
-/**
- * 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 declare function coalesceRootBurst(root: any, fingerprints: any, initial: any, opts?: {}): Promise<{
-    changed: any[];
-    deleted: any[];
-}>;
-/**
- * Walk up from a file to find a package.json directory.
- * @param {string} file
- * @returns {string | null}
- */
-export declare function findPackageRoot(file: any): string;
-/**
- * Prefer package/src when present; otherwise the directory containing the source file.
- * @param {string} sourceFile
- * @returns {string | null}
- */
-export declare function watchRootForSourceFile(sourceFile: any): string;
-/**
- * Absolute roots for workspace / file / link deps that have a src tree.
- * @param {string} project
- * @returns {string[]}
- */
-export declare function localLinkDependencyRoots(project: any): any[];
-/**
- * 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 declare function collectDevWatchRoots(opts: any): {
-    roots: any[];
-    dependencyRoots: unknown[];
-    applicationRoots: any[];
-};
-/**
- * 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 declare function classifyWatchRoot(root: any, ctx: any): "src" | "locales" | "docs" | "designs" | "dep" | "other";
-/**
- * Classify whether a changed file lives under a dependency watch root (not app src).
- * @param {string} file
- * @param {string[]} dependencyRoots
- */
-export declare function isDependencyPath(file: any, dependencyRoots: any): any;