anhedral 0.4.2 → 0.6.1

package/dist/architecture/manifest.js

@@ -1,283 +0,0 @@
-import { DEFAULT_MODULE_REGISTRY, isModuleId, resolveModules, } from './modules.js';
-import { isFileOwnershipClass, isSha256, normalizePlanPath, } from './plan.js';
-import { isTemplateId, templateIdsForModules, } from './templates.js';
-import { isNativeStylingLibrary, isUiProvider, isUiTarget, normalizeUiComponentName, providerForTarget, uiInstallKey, } from '../ui.js';
-export const MANIFEST_SCHEMA_VERSION = 5;
-export class ManifestValidationError extends Error {
-    code;
-    path;
-    constructor(code, message, path) {
-        super(message);
-        this.code = code;
-        this.path = path;
-        this.name = 'ManifestValidationError';
-    }
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function readNonEmptyString(value, path) {
-    if (typeof value !== 'string' || value.trim().length === 0) {
-        throw new ManifestValidationError('INVALID_MANIFEST', `${path} must be a non-empty string`, path);
-    }
-    return value;
-}
-function assertExactKeys(value, expected, path, code = 'INVALID_MANIFEST') {
-    const expectedKeys = new Set(expected);
-    const actual = Object.keys(value);
-    const missing = expected.filter((key) => !Object.hasOwn(value, key));
-    const unknown = actual.filter((key) => !expectedKeys.has(key));
-    if (missing.length === 0 && unknown.length === 0)
-        return;
-    const details = [
-        missing.length > 0 ? `missing ${missing.join(', ')}` : null,
-        unknown.length > 0 ? `unknown ${unknown.join(', ')}` : null,
-    ].filter((entry) => entry !== null).join('; ');
-    throw new ManifestValidationError(code, `${path} has invalid fields (${details})`, path);
-}
-function parseModuleArray(value) {
-    if (!Array.isArray(value)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'modules must be an array', 'modules');
-    }
-    const seen = new Set();
-    const modules = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const entry = value[index];
-        if (!isModuleId(entry)) {
-            throw new ManifestValidationError('UNKNOWN_MODULE', `modules[${index}] is not a supported module: ${String(entry)}`, `modules[${index}]`);
-        }
-        if (seen.has(entry)) {
-            throw new ManifestValidationError('DUPLICATE_MODULE', `modules contains duplicate module ${entry}`, 'modules');
-        }
-        seen.add(entry);
-        modules.push(entry);
-    }
-    return Object.freeze(modules);
-}
-function assertExactModuleClosure(modules, registry) {
-    let expected;
-    try {
-        expected = resolveModules(modules, registry).resolvedModules;
-    }
-    catch (error) {
-        throw new ManifestValidationError('INVALID_MANIFEST', error instanceof Error ? error.message : 'Manifest modules are invalid', 'modules');
-    }
-    if (expected.length !== modules.length || expected.some((moduleId, index) => modules[index] !== moduleId)) {
-        throw new ManifestValidationError('INVALID_MODULE_CLOSURE', `modules must be the complete, canonically ordered dependency closure: ${expected.join(', ')}`, 'modules');
-    }
-}
-function readFileRecord(value, path, modules) {
-    if (!isRecord(value)) {
-        throw new ManifestValidationError('INVALID_FILE_RECORD', `${path} must be an object`, path);
-    }
-    assertExactKeys(value, ['owner', 'ownership', 'hash', 'mode'], path, 'INVALID_FILE_RECORD');
-    const owner = value.owner;
-    if (owner !== 'root' && !isModuleId(owner)) {
-        throw new ManifestValidationError('INVALID_FILE_RECORD', `${path}.owner is invalid`, `${path}.owner`);
-    }
-    if (owner !== 'root' && !modules.has(owner)) {
-        throw new ManifestValidationError('INVALID_FILE_RECORD', `${path}.owner references an unselected module: ${owner}`, `${path}.owner`);
-    }
-    if (!isFileOwnershipClass(value.ownership)) {
-        throw new ManifestValidationError('INVALID_FILE_RECORD', `${path}.ownership is invalid`, `${path}.ownership`);
-    }
-    if (!isSha256(value.hash)) {
-        throw new ManifestValidationError('INVALID_FILE_RECORD', `${path}.hash must be a SHA-256 hex digest`, `${path}.hash`);
-    }
-    const mode = value.mode;
-    if (mode !== null && (!Number.isInteger(mode) || mode < 0 || mode > 0o777)) {
-        throw new ManifestValidationError('INVALID_FILE_RECORD', `${path}.mode must be null or normalized Unix permission bits between 0 and 511`, `${path}.mode`);
-    }
-    return Object.freeze({
-        owner,
-        ownership: value.ownership,
-        hash: value.hash,
-        mode: mode,
-    });
-}
-function readFiles(value, modules) {
-    if (!isRecord(value)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'files must be an object', 'files');
-    }
-    const moduleSet = new Set(modules);
-    const entries = [];
-    for (const rawPath of Object.keys(value).sort()) {
-        let filePath;
-        try {
-            filePath = normalizePlanPath(rawPath);
-        }
-        catch {
-            throw new ManifestValidationError('INVALID_FILE_RECORD', `Invalid manifest file path: ${rawPath}`, `files.${rawPath}`);
-        }
-        if (filePath !== rawPath) {
-            throw new ManifestValidationError('INVALID_FILE_RECORD', `Manifest file path is not canonical: ${rawPath}`, `files.${rawPath}`);
-        }
-        entries.push([filePath, readFileRecord(value[rawPath], `files.${rawPath}`, moduleSet)]);
-    }
-    return Object.freeze(Object.fromEntries(entries));
-}
-function readTemplates(value, modules) {
-    if (!isRecord(value)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'templates must be an object', 'templates');
-    }
-    const entries = [];
-    const expectedIds = [...templateIdsForModules(modules)].sort();
-    const actualIds = Object.keys(value).sort();
-    if (expectedIds.length !== actualIds.length
-        || expectedIds.some((id, index) => id !== actualIds[index])) {
-        throw new ManifestValidationError('INVALID_MANIFEST', `templates must exactly match selected modules: ${expectedIds.join(', ')}`, 'templates');
-    }
-    for (const id of Object.keys(value).sort()) {
-        if (!isTemplateId(id)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `Unknown template: ${id}`, `templates.${id}`);
-        }
-        const entry = value[id];
-        if (!isRecord(entry)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `templates.${id} must be an object`, `templates.${id}`);
-        }
-        assertExactKeys(entry, ['version', 'sha256'], `templates.${id}`);
-        if (!Number.isInteger(entry.version) || entry.version < 1) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `templates.${id}.version must be a positive integer`, `templates.${id}.version`);
-        }
-        if (!isSha256(entry.sha256)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `templates.${id}.sha256 must be a SHA-256 hex digest`, `templates.${id}.sha256`);
-        }
-        entries.push([id, Object.freeze({ version: entry.version, sha256: entry.sha256 })]);
-    }
-    return Object.freeze(Object.fromEntries(entries));
-}
-function readUi(value, modules) {
-    if (!isRecord(value)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'ui must be an object', 'ui');
-    }
-    assertExactKeys(value, ['nativeStyling', 'components'], 'ui');
-    if (!isNativeStylingLibrary(value.nativeStyling)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'ui.nativeStyling must be nativewind or uniwind', 'ui.nativeStyling');
-    }
-    if (!Array.isArray(value.components)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'ui.components must be an array', 'ui.components');
-    }
-    const selectedModules = new Set(modules);
-    const seen = new Set();
-    const components = [];
-    for (let index = 0; index < value.components.length; index += 1) {
-        const itemPath = `ui.components[${index}]`;
-        const item = value.components[index];
-        if (!isRecord(item)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `${itemPath} must be an object`, itemPath);
-        }
-        assertExactKeys(item, ['name', 'target', 'provider', 'source', 'variant'], itemPath);
-        let name;
-        try {
-            name = normalizeUiComponentName(readNonEmptyString(item.name, `${itemPath}.name`));
-        }
-        catch (error) {
-            throw new ManifestValidationError('INVALID_MANIFEST', error instanceof Error ? error.message : `${itemPath}.name is invalid`, `${itemPath}.name`);
-        }
-        if (!isUiTarget(item.target) || !selectedModules.has(item.target)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `${itemPath}.target is not a selected UI client`, `${itemPath}.target`);
-        }
-        if (!isUiProvider(item.provider) || item.provider !== providerForTarget(item.target)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `${itemPath}.provider does not match its target`, `${itemPath}.provider`);
-        }
-        const source = readNonEmptyString(item.source, `${itemPath}.source`);
-        const variant = item.variant;
-        if (item.target === 'mobile') {
-            if (!isNativeStylingLibrary(variant) || variant !== value.nativeStyling) {
-                throw new ManifestValidationError('INVALID_MANIFEST', `${itemPath}.variant must match ui.nativeStyling`, `${itemPath}.variant`);
-            }
-        }
-        else if (variant !== null) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `${itemPath}.variant must be null for DOM clients`, `${itemPath}.variant`);
-        }
-        const install = Object.freeze({ name, target: item.target, provider: item.provider, source, variant });
-        const key = uiInstallKey(install);
-        if (seen.has(key)) {
-            throw new ManifestValidationError('INVALID_MANIFEST', `Duplicate UI component installation: ${key}`, itemPath);
-        }
-        seen.add(key);
-        components.push(install);
-    }
-    const canonical = [...components].sort((left, right) => uiInstallKey(left).localeCompare(uiInstallKey(right)));
-    if (canonical.some((component, index) => component !== components[index])) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'ui.components must be canonically sorted', 'ui.components');
-    }
-    return Object.freeze({ nativeStyling: value.nativeStyling, components: Object.freeze(components) });
-}
-function parseInput(input) {
-    if (typeof input !== 'string')
-        return input;
-    try {
-        return JSON.parse(input);
-    }
-    catch (error) {
-        throw new ManifestValidationError('INVALID_JSON', `Manifest is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, '$');
-    }
-}
-export function readManifest(input, registry = DEFAULT_MODULE_REGISTRY) {
-    const value = parseInput(input);
-    if (!isRecord(value)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'Manifest must be an object', '$');
-    }
-    const schemaVersion = value.schemaVersion;
-    if (typeof schemaVersion !== 'number' || !Number.isInteger(schemaVersion) || schemaVersion < 1) {
-        throw new ManifestValidationError('INVALID_SCHEMA_VERSION', `schemaVersion must be exactly ${MANIFEST_SCHEMA_VERSION}`, 'schemaVersion');
-    }
-    if (schemaVersion > MANIFEST_SCHEMA_VERSION) {
-        throw new ManifestValidationError('FUTURE_SCHEMA_VERSION', `Manifest schema ${schemaVersion} is newer than supported schema ${MANIFEST_SCHEMA_VERSION}`, 'schemaVersion');
-    }
-    if (schemaVersion !== MANIFEST_SCHEMA_VERSION) {
-        throw new ManifestValidationError('INVALID_SCHEMA_VERSION', `Unsupported manifest schema: ${schemaVersion}; expected ${MANIFEST_SCHEMA_VERSION}`, 'schemaVersion');
-    }
-    assertExactKeys(value, ['schemaVersion', 'generatorVersion', 'project', 'modules', 'toolchain', 'templates', 'ui', 'files'], '$');
-    if (!isRecord(value.project)) {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'project must be an object', 'project');
-    }
-    assertExactKeys(value.project, ['name', 'displayName'], 'project');
-    const project = Object.freeze({
-        name: readNonEmptyString(value.project.name, 'project.name'),
-        displayName: readNonEmptyString(value.project.displayName, 'project.displayName'),
-    });
-    const modules = parseModuleArray(value.modules);
-    assertExactModuleClosure(modules, registry);
-    if (value.toolchain !== 'stable' && value.toolchain !== 'latest') {
-        throw new ManifestValidationError('INVALID_MANIFEST', 'toolchain must be either stable or latest', 'toolchain');
-    }
-    return Object.freeze({
-        schemaVersion: MANIFEST_SCHEMA_VERSION,
-        generatorVersion: readNonEmptyString(value.generatorVersion, 'generatorVersion'),
-        project,
-        modules,
-        toolchain: value.toolchain,
-        templates: readTemplates(value.templates, modules),
-        ui: readUi(value.ui, modules),
-        files: readFiles(value.files, modules),
-    });
-}
-export function createManifest(input) {
-    const files = Object.fromEntries(input.plan.files.map((file) => [
-        file.path,
-        {
-            owner: file.owner,
-            ownership: file.ownership,
-            hash: file.contentHash,
-            mode: null,
-        },
-    ]));
-    return readManifest({
-        schemaVersion: MANIFEST_SCHEMA_VERSION,
-        generatorVersion: input.generatorVersion,
-        project: input.project,
-        modules: input.plan.resolvedModules,
-        toolchain: input.toolchain,
-        templates: input.templates,
-        ui: {
-            nativeStyling: input.nativeStyling ?? 'nativewind',
-            components: input.components ?? [],
-        },
-        files,
-    }, input.registry ?? DEFAULT_MODULE_REGISTRY);
-}
-export function serializeManifest(manifest) {
-    return `${JSON.stringify(manifest, null, 2)}\n`;
-}

package/dist/architecture/modules.d.ts

@@ -1,41 +0,0 @@
-export declare const APP_MODULES: readonly ["web", "mobile", "api", "desktop", "extension"];
-export declare const FEATURE_MODULES: readonly ["db", "auth", "billing", "storage", "native-subscriptions", "electron-updater"];
-export declare const MODULE_IDS: readonly ["web", "mobile", "api", "desktop", "extension", "db", "auth", "billing", "storage", "native-subscriptions", "electron-updater"];
-export type AppModule = (typeof APP_MODULES)[number];
-export type FeatureModule = (typeof FEATURE_MODULES)[number];
-export type ModuleId = (typeof MODULE_IDS)[number];
-export type ModuleKind = 'app' | 'feature';
-export type ModuleDefinition = {
-    readonly id: ModuleId;
-    readonly kind: ModuleKind;
-    readonly requires: readonly ModuleId[];
-    readonly conflicts: readonly ModuleId[];
-};
-export type ModuleRegistry = Readonly<Record<ModuleId, ModuleDefinition>>;
-export type DependencyEdge = {
-    readonly module: ModuleId;
-    readonly requires: ModuleId;
-};
-export type ModuleResolution = {
-    readonly requestedModules: readonly ModuleId[];
-    readonly resolvedModules: readonly ModuleId[];
-    readonly dependencyAddedModules: readonly ModuleId[];
-    readonly dependencyEdges: readonly DependencyEdge[];
-};
-export type ModuleRegistryErrorCode = 'DUPLICATE_MODULE_DEFINITION' | 'MISSING_MODULE_DEFINITION' | 'UNKNOWN_MODULE_REFERENCE' | 'SELF_DEPENDENCY' | 'SELF_CONFLICT' | 'DEPENDENCY_CYCLE';
-export declare class ModuleRegistryError extends Error {
-    readonly code: ModuleRegistryErrorCode;
-    readonly modules: readonly string[];
-    constructor(code: ModuleRegistryErrorCode, message: string, modules?: readonly string[]);
-}
-export type ModuleResolutionErrorCode = 'UNKNOWN_MODULE' | 'MODULE_CONFLICT';
-export declare class ModuleResolutionError extends Error {
-    readonly code: ModuleResolutionErrorCode;
-    readonly modules: readonly string[];
-    constructor(code: ModuleResolutionErrorCode, message: string, modules: readonly string[]);
-}
-export declare function isModuleId(value: unknown): value is ModuleId;
-export declare function createModuleRegistry(definitions: readonly ModuleDefinition[]): ModuleRegistry;
-export declare const DEFAULT_MODULE_DEFINITIONS: readonly ModuleDefinition[];
-export declare const DEFAULT_MODULE_REGISTRY: Readonly<Record<"electron-updater" | "web" | "mobile" | "desktop" | "extension" | "auth" | "billing" | "storage" | "api" | "db" | "native-subscriptions", ModuleDefinition>>;
-export declare function resolveModules(requested: readonly string[], registry?: ModuleRegistry): ModuleResolution;

package/dist/architecture/modules.js

@@ -1,187 +0,0 @@
-export const APP_MODULES = [
-    'web',
-    'mobile',
-    'api',
-    'desktop',
-    'extension',
-];
-export const FEATURE_MODULES = [
-    'db',
-    'auth',
-    'billing',
-    'storage',
-    'native-subscriptions',
-    'electron-updater',
-];
-export const MODULE_IDS = [...APP_MODULES, ...FEATURE_MODULES];
-export class ModuleRegistryError extends Error {
-    code;
-    modules;
-    constructor(code, message, modules = []) {
-        super(message);
-        this.code = code;
-        this.modules = modules;
-        this.name = 'ModuleRegistryError';
-    }
-}
-export class ModuleResolutionError extends Error {
-    code;
-    modules;
-    constructor(code, message, modules) {
-        super(message);
-        this.code = code;
-        this.modules = modules;
-        this.name = 'ModuleResolutionError';
-    }
-}
-const MODULE_ID_SET = new Set(MODULE_IDS);
-const MODULE_ORDER = new Map(MODULE_IDS.map((id, index) => [id, index]));
-export function isModuleId(value) {
-    return typeof value === 'string' && MODULE_ID_SET.has(value);
-}
-function compareModules(left, right) {
-    return (MODULE_ORDER.get(left) ?? Number.MAX_SAFE_INTEGER)
-        - (MODULE_ORDER.get(right) ?? Number.MAX_SAFE_INTEGER);
-}
-function normalizeModuleList(values) {
-    return Object.freeze([...new Set(values)].sort(compareModules));
-}
-function freezeDefinition(definition) {
-    return Object.freeze({
-        id: definition.id,
-        kind: definition.kind,
-        requires: normalizeModuleList(definition.requires),
-        conflicts: normalizeModuleList(definition.conflicts),
-    });
-}
-function assertNoDependencyCycles(registry) {
-    const visited = new Set();
-    const active = new Set();
-    const stack = [];
-    const visit = (moduleId) => {
-        if (visited.has(moduleId))
-            return;
-        if (active.has(moduleId)) {
-            const cycleStart = stack.indexOf(moduleId);
-            const cycle = [...stack.slice(cycleStart), moduleId];
-            throw new ModuleRegistryError('DEPENDENCY_CYCLE', `Module dependency cycle detected: ${cycle.join(' -> ')}`, Object.freeze(cycle));
-        }
-        active.add(moduleId);
-        stack.push(moduleId);
-        for (const required of registry[moduleId].requires)
-            visit(required);
-        stack.pop();
-        active.delete(moduleId);
-        visited.add(moduleId);
-    };
-    for (const moduleId of MODULE_IDS)
-        visit(moduleId);
-}
-export function createModuleRegistry(definitions) {
-    const registry = {};
-    for (const definition of definitions) {
-        if (!isModuleId(definition.id)) {
-            throw new ModuleRegistryError('UNKNOWN_MODULE_REFERENCE', `Unknown module definition: ${String(definition.id)}`, Object.freeze([String(definition.id)]));
-        }
-        if (registry[definition.id]) {
-            throw new ModuleRegistryError('DUPLICATE_MODULE_DEFINITION', `Duplicate module definition: ${definition.id}`, Object.freeze([definition.id]));
-        }
-        for (const required of definition.requires) {
-            if (!isModuleId(required)) {
-                throw new ModuleRegistryError('UNKNOWN_MODULE_REFERENCE', `Module ${definition.id} requires unknown module ${String(required)}`, Object.freeze([definition.id, String(required)]));
-            }
-            if (required === definition.id) {
-                throw new ModuleRegistryError('SELF_DEPENDENCY', `Module ${definition.id} cannot require itself`, Object.freeze([definition.id]));
-            }
-        }
-        for (const conflict of definition.conflicts) {
-            if (!isModuleId(conflict)) {
-                throw new ModuleRegistryError('UNKNOWN_MODULE_REFERENCE', `Module ${definition.id} conflicts with unknown module ${String(conflict)}`, Object.freeze([definition.id, String(conflict)]));
-            }
-            if (conflict === definition.id) {
-                throw new ModuleRegistryError('SELF_CONFLICT', `Module ${definition.id} cannot conflict with itself`, Object.freeze([definition.id]));
-            }
-        }
-        registry[definition.id] = freezeDefinition(definition);
-    }
-    const missing = MODULE_IDS.filter((moduleId) => !registry[moduleId]);
-    if (missing.length > 0) {
-        throw new ModuleRegistryError('MISSING_MODULE_DEFINITION', `Missing module definitions: ${missing.join(', ')}`, Object.freeze(missing));
-    }
-    const completeRegistry = Object.freeze(registry);
-    assertNoDependencyCycles(completeRegistry);
-    return completeRegistry;
-}
-const DEFAULT_MODULE_DEFINITION_INPUTS = [
-    { id: 'web', kind: 'app', requires: [], conflicts: [] },
-    { id: 'mobile', kind: 'app', requires: [], conflicts: [] },
-    { id: 'api', kind: 'app', requires: [], conflicts: [] },
-    { id: 'desktop', kind: 'app', requires: [], conflicts: [] },
-    { id: 'extension', kind: 'app', requires: [], conflicts: [] },
-    { id: 'db', kind: 'feature', requires: [], conflicts: [] },
-    { id: 'auth', kind: 'feature', requires: ['api', 'db'], conflicts: [] },
-    { id: 'billing', kind: 'feature', requires: ['auth'], conflicts: [] },
-    { id: 'storage', kind: 'feature', requires: ['auth'], conflicts: [] },
-    { id: 'native-subscriptions', kind: 'feature', requires: ['mobile', 'billing'], conflicts: [] },
-    { id: 'electron-updater', kind: 'feature', requires: ['desktop'], conflicts: [] },
-];
-export const DEFAULT_MODULE_DEFINITIONS = Object.freeze(DEFAULT_MODULE_DEFINITION_INPUTS.map(freezeDefinition));
-export const DEFAULT_MODULE_REGISTRY = createModuleRegistry(DEFAULT_MODULE_DEFINITIONS);
-export function resolveModules(requested, registry = DEFAULT_MODULE_REGISTRY) {
-    const unknown = [...new Set(requested.filter((moduleId) => !isModuleId(moduleId)))].sort();
-    if (unknown.length > 0) {
-        throw new ModuleResolutionError('UNKNOWN_MODULE', `Unknown modules: ${unknown.join(', ')}`, Object.freeze(unknown));
-    }
-    const requestedModules = normalizeModuleList(requested);
-    const resolved = new Set();
-    const visiting = new Set();
-    const ordered = [];
-    const visit = (moduleId) => {
-        if (resolved.has(moduleId))
-            return;
-        if (visiting.has(moduleId)) {
-            throw new ModuleRegistryError('DEPENDENCY_CYCLE', `Module dependency cycle reached while resolving ${moduleId}`, Object.freeze([moduleId]));
-        }
-        visiting.add(moduleId);
-        for (const required of registry[moduleId].requires)
-            visit(required);
-        visiting.delete(moduleId);
-        resolved.add(moduleId);
-        ordered.push(moduleId);
-    };
-    for (const moduleId of requestedModules)
-        visit(moduleId);
-    const conflictPairs = new Set();
-    for (const moduleId of ordered) {
-        for (const conflict of registry[moduleId].conflicts) {
-            if (!resolved.has(conflict))
-                continue;
-            const pair = [moduleId, conflict].sort(compareModules);
-            conflictPairs.add(`${pair[0]}\0${pair[1]}`);
-        }
-    }
-    if (conflictPairs.size > 0) {
-        const conflicts = [...conflictPairs]
-            .map((pair) => pair.split('\0'))
-            .sort(([leftA, leftB], [rightA, rightB]) => compareModules(leftA, rightA) || compareModules(leftB, rightB));
-        const modules = Object.freeze([...new Set(conflicts.flat())].sort(compareModules));
-        throw new ModuleResolutionError('MODULE_CONFLICT', `Conflicting modules: ${conflicts.map(([left, right]) => `${left} + ${right}`).join(', ')}`, modules);
-    }
-    // Resolution must have one stable representation regardless of whether a
-    // dependency was requested directly or discovered while walking another
-    // module. Without this final normalization, adding a module to an existing
-    // project could produce a different manifest order than creating the same
-    // topology directly (for example, adding electron-updater after db/auth).
-    const resolvedModules = normalizeModuleList(ordered);
-    const requestedSet = new Set(requestedModules);
-    const dependencyAddedModules = resolvedModules.filter((moduleId) => !requestedSet.has(moduleId));
-    const dependencyEdges = resolvedModules.flatMap((moduleId) => registry[moduleId].requires
-        .filter((required) => resolved.has(required))
-        .map((required) => Object.freeze({ module: moduleId, requires: required })));
-    return Object.freeze({
-        requestedModules,
-        resolvedModules,
-        dependencyAddedModules: Object.freeze(dependencyAddedModules),
-        dependencyEdges: Object.freeze(dependencyEdges),
-    });
-}

package/dist/architecture/plan.d.ts

@@ -1,58 +0,0 @@
-import { type DependencyEdge, type ModuleId, type ModuleRegistry } from './modules.js';
-export declare const FILE_OWNERSHIP_CLASSES: readonly ["managed", "mergeable", "user"];
-export type FileOwnershipClass = (typeof FILE_OWNERSHIP_CLASSES)[number];
-export type FileOwner = ModuleId | 'root';
-export type GenerationOperation = 'init' | 'add';
-export type FileWritePolicy = 'replace-if-unmodified' | 'structural-merge' | 'create-only';
-export type PlanFileInput = {
-    readonly path: string;
-    readonly ownership: FileOwnershipClass;
-    readonly content: string;
-};
-export type ModulePlanContribution = {
-    readonly module: FileOwner;
-    readonly files: readonly PlanFileInput[];
-};
-export type PlannedFile = {
-    readonly path: string;
-    readonly owner: FileOwner;
-    readonly ownership: FileOwnershipClass;
-    readonly writePolicy: FileWritePolicy;
-    readonly content: string;
-    readonly contentHash: string;
-};
-export type GenerationPlan = {
-    readonly planVersion: 1;
-    readonly operation: GenerationOperation;
-    readonly requestedModules: readonly ModuleId[];
-    readonly resolvedModules: readonly ModuleId[];
-    readonly dependencyAddedModules: readonly ModuleId[];
-    readonly dependencyEdges: readonly DependencyEdge[];
-    readonly files: readonly PlannedFile[];
-    readonly fingerprint: string;
-};
-export type BuildGenerationPlanInput = {
-    readonly operation: GenerationOperation;
-    readonly requestedModules: readonly string[];
-    readonly contributions?: readonly ModulePlanContribution[];
-    readonly registry?: ModuleRegistry;
-};
-export type PlanBuildErrorCode = 'INVALID_OPERATION' | 'INVALID_PLAN_PATH' | 'INVALID_FILE_OWNER' | 'INVALID_FILE_OWNERSHIP' | 'INVALID_FILE_CONTENT' | 'UNRESOLVED_CONTRIBUTION' | 'DUPLICATE_OUTPUT_PATH';
-export declare class PlanBuildError extends Error {
-    readonly code: PlanBuildErrorCode;
-    readonly paths: readonly string[];
-    constructor(code: PlanBuildErrorCode, message: string, paths?: readonly string[]);
-}
-export declare function isFileOwnershipClass(value: unknown): value is FileOwnershipClass;
-export declare function isSha256(value: unknown): value is string;
-/**
- * Hash rendered text or exact filesystem bytes.
- *
- * Strings are encoded as UTF-8 for deterministic generation-plan fingerprints.
- * Callers hashing an existing file must pass its Buffer/Uint8Array so malformed
- * byte sequences cannot collapse to the same Unicode replacement characters.
- */
-export declare function hashContent(content: string | Uint8Array): string;
-export declare function writePolicyForOwnership(ownership: FileOwnershipClass): FileWritePolicy;
-export declare function normalizePlanPath(value: string): string;
-export declare function buildGenerationPlan(input: BuildGenerationPlanInput): GenerationPlan;