@vmz/vmz 0.0.4 → 0.1.1

package/dist/locale-route-emit.js

@@ -0,0 +1,109 @@
+// @ts-nocheck
+/**
+ * Emit RouteId × LocaleId realization (+ PageMeta / hreflang seed) into dist/_vmz.
+ * Consumed by serve-host + static-emit; LocaleId stays out of stable RouteId.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { checkLocales, localeHasErrors } from './locale-check.js';
+import { buildLocalePageMeta, buildLocaleRouteRealizationTable } from './locale-router.js';
+import { writePrettyJsonFile } from './pretty-json.js';
+import { listPublicPageUnits, unitBrowserPathPattern } from './route-path.js';
+export const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = 'vmz.locale.route_realization.v0';
+/**
+ * @param {string} projectRoot
+ * @param {string} distDir
+ * @param {{ origin?: string }} [opts]
+ */
+export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
+    const report = checkLocales({ projectRoot, checkUnused: false });
+    if (localeHasErrors(report)) {
+        return { ok: false, written: [], diagnostics: report.diagnostics || [], artifact: null };
+    }
+    // Missing /locales is warning (not error) — still never silent; no realization artifact yet.
+    if (!report.manifest) {
+        return { ok: true, written: [], artifact: null, diagnostics: report.diagnostics || [] };
+    }
+    const deploymentPath = path.join(distDir, 'vmz-deployment.json');
+    if (!fs.existsSync(deploymentPath)) {
+        return {
+            ok: false,
+            written: [],
+            diagnostics: [{ severity: 'error', code: 'locale.route.missing_deployment', message: 'missing vmz-deployment.json' }],
+            artifact: null,
+        };
+    }
+    const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+    const pages = listPublicPageUnits(deployment);
+    const routes = pages.map((u) => ({
+        routeId: String(u.chunkId),
+        path: unitBrowserPathPattern(u),
+    }));
+    const localeEntries = report.manifest?.locales || [];
+    const locales = localeEntries.map((l) => l.id);
+    const directions = Object.fromEntries(localeEntries.map((l) => [l.id, l.direction || 'ltr']));
+    const defaultLocale = report.manifest?.defaultLocale;
+    const routing = report.manifest?.routing || { strategy: 'prefix', defaultPrefix: 'include' };
+    const table = buildLocaleRouteRealizationTable({
+        routes,
+        locales,
+        defaultLocale,
+        routing,
+    });
+    if (table.status === 'failed') {
+        return { ok: false, written: [], diagnostics: table.diagnostics || [], artifact: null };
+    }
+    const origin = String(opts.origin || process.env.VMZ_SITE_ORIGIN || 'https://example.test').replace(/\/$/, '');
+    /** @type {any[]} */
+    const pageMetas = [];
+    for (const route of routes) {
+        for (const loc of locales) {
+            const meta = buildLocalePageMeta({
+                routeId: route.routeId,
+                localeId: loc,
+                direction: directions[loc],
+                title: route.routeId,
+                origin,
+                realizations: table.realizations,
+                locales,
+                defaultLocale,
+            });
+            pageMetas.push(meta);
+        }
+    }
+    const artifact = {
+        schema: LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA,
+        defaultLocale,
+        locales: localeEntries.map((l) => ({
+            id: l.id,
+            label: l.label || l.id,
+            direction: l.direction || 'ltr',
+        })),
+        routing: {
+            strategy: routing.strategy || 'prefix',
+            defaultPrefix: routing.defaultPrefix || 'include',
+            defaultLocale,
+        },
+        origin,
+        routes,
+        realizations: table.realizations,
+        pageMetas,
+    };
+    const vmzDir = path.join(distDir, '_vmz');
+    fs.mkdirSync(vmzDir, { recursive: true });
+    const outPath = path.join(vmzDir, 'locale-route-realization.json');
+    writePrettyJsonFile(outPath, artifact);
+    const manifestOut = path.join(vmzDir, 'locale-manifest.json');
+    writePrettyJsonFile(manifestOut, {
+        schema: 'vmz.locale.manifest.v0',
+        defaultLocale,
+        locales: artifact.locales,
+        routing: artifact.routing,
+    });
+    return {
+        ok: true,
+        written: ['_vmz/locale-route-realization.json', '_vmz/locale-manifest.json'],
+        artifact,
+        diagnostics: [],
+    };
+}

