@vmz/vmz 0.0.3 → 0.1.0

package/dist/cli.js

@@ -9,15 +9,23 @@ import { HOST_PROTOCOL, createWorkspace, getProtocolVersions, resolveCoreRuntime
 import { createDevSession } from './dev-session.js';
 import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand } from './invocation.js';
 import { log } from './log.js';
+import { findAvailablePort } from './port.js';
 import { readPackageMeta, resolveWorkspaceDirs } from './resolve.js';
 import { cmdTest } from './test-cmd.js';
 import { cmdDocument } from './document-cmd.js';
 import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
 import { cmdLocale } from './locale-cmd.js';
+import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
+import { emitLocaleRouteRealization } from './locale-route-emit.js';
 import { cmdApplication } from './application-cmd.js';
+import { cmdArtifact } from './release-cmd.js';
 import { cmdRefactor } from './refactor-cmd.js';
 import { cmdExplain } from './explain-cmd.js';
 import { resolveNativeVmzCli } from './resolve-native-cli.js';
+import { loadVmzConfig } from './plugin-host.js';
+import { normalizeDeliveryAuthoring, selectBuildProfile } from './delivery-profile.js';
+import { packFromDeploymentIr } from './pack.js';
+import { assembleDelivery, emitBuildProof } from './build-assemble.js';
 /**
  * @param {string[]} argv
  */
