@vmz/vmz 0.3.6 → 0.3.7

package/dist/dev/dev-session.js

@@ -14,13 +14,20 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { buildIntegratedDocuments, projectHasDocuments } from '../document/document-integrate.js';
 import { createWorkspace, resolveNativePath } from '../workspace/public-api.js';
+import { materializeWechatPackaging } from '../workspace/wechat-packaging.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from '../locale/locale-check.js';
 import { log } from '../workspace/log.js';
-import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectDevConfigPaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectConfigDependencies, configCandidatePaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { createConfigCycle } from './config-cycle.js';
 import { buildReloadPayload, filterGenerationIgnore, parseHmrPlan, registerWrittenOutputsIgnore, shouldSoftReload, staticRevisionFromArtifact, } from './dev-incremental.js';
 import { diffFingerprints, fileFingerprintMap } from '../workspace/watch-diff.js';
 /** Track serve-host so a failed/killed launcher cannot leave an orphan port. */
 const DEV_HOST_PID = '.vmz-dev-host.pid';
+function cycleFailure(report) {
+    const detail = report.error?.args?.detail ?? 'config build process failed';
+    const error = new Error(detail);
+    return report.error ? Object.assign(error, { diagnostic: report.error }) : error;
+}
 export function createDevSession(options) {
     const project = options.project;
     const outDir = options.outDir;
@@ -28,9 +35,13 @@ export function createDevSession(options) {
     const port = options.port ?? 5173;
     const pollMs = Math.max(50, options.pollMs ?? 300);
     const wechatPreview = options.target === 'mini-program-wechat';
+    let delivery = options.delivery ?? null;
     const createWs = options.createWorkspaceFn ?? createWorkspace;
     const spawnHost = options.spawnHostFn ?? defaultSpawnHost;
     const softReload = options.softReloadFn ?? defaultSoftReload;
+    const makeConfigCycle = options.configCycleFn ?? createConfigCycle;
+    const configCandidates = configCandidatePaths(project);
+    let configCycle = null;
     const ws = createWs({ root: project, outDir });
     let child = null;
     let stopped = false;
@@ -119,6 +130,8 @@ export function createDevSession(options) {
         }
         let report;
         try {
+            // Same prepared snapshot for this build cycle; native pack never reads config.
+            materializeWechatPackaging(project, delivery);
             const raw = ws.lowerMiniprogramWechatPackaging();
             report = typeof raw === 'string' ? JSON.parse(raw) : raw;
         }
@@ -191,15 +204,15 @@ export function createDevSession(options) {
         if (!existsSync(src)) {
             throw new Error(`vmz dev: missing src/ under ${project}`);
         }
-        // Same as `vmz build`: materialize plugin sources (e.g. `<Shiki>`) before compile.
-        // Soft rebuilds reuse the workspace; config/plugin changes still need a process restart
-        // until `vmz.config.*` is watched.
-        {
-            const { loadVmzConfig, applyPlugins } = await import('../workspace/plugin-host.js');
-            const { plugins, engines } = await loadVmzConfig(project);
-            if (plugins.length) {
-                await applyPlugins(ws, plugins, { project, outDir, engines });
-            }
+        // Config evaluation + plugin contributions run in a detached build process.
+        // Functions/plugin objects never cross the boundary; only the data report does.
+        if (configCandidates.some((p) => existsSync(p))) {
+            configCycle = makeConfigCycle({ project, outDir, ...(options.configCycleWorkerPath ? { workerPath: options.configCycleWorkerPath } : {}) });
+            const report = await configCycle.start();
+            if (!report.ok)
+                throw cycleFailure(report);
+            delivery = report.delivery ?? delivery;
+            log.info(`config build process ready${report.plugins.length ? ` (${report.plugins.map((p) => p.name).join(', ')})` : ''}`);
         }
         log.info('initial build (N-API workspace, full)…');
         const initialPair = planAndRebuild();
@@ -238,7 +251,14 @@ export function createDevSession(options) {
         const designsRoot = path.join(project, 'designs');
         const watched = collectDevWatchRoots({ project, outDir });
         const publicRoot = watched.publicRoot;
-        const configPaths = watched.configPaths.length ? watched.configPaths : collectDevConfigPaths(project);
+        /** Candidate config files plus their local reachable deps; refreshed after each cycle. */
+        const refreshConfigPaths = () => {
+            const deps = configCandidates
+                .filter((p) => existsSync(p))
+                .flatMap((p) => collectConfigDependencies(p, project));
+            return [...new Set([...configCandidates, ...deps])];
+        };
+        let configPaths = refreshConfigPaths();
         /** @type {string[]} */
         const watchRoots = [...watched.roots];
         /** @type {string[]} */
@@ -359,14 +379,66 @@ export function createDevSession(options) {
                     continue;
                 }
                 if (batch.configDirty) {
-                    log.info('vmz.config change detected — respawn required (devControl)');
-                    configFingerprints = configFingerprintMap(configPaths);
-                    commitFingerprints();
-                    await respawnHost('config-changed');
+                    log.info('vmz.config change detected — restarting the config build process…');
+                    let cycleReport = null;
+                    if (configCandidates.some((p) => existsSync(p))) {
+                        let failure = null;
+                        try {
+                            if (!configCycle) {
+                                configCycle = makeConfigCycle({
+                                    project,
+                                    outDir,
+                                    ...(options.configCycleWorkerPath ? { workerPath: options.configCycleWorkerPath } : {}),
+                                });
+                                cycleReport = await configCycle.start();
+                            }
+                            else {
+                                // Old process is cancelled and awaited before the new one writes artifacts.
+                                cycleReport = await configCycle.restart();
+                            }
+                        }
+                        catch (err) {
+                            failure = err instanceof Error ? err : new Error(String(err));
+                        }
+                        configPaths = refreshConfigPaths();
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        if (failure) {
+                            log.warn(`config build process restart failed: ${failure.message}`);
+                            continue;
+                        }
+                        if (cycleReport && !cycleReport.ok) {
+                            if (cycleReport.error)
+                                log.diagnostic(cycleReport.error);
+                            else
+                                log.error('config build process failed');
+                            continue;
+                        }
+                        if (cycleReport)
+                            delivery = cycleReport.delivery ?? delivery;
+                    }
+                    else if (configCycle) {
+                        await configCycle.cancel();
+                        configCycle = null;
+                        configPaths = refreshConfigPaths();
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        log.warn('vmz.config removed — config build process stopped, last artifacts kept');
+                        continue;
+                    }
+                    else {
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        continue;
+                    }
                     const report = rebuild();
                     if (printReport(report, 'rebuild')) {
                         lastOutputRevision = report.outputRevision ?? report.output_revision ?? null;
                         await emitPublicAndTrack();
+                        if (wechatPreview)
+                            packWechatPreview();
+                        else
+                            await respawnHost('config-changed');
                     }
                     continue;
                 }
@@ -605,6 +677,8 @@ export function createDevSession(options) {
         stopped = true;
         killChild(child);
         child = null;
+        await configCycle?.cancel().catch(() => { });
+        configCycle = null;
         clearDevHostPid(outDir, null);
         try {
             ws.dispose();

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

@@ -7,8 +7,15 @@
  */
 /** Author-facing vs generated dev input bucket. */
 export type DevInputKind = 'author' | 'dependency' | 'public' | 'devControl' | 'locales' | 'docs' | 'designs' | 'other';
+/** All supported `vmz.config.*` candidate paths, existing or not (so creation is detected). */
+export declare function configCandidatePaths(project: string): string[];
 /** `vmz.config.*` at project root (devControl). */
 export declare function collectDevConfigPaths(project: string): string[];
+/**
+ * Reachable local ESM dependencies of a config file (bounded, project-root only).
+ * These changes restart the dev config build process.
+ */
+export declare function collectConfigDependencies(configPath: string, project: string): string[];
 /** Fingerprint map for explicit config files (not directory walks). */
 export declare function configFingerprintMap(configPaths: string[]): Map<string, string>;
 export interface DirtySet {

package/dist/dev/dev-watch-roots.js

@@ -8,11 +8,74 @@
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { diffFingerprints, fileFingerprintMap } from '../workspace/watch-diff.js';
-const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+const LOCAL_MODULE_EXTENSIONS = ['.ts', '.mts', '.js', '.mjs', '.cts', '.cjs'];
+/** All supported `vmz.config.*` candidate paths, existing or not (so creation is detected). */
+export function configCandidatePaths(project) {
+    const root = path.resolve(project);
+    return CONFIG_BASENAMES.map((name) => path.join(root, name));
+}
 /** `vmz.config.*` at project root (devControl). */
 export function collectDevConfigPaths(project) {
+    return configCandidatePaths(project).filter((p) => existsSync(p));
+}
+/**
+ * Reachable local ESM dependencies of a config file (bounded, project-root only).
+ * These changes restart the dev config build process.
+ */
+export function collectConfigDependencies(configPath, project) {
     const root = path.resolve(project);
-    return CONFIG_BASENAMES.map((name) => path.join(root, name)).filter((p) => existsSync(p));
+    const underRoot = (file) => file === root || file.startsWith(root + path.sep);
+    const seen = new Set();
+    const out = [];
+    const visit = (file, depth) => {
+        if (depth > 24 || seen.size > 200 || !existsSync(file) || !underRoot(file))
+            return;
+        if (seen.has(file))
+            return;
+        seen.add(file);
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const specs = new Set();
+        for (const match of text.matchAll(/\b(?:import|export)\s+(?:[^'";]*?\s+from\s+)?['"]([^'"]+)['"]/g)) {
+            if (match[1])
+                specs.add(match[1]);
+        }
+        for (const match of text.matchAll(/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g)) {
+            if (match[1])
+                specs.add(match[1]);
+        }
+        for (const spec of specs) {
+            if (!spec.startsWith('.'))
+                continue;
+            const base = path.resolve(path.dirname(file), spec);
+            const candidates = [
+                base,
+                ...LOCAL_MODULE_EXTENSIONS.map((ext) => base + ext),
+                ...LOCAL_MODULE_EXTENSIONS.map((ext) => path.join(base, `index${ext}`)),
+            ];
+            for (const candidate of candidates) {
+                try {
+                    if (existsSync(candidate) && statSync(candidate).isFile()) {
+                        if (!seen.has(candidate))
+                            out.push(candidate);
+                        visit(candidate, depth + 1);
+                        break;
+                    }
+                }
+                catch {
+                    /* keep looking */
+                }
+            }
+        }
+    };
+    visit(path.resolve(configPath), 0);
+    return out;
 }
 /** Fingerprint map for explicit config files (not directory walks). */
 export function configFingerprintMap(configPaths) {

package/dist/document/document-build.js

@@ -195,20 +195,20 @@ function buildDocumentSlotHtml({ nav, bodyHtml, headings, htmlRel, route, routin
             .map((h) => `      <li class="h${h.level}"><a href="#${esc(h.id)}">${esc(h.text)}</a></li>`)
             .join('\n')}\n    </ol>\n  </nav>\n`
         : '';
-    const docsNav = `  <nav aria-label="Documents" class="doc-subnav">
-    <ul>
-${navItems}
-    </ul>
+    const docsNav = `  <nav aria-label="Documents" class="doc-subnav">
+    <ul>
+${navItems}
+    </ul>
   </nav>`;
-    return `    <aside class="doc-sidebar">
-${docsNav}
-${searchShellHtml}
-    </aside>
-    <div class="doc-content">
-  ${toc}<main id="main">
-${bodyHtml}
-${playgroundShellHtml}
-  </main>
+    return `    <aside class="doc-sidebar">
+${docsNav}
+${searchShellHtml}
+    </aside>
+    <div class="doc-content">
+  ${toc}<main id="main">
+${bodyHtml}
+${playgroundShellHtml}
+  </main>
     </div>`;
 }
 /**
@@ -242,17 +242,17 @@ function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, desig
                 .map((h) => `      <li class="h${h.level}"><a href="#${esc(h.id)}">${esc(h.text)}</a></li>`)
                 .join('\n')}\n    </ol>\n  </nav>\n`
             : '';
-        bodyInner = `  <a class="skip-link" href="#main">Skip to content</a>
-  <nav aria-label="Documents" class="doc-subnav">
-    <ul>
-${navItems}
-    </ul>
-  </nav>
-${searchShellHtml}
-  ${toc}<main id="main">
-${bodyHtml}
-${playgroundShellHtml}
-  </main>
+        bodyInner = `  <a class="skip-link" href="#main">Skip to content</a>
+  <nav aria-label="Documents" class="doc-subnav">
+    <ul>
+${navItems}
+    </ul>
+  </nav>
+${searchShellHtml}
+  ${toc}<main id="main">
+${bodyHtml}
+${playgroundShellHtml}
+  </main>
 `;
     }
     const native = requireNativeAddon();

package/dist/document/document-markdown.d.ts

@@ -1,5 +1,5 @@
 /**
- * Document — resolve engines.markdown via the official plugin runtime.
+ * Document — resolve engines.markdown via the official plugin runtime export.
  */
 export interface ResolveMarkdownEngineOpts {
     engines?: {

package/dist/document/document-markdown.js

@@ -1,36 +1,22 @@
 /**
- * Document — resolve engines.markdown via the official plugin runtime.
+ * Document — resolve engines.markdown via the official plugin runtime export.
  */
-import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { importMaybeTs } from '../workspace/plugin-host.js';
-const require = createRequire(import.meta.url);
 export async function resolveMarkdownEngine(opts = {}) {
     const id = opts.engines?.markdown || 'markdown-it';
     if (id !== 'markdown-it') {
         throw new Error(`unsupported engines.markdown ${JSON.stringify(id)} (markdown-it only)`);
     }
-    let runtimeFile = null;
+    let mod;
     try {
-        const pkg = require.resolve('@vmz/plugin-markdown-it/package.json');
-        runtimeFile = path.join(path.dirname(pkg), 'runtime.ts');
+        // Public JS runtime export of the plugin package; never read the package directory.
+        mod = await import('@vmz/plugin-markdown-it/runtime');
     }
-    catch {
-        // Developer mode: monorepo source checkout.
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        const fallback = path.resolve(here, '../../../plugins/vmz-plugin-markdown-it/runtime.ts');
-        if (existsSync(fallback))
-            runtimeFile = fallback;
-    }
-    if (!runtimeFile || !existsSync(runtimeFile)) {
+    catch (err) {
         throw new Error('markdown engine needs `@vmz/plugin-markdown-it` (optional peer of `@vmz/vmz`).\n' +
-            '  Install:  pnpm add -D @vmz/plugin-markdown-it');
+            '  Install:  pnpm add -D @vmz/plugin-markdown-it', { cause: err });
     }
-    const mod = await importMaybeTs(runtimeFile);
     if (typeof mod.analyzeMarkdown !== 'function') {
-        throw new Error(`cannot load markdown engine markdown-it from ${runtimeFile}`);
+        throw new Error('cannot load markdown engine markdown-it: runtime export is missing analyzeMarkdown');
     }
     return {
         engine: id,

package/dist/workspace/plugin-host.d.ts

@@ -4,11 +4,9 @@
 import { contentHash, defineConfig, definePlugin } from '@vmz/plugin';
 export { contentHash, defineConfig, definePlugin };
 export declare const PLUGIN_PROTOCOL = "0.1.0";
-/**
- * @param {string} full
- * @returns {Promise<any>}
- */
-export declare function importMaybeTs(full: any): Promise<any>;
+export declare const CONFIG_NAMES: string[];
+export declare const CONFIG_LOAD_FAILED = "vmz::config::load_failed";
+export declare const PLUGIN_ENTRY_INVALID = "vmz::plugin::invalid_entry";
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project

package/dist/workspace/plugin-host.js

@@ -4,30 +4,57 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { createJiti } from 'jiti';
 import { PLUGIN_PROTOCOL as PLUGIN_PROTOCOL_PKG, contentHash, defineConfig, definePlugin } from '@vmz/plugin';
 import { log } from './log.js';
 import { resolveWorkspacePackages } from './packages.js';
 export { contentHash, defineConfig, definePlugin };
 export const PLUGIN_PROTOCOL = PLUGIN_PROTOCOL_PKG;
-const CONFIG_NAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.mjs', 'vmz.config.js'];
+export const CONFIG_NAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.mjs', 'vmz.config.js'];
 const ROOT_PLUGIN_NAMES = ['vmz.plugin.ts', 'vmz.plugin.mts', 'vmz.plugin.mjs', 'vmz.plugin.js'];
+export const CONFIG_LOAD_FAILED = 'vmz::config::load_failed';
+export const PLUGIN_ENTRY_INVALID = 'vmz::plugin::invalid_entry';
 /**
+ * Load an ES module through the Node host (native `import()`).
+ * Project config and plugin entries must be erasable TS or JS: the host never
+ * runs a runtime TypeScript transpiler.
  * @param {string} full
  * @returns {Promise<any>}
  */
-export async function importMaybeTs(full) {
-    const ext = path.extname(full).toLowerCase();
-    if (ext === '.ts' || ext === '.mts') {
-        const jiti = createJiti(import.meta.url, {
-            interopDefault: true,
-            moduleCache: false,
-        });
-        return jiti(full);
-    }
+async function importHostModule(full) {
     const mod = await import(pathToFileURL(full).href);
     return mod.default ?? mod;
 }
+function errorDetail(err) {
+    const parts = [];
+    let cur = err;
+    for (let i = 0; cur && i < 4; i += 1) {
+        const message = cur instanceof Error ? cur.message : String(cur);
+        if (message && !parts.includes(message))
+            parts.push(message);
+        cur = cur && typeof cur === 'object' && 'cause' in cur ? cur.cause : null;
+    }
+    return parts.join(' ← ') || 'unknown error';
+}
+/**
+ * Build a host error carrying a product diagnostic (one print at the CLI boundary).
+ * @param {string} code
+ * @param {string} sourcePath
+ * @param {unknown} err
+ */
+function configDiagnosticError(code, sourcePath, err) {
+    const detail = errorDetail(err);
+    const error = new Error(detail);
+    if (err instanceof Error)
+        error.cause = err;
+    return Object.assign(error, {
+        diagnostic: {
+            code,
+            severity: 'error',
+            path: sourcePath,
+            args: { detail },
+        },
+    });
+}
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project
@@ -61,7 +88,13 @@ export async function loadVmzConfig(project) {
         if (!existsSync(full))
             continue;
         configPath = full;
-        const cfg = await importMaybeTs(full);
+        let cfg;
+        try {
+            cfg = await importHostModule(full);
+        }
+        catch (err) {
+            throw configDiagnosticError(CONFIG_LOAD_FAILED, full, err);
+        }
         const raw = cfg?.plugins ?? [];
         engines = cfg?.engines && typeof cfg.engines === 'object' ? { ...cfg.engines } : {};
         if (cfg?.delivery && typeof cfg.delivery === 'object') {
@@ -96,9 +129,11 @@ async function resolvePluginEntry(project, entry) {
     let value = entry;
     if (typeof value === 'string') {
         const resolved = path.isAbsolute(value) ? value : path.join(project, value);
-        value = await importMaybeTs(resolved);
-        if (value && typeof value === 'object' && 'default' in value && value.default) {
-            value = value.default;
+        try {
+            value = await importHostModule(resolved);
+        }
+        catch (err) {
+            throw configDiagnosticError(PLUGIN_ENTRY_INVALID, resolved, err);
         }
     }
     value = await value;
@@ -106,7 +141,8 @@ async function resolvePluginEntry(project, entry) {
         return value;
     if (value?.name && value?.stages)
         return definePlugin(value);
-    throw new Error(`invalid vmz plugin entry: ${String(entry)}`);
+    const sourcePath = typeof entry === 'string' ? (path.isAbsolute(entry) ? entry : path.join(project, entry)) : '';
+    throw configDiagnosticError(PLUGIN_ENTRY_INVALID, sourcePath, new Error(`invalid vmz plugin entry: ${String(entry)}`));
 }
 /**
  * Collect + apply contribution batches for the given stages onto a Workspace.
@@ -289,17 +325,17 @@ function buildMathFacade(defaultEngine, engines) {
         return `  <${tag} ${kw}="(engine || ${defaultLit}) === ${engLit}" :tex="tex" :display="display" />`;
     })
         .join('\n');
-    return `<template>
-${branches}
-</template>
-
-<script client>
-export default class Math {
-  public tex: string = '';
-  public display: boolean = false;
-  public engine: string | null = null;
-}
-</script>
+    return `<template>
+${branches}
+</template>
+
+<script client>
+export default class Math {
+  public tex: string = '';
+  public display: boolean = false;
+  public engine: string | null = null;
+}
+</script>
 `;
 }
 /**
@@ -316,18 +352,18 @@ function buildCodeFacade(defaultEngine, engines) {
         return `  <${tag} ${kw}="(engine || ${defaultLit}) === ${engLit}" :code="code" :lang="lang" :theme="theme" />`;
     })
         .join('\n');
-    return `<template>
-${branches}
-</template>
-
-<script client>
-export default class Code {
-  public code: string = '';
-  public lang: string = 'text';
-  public theme: string | null = null;
-  public engine: string | null = null;
-}
-</script>
+    return `<template>
+${branches}
+</template>
+
+<script client>
+export default class Code {
+  public code: string = '';
+  public lang: string = 'text';
+  public theme: string | null = null;
+  public engine: string | null = null;
+}
+</script>
 `;
 }
 /**
@@ -344,16 +380,16 @@ function buildMarkdownFacade(defaultEngine, engines) {
         return `  <${tag} ${kw}="(engine || ${defaultLit}) === ${engLit}" :source="source" />`;
     })
         .join('\n');
-    return `<template>
-${branches}
-</template>
-
-<script client>
-export default class Markdown {
-  public source: string = '';
-  public engine: string | null = null;
-}
-</script>
+    return `<template>
+${branches}
+</template>
+
+<script client>
+export default class Markdown {
+  public source: string = '';
+  public engine: string | null = null;
+}
+</script>
 `;
 }
 /** Embed a JS string literal inside a double-quoted Vue attribute. */

package/dist/workspace/public-api.d.ts

@@ -46,6 +46,10 @@ export declare function lowerMiniprogramBindingEventJson(rootPath: string): stri
 export declare function lowerMiniprogramStructureJson(rootPath: string): string;
 export declare function lowerMiniprogramRouteServerStyleJson(rootPath: string): string;
 export declare function lowerMiniprogramToolingDeployJson(rootPath: string): string;
+/**
+ * Consume the prepared `dist/_vmz/wechat-packaging.json` snapshot.
+ * Callers that start from a config must `await prepareWechatPackaging(rootPath)` first.
+ */
 export declare function lowerMiniprogramWechatPackagingJson(rootPath: string): string;
 export declare function lowerMiniprogramMultiAdapterJson(rootPath: string): string;
 import { createMiniHost } from './mini-host.js';
@@ -99,7 +103,7 @@ export { CDN_POLICY_MANIFEST_SCHEMA, CDN_ADAPTER_PROJECTION_SCHEMA, CACHE_HTML,
 export { SITE_DELIVERY_CONTRACT_SCHEMA, SITE_DELIVERY_RESOLUTION_SCHEMA, defineSite, normalizeSiteDelivery, normalizeSourceProbe, resolveSiteRelease, probeReleaseDirectory, emitSiteDelivery, } from './site-delivery.js';
 export { EMBEDDED_RESOURCE_INDEX_SCHEMA, emitEmbeddedPackaging } from './embedded-packaging.js';
 export { SERVER_LANG_IDS, SERVER_LANG_ALIASES, SERVER_LANGUAGE_BACKENDS, resolveServerLanguage, assertLangRuntimePair, } from './server-language-backend.js';
-export { WECHAT_PACKAGING_SCHEMA, WECHAT_PACKAGING_REL, wechatPackagingFromDelivery, materializeWechatPackaging } from './wechat-packaging.js';
+export { WECHAT_PACKAGING_SCHEMA, WECHAT_PACKAGING_REL, wechatPackagingFromDelivery, materializeWechatPackaging, prepareWechatPackaging, } from './wechat-packaging.js';
 export { DELIVERY_PROFILE_AUTHORING_SCHEMA, BUILD_PROFILE_SELECTION_SCHEMA, ASSEMBLIES, SERVER_RUNTIMES, BUILTIN_PROFILES, pickSiteAuthoring, pickDeliveryPackaging, normalizeProfileArtifactName, resolveProfileArtifactDir, normalizeDeliveryAuthoring, selectBuildProfile, semanticIdsForAssembly, } from '../delivery/delivery-profile.js';
 export { PACK_MANIFEST_SCHEMA, packFromDeploymentIr, ensureRuntimeCompanions } from './pack.js';
 export { SERVER_ARTIFACT_SCHEMA, HTTP_CONTRACT_SCHEMA, SERVER_RUNTIME_ADAPTER_SCHEMA, emitServerArtifact, projectServerRuntimeAdapter, } from './server-artifact.js';