anhedral 0.4.1 → 0.6.0

package/dist/architecture/contributions.d.ts

@@ -1,28 +0,0 @@
-import { type ModuleId } from './modules.js';
-export type EnvironmentContribution = {
-    readonly owner: ModuleId;
-    readonly name: string;
-    readonly defaultValue: string;
-};
-export type CronContribution = {
-    readonly owner: ModuleId;
-    readonly id: string;
-    readonly path: string;
-    readonly schedule: string;
-};
-export type ModuleCompositionContribution = {
-    readonly module: ModuleId;
-    readonly environment: readonly Omit<EnvironmentContribution, 'owner'>[];
-    readonly crons: readonly Omit<CronContribution, 'owner'>[];
-};
-export type CompositionModel = {
-    readonly modules: readonly ModuleId[];
-    readonly environment: readonly EnvironmentContribution[];
-    readonly crons: readonly CronContribution[];
-};
-export type CompositionErrorCode = 'DUPLICATE_ENVIRONMENT_CONTRIBUTION' | 'DUPLICATE_CRON_CONTRIBUTION';
-export declare class CompositionError extends Error {
-    readonly code: CompositionErrorCode;
-    constructor(code: CompositionErrorCode, message: string);
-}
-export declare function collectModuleContributions(requestedModules: readonly ModuleId[], overrides?: Readonly<Partial<Record<ModuleId, ModuleCompositionContribution>>>): CompositionModel;

package/dist/architecture/contributions.js

@@ -1,125 +0,0 @@
-import { resolveModules } from './modules.js';
-export class CompositionError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'CompositionError';
-    }
-}
-const EMPTY = Object.freeze([]);
-const MODULE_CONTRIBUTIONS = Object.freeze({
-    web: Object.freeze({ module: 'web', environment: EMPTY, crons: EMPTY }),
-    mobile: Object.freeze({ module: 'mobile', environment: EMPTY, crons: EMPTY }),
-    api: Object.freeze({
-        module: 'api',
-        environment: Object.freeze([
-            { name: 'ANHEDRAL_DEMO', defaultValue: 'false' },
-            { name: 'PORT', defaultValue: '8787' },
-            { name: 'TRUST_PROXY_HOPS', defaultValue: '0' },
-            { name: 'CORS_ORIGINS', defaultValue: '' },
-        ]),
-        crons: EMPTY,
-    }),
-    desktop: Object.freeze({ module: 'desktop', environment: EMPTY, crons: EMPTY }),
-    extension: Object.freeze({ module: 'extension', environment: EMPTY, crons: EMPTY }),
-    db: Object.freeze({
-        module: 'db',
-        environment: Object.freeze([{ name: 'DATABASE_URL', defaultValue: 'YOUR_NEON_POSTGRES_URL' }]),
-        crons: EMPTY,
-    }),
-    auth: Object.freeze({
-        module: 'auth',
-        environment: Object.freeze([
-            { name: 'CLERK_PUBLISHABLE_KEY', defaultValue: 'pk_test_***' },
-            { name: 'CLERK_SECRET_KEY', defaultValue: 'sk_test_***' },
-        ]),
-        crons: EMPTY,
-    }),
-    billing: Object.freeze({
-        module: 'billing',
-        environment: Object.freeze([
-            { name: 'RC_WEBHOOK_SECRET', defaultValue: '' },
-            { name: 'RC_SECRET_API_KEY', defaultValue: '' },
-            { name: 'RC_ENTITLEMENT_ID', defaultValue: 'pro' },
-            { name: 'ABLY_API_KEY', defaultValue: '' },
-            { name: 'CRON_SECRET', defaultValue: '' },
-        ]),
-        crons: Object.freeze([
-            { id: 'realtime-outbox', path: '/api/internal/realtime/flush', schedule: '*/5 * * * *' },
-        ]),
-    }),
-    storage: Object.freeze({
-        module: 'storage',
-        environment: Object.freeze([
-            { name: 'BASE_URL', defaultValue: 'http://localhost:8787' },
-            { name: 'R2_ACCOUNT_ID', defaultValue: '' },
-            { name: 'R2_ACCESS_KEY_ID', defaultValue: '' },
-            { name: 'R2_SECRET_ACCESS_KEY', defaultValue: '' },
-            { name: 'R2_BUCKET_NAME', defaultValue: '' },
-            { name: 'R2_PREFIX', defaultValue: 'storage' },
-            { name: 'R2_PROXY_READ_URL_TTL_SECONDS', defaultValue: '600' },
-            { name: 'CLOUDFLARE_API_TOKEN', defaultValue: '' },
-            { name: 'CRON_SECRET', defaultValue: '' },
-        ]),
-        crons: Object.freeze([
-            { id: 'storage-cleanup', path: '/api/internal/storage/cleanup', schedule: '0 3 * * *' },
-        ]),
-    }),
-    'native-subscriptions': Object.freeze({
-        module: 'native-subscriptions',
-        environment: EMPTY,
-        crons: EMPTY,
-    }),
-    'electron-updater': Object.freeze({
-        module: 'electron-updater',
-        environment: Object.freeze([
-            { name: 'DESKTOP_UPDATE_BASE_URL', defaultValue: 'https://updates.example.com' },
-        ]),
-        crons: EMPTY,
-    }),
-});
-function collectEnvironmentFromRegistry(modules, registry) {
-    const byName = new Map();
-    for (const module of modules) {
-        for (const contribution of registry[module].environment) {
-            const candidate = Object.freeze({ owner: module, ...contribution });
-            const previous = byName.get(candidate.name);
-            if (previous && previous.defaultValue !== candidate.defaultValue) {
-                throw new CompositionError('DUPLICATE_ENVIRONMENT_CONTRIBUTION', `Environment variable ${candidate.name} has incompatible defaults from ${previous.owner} and ${module}.`);
-            }
-            if (!previous)
-                byName.set(candidate.name, candidate);
-        }
-    }
-    return Object.freeze([...byName.values()]);
-}
-function collectCronsFromRegistry(modules, registry) {
-    const byId = new Map();
-    for (const module of modules) {
-        for (const contribution of registry[module].crons) {
-            const candidate = Object.freeze({ owner: module, ...contribution });
-            const previous = byId.get(candidate.id);
-            if (previous && (previous.path !== candidate.path || previous.schedule !== candidate.schedule)) {
-                throw new CompositionError('DUPLICATE_CRON_CONTRIBUTION', `Cron ${candidate.id} has incompatible definitions from ${previous.owner} and ${module}.`);
-            }
-            if (!previous)
-                byId.set(candidate.id, candidate);
-        }
-    }
-    return Object.freeze([...byId.values()]);
-}
-export function collectModuleContributions(requestedModules, overrides = {}) {
-    const modules = resolveModules(requestedModules).resolvedModules;
-    const contributions = Object.freeze({ ...MODULE_CONTRIBUTIONS, ...overrides });
-    for (const module of modules) {
-        if (contributions[module].module !== module) {
-            throw new Error(`Composition contribution key ${module} must declare the same module ID.`);
-        }
-    }
-    return Object.freeze({
-        modules,
-        environment: collectEnvironmentFromRegistry(modules, contributions),
-        crons: collectCronsFromRegistry(modules, contributions),
-    });
-}

