@vmz/vmz 0.0.2 → 0.0.4

package/dist/release-pack.d.ts

@@ -0,0 +1,96 @@
+/**
+ * A3 filesystem release packaging — digests, atomic pointer, rollback, artifact diff.
+ *
+ * Not the full CDN/StaticDelivery matrix. Same VPG build (`dist/`) is packed into
+ * `_vmz/*` manifests + content digests; publish retains previous release for rollback
+ * without rebuild.
+ */
+export declare const RELEASE_ENVELOPE_SCHEMA = "vmz.release.envelope.v0";
+export declare const APPLICATION_ARTIFACT_SCHEMA = "vmz.application.artifact.v0";
+export declare const DELIVERY_ARTIFACT_MANIFEST_SCHEMA = "vmz.profile.delivery_artifact_manifest.v0";
+export declare const ROUTE_REALIZATION_TABLE_SCHEMA = "vmz.profile.route_realization_table.v0";
+export declare const ARTIFACT_DIFF_SCHEMA = "vmz.artifact.diff.v0";
+/**
+ * @param {Buffer | string} data
+ */
+export declare function sha256Hex(data: any): string;
+/**
+ * @param {string} filePath
+ */
+export declare function sha256File(filePath: any): string;
+/**
+ * @param {unknown} value
+ */
+export declare function canonicalJson(value: any): string;
+/**
+ * Pack `dist/` into `_vmz` manifests + release envelope (filesystem Delivery Profile).
+ * @param {string} distDir
+ * @param {{ applicationId?: string }} [opts]
+ */
+export declare function packRelease(distDir: any, opts?: {}): {
+    artifactDigest: string;
+    schema: string;
+    applicationId: any;
+    deliveryProfile: string;
+    applicationIntegrity: any;
+    deploymentDigest: any;
+    programDigest: string;
+    styleDigest: any;
+    routeDigest: string;
+    fileDigests: {};
+    manifests: {
+        applicationArtifact: string;
+        deliveryArtifactManifest: string;
+        routeRealization: string;
+    };
+};
+/**
+ * @param {string} pointerPath
+ * @param {string} digest
+ */
+export declare function atomicWritePointer(pointerPath: any, digest: any): void;
+/**
+ * @param {string} pointerPath
+ * @returns {string | null}
+ */
+export declare function readPointer(pointerPath: any): string;
+/**
+ * Publish packed dist into releases root; retain previous pointer for rollback.
+ * @param {string} releasesRoot
+ * @param {string} distDir
+ * @param {ReturnType<typeof packRelease>} envelope
+ */
+export declare function publishRelease(releasesRoot: any, distDir: any, envelope: any): {
+    digest: any;
+    previous: string;
+    currentPath: string;
+    releaseDir: string;
+};
+/**
+ * Rollback CURRENT → PREVIOUS without rebuild.
+ * @param {string} releasesRoot
+ */
+export declare function rollbackRelease(releasesRoot: any): {
+    restored: string;
+    demoted: string;
+    releaseDir: string;
+};
+/**
+ * Structured diff between two release envelopes / digest maps.
+ * @param {{ fileDigests?: Record<string, string>, artifactDigest?: string }} a
+ * @param {{ fileDigests?: Record<string, string>, artifactDigest?: string }} b
+ */
+export declare function diffArtifacts(a: any, b: any): {
+    schema: string;
+    beforeDigest: any;
+    afterDigest: any;
+    added: any[];
+    removed: any[];
+    changed: any[];
+    identical: boolean;
+};
+/**
+ * @param {string} releasesRoot
+ * @param {string} digest
+ */
+export declare function loadReleaseEnvelope(releasesRoot: any, digest: any): any;

package/dist/release-pack.js