package/dist/locale-router.d.ts

@@ -116,6 +116,26 @@ export declare function parseLocaleFromPath(pathname: any, supportedLocales: any
     localeId: string;
     restPath: string;
 };
+/**
+ * Rewrite a same-app href to the given LocaleId via route realization.
+ * Stable path (no locale) is recovered first, then re-realized — Link never hardcodes locale.
+ * @param {string} href
+ * @param {string} localeId
+ * @param {{
+ *   locales?: Array<{ id: string }|string>,
+ *   defaultLocale?: string,
+ *   routing?: { strategy?: string, defaultPrefix?: string, defaultLocale?: string },
+ * }} artifact
+ */
+export declare function localizeSameAppHref(href: any, localeId: any, artifact: any): any;
+/**
+ * Rewrite `<a data-vmz-route href>` in HTML body to retain `localeId`.
+ * @param {string} html
+ * @param {string} localeId
+ * @param {Parameters<typeof localizeSameAppHref>[2]} artifact
+ * @param {(s: string) => string} [escapeAttr]
+ */
+export declare function localizeBodyLinks(html: any, localeId: any, artifact: any, escapeAttr?: (s: any) => string): any;
 /**
  * Plan redirect / negotiation for an incoming URL (omit-prefix aware).
  * @param {{

package/dist/locale-router.js

@@ -260,6 +260,74 @@ export function parseLocaleFromPath(pathname, supportedLocales) {
     }
     return { localeId: null, restPath: normalizePath(pathname) };
 }
+/**
+ * Rewrite a same-app href to the given LocaleId via route realization.
+ * Stable path (no locale) is recovered first, then re-realized — Link never hardcodes locale.
+ * @param {string} href
+ * @param {string} localeId
+ * @param {{
+ *   locales?: Array<{ id: string }|string>,
+ *   defaultLocale?: string,
+ *   routing?: { strategy?: string, defaultPrefix?: string, defaultLocale?: string },
+ * }} artifact
+ */
+export function localizeSameAppHref(href, localeId, artifact) {
+    if (!href || !localeId || !artifact)
+        return href;
+    if (href.startsWith('#') || /^(mailto|tel|javascript):/i.test(href))
+        return href;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(href) && !href.startsWith('/'))
+        return href;
+    let pathname = String(href);
+    let search = '';
+    let hash = '';
+    const hashIdx = pathname.indexOf('#');
+    if (hashIdx >= 0) {
+        hash = pathname.slice(hashIdx);
+        pathname = pathname.slice(0, hashIdx);
+    }
+    const qIdx = pathname.indexOf('?');
+    if (qIdx >= 0) {
+        search = pathname.slice(qIdx);
+        pathname = pathname.slice(0, qIdx);
+    }
+    if (!pathname)
+        pathname = '/';
+    const supported = (artifact.locales || []).map((l) => (typeof l === 'string' ? l : l.id)).filter(Boolean);
+    const defaultLocale = artifact.defaultLocale || artifact.routing?.defaultLocale;
+    const routing = {
+        strategy: artifact.routing?.strategy || 'prefix',
+        defaultPrefix: artifact.routing?.defaultPrefix || 'include',
+        defaultLocale,
+    };
+    const parsed = parseLocaleFromPath(pathname, supported);
+    const rest = parsed.restPath || '/';
+    const realized = realizeRoutePath(localeId, rest, routing);
+    return `${realized.path}${search}${hash}`;
+}
+/**
+ * Rewrite `<a data-vmz-route href>` in HTML body to retain `localeId`.
+ * @param {string} html
+ * @param {string} localeId
+ * @param {Parameters<typeof localizeSameAppHref>[2]} artifact
+ * @param {(s: string) => string} [escapeAttr]
+ */
+export function localizeBodyLinks(html, localeId, artifact, escapeAttr = (s) => String(s).replace(/&/g, '&amp;').replace(/"/g, '&quot;')) {
+    if (!html || !localeId || !artifact)
+        return html;
+    return String(html).replace(/<a\b([^>]*)>/gi, (full, attrs) => {
+        if (!/\bdata-vmz-route\s*=/.test(attrs))
+            return full;
+        const hm = attrs.match(/\bhref\s*=\s*"([^"]*)"/i);
+        if (!hm)
+            return full;
+        const next = localizeSameAppHref(hm[1], localeId, artifact);
+        if (next === hm[1])
+            return full;
+        const newAttrs = attrs.replace(/\bhref\s*=\s*"[^"]*"/i, `href="${escapeAttr(next)}"`);
+        return `<a${newAttrs}>`;
+    });
+}
 /**
  * Plan redirect / negotiation for an incoming URL (omit-prefix aware).
  * @param {{

package/dist/log.d.ts

@@ -8,10 +8,10 @@ export declare const log: {
     warn(...args: any[]): void;
     /** @param {...unknown} args */
     error(...args: any[]): void;