package/dist/architecture/index.d.ts

@@ -1,12 +0,0 @@
-export { DEFAULT_MODULE_DEFINITIONS, DEFAULT_MODULE_REGISTRY, MODULE_IDS, ModuleRegistryError, ModuleResolutionError, createModuleRegistry, isModuleId, resolveModules, } from './modules.js';
-export type { DependencyEdge, ModuleDefinition, ModuleId, ModuleKind, ModuleRegistry, ModuleRegistryErrorCode, ModuleResolution, ModuleResolutionErrorCode, } from './modules.js';
-export { FILE_OWNERSHIP_CLASSES, PlanBuildError, buildGenerationPlan, hashContent, isFileOwnershipClass, isSha256, normalizePlanPath, writePolicyForOwnership, } from './plan.js';
-export type { BuildGenerationPlanInput, FileOwner, FileOwnershipClass, FileWritePolicy, GenerationOperation, GenerationPlan, ModulePlanContribution, PlanBuildErrorCode, PlanFileInput, PlannedFile, } from './plan.js';
-export { MANIFEST_SCHEMA_VERSION, ManifestValidationError, createManifest, readManifest, serializeManifest, } from './manifest.js';
-export { TEMPLATE_IDS, isTemplateId, templateIdsForModules, } from './templates.js';
-export type { TemplateId, TemplateProvenance, TemplateProvenanceMap, } from './templates.js';
-export { CompositionError, collectModuleContributions, } from './contributions.js';
-export type { CompositionErrorCode, CompositionModel, CronContribution, EnvironmentContribution, ModuleCompositionContribution, } from './contributions.js';
-export type { CreateManifestInput, ManifestFileRecord, ManifestToolchain, ManifestValidationErrorCode, ProjectManifest, } from './manifest.js';
-export { NATIVE_STYLING_LIBRARIES, UI_PROVIDERS, UI_TARGETS, buildUiInstallCommands, isNativeStylingLibrary, isUiProvider, isUiTarget, mergeUiInstalls, normalizeUiComponentName, parseUiComponentList, providerForTarget, registrySourceFor, resolveUiInstalls, uiInstallKey, } from '../ui.js';
-export type { NativeStylingLibrary, UiComponentInstall, UiInstallCommand, UiProvider, UiTarget, } from '../ui.js';

