@dokebi/cli 0.1.0 → 0.2.0

package/dist/install-module.js

@@ -0,0 +1,107 @@
+import { spawn } from 'node:child_process';
+import { realpath } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+export class InstallPlanningError extends Error {
+    code;
+    constructor(code) {
+        super('Plugin installation planning failed (' + code + ').');
+        this.code = code;
+        this.name = 'InstallPlanningError';
+    }
+}
+/** Returned when the module does not export the requested phase. */
+export const PHASE_MISSING = Symbol('dokebi.install.phase-missing');
+const MAX_BYTES = 1024 * 1024;
+const TIMEOUT_MS = 5000;
+const RUNNER = "\nconst finish = (value) => process.stdout.write(JSON.stringify(value), () => process.exit(0));\ntry {\n let input = '';\n for await (const chunk of process.stdin) input += chunk;\n const freeze = (value) => {\n  if (value && typeof value === 'object') {for (const child of Object.values(value)) freeze(child);Object.freeze(value);}\n  return value;\n };\n const phase = process.argv[2];\n const context = freeze({ ...JSON.parse(input), phase });\n const module = await import(process.argv[1]);\n if (typeof module[phase] !== 'function') finish({ok:true,missing:true});\n else {\n  const plan = await module[phase](context);\n  if(plan === undefined)finish({ok:false,code:'INSTALL_PLAN_INVALID'});\n  else finish({ok:true,plan});\n }\n} catch(error) {\n const code = error && error.code === 'ERR_ACCESS_DENIED' ? 'INSTALL_PERMISSION_DENIED' : error && typeof error.code === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(error.code) ? error.code : 'INSTALL_MODULE_FAILED';\n finish({ok:false,code});\n}\n";
+/**
+ * Runs one lifecycle phase of a plugin installation module in a child process.
+ * The child uses the Node permission model: it may read only `readRoots`
+ * (real paths), cannot write files or spawn processes, and receives no
+ * parent environment variables. Node 24 does not restrict network access.
+ */
+export async function runInstallModule(modulePath, phase, context, readRoots = [dirname(modulePath)]) {
+    const input = JSON.stringify(context);
+    if (Buffer.byteLength(input) > MAX_BYTES)
+        throw new InstallPlanningError('INSTALL_CONTEXT_LIMIT');
+    let roots;
+    let moduleUrl;
+    try {
+        roots = await Promise.all(readRoots.map((root) => realpath(root)));
+        moduleUrl = pathToFileURL(await realpath(modulePath)).href;
+    }
+    catch {
+        throw new InstallPlanningError('INSTALL_MODULE_MISSING');
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [
+            '--permission',
+            ...roots.map((root) => `--allow-fs-read=${root}`),
+            '--input-type=module',
+            '--eval',
+            RUNNER,
+            moduleUrl,
+            phase,
+        ], { stdio: ['pipe', 'pipe', 'pipe'], env: {}, cwd: roots[0] });
+        const chunks = [];
+        let size = 0;
+        let failure;
+        const stop = (code) => {
+            failure ??= new InstallPlanningError(code);
+            child.kill('SIGKILL');
+        };
+        const timer = setTimeout(() => stop('INSTALL_TIMEOUT'), TIMEOUT_MS);
+        child.stdout.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BYTES)
+                stop('INSTALL_OUTPUT_LIMIT');
+            else if (!failure)
+                chunks.push(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BYTES)
+                stop('INSTALL_OUTPUT_LIMIT');
+        });
+        child.on('error', () => stop('INSTALL_PROCESS_FAILED'));
+        child.stdin.on('error', () => stop('INSTALL_INPUT_FAILED'));
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            if (code !== 0) {
+                reject(new InstallPlanningError('INSTALL_PROCESS_FAILED'));
+                return;
+            }
+            try {
+                const result = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                if (typeof result !== 'object' || result === null || Array.isArray(result))
+                    throw new Error();
+                const envelope = result;
+                if (envelope.ok === true && envelope.missing === true) {
+                    resolve(PHASE_MISSING);
+                    return;
+                }
+                if (envelope.ok === true && Object.hasOwn(envelope, 'plan')) {
+                    resolve(envelope.plan);
+                    return;
+                }
+                if (envelope.ok === false &&
+                    typeof envelope.code === 'string' &&
+                    /^[A-Z][A-Z0-9_]{0,63}$/.test(envelope.code)) {
+                    reject(new InstallPlanningError(envelope.code));
+                    return;
+                }
+            }
+            catch {
+                reject(new InstallPlanningError('INSTALL_OUTPUT_INVALID'));
+                return;
+            }
+            reject(new InstallPlanningError('INSTALL_OUTPUT_INVALID'));
+        });
+        child.stdin.end(input);
+    });
+}