@@ -0,0 +1,337 @@
+/**
+ * A3 filesystem release packaging — digests, atomic pointer, rollback, artifact diff.
+ *
+ * Not the full CDN/StaticDelivery matrix. Same VPG build (`dist/`) is packed into
+ * `_vmz/*` manifests + content digests; publish retains previous release for rollback
+ * without rebuild.
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+export const RELEASE_ENVELOPE_SCHEMA = 'vmz.release.envelope.v0';
+export const APPLICATION_ARTIFACT_SCHEMA = 'vmz.application.artifact.v0';
+export const DELIVERY_ARTIFACT_MANIFEST_SCHEMA = 'vmz.profile.delivery_artifact_manifest.v0';
+export const ROUTE_REALIZATION_TABLE_SCHEMA = 'vmz.profile.route_realization_table.v0';
+export const ARTIFACT_DIFF_SCHEMA = 'vmz.artifact.diff.v0';
+/**
+ * @param {Buffer | string} data
+ */
+export function sha256Hex(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+/**
+ * @param {string} filePath
+ */
+export function sha256File(filePath) {
+    return sha256Hex(fs.readFileSync(filePath));
+}
+/**
+ * @param {unknown} value
+ */
+export function canonicalJson(value) {
+    return JSON.stringify(sortKeys(value));
+}
+/**
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === 'object') {
+        /** @type {Record<string, unknown>} */
+        const out = {};
+        for (const k of Object.keys(value).sort()) {
+            out[k] = sortKeys(/** @type {Record<string, unknown>} */ (value)[k]);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * @param {string} distDir
+ * @returns {string[]}
+ */
+function listContentFiles(distDir) {
+    /** @type {string[]} */
+    const out = [];
+    const skipDir = new Set(['_vmz', 'node_modules']);
+    const skipName = new Set(['vmz-serve-host.mjs', 'vmz-serve-host.js']);
+    /** @param {string} abs */
+    /** @param {string} rel */
+    function walk(abs, rel) {
+        let ents;
+        try {
+            ents = fs.readdirSync(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of ents) {
+            if (e.name.startsWith('.'))
+                continue;
+            const nextAbs = path.join(abs, e.name);
+            const nextRel = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (skipDir.has(e.name))
+                    continue;
+                walk(nextAbs, nextRel);
+                continue;
+            }
+            if (skipName.has(e.name))
+                continue;
+            out.push(nextRel.replace(/\\/g, '/'));
+        }
+    }
+    walk(distDir, '');
+    out.sort();
+    return out;
+}
+/**
+ * @param {string} chunkId
+ */
+function pathPatternFromChunk(chunkId) {
+    const rel = chunkId.replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    const segs = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p === 'index' && i === parts.length - 1)
+            continue;
+        segs.push(p);
+    }
+    return segs.length ? `/${segs.join('/')}` : '/';
+}
+/**
+ * Pack `dist/` into `_vmz` manifests + release envelope (filesystem Delivery Profile).
+ * @param {string} distDir
+ * @param {{ applicationId?: string }} [opts]
+ */
+export function packRelease(distDir, opts = {}) {
+    const abs = path.resolve(distDir);
+    if (!fs.existsSync(abs)) {
+        throw new Error(`packRelease: missing dist ${abs}`);
+    }
+    const deploymentPath = path.join(abs, 'vmz-deployment.json');
+    if (!fs.existsSync(deploymentPath)) {
+        throw new Error(`packRelease: missing ${deploymentPath}`);
+    }
+    const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+    const files = listContentFiles(abs);
+    /** @type {Record<string, string>} */
+    const fileDigests = {};
+    for (const rel of files) {
+        fileDigests[rel] = sha256File(path.join(abs, ...rel.split('/')));
+    }
+    const pages = (deployment.units || []).filter((u) => u.kind === 'page');
+    const routeRealization = {
+        schema: ROUTE_REALIZATION_TABLE_SCHEMA,
+        routes: pages.map((u) => ({
+            routeId: String(u.chunkId),
+            chunkId: String(u.chunkId),
+            pathPattern: pathPatternFromChunk(String(u.chunkId)),
+            clientEntry: u.clientEntry || null,
+            programIr: u.programIr || null,
+        })),
+    };
+    const programParts = pages
+        .map((u) => u.programIr)
+        .filter(Boolean)
+        .map((rel) => fileDigests[String(rel).replace(/\\/g, '/')] || '')
+        .filter(Boolean)
+        .sort();
+    const programDigest = sha256Hex(programParts.join('|'));
+    const styleDigest = typeof deployment.styleBundleHash === 'string' && deployment.styleBundleHash ? deployment.styleBundleHash : null;
+    const deploymentDigest = fileDigests['vmz-deployment.json'] || sha256File(deploymentPath);
+    const applicationId = opts.applicationId || 'production-router';
+    const applicationArtifact = {
+        schema: APPLICATION_ARTIFACT_SCHEMA,
+        applicationId,
+        deliveryProfile: 'filesystem',
+        programDigest,
+        planDigest: programDigest,
+        deploymentDigest,
+        styleDigest,
+        routeDigest: sha256Hex(canonicalJson(routeRealization)),
+        fileDigests,
+        publicRouteContracts: routeRealization.routes.map((r) => r.routeId),
+    };
+    applicationArtifact.integrity = sha256Hex(canonicalJson({ ...applicationArtifact, integrity: undefined }));
+    const deliveryManifest = {
+        schema: DELIVERY_ARTIFACT_MANIFEST_SCHEMA,
+        deliveryProfile: 'filesystem',
+        copiesSemanticIr: false,
+        applicationId,
+        applicationIntegrity: applicationArtifact.integrity,
+        routeCount: routeRealization.routes.length,
+        assetCount: Object.keys(fileDigests).length,
+        styleDigest,
+        deploymentDigest,
+    };
+    const envelopeBody = {
+        schema: RELEASE_ENVELOPE_SCHEMA,
+        applicationId,
+        deliveryProfile: 'filesystem',
+        applicationIntegrity: applicationArtifact.integrity,
+        deploymentDigest,
+        programDigest,
+        styleDigest,
+        routeDigest: applicationArtifact.routeDigest,
+        fileDigests,
+        manifests: {
+            applicationArtifact: '_vmz/application-artifact.json',
+            deliveryArtifactManifest: '_vmz/delivery-artifact-manifest.json',
+            routeRealization: '_vmz/route-realization.json',
+        },
+    };
+    const artifactDigest = sha256Hex(canonicalJson(envelopeBody));
+    const envelope = { ...envelopeBody, artifactDigest };
+    const vmzDir = path.join(abs, '_vmz');
+    fs.mkdirSync(vmzDir, { recursive: true });
+    writeJson(path.join(vmzDir, 'application-artifact.json'), applicationArtifact);
+    writeJson(path.join(vmzDir, 'delivery-artifact-manifest.json'), deliveryManifest);
+    writeJson(path.join(vmzDir, 'route-realization.json'), routeRealization);
+    writeJson(path.join(vmzDir, 'release-envelope.json'), envelope);
+    return envelope;
+}
+/**
+ * @param {string} file
+ * @param {unknown} value
+ */
+function writeJson(file, value) {
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+/**
+ * @param {string} pointerPath
+ * @param {string} digest
+ */
+export function atomicWritePointer(pointerPath, digest) {
+    const dir = path.dirname(pointerPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = `${pointerPath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, `${digest.trim()}\n`, 'utf8');
+    try {
+        fs.renameSync(tmp, pointerPath);
+    }
+    catch {
+        if (fs.existsSync(pointerPath))
+            fs.unlinkSync(pointerPath);
+        fs.renameSync(tmp, pointerPath);
+    }
+}
+/**
+ * @param {string} pointerPath
+ * @returns {string | null}
+ */
+export function readPointer(pointerPath) {
+    if (!fs.existsSync(pointerPath))
+        return null;
+    const t = fs.readFileSync(pointerPath, 'utf8').trim();
+    return t || null;
+}
+/**
+ * Publish packed dist into releases root; retain previous pointer for rollback.
+ * @param {string} releasesRoot
+ * @param {string} distDir
+ * @param {ReturnType<typeof packRelease>} envelope
+ */
+export function publishRelease(releasesRoot, distDir, envelope) {
+    const digest = envelope.artifactDigest;
+    if (!digest)
+        throw new Error('publishRelease: envelope missing artifactDigest');
+    const root = path.resolve(releasesRoot);
+    const dest = path.join(root, digest);
+    fs.mkdirSync(dest, { recursive: true });
+    // Immutable snapshot of packed dist (exclude prior releases nesting).
+    const destDist = path.join(dest, 'dist');
+    fs.rmSync(destDist, { recursive: true, force: true });
+    fs.cpSync(path.resolve(distDir), destDist, {
+        recursive: true,
+        filter: (src) => {
+            const n = src.replace(/\\/g, '/');
+            return !n.includes('/.vmz-releases/') && !n.includes('/dist/releases');
+        },
+    });
+    writeJson(path.join(dest, 'envelope.json'), envelope);
+    const currentPath = path.join(root, 'CURRENT');
+    const previousPath = path.join(root, 'PREVIOUS');
+    const prev = readPointer(currentPath);
+    if (prev && prev !== digest) {
+        atomicWritePointer(previousPath, prev);
+    }
+    atomicWritePointer(currentPath, digest);
+    return {
+        digest,
+        previous: prev && prev !== digest ? prev : readPointer(previousPath),
+        currentPath,
+        releaseDir: dest,
+    };
+}
+/**
+ * Rollback CURRENT → PREVIOUS without rebuild.
+ * @param {string} releasesRoot
+ */
+export function rollbackRelease(releasesRoot) {
+    const root = path.resolve(releasesRoot);
+    const currentPath = path.join(root, 'CURRENT');
+    const previousPath = path.join(root, 'PREVIOUS');
+    const current = readPointer(currentPath);
+    const previous = readPointer(previousPath);
+    if (!previous) {
+        throw new Error('rollbackRelease: no PREVIOUS pointer');
+    }
+    if (!fs.existsSync(path.join(root, previous, 'envelope.json'))) {
+        throw new Error(`rollbackRelease: missing retained release ${previous}`);
+    }
+    if (current) {
+        atomicWritePointer(previousPath, current);
+    }
+    atomicWritePointer(currentPath, previous);
+    return {
+        restored: previous,
+        demoted: current,
+        releaseDir: path.join(root, previous),
+    };
+}
+/**
+ * Structured diff between two release envelopes / digest maps.
+ * @param {{ fileDigests?: Record<string, string>, artifactDigest?: string }} a
+ * @param {{ fileDigests?: Record<string, string>, artifactDigest?: string }} b
+ */
+export function diffArtifacts(a, b) {
+    const da = a.fileDigests || {};
+    const db = b.fileDigests || {};
+    const keys = new Set([...Object.keys(da), ...Object.keys(db)]);
+    /** @type {string[]} */
+    const added = [];
+    /** @type {string[]} */
+    const removed = [];
+    /** @type {Array<{ path: string, before: string, after: string }>} */
+    const changed = [];
+    for (const k of [...keys].sort()) {
+        if (!(k in da))
+            added.push(k);
+        else if (!(k in db))
+            removed.push(k);
+        else if (da[k] !== db[k])
+            changed.push({ path: k, before: da[k], after: db[k] });
+    }
+    return {
+        schema: ARTIFACT_DIFF_SCHEMA,
+        beforeDigest: a.artifactDigest || null,
+        afterDigest: b.artifactDigest || null,
+        added,
+        removed,
+        changed,
+        identical: added.length === 0 && removed.length === 0 && changed.length === 0,
+    };
+}
+/**
+ * @param {string} releasesRoot
+ * @param {string} digest
+ */
+export function loadReleaseEnvelope(releasesRoot, digest) {
+    const p = path.join(path.resolve(releasesRoot), digest, 'envelope.json');
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+}

package/dist/resolve-native-cli.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve the native `vmz` CLI binary (vmz-tools), never the Node wrapper.
+ * Used by `vmz lsp` / `vmz mcp` so stdio servers stay one binary for all hosts.
+ */
+/**
+ * @param {string} [startDir]
+ * @returns {string | null}
+ */
+export declare function findRepoRoot(startDir?: string): string;
+/**
+ * @param {{ cwd?: string }} [opts]
+ * @returns {string | null} absolute path to native vmz binary
+ */
+export declare function resolveNativeVmzCli(opts?: {}): any;

package/dist/resolve-native-cli.js

@@ -0,0 +1,84 @@
+// @ts-nocheck
+/**
+ * Resolve the native `vmz` CLI binary (vmz-tools), never the Node wrapper.
+ * Used by `vmz lsp` / `vmz mcp` so stdio servers stay one binary for all hosts.
+ */
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const exe = process.platform === 'win32' ? 'vmz.exe' : 'vmz';
+/**
+ * @param {string} [startDir]
+ * @returns {string | null}
+ */
+export function findRepoRoot(startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    for (let i = 0; i < 12; i++) {
+        if (existsSync(path.join(dir, 'Cargo.toml')) && existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Prefer the newer of release/debug so a fresh `cargo build` is not shadowed by a stale release.
+ * @param {string} repo
+ * @returns {string | null}
+ */
+function pickNewestProfileBinary(repo) {
+    /** @type {{ path: string, mtime: number } | null} */
+    let best = null;
+    for (const profile of ['release', 'debug']) {
+        const candidate = path.join(repo, 'target', profile, exe);
+        if (!existsSync(candidate))
+            continue;
+        let mtime = 0;
+        try {
+            mtime = statSync(candidate).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        if (!best || mtime > best.mtime)
+            best = { path: candidate, mtime };
+    }
+    return best?.path ?? null;
+}
+/**
+ * @param {{ cwd?: string }} [opts]
+ * @returns {string | null} absolute path to native vmz binary
+ */
+export function resolveNativeVmzCli(opts = {}) {
+    if (typeof process.env.VMZ_NATIVE === 'string' && process.env.VMZ_NATIVE.trim()) {
+        const p = path.resolve(process.env.VMZ_NATIVE.trim());
+        if (existsSync(p))
+            return p;
+    }
+    const roots = [];
+    if (opts.cwd)
+        roots.push(path.resolve(opts.cwd));
+    roots.push(process.cwd());
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        // packages/runtimes/vmz/dist → repo root
+        roots.push(path.resolve(here, '../../../..'));
+    }
+    catch {
+        /* ignore */
+    }
+    const seen = new Set();
+    for (const start of roots) {
+        const repo = findRepoRoot(start);
+        if (!repo || seen.has(repo))
+            continue;
+        seen.add(repo);
+        const picked = pickNewestProfileBinary(repo);
+        if (picked)
+            return picked;
+    }
+    return null;
+}

package/dist/resolve.d.ts

@@ -1,6 +1,5 @@
 /**
- * Shared project path resolution for the Node CLI host (N2).
- * Design: `规划设计/vmz/14-Node-NAPI与插件宿主.md`
+ * Shared project path resolution for the Node CLI host .
  */
 /**
  * @param {string} startDir

package/dist/resolve.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 /**
- * Shared project path resolution for the Node CLI host (N2).
- * Design: `规划设计/vmz/14-Node-NAPI与插件宿主.md`
+ * Shared project path resolution for the Node CLI host .
  */
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';

package/dist/site-delivery.d.ts

@@ -0,0 +1,134 @@
+/**
+ * A3-site: SiteDeliveryContract — embedded | filesystem | remote selection + release fallback.
+ * Authoring via defineConfig({ delivery }) / defineSite(...); pure data only.
+ */
+export declare const SITE_DELIVERY_CONTRACT_SCHEMA = "vmz.site.delivery_contract.v0";
+export declare const SITE_DELIVERY_RESOLUTION_SCHEMA = "vmz.site.delivery_resolution.v0";
+/**
+ * Pure-data helper for `defineConfig({ delivery: defineSite(...) })`.
+ * Not a second config entry — CLI never auto-discovers `vmz.site.ts`.
+ * @param {Record<string, unknown>} delivery
+ */
+export declare function defineSite(delivery: any): any;
+/**
+ * Normalize authoring delivery → frozen SiteDeliveryContract.
+ * @param {unknown} raw
+ * @param {{ siteId?: string, projectRoot?: string }} [opts]
+ * @returns {{ ok: true, contract: Record<string, any> } | { ok: false, diagnostics: Array<{ code: string, message: string }> }}
+ */
+export declare function normalizeSiteDelivery(raw: any, opts?: {}): {
+    ok: boolean;
+    diagnostics: any[];
+    contract?: undefined;
+} | {
+    ok: boolean;
+    contract: {
+        schema: string;
+        schemaVersion: string;
+        siteId: any;
+        artifact: string;
+        expectedCompatibility: any;
+        sources: any[];
+        resolutionPolicy: {
+            mode: string;
+            fallback: any;
+            fileLevelMix: boolean;
+        };
+        failurePolicy: any;
+        updatePolicy: any;
+        rollbackPolicy: any;
+        securityPolicy: any;
+        activation: string;
+    };
+    diagnostics?: undefined;
+};
+/**
+ * Probe one physical source for release-level readiness (not per-URL).
+ * @param {{
+ *   available?: boolean,
+ *   artifactDigest?: string | null,
+ *   integrityOk?: boolean,
+ *   signatureOk?: boolean,
+ *   objectClosureOk?: boolean,
+ *   mixedDigestObjects?: boolean,
+ *   error?: string | null,
+ * }} [probe]
+ */
+export declare function normalizeSourceProbe(probe?: {}): {
+    available: boolean;
+    artifactDigest: any;
+    integrityOk: boolean;
+    signatureOk: boolean;
+    objectClosureOk: boolean;
+    mixedDigestObjects: boolean;
+    error: any;
+};
+/**
+ * Resolve one complete release per SiteDeliveryContract (no file-level mix).
+ * @param {Record<string, any>} contract
+ * @param {Record<string, ReturnType<typeof normalizeSourceProbe>>} probes by sourceId
+ */
+export declare function resolveSiteRelease(contract: any, probes?: {}): {
+    schema: string;
+    status: string;
+    selectedSourceId: any;
+    selectedKind: any;
+    selectedDigest: any;
+    fallbackReason: string;
+    attempted: any[];
+    fileLevelMix: boolean;
+    activation: string;
+    contractDigest: any;
+} | {
+    schema: string;
+    status: string;
+    selectedSourceId: any;
+    selectedKind: any;
+    selectedDigest: any;
+    fallbackReason: string;
+    attempted: any[];
+    fileLevelMix: boolean;
+    activation: string;
+    contractDigest: any;
+    resolutionDigest: any;
+};
+/**
+ * Read a packed release directory probe (expects _vmz/release-envelope.json + object closure).
+ * @param {string} releaseDir absolute path to a release snapshot (contains dist/ or is dist/)
+ */
+export declare function probeReleaseDirectory(releaseDir: any): {
+    available: boolean;
+    artifactDigest: any;
+    integrityOk: boolean;
+    signatureOk: boolean;
+    objectClosureOk: boolean;
+    mixedDigestObjects: boolean;
+    error: any;
+};
+/**
+ * Emit normalized contract (+ optional resolution) under dist/_vmz.
+ * @param {string} outDir
+ * @param {unknown} deliveryRaw
+ * @param {{ siteId?: string, probes?: Record<string, any> }} [opts]
+ */
+export declare function emitSiteDelivery(outDir: any, deliveryRaw: any, opts?: {}): {
+    contract: {
+        schema: string;
+        schemaVersion: string;
+        siteId: any;
+        artifact: string;
+        expectedCompatibility: any;
+        sources: any[];
+        resolutionPolicy: {
+            mode: string;
+            fallback: any;
+            fileLevelMix: boolean;
+        };
+        failurePolicy: any;
+        updatePolicy: any;
+        rollbackPolicy: any;
+        securityPolicy: any;
+        activation: string;
+    };
+    resolution: any;
+};