@@ -66,8 +74,11 @@ export function parseArgs(argv) {
 export function printGlobalHelp() {
     console.log(`vmz — global mode (scaffold only)
 
+Install faces: @vmz/core (runtime) · @vmz/vmz (this CLI) · optional @vmz/ui / @vmz/plugin-*
+
+Three install modes:
   developer  monorepo source (packages/runtimes/vmz) — full CLI
-  project    app node_modules/@vmz/vmz (or vmz) — full CLI
+  project    app node_modules/@vmz/vmz — full CLI
   global     npm/pnpm -g — only new/init/help/version
 
 You are in global mode. Pin \`@vmz/vmz\` in the app so check/build/lsp
@@ -79,11 +90,11 @@ Usage:
   vmz help                      Show this help
 
 Project commands:
-  pnpm add -D @vmz/vmz
+  pnpm add @vmz/core && pnpm add -D @vmz/vmz
   pnpm exec vmz check
   # or: vmz new my-app && cd my-app && pnpm install
 
-If a project \`node_modules/@vmz/vmz\` (or \`vmz\`) exists, a global
+If a project \`node_modules/@vmz/vmz\` exists, a global
 \`vmz <cmd>\` re-execs that bin.
 `);
 }
@@ -101,6 +112,7 @@ Usage:
   vmz test [path] [options]     Native test discover / report
   vmz document|docs <cmd>       Project /documents domain 
   vmz application <cmd>         Application Collection / Mount 
+  vmz artifact <cmd>            Release pack / publish / rollback / diff (A3)
   vmz refactor <cmd>            DX rename plans / apply 
   vmz explain [style] <target>  DX causal explain (style Theme chain)
   vmz lsp [root] [--out-dir]    Language server (stdio; native CLI)
@@ -110,9 +122,11 @@ Usage:
 
 Options:
   --out-dir, -o <dir>   Output directory (default: dist)
-  --release             Release build (build only)
+  --release             Release build (omit serve-host; pack minify slot; proof)
+  --profile <name>      Delivery profile (default from config; builtins: web-ssr|web-static|web-client|web-hybrid)
+  --origin <url>        Site origin for static-cdn canonical/sitemap
   --host <host>         Listen host (default: 127.0.0.1)
-  --port <port>         Listen port (default: 5173)
+  --port <port>         Listen port (dev: omit = auto from 5173; set = lock)
   --poll-ms <ms>        Dev watch poll interval (default: 300)
   --build               Build before serve
   --check               Format check-only (format)
@@ -197,6 +211,10 @@ export async function runCli(argv, opts = {}) {
         case 'applications':
         case 'app':
             return cmdApplication(rest);
+        case 'artifact':
+        case 'artifacts':
+        case 'release':
+            return cmdArtifact(rest);
         case 'refactor':
             return cmdRefactor(rest);
         case 'explain':
@@ -265,7 +283,11 @@ function cmdCheck(args) {
     try {
         return runWithPlugins(ws, project, outDir, async () => {
             const report = ws.check();
-            const errors = log.diagnostics(report.diagnostics ?? []);
+            const { checkLocales, localeHasErrors } = await import('./locale-check.js');
+            const localeReport = checkLocales({ projectRoot: project, checkUnused: false });
+            // Locale policy is first-class: missing /locales is warning (not silent), hard errors still fail.
+            const errors = log.diagnostics([...(report.diagnostics ?? []), ...(localeReport.diagnostics ?? [])]) ||
+                (localeHasErrors(localeReport) ? 1 : 0);
             log.info(`checked ${report.filesChecked} file(s)`);
             return errors ? 1 : 0;
         });
@@ -274,11 +296,28 @@ function cmdCheck(args) {
         ws.dispose();
     }
 }
+/**
+ * Dedupe locale/build diagnostics by code+path+message (runtime + route emit both report missing manifest).
+ * @param {Array<{ code?: string, path?: string, message?: string, severity?: string }>} list
+ */
+function dedupeDiagnostics(list) {
+    const seen = new Set();
+    /** @type {typeof list} */
+    const out = [];
+    for (const d of list || []) {
+        const key = `${d.code || ''}\0${d.path || ''}\0${d.message || ''}\0${d.severity || ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(d);
+    }
+    return out;
+}
 /**
  * @param {import('./index.js').Workspace} ws
  * @param {string} project
  * @param {string} outDir
- * @param { => Promise<number> | number} fn
+ * @param {() => Promise<number> | number} fn
  */
 async function runWithPlugins(ws, project, outDir, fn) {
     const { loadVmzConfig, applyPlugins } = await import('./plugin-host.js');
@@ -300,6 +339,21 @@ async function cmdBuild(args) {
     log.info(`build ${project} → ${outDir}`);
     const ws = createWorkspace({ root: project, outDir });
     try {
+        const cfg = await loadVmzConfig(project);
+        const cliProfile = typeof args.profile === 'string' ? args.profile : '';
+        const norm = normalizeDeliveryAuthoring(cfg.delivery ?? null);
+        if (!norm.ok) {
+            log.diagnostics(norm.diagnostics ?? []);
+            log.error('delivery authoring invalid');
+            return 1;
+        }
+        const selected = selectBuildProfile(norm.table, cliProfile);
+        if (!selected.ok) {
+            log.diagnostics(selected.diagnostics ?? []);
+            log.error(`unknown build --profile ${cliProfile || norm.table.default}`);
+            return 1;
+        }
+        log.info(`delivery profile ${selected.selection.profileId} (assembly=${selected.selection.assembly})`);
         const code = await runWithPlugins(ws, project, outDir, () => {
             const report = ws.build(Boolean(args.release));
             const errors = log.diagnostics(report.diagnostics ?? []);
@@ -313,20 +367,92 @@ async function cmdBuild(args) {
         });
         if (code !== 0)
             return code;
+        const localeEmit = emitLocaleRuntimeModules(project, outDir);
+        const localeRoutes = emitLocaleRouteRealization(project, outDir, {
+            origin: typeof args.origin === 'string' ? args.origin : undefined,
+        });
+        // Always surface locale diagnostics (warnings included) — missing /locales must not be silent.
+        // Dedupe: runtime emit + route realization both report the same missing-manifest warning.
+        const localeDiags = dedupeDiagnostics([
+            ...(localeEmit.diagnostics ?? []),
+            ...(localeRoutes.diagnostics ?? []),
+        ]);
+        log.diagnostics(localeDiags);
+        if (!localeEmit.ok || localeHasErrors({ diagnostics: localeEmit.diagnostics })) {
+            log.error('locale runtime emit failed');
+            return 1;
+        }
+        if (localeEmit.written.length) {
+            log.info(`locale runtime emit (${localeEmit.written.length} module(s))`);
+        }
+        if (!localeRoutes.ok) {
+            log.error('locale route realization emit failed');
+            return 1;
+        }
+        if (localeRoutes.written.length) {
+            log.info(`locale route realization (${localeRoutes.written.length} artifact(s))`);
+        }
         if (projectHasDocuments(project)) {
             const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
             if (!docs.ok)
                 return 1;
         }
+        let pack = null;
+        try {
+            pack = packFromDeploymentIr(outDir, {
+                release: Boolean(args.release),
+                profileId: selected.selection.profileId,
+                assembly: selected.selection.assembly,
+                coreDist: resolveCoreRuntimeDist(),
+            });
+            log.info(`pack ok (units=${pack.manifest.unitCount}, digest=${String(pack.manifest.packDigest).slice(0, 12)}…)`);
+        }
+        catch (err) {
+            log.error(`pack failed: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+        const origin = typeof args.origin === 'string' ? args.origin : undefined;
+        let assemble = null;
+        try {
+            if (selected.selection.assembly === 'static-cdn') {
+                log.info(`web-static emit ${outDir}`);
+            }
+            assemble = await assembleDelivery(outDir, {
+                selection: selected.selection,
+                profile: {
+                    ...selected.profile,
+                    sources: selected.profile.sources || (norm.table.sugar ? norm.table.profiles[norm.table.default]?.sources : null),
+                },
+                siteId: cfg.application?.id || undefined,
+                origin,
+                pack: pack.manifest,
+            });
+            for (const step of assemble.manifest.steps || []) {
+                if (step.kind === 'static-cdn') {
+                    log.info(`web-static ok (${step.htmlFiles} html, ${step.skipped} skipped, digest=${String(step.digest).slice(0, 12)}…)`);
+                }
+                else if (step.kind === 'site-delivery' && step.digest) {
+                    log.info(`site-delivery ok (digest=${String(step.digest).slice(0, 12)}…)`);
+                }
+            }
+        }
+        catch (err) {
+            log.error(`assemble failed: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+        const proof = emitBuildProof(outDir, {
+            selection: selected.selection,
+            pack: pack.manifest,
+            assemble: assemble.manifest,
+            release: Boolean(args.release),
+        });
+        log.info(`build-proof ok (profile=${proof.proof.profileId}, slots=${proof.proof.semanticIds.join(',')})`);
         return 0;
     }
     finally {
         ws.dispose();
     }
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
 async function cmdServe(args) {
     const pathArg = args._[0] ?? '.';
     if (args.build) {
@@ -391,7 +517,22 @@ async function cmdDev(args) {
         outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
     });
     const host = typeof args.host === 'string' ? args.host : '127.0.0.1';
-    const port = Number(args.port ?? 5173);
+    const portLocked = Object.prototype.hasOwnProperty.call(args, 'port');
+    let port;
+    if (portLocked) {
+        port = Number(args.port);
+        if (!Number.isFinite(port) || port <= 0) {
+            log.error(`invalid --port ${String(args.port)}`);
+            return 1;
+        }
+    }
+    else {
+        const preferred = 5173;
+        port = await findAvailablePort(host, preferred);
+        if (port !== preferred) {
+            log.info(`port ${preferred} busy → using ${port}`);
+        }
+    }
     const pollMs = Number(args['poll-ms'] ?? 300);
     const ac = new AbortController();
     const onSig = () => {

package/dist/content-addressed-assets.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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).
+ */
+export declare const CONTENT_ADDRESSED_ASSETS_SCHEMA = "vmz.content_addressed_assets.v0";
+/**
+ * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
+ * @param {string} distDir
+ * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
+ */
+export declare function emitContentAddressedAssets(distDir: any, opts?: {}): {
+    manifest: {
+        schema: string;
+        layout: string;
+        immutable: boolean;
+        objectCount: number;
+        objects: any[];
+        rewrittenHtml: number;
+    };
+    assetsDir: string;
+    rewrites: {};
+    manifestPath: string;
+};
+/**
+ * Resolve an immutable object by digest under dist/assets (cross-source reuse).
+ * @param {string} distDir
+ * @param {string} digest
+ * @param {string} [ext]
+ */
+export declare function resolveAssetByDigest(distDir: any, digest: any, ext?: string): {
+    assetPath: string;
+    digest: string;
+    bytes: number;
+};
+/**
+ * Prove two buffers share one asset path (content-address stability).
+ * @param {string} distDir
+ * @param {Buffer|string} a
+ * @param {Buffer|string} b
+ * @param {string} [ext]
+ */
+export declare function assertSharedAssetPath(distDir: any, a: any, b: any, ext?: string): {
+    ok: boolean;
+    reason: string;
+    digestA: string;
+    digestB: string;
+    rel?: undefined;
+    assetPath?: undefined;
+    digest?: undefined;
+} | {
+    ok: boolean;
+    reason: string;
+    rel: string;
+    digestA?: undefined;
+    digestB?: undefined;
+    assetPath?: undefined;
+    digest?: undefined;
+} | {
+    ok: boolean;
+    assetPath: string;
+    digest: string;
+    reason?: undefined;
+    digestA?: undefined;
+    digestB?: undefined;
+    rel?: undefined;
+};
+export declare function contentAddressedAssetsDigest(manifest: any): any;
+export declare function sha256Buffer(buf: any): string;

package/dist/content-addressed-assets.js

@@ -0,0 +1,206 @@
+/**
+ * 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).
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { canonicalJson, sha256Hex } from './release-pack.js';
+export const CONTENT_ADDRESSED_ASSETS_SCHEMA = 'vmz.content_addressed_assets.v0';
+/** Immutable delivery candidates (client-facing bytes). */
+const DEFAULT_CANDIDATES = [
+    'entry-client.js',
+    'entry-event.js',
+    'vmz.css',
+    'vmz-designs.css',
+    'vmz-dom.js',
+    'vmz-runtime.js',
+    'vmz-http.js',
+    'vmz-client-nav.js',
+];
+/**
+ * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
+ * @param {string} distDir
+ * @param {{ candidates?: string[], rewriteHtml?: boolean }} [opts]
+ */
+export function emitContentAddressedAssets(distDir, opts = {}) {
+    const abs = path.resolve(distDir);
+    if (!fs.existsSync(abs)) {
+        throw new Error(`emitContentAddressedAssets: missing dist ${abs}`);
+    }
+    const assetsDir = path.join(abs, 'assets');
+    fs.mkdirSync(assetsDir, { recursive: true });
+    const candidates = Array.isArray(opts.candidates) ? opts.candidates : collectCandidates(abs);
+    /** @type {Array<Record<string, any>>} */
+    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())
+            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}`);
+            }
+        }
+        objects.push({
+            logicalPath: logical,
+            assetPath: assetRel,
+            digest,
+            bytes: buf.length,
+            immutable: true,
+        });
+        rewrites[`/${logical}`] = `/${assetRel}`;
+        rewrites[logical] = assetRel;
+    }
+    objects.sort((a, b) => (a.logicalPath < b.logicalPath ? -1 : a.logicalPath > b.logicalPath ? 1 : 0));
+    let rewrittenHtml = 0;
+    if (opts.rewriteHtml !== false) {
+        rewrittenHtml = rewriteHtmlReferences(abs, rewrites);
+    }
+    const manifest = {
+        schema: CONTENT_ADDRESSED_ASSETS_SCHEMA,
+        layout: 'assets/<sha256>.<ext>',
+        immutable: true,
+        objectCount: objects.length,
+        objects,
+        rewrittenHtml,
+    };
+    manifest.manifestDigest = sha256Hex(canonicalJson({ ...manifest, manifestDigest: undefined }));
+    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');
+    return { manifest, assetsDir, rewrites, manifestPath: outPath };
+}
+/**
+ * Resolve an immutable object by digest under dist/assets (cross-source reuse).
+ * @param {string} distDir
+ * @param {string} digest
+ * @param {string} [ext]
+ */
+export function resolveAssetByDigest(distDir, digest, ext = '') {
+    const d = String(digest || '').trim();
+    if (!/^[a-f0-9]{64}$/i.test(d))
+        return null;
+    const suffix = ext && !ext.startsWith('.') ? `.${ext}` : ext;
+    const rel = `assets/${d}${suffix}`;
+    const abs = path.join(distDir, ...rel.split('/'));
+    if (!fs.existsSync(abs))
+        return null;
+    return { assetPath: rel, digest: d.toLowerCase(), bytes: fs.statSync(abs).size };
+}
+/**
+ * Prove two buffers share one asset path (content-address stability).
+ * @param {string} distDir
+ * @param {Buffer|string} a
+ * @param {Buffer|string} b
+ * @param {string} [ext]
+ */
+export function assertSharedAssetPath(distDir, a, b, ext = '.js') {
+    const da = sha256Hex(a);
+    const db = sha256Hex(b);
+    if (da !== db) {
+        return { ok: false, reason: 'digests differ', digestA: da, digestB: db };
+    }
+    const assetsDir = path.join(distDir, 'assets');
+    fs.mkdirSync(assetsDir, { recursive: true });
+    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) {
+        return { ok: false, reason: 'resolve missed shared path', rel };
+    }
+    return { ok: true, assetPath: rel, digest: da };
+}
+function collectCandidates(distDir) {
+    /** @type {string[]} */
+    const out = [];
+    for (const name of DEFAULT_CANDIDATES) {
+        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);
+    });
+    return [...new Set(out)].sort();
+}
+function walk(root, dir, onFile) {
+    for (const name of fs.readdirSync(dir)) {
+        if (name === 'assets' || name === '_vmz' || name === 'node_modules')
+            continue;
+        const full = path.join(dir, name);
+        const st = fs.statSync(full);
+        if (st.isDirectory())
+            walk(root, full, onFile);
+        else
+            onFile(path.relative(root, full).replace(/\\/g, '/'));
+    }
+}
+/**
+ * @param {string} distDir
+ * @param {Record<string, string>} rewrites map `/logical` → `/assets/hash.ext`
+ */
+function rewriteHtmlReferences(distDir, rewrites) {
+    const pairs = Object.entries(rewrites)
+        .filter(([from]) => from.startsWith('/'))
+        .sort((a, b) => b[0].length - a[0].length);
+    if (!pairs.length)
+        return 0;
+    let count = 0;
+    walkHtml(distDir, (file) => {
+        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) {
+            fs.writeFileSync(file, next, 'utf8');
+            count += 1;
+        }
+    });
+    return count;
+}
+function walkHtml(dir, onFile) {
+    const stack = [dir];
+    while (stack.length) {
+        const cur = stack.pop();
+        for (const name of fs.readdirSync(cur)) {
+            if (name === 'assets' || name === '_vmz' || name === 'node_modules')
+                continue;
+            const full = path.join(cur, name);
+            const st = fs.statSync(full);
+            if (st.isDirectory())
+                stack.push(full);
+            else if (name.endsWith('.html'))
+                onFile(full);
+        }
+    }
+}
+export function contentAddressedAssetsDigest(manifest) {
+    return manifest.manifestDigest || sha256Hex(canonicalJson({ ...manifest, manifestDigest: undefined }));
+}
+export function sha256Buffer(buf) {
+    return crypto.createHash('sha256').update(buf).digest('hex');
+}