package/dist/install-plan.d.ts

@@ -0,0 +1,12 @@
+import type { Template } from './manifest.js';
+export interface InstallPlan {
+    files: Template[];
+    directories?: string[];
+    entry?: Template;
+    configDefaults?: Record<string, unknown>;
+}
+/**
+ * Validates one installation plan and merges it after the given files.
+ * Extended plans (manifest v2 and installation modules) may declare an entry and defaults.
+ */
+export declare function readInstallPlan(value: unknown, legacy: readonly Template[], extended?: boolean): InstallPlan;

package/dist/install-plan.js

@@ -0,0 +1,90 @@
+import { path as paths } from '@dokebi/core/libraries';
+import { CliError } from './errors.js';
+import { object, relativePath, templateTarget } from './filesystem.js';
+import { validateDefaults } from './merge-install-defaults.js';
+const ENTRY_EXTENSION = /\.(?:ts|mts|js|mjs)$/;
+function template(value, label) {
+    const file = object(value, label);
+    if (Object.keys(file).some((key) => key !== 'source' && key !== 'target') ||
+        typeof file.source !== 'string' ||
+        typeof file.target !== 'string')
+        throw new CliError('INVALID_MANIFEST', `Invalid ${label}`);
+    relativePath(file.source);
+    templateTarget(file.target);
+    return { source: file.source, target: file.target };
+}
+/**
+ * Validates one installation plan and merges it after the given files.
+ * Extended plans (manifest v2 and installation modules) may declare an entry and defaults.
+ */
+export function readInstallPlan(value, legacy, extended = true) {
+    const files = [...legacy];
+    const directories = [];
+    let entry;
+    let configDefaults;
+    if (value !== undefined) {
+        const plan = object(value, 'dokebi.install');
+        const allowed = extended
+            ? ['files', 'directories', 'entry', 'configDefaults']
+            : ['files', 'directories'];
+        if (Object.keys(plan).some((key) => !allowed.includes(key)))
+            throw new CliError('INVALID_MANIFEST', 'Unknown install operation');
+        if (plan.files !== undefined) {
+            if (!Array.isArray(plan.files))
+                throw new CliError('INVALID_MANIFEST', 'Install files must be an array');
+            for (const item of plan.files)
+                files.push(template(item, 'install file'));
+        }
+        if (plan.directories !== undefined) {
+            if (!Array.isArray(plan.directories))
+                throw new CliError('INVALID_MANIFEST', 'Install directories must be an array');
+            for (const directory of plan.directories) {
+                if (typeof directory !== 'string')
+                    throw new CliError('INVALID_MANIFEST', 'Invalid install directory');
+                templateTarget(directory);
+                directories.push(directory);
+            }
+        }
+        if (plan.entry !== undefined) {
+            entry = template(plan.entry, 'install entry');
+            if (!ENTRY_EXTENSION.test(entry.target))
+                throw new CliError('INVALID_MANIFEST', 'Install entry must be a .ts, .mts, .js or .mjs file');
+        }
+        if (plan.configDefaults !== undefined) {
+            try {
+                validateDefaults(plan.configDefaults);
+            }
+            catch {
+                throw new CliError('INVALID_MANIFEST', 'Invalid install configuration defaults');
+            }
+            configDefaults = plan.configDefaults;
+        }
+    }
+    const fileKeys = new Set();
+    for (const file of entry ? [...files, entry] : files) {
+        const key = paths.portablePathKey(file.target);
+        if (fileKeys.has(key))
+            throw new CliError('INVALID_MANIFEST', 'Duplicate install file');
+        fileKeys.add(key);
+    }
+    const directoryKeys = new Set();
+    for (const directory of directories) {
+        const key = paths.portablePathKey(directory);
+        if (directoryKeys.has(key) || fileKeys.has(key))
+            throw new CliError('INVALID_MANIFEST', 'Conflicting install directory');
+        directoryKeys.add(key);
+    }
+    for (const target of [...fileKeys, ...directoryKeys]) {
+        const parts = target.split('/');
+        for (let end = 1; end < parts.length; end++) {
+            if (fileKeys.has(parts.slice(0, end).join('/')))
+                throw new CliError('INVALID_MANIFEST', 'Install file cannot be a parent directory');
+        }
+    }
+    return {
+        files,
+        ...(directories.length ? { directories } : {}),
+        ...(entry ? { entry } : {}),
+        ...(configDefaults ? { configDefaults } : {}),
+    };
+}