-    /** @param {{ severity: string, path: string, message: string }} d */
+    /** @param {{ severity: string, path?: string, message: string, code?: string }} d */
     diagnostic(d: any): void;
     /**
-     * @param {Array<{ severity: string, path: string, message: string }>} diagnostics
+     * @param {Array<{ severity: string, path?: string, message: string, code?: string }>} diagnostics
      * @param {{ denyWarnings?: boolean }} [opts]
      * @returns {number} failing count (errors, and warnings if denyWarnings)
      */

package/dist/log.js

@@ -19,12 +19,20 @@ export const log = {
     error(...args) {
         console.error(stamp('error'), ...args);
     },
-    /** @param {{ severity: string, path: string, message: string }} d */
+    /** @param {{ severity: string, path?: string, message: string, code?: string }} d */
     diagnostic(d) {
-        console.error(`${d.severity}: ${d.path}: ${d.message}`);
+        const sev = d.severity || 'error';
+        const code = d.code ? `${d.code}: ` : '';
+        const loc = d.path ? ` (${d.path})` : '';
+        // Prefer `vmz warn|error CODE: message (path)` so locale warnings are visible, not silent.
+        if (sev === 'warning') {
+            console.error(`${stamp('warn')} ${code}${d.message}${loc}`);
+            return;
+        }
+        console.error(`${stamp(sev === 'error' ? 'error' : sev)} ${code}${d.path ? `${d.path}: ` : ''}${d.message}`);
     },
     /**
-     * @param {Array<{ severity: string, path: string, message: string }>} diagnostics
+     * @param {Array<{ severity: string, path?: string, message: string, code?: string }>} diagnostics
      * @param {{ denyWarnings?: boolean }} [opts]
      * @returns {number} failing count (errors, and warnings if denyWarnings)
      */

package/dist/mini-host.d.ts

@@ -0,0 +1,47 @@
+/**
+ * VMZ-owned deterministic Mini Host (TemplateSurface).
+ * Interprets MiniProgramArtifact tables — not vendor runtime, not WXML.
+ */
+/**
+ * Create a deterministic Mini Host over a deploy package + on-disk artifacts.
+ * @param {object} opts
+ * @param {MiniDeployPackage} opts.package
+ * @param {(artifactPath: string) => MiniPageArtifact} opts.loadArtifact
+ */
+export declare function createMiniHost(opts: any): {
+    package: any;
+    /** @param {string} [chunkId] */
+    mount(chunkId: any): {
+        chunkId: any;
+        data: {};
+    };
+    /** @param {string} handlerId */
+    dispatchEvent(handlerId: any): {
+        handlerId: any;
+        method: any;
+        patchPaths: any[];
+        data: {};
+    };
+    /** @param {string} routeId */
+    navigate(routeId: any): {
+        routeId: any;
+        chunkId: any;
+        data: {};
+    };
+    /** @param {string} method */
+    callServerStub(method: any): {
+        method: any;
+        scheme: string;
+        transport: string;
+        pending: boolean;
+        bodyShipped: boolean;
+    };
+    getState(): {
+        chunkId: any;
+        data: {};
+        appliedPatches: any[];
+        navigations: any[];
+        serverCalls: any[];
+        lifecycle: any[];
+    };
+};

package/dist/mini-host.js

@@ -0,0 +1,202 @@
+/**
+ * VMZ-owned deterministic Mini Host (TemplateSurface).
+ * Interprets MiniProgramArtifact tables — not vendor runtime, not WXML.
+ */
+/**
+ * @typedef {object} MiniDeployPackage
+ * @property {string} schema
+ * @property {string} [platformId]
+ * @property {object} [host]
+ * @property {object} [vendorTooling]
+ * @property {object} [constraints]
+ * @property {Array<{chunkId?: string, artifactPath?: string}>} [artifacts]
+ * @property {Array<{routeId?: string, chunkId?: string}>} [pages]
+ * @property {Array<{routeId?: string, fromChunkId?: string}>} [routeLinks]
+ * @property {Array<{method?: string, chunkId?: string}>} [serverCapabilities]
+ */
+/**
+ * @typedef {object} MiniPageArtifact
+ * @property {string} [template]
+ * @property {string} [logic]
+ * @property {string} [eventTable]
+ * @property {string} [dataPatchTable]
+ * @property {string} [manifest]
+ * @property {string} [style]
+ * @property {string} [platformId]
+ */
+/**
+ * @param {unknown} value
+ * @returns {any}
+ */
+function parseMaybeJson(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'object')
+        return value;
+    if (typeof value === 'string') {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * @param {string} path
+ * @param {Record<string, unknown>} data
+ * @param {unknown} value
+ */
+function setDataPath(path, data, value) {
+    const parts = String(path).split('.').filter(Boolean);
+    if (!parts.length)
+        return;
+    /** @type {any} */
+    let cur = data;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (cur[key] == null || typeof cur[key] !== 'object')
+            cur[key] = {};
+        cur = cur[key];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+/**
+ * Create a deterministic Mini Host over a deploy package + on-disk artifacts.
+ * @param {object} opts
+ * @param {MiniDeployPackage} opts.package
+ * @param {(artifactPath: string) => MiniPageArtifact} opts.loadArtifact
+ */
+export function createMiniHost(opts) {
+    const pkg = opts.package;
+    if (!pkg || pkg.schema !== 'vmz.mini.deploy_package.v0') {
+        throw new Error(`createMiniHost: expected vmz.mini.deploy_package.v0, got ${pkg?.schema}`);
+    }
+    if (pkg.constraints?.wxmlEmitter === true || pkg.constraints?.wxssEmitter === true) {
+        throw new Error('createMiniHost: package must not claim WXML/WXSS emitter');
+    }
+    if (pkg.constraints?.serverImplInMiniPackage === true) {
+        throw new Error('createMiniHost: server impl must not ship in mini package');
+    }
+    if (pkg.host?.schema !== 'vmz.mini.host.v0' || pkg.host?.kind !== 'deterministic-interpreter') {
+        throw new Error(`createMiniHost: invalid host descriptor ${JSON.stringify(pkg.host)}`);
+    }
+    if (pkg.vendorTooling?.role !== 'transport-conformance') {
+        throw new Error('createMiniHost: vendor tooling must stay transport-conformance');
+    }
+    if (pkg.vendorTooling?.invokedInCi !== false) {
+        throw new Error('createMiniHost: vendor tooling must not be invoked in CI gate');
+    }
+    /** @type {string | null} */
+    let currentChunkId = null;
+    /** @type {MiniPageArtifact | null} */
+    let currentArt = null;
+    /** @type {Record<string, unknown>} */
+    let data = {};
+    /** @type {string[]} */
+    const appliedPatches = [];
+    /** @type {Array<{method: string, scheme: string}>} */
+    const serverCalls = [];
+    /** @type {string[]} */
+    const navigations = [];
+    /** @type {string[]} */
+    const lifecycle = [];
+    function resolveArtifact(chunkId) {
+        const row = (pkg.artifacts || []).find((a) => a.chunkId === chunkId);
+        if (!row?.artifactPath) {
+            throw new Error(`createMiniHost: unknown chunk ${chunkId}`);
+        }
+        return opts.loadArtifact(row.artifactPath);
+    }
+    return {
+        package: pkg,
+        /** @param {string} [chunkId] */
+        mount(chunkId) {
+            const pages = pkg.pages || [];
+            const home = pages.find((p) => p.routeId === 'IndexPage' || String(p.chunkId || '').includes('pages/index')) || pages[0];
+            const pick = chunkId || home?.chunkId || pkg.artifacts?.[0]?.chunkId;
+            if (!pick)
+                throw new Error('createMiniHost.mount: no page chunk');
+            currentArt = resolveArtifact(pick);
+            currentChunkId = pick;
+            const logic = parseMaybeJson(currentArt.logic) || {};
+            data = structuredClone(logic.initialData || {});
+            lifecycle.push('mount');
+            return { chunkId: pick, data };
+        },
+        /** @param {string} handlerId */
+        dispatchEvent(handlerId) {
+            if (!currentArt)
+                throw new Error('createMiniHost.dispatchEvent: not mounted');
+            const events = parseMaybeJson(currentArt.eventTable);
+            if (!events || events.schema !== 'vmz.mini.event_table.v0') {
+                throw new Error('createMiniHost: missing event_table');
+            }
+            const handler = (events.handlers || []).find((h) => h.handlerId === handlerId);
+            if (!handler)
+                throw new Error(`createMiniHost: unknown handler ${handlerId}`);
+            const stamp = `patched:${handler.method || handlerId}`;
+            for (const p of handler.patchPaths || []) {
+                setDataPath(p, data, stamp);
+                appliedPatches.push(p);
+            }
+            lifecycle.push(`event:${handlerId}`);
+            return {
+                handlerId,
+                method: handler.method,
+                patchPaths: [...(handler.patchPaths || [])],
+                data,
+            };
+        },
+        /** @param {string} routeId */
+        navigate(routeId) {
+            const pages = pkg.pages || [];
+            const hit = pages.find((p) => p.routeId === routeId) || pages.find((p) => String(p.chunkId || '').includes(routeId));
+            if (!hit?.chunkId) {
+                throw new Error(`createMiniHost.navigate: unknown RouteId ${routeId}`);
+            }
+            const links = pkg.routeLinks || [];
+            const linked = !links.length || links.some((l) => l.routeId === routeId) || String(currentChunkId || '') === hit.chunkId;
+            if (!linked && currentChunkId) {
+                // Allow workspace-level pages even without a Link from current page.
+            }
+            currentArt = resolveArtifact(hit.chunkId);
+            currentChunkId = hit.chunkId;
+            const logic = parseMaybeJson(currentArt.logic) || {};
+            data = structuredClone(logic.initialData || {});
+            navigations.push(routeId);
+            lifecycle.push(`navigate:${routeId}`);
+            return { routeId, chunkId: hit.chunkId, data };
+        },
+        /** @param {string} method */
+        callServerStub(method) {
+            const caps = pkg.serverCapabilities || [];
+            const hit = caps.find((c) => c.method === method);
+            if (!hit)
+                throw new Error(`createMiniHost.callServerStub: unknown ${method}`);
+            if (pkg.constraints?.serverImplInMiniPackage !== false) {
+                throw new Error('createMiniHost: server impl leaked into mini package');
+            }
+            serverCalls.push({ method, scheme: '#server' });
+            lifecycle.push(`server-stub:${method}`);
+            return {
+                method,
+                scheme: '#server',
+                transport: 'mini-request',
+                pending: true,
+                bodyShipped: false,
+            };
+        },
+        getState() {
+            return {
+                chunkId: currentChunkId,
+                data: structuredClone(data),
+                appliedPatches: [...appliedPatches],
+                navigations: [...navigations],
+                serverCalls: [...serverCalls],
+                lifecycle: [...lifecycle],
+            };
+        },
+    };
+}

package/dist/native-addon.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,84 @@
+// @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/pack-client-packages.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Browser-safe client package lowering (Pack stage thin slice).
+ *
+ * Bare npm/workspace imports are legal on the author surface (01/04).
+ * Browser ESM cannot resolve them. Pack materializes reachable package
+ * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths.
+ *
+ * Not full oxc chunk-split/minify (`oxc-pending` remains for release minify).
+ */
+/**
+ * @param {string} outDir
+ * @param {{ projectRoot?: string | null }} [opts]
+ * @returns {{ rewrittenFiles: number, vendoredModules: string[], bareSpecs: string[] }}
+ */
+export declare function packClientBareImports(outDir: any, opts?: {}): {
+    rewrittenFiles: number;
+    vendoredModules: string[];
+    bareSpecs: any[];
+    unresolvedBareSpecs: any[];
+    skippedVmzExports: any[];
+    remainingBareSpecs: any[];
+};
+/** @param {string} js */
+export declare function collectBareSpecs(js: any): unknown[];
+export declare function rewriteRelativeTsSpecs(js: any): any;