package/dist/architecture/index.js

@@ -1,6 +0,0 @@
-export { DEFAULT_MODULE_DEFINITIONS, DEFAULT_MODULE_REGISTRY, MODULE_IDS, ModuleRegistryError, ModuleResolutionError, createModuleRegistry, isModuleId, resolveModules, } from './modules.js';
-export { FILE_OWNERSHIP_CLASSES, PlanBuildError, buildGenerationPlan, hashContent, isFileOwnershipClass, isSha256, normalizePlanPath, writePolicyForOwnership, } from './plan.js';
-export { MANIFEST_SCHEMA_VERSION, ManifestValidationError, createManifest, readManifest, serializeManifest, } from './manifest.js';
-export { TEMPLATE_IDS, isTemplateId, templateIdsForModules, } from './templates.js';
-export { CompositionError, collectModuleContributions, } from './contributions.js';
-export { NATIVE_STYLING_LIBRARIES, UI_PROVIDERS, UI_TARGETS, buildUiInstallCommands, isNativeStylingLibrary, isUiProvider, isUiTarget, mergeUiInstalls, normalizeUiComponentName, parseUiComponentList, providerForTarget, registrySourceFor, resolveUiInstalls, uiInstallKey, } from '../ui.js';

package/dist/architecture/manifest.d.ts

@@ -1,53 +0,0 @@
-import { type ModuleId, type ModuleRegistry } from './modules.js';
-import { type FileOwner, type FileOwnershipClass, type GenerationPlan } from './plan.js';
-import { type TemplateProvenanceMap } from './templates.js';
-import { type NativeStylingLibrary, type UiComponentInstall } from '../ui.js';
-export declare const MANIFEST_SCHEMA_VERSION: 5;
-export type ManifestToolchain = 'stable' | 'latest';
-export type ManifestFileRecord = {
-    readonly owner: FileOwner;
-    readonly ownership: FileOwnershipClass;
-    readonly hash: string;
-    /** Normalized Unix permission bits (0o000-0o777), or null on platforms without portable modes. */
-    readonly mode: number | null;
-};
-export type ProjectManifest = {
-    readonly schemaVersion: typeof MANIFEST_SCHEMA_VERSION;
-    readonly generatorVersion: string;
-    readonly project: {
-        readonly name: string;
-        readonly displayName: string;
-    };
-    /** The complete, canonically ordered module dependency closure. */
-    readonly modules: readonly ModuleId[];
-    readonly toolchain: ManifestToolchain;
-    /** Immutable template catalog entries used to seed the generated workspace. */
-    readonly templates: TemplateProvenanceMap;
-    readonly ui: {
-        readonly nativeStyling: NativeStylingLibrary;
-        readonly components: readonly UiComponentInstall[];
-    };
-    readonly files: Readonly<Record<string, ManifestFileRecord>>;
-};
-export type CreateManifestInput = {
-    readonly generatorVersion: string;
-    readonly project: {
-        readonly name: string;
-        readonly displayName: string;
-    };
-    readonly plan: GenerationPlan;
-    readonly toolchain: ManifestToolchain;
-    readonly templates: TemplateProvenanceMap;
-    readonly nativeStyling?: NativeStylingLibrary;
-    readonly components?: readonly UiComponentInstall[];
-    readonly registry?: ModuleRegistry;
-};
-export type ManifestValidationErrorCode = 'INVALID_JSON' | 'INVALID_MANIFEST' | 'INVALID_SCHEMA_VERSION' | 'FUTURE_SCHEMA_VERSION' | 'UNKNOWN_MODULE' | 'DUPLICATE_MODULE' | 'INVALID_MODULE_CLOSURE' | 'INVALID_FILE_RECORD';
-export declare class ManifestValidationError extends Error {
-    readonly code: ManifestValidationErrorCode;
-    readonly path: string;
-    constructor(code: ManifestValidationErrorCode, message: string, path: string);
-}
-export declare function readManifest(input: string | unknown, registry?: ModuleRegistry): ProjectManifest;
-export declare function createManifest(input: CreateManifestInput): ProjectManifest;
-export declare function serializeManifest(manifest: ProjectManifest): string;

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,37 +0,0 @@
-export declare const MODULE_IDS: readonly ["web", "mobile", "api", "desktop", "extension", "db", "auth", "billing", "storage", "native-subscriptions", "electron-updater"];
-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" | "auth" | "billing" | "storage" | "api" | "desktop" | "web" | "mobile" | "extension" | "db" | "native-subscriptions", ModuleDefinition>>;
-export declare function resolveModules(requested: readonly string[], registry?: ModuleRegistry): ModuleResolution;