package/dist/layout.d.ts

@@ -0,0 +1,17 @@
+import type { InstallPlan } from './install-plan.js';
+/**
+ * Project layout (D-0031, D-0032). Plugins write only into
+ * - `src/shared/<area>/…` — shared business code: models, modules (D-0032), views
+ * - `src/infra/<name>/…` — code that wires a plugin up (connections, types, shared props …)
+ * Files sit inside such a folder; plugins may also create the folder itself.
+ * The app plugin also prepares `src/apps/` (each app's folder is made by `dokebi app add`).
+ */
+export declare function layoutAllowed(path: string, pluginId: string, kind?: 'file' | 'directory'): boolean;
+/** Rejects plugin files and folders outside the layout with INVALID_MANIFEST. */
+export declare function assertLayout(plan: Pick<InstallPlan, 'files' | 'directories'> & {
+    entry?: {
+        target: string;
+    } | undefined;
+}, pluginId: string): void;
+/** Installed entry paths from before D-0031 keep working; doctor reports them once. */
+export declare function legacyLayout(path: string, pluginId: string): boolean;

package/dist/layout.js

@@ -0,0 +1,35 @@
+import { path as paths } from '@dokebi/core/libraries';
+import { CliError } from './errors.js';
+/**
+ * Project layout (D-0031, D-0032). Plugins write only into
+ * - `src/shared/<area>/…` — shared business code: models, modules (D-0032), views
+ * - `src/infra/<name>/…` — code that wires a plugin up (connections, types, shared props …)
+ * Files sit inside such a folder; plugins may also create the folder itself.
+ * The app plugin also prepares `src/apps/` (each app's folder is made by `dokebi app add`).
+ */
+export function layoutAllowed(path, pluginId, kind = 'file') {
+    const key = paths.portablePathKey(path);
+    // Files live inside a named folder: src/shared/<area>/… (models, modules, views — D-0032) or
+    // src/infra/<name>/…
+    const area = kind === 'file'
+        ? /^src\/(shared\/(models|modules|views)|infra\/[^/]+)\/.+$/
+        : /^src\/(shared\/(models|modules|views)|infra\/[^/]+)(\/.+)?$/;
+    if (area.test(key))
+        return true;
+    return pluginId === 'dokebi-app' && (key === 'src/apps' || key.startsWith('src/apps/'));
+}
+/** Rejects plugin files and folders outside the layout with INVALID_MANIFEST. */
+export function assertLayout(plan, pluginId) {
+    const targets = [
+        ...plan.files.map((file) => [file.target, 'file']),
+        ...(plan.entry ? [[plan.entry.target, 'file']] : []),
+        ...(plan.directories ?? []).map((directory) => [directory, 'directory']),
+    ];
+    for (const [target, kind] of targets)
+        if (!layoutAllowed(target, pluginId, kind))
+            throw new CliError('INVALID_MANIFEST', `Plugin ${pluginId} writes outside src/shared/{models,modules,views}/ and src/infra/<name>/: ${target}`);
+}
+/** Installed entry paths from before D-0031 keep working; doctor reports them once. */
+export function legacyLayout(path, pluginId) {
+    return !layoutAllowed(path, pluginId);
+}

package/dist/manifest.d.ts