package/dist/delivery-profile.d.ts

@@ -0,0 +1,74 @@
+/**
+ * B0 — Delivery profile authoring normalize + CLI --profile resolve.
+ * Pure data only; expands legacy site-delivery sugar into profiles[default].
+ */
+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). */
+export declare const ASSEMBLIES: readonly string[];
+export declare const SERVER_RUNTIMES: readonly string[];
+/** Official built-in aliases when not overridden in config. */
+export declare const BUILTIN_PROFILES: Readonly<{
+    'web-client': {
+        host: string;
+        assembly: string;
+    };
+    'web-static': {
+        host: string;
+        assembly: string;
+    };
+    'web-ssr': {
+        host: string;
+        assembly: string;
+        serverRuntime: string;
+    };
+    'web-hybrid': {
+        host: string;
+        assembly: string;
+        serverRuntime: string;
+    };
+}>;
+export declare function pickSiteAuthoring(raw: any): {
+    artifact: string;
+    sources: any;
+};
+export declare function normalizeDeliveryAuthoring(raw: any): {
+    ok: boolean;
+    table: {
+        schema: string;
+        default: string;
+        profiles: {};
+        sugar: boolean;
+    };
+    diagnostics?: undefined;
+} | {
+    ok: boolean;
+    diagnostics: any[];
+    table?: undefined;
+};
+export declare function selectBuildProfile(table: any, cliProfile?: string): {
+    ok: boolean;
+    diagnostics: {
+        code: string;
+        message: string;
+    }[];
+    selection?: undefined;
+    profile?: undefined;
+} | {
+    ok: boolean;
+    selection: {
+        schema: string;
+        profileId: any;
+        host: any;
+        assembly: any;
+        serverRuntime: any;
+        hasSiteSources: boolean;
+        authoringDigest: any;
+        fromCli: boolean;
+    };
+    profile: any;
+    diagnostics?: undefined;
+};
+export declare function semanticIdsForAssembly(assembly: any): string[];
+export declare function canonicalJson(value: any): string;
+export declare function sha256Hex(text: any): string;