@vmz/vmz 0.1.13 → 0.1.15

package/dist/content-addressed-assets.js

@@ -1,13 +1,16 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
- * Logical paths stay available for serve/dev; web-static HTML rewrites to hashed URLs.
- * Identical bytes → identical asset path (cross-release / cross-source reuse by digest).
+ * Logical paths stay available for serve/dev; static HTML rewrites to hashed URLs.
+ * CSS aggregators (vmz.css) rewrite `@import` to hashed sibling paths under assets/.
+ * JS under assets/ always rewrites ESM `./` → `../` so barrels (vmz-dom → dom-core)
+ * resolve at dist root — never prefer hashed siblings for JS (second-hop 404).
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { canonicalJson, sha256Hex } from './release-pack.js';
+import { writePrettyJsonFile } from './pretty-json.js';
 export const CONTENT_ADDRESSED_ASSETS_SCHEMA = 'vmz.content_addressed_assets.v0';
 /** Immutable delivery candidates (client-facing bytes). */
 const DEFAULT_CANDIDATES = [
@@ -15,11 +18,64 @@ const DEFAULT_CANDIDATES = [
     'entry-event.js',
     'vmz.css',
     'vmz-designs.css',
+    'vmz-style.css',
     'vmz-dom.js',
     'vmz-runtime.js',
     'vmz-http.js',
     'vmz-client-nav.js',
 ];
+/** CSS files that may @import other logical CSS; processed after leaf CSS is hashed. */
+const CSS_AGGREGATORS = new Set(['vmz.css']);
+/** JS entry shells hashed under assets/; relative ESM must be rewritten first. */
+const JS_ENTRY_AGGREGATORS = new Set(['entry-client.js', 'entry-event.js']);
+const CSS_IMPORT_RE = /@import\s*(?:url\()?['"]?(\.\/)?([^'")\s;]+)['"]?\)?/gi;
+/**
+ * Rewrite relative `@import "./foo.css"` to hashed paths under assets/.
+ * @param {string} cssText
+ * @param {Record<string, string>} rewrites logical (no leading slash) or `/logical` → `assets/hash.ext`
+ */
+export function rewriteCssImports(cssText, rewrites) {
+    return cssText.replace(CSS_IMPORT_RE, (match, _dot, target) => {
+        const logical = String(target || '').replace(/^\.\//, '');
+        if (!logical)
+            return match;
+        const hashed = rewrites[logical] || rewrites[`/${logical}`] || rewrites[`assets/${logical}`];
+        if (!hashed)
+            return match;
+        const rel = hashed.startsWith('/') ? hashed.slice(1) : hashed;
+        const sibling = rel.startsWith('assets/') ? `./${path.basename(rel)}` : `./${rel}`;
+        return `@import"${sibling}"`;
+    });
+}
+/**
+ * Rewrite relative ESM so a file served from `/assets/<hash>.js` resolves against
+ * dist root (static `from "./x"` / `export * from "./x"` + dynamic `import("./"+…)`).
+ *
+ * Always use `../…` (Fix A). Do **not** prefer hashed siblings under `assets/`:
+ * barrels like `vmz-dom.js` (`export * from './dom-core.js'`) would then resolve
+ * as `/assets/dom-core.js` and 404. `rewrites` is accepted for API parity with CSS
+ * but intentionally ignored for JS path choice.
+ *
+ * @param {string} jsText
+ * @param {Record<string, string>} [_rewrites]
+ */
+export function rewriteJsEntryRelativeImports(jsText, _rewrites = {}) {
+    let out = String(jsText || '');
+    // Dynamic: import("./" + id) → import("../" + id)
+    out = out.replace(/import\(\s*"\.\/"\s*\+/g, 'import("../"+');
+    out = out.replace(/import\(\s*'\.\/'\s*\+/g, "import('../'+");
+    const rewriteSpec = (spec) => {
+        const logical = String(spec || '').replace(/^\.\//, '');
+        if (!logical || logical.startsWith('../') || logical.startsWith('/'))
+            return spec;
+        return `../${logical}`;
+    };
+    // import/export … from "./x"  |  import("./x")
+    out = out.replace(/\b((?:import|export)\s+[^'"\n]*?\s+from\s+|import\s*\(\s*)(['"])(\.\/[^'"]+)\2/g, (match, prefix, quote, spec) => `${prefix}${quote}${rewriteSpec(spec)}${quote}`);
+    // side-effect: import "./x.js"
+    out = out.replace(/(^|[;\s])(import\s*)(['"])(\.\/[^'"]+)\3/gm, (match, lead, kw, quote, spec) => `${lead}${kw}${quote}${rewriteSpec(spec)}${quote}`);
+    return out;
+}
 /**
  * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
  * @param {string} distDir
@@ -37,36 +93,55 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
     const objects = [];
     /** @type {Record<string, string>} */
     const rewrites = {};
-    for (const rel of candidates) {
-        const logical = String(rel).replace(/\\/g, '/').replace(/^\//, '');
-        const src = path.join(abs, ...logical.split('/'));
-        if (!fs.existsSync(src) || !fs.statSync(src).isFile())
+    const ordered = orderCandidates(candidates);
+    for (const rel of ordered) {
+        // Aggregators are replaced in later passes; leaf JS must rewrite ./ → ../ so a
+        // hashed barrel under assets/ never 404s on second-hop relative re-exports.
+        if (CSS_AGGREGATORS.has(rel) || JS_ENTRY_AGGREGATORS.has(rel)) {
+            ingestCandidate(abs, rel, rewrites, objects, { transform: null });
             continue;
-        const buf = fs.readFileSync(src);
-        const digest = sha256Hex(buf);
-        const ext = path.extname(logical) || '';
-        const assetRel = `assets/${digest}${ext}`;
-        const dest = path.join(abs, ...assetRel.split('/'));
-        if (!fs.existsSync(dest)) {
-            fs.mkdirSync(path.dirname(dest), { recursive: true });
-            fs.writeFileSync(dest, buf);
         }
-        else {
-            // Cross-release reuse: identical digest must not be rewritten.
-            const existing = sha256Hex(fs.readFileSync(dest));
-            if (existing !== digest) {
-                throw new Error(`content-address collision at ${assetRel}`);
-            }
+        if (/\.m?js$/i.test(rel)) {
+            const src = path.join(abs, rel);
+            if (!fs.existsSync(src))
+                continue;
+            const rewritten = rewriteJsEntryRelativeImports(fs.readFileSync(src, 'utf8'), {});
+            ingestCandidate(abs, rel, rewrites, objects, {
+                transform: () => Buffer.from(rewritten, 'utf8'),
+            });
+            continue;
         }
-        objects.push({
-            logicalPath: logical,
-            assetPath: assetRel,
-            digest,
-            bytes: buf.length,
-            immutable: true,
+        ingestCandidate(abs, rel, rewrites, objects, { transform: null });
+    }
+    // Aggregator CSS (vmz.css) must import hashed leaf files — rewrite then hash.
+    for (const rel of ordered) {
+        if (!CSS_AGGREGATORS.has(rel))
+            continue;
+        const src = path.join(abs, rel);
+        if (!fs.existsSync(src))
+            continue;
+        const rewritten = rewriteCssImports(fs.readFileSync(src, 'utf8'), rewrites);
+        removeLogicalObject(objects, rel);
+        delete rewrites[`/${rel}`];
+        delete rewrites[rel];
+        ingestCandidate(abs, rel, rewrites, objects, {
+            transform: () => Buffer.from(rewritten, 'utf8'),
+        });
+    }
+    // JS entry shells: rewrite relative ESM (static + dynamic) then re-hash.
+    for (const rel of ordered) {
+        if (!JS_ENTRY_AGGREGATORS.has(rel))
+            continue;
+        const src = path.join(abs, rel);
+        if (!fs.existsSync(src))
+            continue;
+        const rewritten = rewriteJsEntryRelativeImports(fs.readFileSync(src, 'utf8'), rewrites);
+        removeLogicalObject(objects, rel);
+        delete rewrites[`/${rel}`];
+        delete rewrites[rel];
+        ingestCandidate(abs, rel, rewrites, objects, {
+            transform: () => Buffer.from(rewritten, 'utf8'),
         });
-        rewrites[`/${logical}`] = `/${assetRel}`;
-        rewrites[logical] = assetRel;
     }
     objects.sort((a, b) => (a.logicalPath < b.logicalPath ? -1 : a.logicalPath > b.logicalPath ? 1 : 0));
     let rewrittenHtml = 0;
@@ -85,9 +160,83 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
     const vmzDir = path.join(abs, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
     const outPath = path.join(vmzDir, 'content-addressed-assets.json');
-    fs.writeFileSync(outPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(outPath, manifest);
     return { manifest, assetsDir, rewrites, manifestPath: outPath };
 }
+/**
+ * @param {string[]} candidates
+ */
+function orderCandidates(candidates) {
+    const set = new Set(candidates.map((c) => String(c).replace(/\\/g, '/').replace(/^\//, '')));
+    /** @type {string[]} */
+    const out = [];
+    for (const name of DEFAULT_CANDIDATES) {
+        if (set.has(name) && !CSS_AGGREGATORS.has(name) && !JS_ENTRY_AGGREGATORS.has(name))
+            out.push(name);
+    }
+    for (const name of [...set].sort()) {
+        if (!CSS_AGGREGATORS.has(name) && !JS_ENTRY_AGGREGATORS.has(name) && !out.includes(name)) {
+            out.push(name);
+        }
+    }
+    if (set.has('vmz.css'))
+        out.push('vmz.css');
+    for (const name of ['entry-client.js', 'entry-event.js']) {
+        if (set.has(name))
+            out.push(name);
+    }
+    return out;
+}
+/**
+ * @param {Array<Record<string, any>>} objects
+ * @param {string} logical
+ */
+function removeLogicalObject(objects, logical) {
+    const idx = objects.findIndex((o) => o.logicalPath === logical);
+    if (idx >= 0)
+        objects.splice(idx, 1);
+}
+/**
+ * @param {string} absDist
+ * @param {string} rel
+ * @param {Record<string, string>} rewrites
+ * @param {Array<Record<string, any>>} objects
+ * @param {{ transform?: ((buf: Buffer) => Buffer) | null }} opts
+ */
+function ingestCandidate(absDist, rel, rewrites, objects, opts) {
+    const logical = String(rel).replace(/\\/g, '/').replace(/^\//, '');
+    const src = path.join(absDist, ...logical.split('/'));
+    if (!fs.existsSync(src) || !fs.statSync(src).isFile())
+        return;
+    let buf = fs.readFileSync(src);
+    if (typeof opts.transform === 'function') {
+        buf = opts.transform(buf);
+    }
+    const digest = sha256Hex(buf);
+    const ext = path.extname(logical) || '';
+    const assetRel = `assets/${digest}${ext}`;
+    const dest = path.join(absDist, ...assetRel.split('/'));
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, buf);
+    }
+    else {
+        const existing = sha256Hex(fs.readFileSync(dest));
+        if (existing !== digest) {
+            // Stale assets/ from a prior partial build can reuse hash filenames with different bytes.
+            fs.writeFileSync(dest, buf);
+        }
+    }
+    objects.push({
+        logicalPath: logical,
+        assetPath: assetRel,
+        digest,
+        bytes: buf.length,
+        immutable: true,
+    });
+    rewrites[`/${logical}`] = `/${assetRel}`;
+    rewrites[logical] = assetRel;
+}
 /**
  * Resolve an immutable object by digest under dist/assets (cross-source reuse).
  * @param {string} distDir
@@ -123,7 +272,6 @@ export function assertSharedAssetPath(distDir, a, b, ext = '.js') {
     const rel = `assets/${da}${ext}`;
     const dest = path.join(distDir, ...rel.split('/'));
     fs.writeFileSync(dest, typeof a === 'string' ? Buffer.from(a) : a);
-    // Second write of identical bytes must be reuse, not fork.
     fs.writeFileSync(dest, typeof b === 'string' ? Buffer.from(b) : b);
     const again = resolveAssetByDigest(distDir, da, ext);
     if (!again || again.assetPath !== rel) {
@@ -138,7 +286,6 @@ function collectCandidates(distDir) {
         if (fs.existsSync(path.join(distDir, name)))
             out.push(name);
     }
-    // Include top-level *.client.js and pages/**/*.client.js referenced by resume.
     walk(distDir, distDir, (rel) => {
         if (/\.client\.js$/i.test(rel))
             out.push(rel);
@@ -172,7 +319,6 @@ function rewriteHtmlReferences(distDir, rewrites) {
         let text = fs.readFileSync(file, 'utf8');
         let next = text;
         for (const [from, to] of pairs) {
-            // href="/x" src="/x" and unquoted variants in attributes
             next = next.split(from).join(to);
         }
         if (next !== text) {

package/dist/delivery-profile.d.ts

@@ -4,7 +4,7 @@
  */
 export declare const DELIVERY_PROFILE_AUTHORING_SCHEMA = "vmz.delivery.authoring.v0";
 export declare const BUILD_PROFILE_SELECTION_SCHEMA = "vmz.build.profile_selection.v0";
-/** Browser-era assembly kinds (04 B5). */
+/** Browser-era assembly kinds (04 B5). `static-cdn` was renamed to `web-static`. */
 export declare const ASSEMBLIES: readonly string[];
 export declare const SERVER_RUNTIMES: readonly string[];
 /** Official built-in aliases when not overridden in config. */
@@ -13,7 +13,7 @@ export declare const BUILTIN_PROFILES: Readonly<{
         host: string;
         assembly: string;
     };
-    'web-static': {
+    static: {
         host: string;
         assembly: string;
     };
@@ -28,10 +28,36 @@ export declare const BUILTIN_PROFILES: Readonly<{
         serverRuntime: string;
     };
 }>;
+/**
+ * Profile artifact directory name under CLI `--out-dir` (default = profile id).
+ * @param {string} id
+ * @param {unknown} rawName
+ * @param {Array<{ code: string, message: string }>} diagnostics
+ * @returns {string | null}
+ */
+export declare function normalizeProfileArtifactName(id: any, rawName: any, diagnostics: any): string;
+/**
+ * Workspace `--out-dir` + profile `name` → artifact root.
+ * Always nests: `path.join(outDir, name)` where `name` defaults to profile id
+ * (`name: 'cdn'` → `dist/cdn`; omit → `dist/static` for profile `static`).
+ * @param {string} outDir
+ * @param {{ name?: string, id?: string } | null | undefined} profile
+ */
+export declare function resolveProfileArtifactDir(outDir: any, profile: any): any;
 export declare function pickSiteAuthoring(raw: any): {
     artifact: string;
     sources: any;
 };
+/**
+ * `delivery.packaging.wechat` — vendor identity, not WeChat JSON / wx APIs.
+ * @param {unknown} raw
+ * @param {Array<{ code: string, message: string }>} diagnostics
+ */
+export declare function pickDeliveryPackaging(raw: any, diagnostics: any): {
+    wechat?: undefined;
+} | {
+    wechat: {};
+};
 export declare function normalizeDeliveryAuthoring(raw: any): {
     ok: boolean;
     table: {
@@ -59,6 +85,8 @@ export declare function selectBuildProfile(table: any, cliProfile?: string): {
     selection: {
         schema: string;
         profileId: any;
+        name: any;
+        nameExplicit: boolean;
         host: any;
         assembly: any;
         serverRuntime: any;

package/dist/delivery-profile.js

@@ -4,18 +4,67 @@
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
+import path from 'node:path';
 export const DELIVERY_PROFILE_AUTHORING_SCHEMA = 'vmz.delivery.authoring.v0';
 export const BUILD_PROFILE_SELECTION_SCHEMA = 'vmz.build.profile_selection.v0';
-/** Browser-era assembly kinds (04 B5). */
-export const ASSEMBLIES = Object.freeze(['local-static', 'static-cdn', 'server-host', 'cdn+server', 'rust-embedded']);
+/** Browser-era assembly kinds (04 B5). `static-cdn` was renamed to `web-static`. */
+export const ASSEMBLIES = Object.freeze(['local-static', 'web-static', 'server-host', 'cdn+server', 'rust-embedded']);
 export const SERVER_RUNTIMES = Object.freeze(['node', 'worker', 'deno', 'bun', 'rust-host']);
 /** Official built-in aliases when not overridden in config. */
 export const BUILTIN_PROFILES = Object.freeze({
     'web-client': { host: 'browser', assembly: 'local-static' },
-    'web-static': { host: 'browser', assembly: 'static-cdn' },
+    static: { host: 'browser', assembly: 'web-static' },
     'web-ssr': { host: 'browser', assembly: 'server-host', serverRuntime: 'node' },
     'web-hybrid': { host: 'browser', assembly: 'cdn+server', serverRuntime: 'node' },
 });
+/**
+ * Profile artifact directory name under CLI `--out-dir` (default = profile id).
+ * @param {string} id
+ * @param {unknown} rawName
+ * @param {Array<{ code: string, message: string }>} diagnostics
+ * @returns {string | null}
+ */
+export function normalizeProfileArtifactName(id, rawName, diagnostics) {
+    const fallback = String(id || '').trim();
+    if (rawName == null || rawName === '')
+        return fallback || null;
+    if (typeof rawName !== 'string') {
+        diagnostics.push({
+            code: 'delivery.profile.name',
+            message: `profiles.${id}.name must be a string (got ${typeof rawName})`,
+        });
+        return null;
+    }
+    const name = rawName.trim();
+    if (!name) {
+        diagnostics.push({
+            code: 'delivery.profile.name',
+            message: `profiles.${id}.name must be a non-empty string`,
+        });
+        return null;
+    }
+    if (name === '.' || name === '..' || name.includes('/') || name.includes('\\') || name.includes('\0')) {
+        diagnostics.push({
+            code: 'delivery.profile.name',
+            message: `profiles.${id}.name must be a single path segment under --out-dir (got '${name}')`,
+        });
+        return null;
+    }
+    return name;
+}
+/**
+ * Workspace `--out-dir` + profile `name` → artifact root.
+ * Always nests: `path.join(outDir, name)` where `name` defaults to profile id
+ * (`name: 'cdn'` → `dist/cdn`; omit → `dist/static` for profile `static`).
+ * @param {string} outDir
+ * @param {{ name?: string, id?: string } | null | undefined} profile
+ */
+export function resolveProfileArtifactDir(outDir, profile) {
+    const name = String(profile?.name || profile?.id || '').trim();
+    if (!name)
+        return outDir;
+    return path.join(outDir, name);
+}
 function isPlainObject(v) {
     return v != null && typeof v === 'object' && !Array.isArray(v);
 }
@@ -49,6 +98,67 @@ export function pickSiteAuthoring(raw) {
     }
     return site;
 }
+/**
+ * `delivery.packaging.wechat` — vendor identity, not WeChat JSON / wx APIs.
+ * @param {unknown} raw
+ * @param {Array<{ code: string, message: string }>} diagnostics
+ */
+export function pickDeliveryPackaging(raw, diagnostics) {
+    if (!isPlainObject(raw) || raw.packaging == null)
+        return null;
+    if (!isPlainObject(raw.packaging)) {
+        diagnostics.push({ code: 'delivery.packaging', message: 'delivery.packaging must be an object' });
+        return null;
+    }
+    for (const key of Object.keys(raw.packaging)) {
+        if (key !== 'wechat') {
+            diagnostics.push({
+                code: 'delivery.packaging.vendor',
+                message: `delivery.packaging.${key} is not a known vendor (wechat)`,
+            });
+        }
+    }
+    const wechat = raw.packaging.wechat;
+    if (wechat == null)
+        return {};
+    if (!isPlainObject(wechat)) {
+        diagnostics.push({
+            code: 'delivery.packaging.wechat',
+            message: 'delivery.packaging.wechat must be an object',
+        });
+        return null;
+    }
+    for (const [k, v] of Object.entries(wechat)) {
+        if (typeof v === 'function') {
+            diagnostics.push({
+                code: 'delivery.packaging.executable',
+                message: `delivery.packaging.wechat.${k} must be pure data (no functions)`,
+            });
+            continue;
+        }
+        if (k !== 'appId' && k !== 'projectName' && k !== 'title') {
+            diagnostics.push({
+                code: 'delivery.packaging.wechat.field',
+                message: `delivery.packaging.wechat.${k} is not a known field (appId|projectName|title)`,
+            });
+        }
+        else if (v != null && typeof v !== 'string') {
+            diagnostics.push({
+                code: 'delivery.packaging.wechat.type',
+                message: `delivery.packaging.wechat.${k} must be a string`,
+            });
+        }
+    }
+    const out = {};
+    if (typeof wechat.appId === 'string' && wechat.appId.trim())
+        out.appId = wechat.appId.trim();
+    if (typeof wechat.projectName === 'string' && wechat.projectName.trim()) {
+        out.projectName = wechat.projectName.trim();
+    }
+    if (typeof wechat.title === 'string' && wechat.title.trim())
+        out.title = wechat.title.trim();
+    return { wechat: out };
+}
 function normalizeProfileEntry(entry, id, diagnostics) {
     if (!isPlainObject(entry)) {
         diagnostics.push({ code: 'delivery.profile.invalid', message: `profiles.${id} must be an object` });
@@ -61,7 +171,14 @@ function normalizeProfileEntry(entry, id, diagnostics) {
             message: `profiles.${id}.host: only 'browser' is supported before Browser Production (got ${host})`,
         });
     }
-    const assembly = String(entry.assembly || '').trim();
+    let assembly = String(entry.assembly || '').trim();
+    if (assembly === 'static-cdn') {
+        diagnostics.push({
+            code: 'delivery.profile.assembly.renamed',
+            message: `profiles.${id}.assembly 'static-cdn' was renamed to 'web-static'`,
+        });
+        return null;
+    }
     if (!ASSEMBLIES.includes(assembly)) {
         diagnostics.push({
             code: 'delivery.profile.assembly',
@@ -69,6 +186,10 @@ function normalizeProfileEntry(entry, id, diagnostics) {
         });
         return null;
     }
+    const nameExplicit = entry.name != null && String(entry.name).trim() !== '';
+    const name = normalizeProfileArtifactName(id, nameExplicit ? entry.name : id, diagnostics);
+    if (!name)
+        return null;
     let serverRuntime = null;
     if (assembly === 'server-host' || assembly === 'cdn+server') {
         serverRuntime = String(entry.serverRuntime || 'node');
@@ -110,6 +231,9 @@ function normalizeProfileEntry(entry, id, diagnostics) {
     }
     return {
         id,
+        name,
+        /** True when author set `profiles.<id>.name`; false → `name` defaulted to profile id. */
+        nameExplicit,
         host: 'browser',
         assembly,
         serverRuntime,
@@ -183,6 +307,10 @@ export function normalizeDeliveryAuthoring(raw) {
             },
         };
     }
+    else if (isPlainObject(raw.packaging)) {
+        defaultId = String(raw.default || 'web-ssr').trim() || 'web-ssr';
+        profileInputs = { ...BUILTIN_PROFILES };
+    }
     else {
         return {
             ok: false,
@@ -206,6 +334,9 @@ export function normalizeDeliveryAuthoring(raw) {
             message: `delivery.default '${defaultId}' is not a known profile`,
         });
     }
+    if (diagnostics.length)
+        return { ok: false, diagnostics };
+    const packaging = pickDeliveryPackaging(raw, diagnostics);
     if (diagnostics.length)
         return { ok: false, diagnostics };
     const table = {
@@ -213,6 +344,7 @@ export function normalizeDeliveryAuthoring(raw) {
         default: defaultId,
         profiles,
         sugar,
+        ...(packaging ? { packaging } : {}),
     };
     table.digest = sha256Hex(canonicalJson(table));
     return { ok: true, table };
@@ -234,6 +366,8 @@ export function selectBuildProfile(table, cliProfile = '') {
     const selection = {
         schema: BUILD_PROFILE_SELECTION_SCHEMA,
         profileId: id,
+        name: profile.name,
+        nameExplicit: Boolean(profile.nameExplicit),
         host: profile.host,
         assembly: profile.assembly,
         serverRuntime: profile.serverRuntime,
@@ -246,7 +380,7 @@ export function selectBuildProfile(table, cliProfile = '') {
 }
 export function semanticIdsForAssembly(assembly) {
     switch (assembly) {
-        case 'static-cdn':
+        case 'web-static':
             return ['static-delivery', 'asset-graph'];
         case 'server-host':
             return ['server-host', 'asset-graph'];

package/dist/dev-session.d.ts

@@ -16,6 +16,7 @@
  * @property {string} [host]
  * @property {number} [port]
  * @property {number} [pollMs]
+ * @property {'browser' | 'mini-program-wechat'} [target]
  * @property {AbortSignal} [signal]
  * @property {typeof createWorkspace} [createWorkspaceFn]
  * @property {(opts: { project: string, outDir: string, host: string, port: number }) => import('node:child_process').ChildProcess} [spawnHostFn]