@@ -1,6 +1,9 @@
 export interface Dependency {
     name: string;
     version: string;
+    optional?: true;
+    /** npm package that provides it; `dokebi add` installs missing required ones (D-0030). */
+    package?: string;
 }
 export interface Template {
     source: string;
@@ -13,9 +16,28 @@ export interface PluginManifest {
     core: string;
     dependencies: Dependency[];
     files: Template[];
+    directories?: string[];
+    entry?: Template;
+    configDefaults?: Record<string, unknown>;
     optionsSchema?: string;
     documentation?: string;
+    installModule?: string;
 }
 export declare const PACKAGE_NAME: RegExp;
-export declare function readManifest(value: unknown): PluginManifest;
-export declare function orderPlugins(plugins: PluginManifest[], coreVersion: string): PluginManifest[];
+export declare const ID: RegExp;
+/**
+ * Reads package.json `dokebi` metadata. Schema 1 keeps the legacy top-level files list.
+ * Schema 2 moves files into `install` and adds optional dependencies, entry and defaults.
+ */
+/**
+ * Reads a package manifest. New packages must follow the project layout (D-0031); manifests
+ * already stored in .dokebi/state.json are read with `checkLayout: false` so older installs work.
+ */
+export declare function readManifest(value: unknown, options?: {
+    checkLayout?: boolean;
+}): PluginManifest;
+/** Reads a manifest previously normalized into .dokebi/state.json. */
+export declare function readStoredManifest(value: unknown): PluginManifest;
+export declare function orderPlugins(plugins: PluginManifest[], coreVersion: string, requiredPlugins?: ReadonlyArray<{
+    id: string;
+}>): PluginManifest[];

package/dist/manifest.js

@@ -1,68 +1,128 @@
-// [AI:생성] CLI 변경 경계를 검증하고 부분 실패 시 원본을 복구할 기반을 구현한다.
 import satisfies from 'semver/functions/satisfies.js';
 import valid from 'semver/functions/valid.js';
 import validRange from 'semver/ranges/valid.js';
 import { CliError } from './errors.js';
-import { object, relativePath, templateTarget } from './filesystem.js';
+import { object, relativePath } from './filesystem.js';
+import { readInstallPlan } from './install-plan.js';
+import { assertLayout } from './layout.js';
 export const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
-const ID = /^[a-z0-9][a-z0-9._/-]*$/;
+export const ID = /^[a-z0-9][a-z0-9._/-]*$/;
 function field(value, label) {
     if (typeof value !== 'string' || !value)
         throw new CliError('INVALID_MANIFEST', label);
     return value;
 }
-export function readManifest(value) {
-    const pkg = object(value, 'package');
-    const metadata = object(pkg.dokebi, 'dokebi');
-    const packageName = field(pkg.name, 'package.name');
-    const version = field(pkg.version, 'package.version');
-    const id = field(metadata.id, 'dokebi.id');
-    const core = field(metadata.core, 'dokebi.core');
-    if (!PACKAGE_NAME.test(packageName) ||
-        !ID.test(id) ||
-        !valid(version) ||
-        !core.trim() ||
-        !validRange(core) ||
-        metadata.schemaVersion !== 1) {
-        throw new CliError('INVALID_MANIFEST', 'Invalid plugin identity, version or schema');
-    }
+function readDependencies(value, extended) {
+    if (!Array.isArray(value))
+        throw new CliError('INVALID_MANIFEST', 'dependencies must be an array');
     const dependencies = [];
-    const files = [];
-    if (!Array.isArray(metadata.dependencies) || !Array.isArray(metadata.files))
-        throw new CliError('INVALID_MANIFEST', 'dependencies and files must be arrays');
-    for (const item of metadata.dependencies) {
+    for (const item of value) {
         const dep = object(item, 'dependency');
         const name = field(dep.name, 'dependency.name');
         const range = field(dep.version, 'dependency.version');
-        if (!ID.test(name) ||
+        const keys = extended ? ['name', 'version', 'optional', 'package'] : ['name', 'version'];
+        if (Object.keys(dep).some((key) => !keys.includes(key)) ||
+            (dep.optional !== undefined && dep.optional !== true) ||
+            (dep.package !== undefined &&
+                (typeof dep.package !== 'string' || !PACKAGE_NAME.test(dep.package))) ||
+            !ID.test(name) ||
             !range.trim() ||
             !validRange(range) ||
             dependencies.some((entry) => entry.name === name)) {
             throw new CliError('INVALID_MANIFEST', 'Invalid or duplicate dependency');
         }
-        dependencies.push({ name, version: range });
-    }
-    for (const item of metadata.files) {
-        const file = object(item, 'template');
-        const source = field(file.source, 'source');
-        const target = field(file.target, 'target');
-        relativePath(source);
-        templateTarget(target);
-        if (files.some((entry) => entry.target === target))
-            throw new CliError('INVALID_MANIFEST', 'Duplicate template target');
-        files.push({ source, target });
+        dependencies.push({
+            name,
+            version: range,
+            ...(dep.optional ? { optional: true } : {}),
+            ...(typeof dep.package === 'string' ? { package: dep.package } : {}),
+        });
     }
+    return dependencies;
+}
+function readResources(metadata) {
     const resources = {};
-    for (const key of ['optionsSchema', 'documentation']) {
+    for (const key of ['optionsSchema', 'documentation', 'installModule']) {
         if (metadata[key] !== undefined) {
             const path = field(metadata[key], key);
             relativePath(path);
             resources[key] = path;
         }
     }
-    return { packageName, version, id, core, dependencies, files, ...resources };
+    return resources;
+}
+/**
+ * Reads package.json `dokebi` metadata. Schema 1 keeps the legacy top-level files list.
+ * Schema 2 moves files into `install` and adds optional dependencies, entry and defaults.
+ */
+/**
+ * Reads a package manifest. New packages must follow the project layout (D-0031); manifests
+ * already stored in .dokebi/state.json are read with `checkLayout: false` so older installs work.
+ */
+export function readManifest(value, options = {}) {
+    const pkg = object(value, 'package');
+    if (pkg.dokebi === undefined)
+        throw new CliError('INVALID_MANIFEST', 'Package is not a Dokebi plugin (no dokebi field)');
+    const metadata = object(pkg.dokebi, 'dokebi');
+    const packageName = field(pkg.name, 'package.name');
+    const version = field(pkg.version, 'package.version');
+    const id = field(metadata.id, 'dokebi.id');
+    const core = field(metadata.core, 'dokebi.core');
+    const schemaVersion = metadata.schemaVersion;
+    if (!PACKAGE_NAME.test(packageName) ||
+        !ID.test(id) ||
+        !valid(version) ||
+        !core.trim() ||
+        !validRange(core) ||
+        (schemaVersion !== 1 && schemaVersion !== 2)) {
+        throw new CliError('INVALID_MANIFEST', 'Invalid plugin identity, version or schema');
+    }
+    const extended = schemaVersion === 2;
+    const dependencies = readDependencies(metadata.dependencies, extended);
+    let legacy = [];
+    if (extended) {
+        if (metadata.files !== undefined)
+            throw new CliError('INVALID_MANIFEST', 'Schema 2 declares files under dokebi.install');
+    }
+    else {
+        if (!Array.isArray(metadata.files))
+            throw new CliError('INVALID_MANIFEST', 'dependencies and files must be arrays');
+        legacy = metadata.files;
+    }
+    const legacyFiles = readInstallPlan({ files: legacy }, [], false).files;
+    const install = readInstallPlan(metadata.install, legacyFiles, extended);
+    if (options.checkLayout !== false)
+        assertLayout(install, id);
+    return { packageName, version, id, core, dependencies, ...install, ...readResources(metadata) };
+}
+/** Reads a manifest previously normalized into .dokebi/state.json. */
+export function readStoredManifest(value) {
+    const stored = object(value, 'plugin');
+    const install = {};
+    if (stored.files !== undefined)
+        install.files = stored.files;
+    if (stored.directories !== undefined)
+        install.directories = stored.directories;
+    if (stored.entry !== undefined)
+        install.entry = stored.entry;
+    if (stored.configDefaults !== undefined)
+        install.configDefaults = stored.configDefaults;
+    return readManifest({
+        name: stored.packageName,
+        version: stored.version,
+        dokebi: {
+            schemaVersion: 2,
+            id: stored.id,
+            core: stored.core,
+            dependencies: stored.dependencies,
+            install,
+            ...(stored.optionsSchema === undefined ? {} : { optionsSchema: stored.optionsSchema }),
+            ...(stored.documentation === undefined ? {} : { documentation: stored.documentation }),
+            ...(stored.installModule === undefined ? {} : { installModule: stored.installModule }),
+        },
+    }, { checkLayout: false });
 }
-export function orderPlugins(plugins, coreVersion) {
+export function orderPlugins(plugins, coreVersion, requiredPlugins = []) {
     const byId = new Map(plugins.map((plugin) => [plugin.id, plugin]));
     if (byId.size !== plugins.length)
         throw new CliError('DUPLICATE_PLUGIN', 'Duplicate plugin ID');
@@ -78,9 +138,14 @@ export function orderPlugins(plugins, coreVersion) {
             throw new CliError('INCOMPATIBLE_VERSION', plugin.id);
         visiting.add(plugin.id);
         for (const dep of plugin.dependencies) {
+            if (requiredPlugins.some((required) => required.id === dep.name))
+                throw new CliError('REQUIRED_PLUGIN_DEPENDENCY', 'Use app.config for core configuration; required plugins are not factory dependency references');
             const provider = byId.get(dep.name);
-            if (!provider)
+            if (!provider) {
+                if (dep.optional)
+                    continue;
                 throw new CliError('MISSING_DEPENDENCY', dep.name);
+            }
             if (!satisfies(provider.version, dep.version))
                 throw new CliError('INCOMPATIBLE_VERSION', dep.name);
             visit(provider);

package/dist/merge-install-defaults.d.ts

@@ -0,0 +1,2 @@
+export declare function validateDefaults(value: unknown): asserts value is Record<string, unknown>;
+export declare function mergeInstallDefaults(source: string, id: string, defaults: unknown): string;

package/dist/merge-install-defaults.js

@@ -0,0 +1,79 @@
+import { isDeepStrictEqual } from 'node:util';
+import { isMap, parseDocument } from 'yaml';
+import { parseProjectConfig, renderConfig } from './configuration.js';
+import { CliError } from './errors.js';
+function invalid() {
+    throw new CliError('INVALID_INSTALL_DEFAULTS', 'Plugin defaults must be bounded JSON values within their own configuration namespace.');
+}
+function isRecord(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+export function validateDefaults(value) {
+    if (!isRecord(value))
+        invalid();
+    let count = 0;
+    const seen = new WeakSet();
+    const visit = (item, depth) => {
+        count += 1;
+        if (count > 2000 || depth > 16)
+            invalid();
+        if (item === null || typeof item === 'string' || typeof item === 'boolean')
+            return;
+        if (typeof item === 'number' && Number.isFinite(item))
+            return;
+        if (typeof item !== 'object' || item === null || seen.has(item))
+            invalid();
+        seen.add(item);
+        if (Array.isArray(item)) {
+            for (const child of item)
+                visit(child, depth + 1);
+            return;
+        }
+        if (!isRecord(item))
+            invalid();
+        for (const [key, child] of Object.entries(item)) {
+            if (['__proto__', 'constructor', 'prototype', '<<'].includes(key))
+                invalid();
+            visit(child, depth + 1);
+        }
+    };
+    visit(value, 0);
+    if (Buffer.byteLength(JSON.stringify(value)) > 1024 * 1024)
+        invalid();
+}
+export function mergeInstallDefaults(source, id, defaults) {
+    validateDefaults(defaults);
+    const before = parseProjectConfig(source);
+    if (Object.keys(defaults).length === 0)
+        return source;
+    const document = parseDocument(source);
+    const merge = (target, values) => {
+        for (const [key, value] of Object.entries(values)) {
+            if (!target.has(key))
+                target.set(key, document.createNode(value));
+            else {
+                const current = target.get(key, true);
+                if (isMap(current) && isRecord(value))
+                    merge(current, value);
+            }
+        }
+    };
+    if (!document.hasIn(['options']))
+        document.setIn(['options'], document.createNode({}));
+    if (!document.hasIn(['options', id]))
+        document.setIn(['options', id], document.createNode(defaults));
+    else {
+        const target = document.getIn(['options', id], true);
+        if (isMap(target))
+            merge(target, defaults);
+    }
+    const result = renderConfig(document);
+    const after = parseProjectConfig(result);
+    for (const [key, value] of Object.entries(before.options))
+        if (key !== id && !isDeepStrictEqual(value, after.options[key]))
+            invalid();
+    return result;
+}

package/dist/npm-client.d.ts

@@ -2,5 +2,11 @@ export declare function packageSpec(spec: string, cwd: string): string;
 export declare function dependencyMap(pkg: Record<string, unknown>): Record<string, string>;
 export declare function validateProjectPackage(pkg: Record<string, unknown>): void;
 export declare class NpmClient {
+    #private;
+    /** Installs into a standalone directory (the project or the CLI's staging). */
     install(directory: string, spec?: string): Promise<void>;
+    /** `npm pack` of a workspace package into `destination`; returns the archive path (D-0035). */
+    pack(directory: string, destination: string): Promise<string>;
+    /** `npm install` at a workspace root: brings its lock and node_modules in line (D-0035). */
+    installWorkspace(root: string): Promise<void>;
 }