anhedral 0.4.2 → 0.6.0

package/SKILL.md

@@ -1,339 +0,0 @@
----
-name: anhedral-init
-description: Guide a user through creating, provisioning, extending, explaining, or diagnosing a complete Anhedral TypeScript stack. Use for skill-led new/init/add/ui/doctor workflows; Computer Use or subagent-assisted cloud setup; domains, DNS, Vercel, Cloudflare, Neon, Clerk, R2, billing, stores, and Electron updates; development inside a generated workspace; ownership interpretation; manual reproduction; or verification.
----
-
-# Anhedral Init
-
-Anhedral is a stack generator, not an application runtime or programming language. Generated projects use ordinary framework source and expose the complete integration code. Do not invent Anhedral-specific models, routes, queries, components, or client hooks when the selected framework already has a documented convention.
-
-For every new project or provisioning request, begin by asking for the project
-name and whether the user already owns a custom domain for it. Do not run init
-or create provider resources until those answers establish canonical names.
-
-`new` creates a destination directory; `init` works in an empty current
-directory where `.git`, `.gitignore`, and `.DS_Store` are allowed.
-
-## Bootstrap a blank workstation
-
-Do not assume Node.js, npm, pnpm, Git, a browser, provider CLIs, or native build
-tools are installed. After collecting the project name and domain status, audit
-the workstation before generation:
-
-```sh
-node --version
-npm --version
-pnpm --version
-git --version
-```
-
-For a new installation, recommend the current Node.js 24 LTS release. The
-generator itself accepts `^20.19.0 || >=22.12.0`, but mobile projects require
-`^22.13.0 || ^24.3.0 || >=25`; Node.js 24 LTS is the single supported choice
-that covers every Anhedral module without using an end-of-life line.
-
-If Node.js is absent, use Computer Use to open `https://nodejs.org/en/download`,
-select the current Node.js 24 LTS installer for the user's operating system and
-architecture, and stop for the user at the installer, administrator-password,
-or operating-system approval boundary. npm is bundled with Node.js and may be
-used to install pnpm, but npm is not the package manager for a generated
-workspace. Installing the public Anhedral package does not require an npm
-account or `npm login`.
-
-Install the exact pnpm release recorded by this generator's
-`package.json#packageManager` (currently `pnpm@10.34.5`):
-
-```sh
-npm install --global pnpm@10.34.5
-```
-
-Ask before a global or administrator-level installation. Verify the four
-commands above again after installation. Install Git with the operating-system
-package manager or official installer when it is missing; stop for UAC,
-administrator credentials, Xcode Command Line Tools approval, or a license
-prompt. Configure the user's real Git name and email only after asking what
-identity they want commits to use.
-
-A modern browser is required for OAuth device flows and provider dashboards.
-No global Vercel, Neon, Wrangler, EAS, shadcn, or Anhedral installation is
-required: generated scripts invoke reviewed CLI versions through `pnpm dlx`.
-GitHub CLI is recommended for repository creation. Clerk CLI and Ably CLI are
-optional supplemental control planes; use them only after the corresponding
-module is selected, record the resolved version, and do not run `clerk init`
-inside an Anhedral project because the integration source already exists.
-
-Native tools are conditional:
-
-- EAS cloud builds do not require local Xcode or Android Studio.
-- Local iOS builds and manual App Store uploads require macOS and Xcode.
-- Local Android builds/emulators require Android Studio and a compatible JDK.
-- Signed Electron releases must be built on each target OS; macOS notarization
-  needs Xcode tooling and Apple credentials, while Windows distribution needs
-  an organization-owned code-signing certificate and Windows runner.
-- Extension development requires a Chromium browser; store publication does
-  not require another build CLI beyond the generated WXT scripts.
-
-Anhedral intentionally requires neither Docker nor local Postgres. Database
-modules use managed Neon.
-
-## Choose the construction path
-
-- Use the manual path whenever the user asks to avoid the Anhedral CLI, the CLI is unavailable, or the task requires explaining/reproducing the scaffold itself.
-- Before creating or changing files manually, read [docs/references/manual-scaffolding.md](docs/references/manual-scaffolding.md) completely and follow its ordered procedure. Treat it as the canonical manual checklist, including its source-file matrix and feature gates.
-- Use the CLI path only when the user permits it. Do not silently substitute `anhedral init`, `anhedral add`, imported generator code, or a generated demo for the manual path.
-- For an exact-version scaffold inside the Anhedral source repository, render from the current `src/templates/*.ts`, `src/scaffold.ts`, and `src/dependencies.ts`; do not copy stale demo output. Outside that repository, implement the behavior and file contract in the manual reference and pin a mutually compatible toolchain.
-
-The manual path must leave a complete working workspace, not merely a directory tree or list of commands. Write the source, configuration, tests, environment examples, CI, deployment configuration, and database migration gate selected by the module plan. Install and verify when the environment permits it.
-
-## Select modules
-
-Choose app surfaces from `web`, `mobile`, `api`, `desktop`, and `extension`.
-
-Choose features from `db`, `auth`, `billing`, `storage`, `native-subscriptions`, and `electron-updater`.
-
-Apply these dependency rules automatically:
-
-```text
-auth                 -> api + db
-billing              -> auth
-storage              -> auth
-native-subscriptions -> mobile + billing
-electron-updater     -> desktop
-```
-
-With no module flags in an interactive terminal, Anhedral prompts and suggests
-a focused web app. In a noninteractive environment, no flags retain the full
-stack for compatibility. Use `--all` when the complete stack is intentional,
-or pass explicit modules for reproducible automation.
-
-## Master stack map
-
-Read [docs/master-stack-map.md](docs/master-stack-map.md) completely before
-explaining the whole platform, selecting modules for a complete product, or
-planning cross-provider provisioning. Treat it as the canonical map of the
-stack, command surface, runtime connections, agent workflow, and release path.
-
-```text
-project + domain intake
-          |
-          v
-1 select + plan -> 2 generate safely -> 3 one pnpm/Turborepo workspace
-                                              |
-                                              v
-4 connected product capabilities -> 5 provision cloud + DNS
-                                              |
-                                              v
-6 generated package.json commands -> 7 developer/agent/Computer Use
-                                              |
-                                              v
-                               8 verify, release, and operate
-```
-
-Use the full fixed-width ASCII map from the document when the user asks for the
-master stack map. Do not redraw it from memory or omit unselected modules when
-describing Anhedral's complete capability surface; mark modules as selected or
-unselected separately.
-
-## Run the guided init workflow
-
-Read [docs/references/provisioning.md](docs/references/provisioning.md) completely before
-starting a new project or provisioning any provider. Follow its intake,
-capability discovery, Computer Use, subagent, authentication, secret-handling,
-domain, provider-order, and verification gates.
-
-The lead agent must:
-
-1. Ask for project name and existing/custom-domain status first.
-2. Audit and bootstrap the workstation, then discover whether Computer
-   Use/browser control and subagents are available.
-3. Resolve modules, required accounts, and canonical project/resource names.
-4. Run the explicit CLI command, then read the generated `PRODUCTION.md`,
-   `anhedral.json`, root scripts, and package-local environment examples.
-5. Provision only selected providers in dependency order, pausing for sign-in, MFA, secret
-   generation, purchases, and final submissions exactly as the reference says.
-6. Keep secrets out of chat and tool output; have the user paste them directly
-   into uncommitted environment files and protected provider fields.
-7. Verify code, cloud resources, DNS, TLS, and provider health before handoff.
-
-## Initialize
-
-```sh
-pnpm dlx anhedral@latest new my-product
-cd my-product
-pnpm first-run
-pnpm ready
-```
-
-`first-run` creates only missing package-local environment files and never
-overwrites existing configuration. `ready` reports missing filenames and
-required variable names without printing values; resolve every blocker before
-starting affected services.
-
-Prefer explicit modules when the user requests a smaller stack:
-
-```sh
-pnpm dlx anhedral@latest new my-product --web --api --db --auth
-pnpm dlx anhedral@latest new my-product --web --mobile --ui button,dialog --native-styling nativewind
-pnpm dlx anhedral@latest new my-api --api --skip-install
-```
-
-Use the stable toolchain for normal generation. The `latest` value is retained only as a metadata compatibility channel for maintainer investigations:
-
-```sh
-pnpm dlx anhedral@latest new my-product --toolchain stable
-pnpm dlx anhedral@latest new my-product --toolchain latest
-```
-
-Both channels generate the same exact verified dependencies and integrity-checked bundled templates; `latest` only records investigation intent in `anhedral.json`. Upstream refreshes happen outside user projects and are shipped only after review and checksum verification. Neither channel invokes mutable upstream framework generators inside a user project.
-
-Do not run any command in this section during the manual path.
-
-## Develop inside a generated project
-
-Read these files before changing product code:
-
-1. `README.md` for the selected modules, first run, and source-location map.
-2. `docs/DEVELOPMENT.md` for end-to-end feature recipes.
-3. `docs/STACK.md` for responsibility boundaries and official tool documentation.
-4. `PRODUCTION.md` only for provisioning, deployment, DNS, stores, or release work.
-
-Use the native source conventions:
-
-- Next.js code belongs in `apps/web/app`, `apps/web/components`, and `apps/web/lib`.
-- Expo Router code belongs in `apps/mobile/app` and `apps/mobile/components`.
-- Product Fastify route registration belongs in `apps/api/src/routes/app.ts`. Server-only feature modules live alongside the managed integrations in `apps/api/src`.
-- Product Zod network schemas belong in `packages/contracts/src/app.ts`.
-- Product client-safe HTTP methods belong in `packages/api-client/src/app.ts`.
-- Product Drizzle tables belong in `packages/db/src/app-schema.ts`; generate and review SQL migrations.
-
-Implement an end-to-end feature as `contracts -> database/service -> route -> API client -> frontend`. The generated `items` feature demonstrates that same path on every selected client—Next.js, Expo, Electron, and WXT—using one contract and API client with platform-native UI. Frontends may import contracts and client-safe packages, never API services, database connections, or server environments. This stack uses managed Neon and intentionally has no local Postgres service.
-
-## Add modules safely
-
-Run `add` only from a project containing `anhedral.json` schema v5 at the current generator version. If `doctor` identifies a supported older generator, preview and apply its transactional upgrade first:
-
-```sh
-pnpm dlx anhedral@latest upgrade --dry-run
-pnpm dlx anhedral@latest upgrade
-pnpm dlx anhedral@latest add desktop extension
-pnpm dlx anhedral@latest add storage --dry-run
-```
-
-Use `--dry-run` before a consequential add. Use `--json` when another program needs the plan; JSON failures include a stable `code` and a human-readable `error`. Use `--verbose` for interactive child-command diagnostics. Anhedral preserves recorded user-owned extension files and intentionally refuses modified managed files, symlinks, and unowned collisions; do not bypass those conflicts.
-
-For a 0.3 upgrade blocked by a modified managed file, preserve the change in source control, restore that file to its recorded 0.3 content, apply the upgrade, and port the product behavior into the corresponding 0.4 user-owned extension seam. Never approve the upgrade by rewriting manifest hashes.
-
-Require the manifest generator version to match the running CLI. Regenerate projects created by another version; do not add compatibility branches.
-
-Do not rewrite a generated project's README or custom workflows while adding modules. Preserve custom package fields and mergeable root configuration.
-
-`README.md` and `PRODUCTION.md` are user-owned and are not regenerated by
-`anhedral add`. After adding modules, do not assume those two files describe the
-new provider set. Reconcile them against `anhedral.json`, the managed project
-`SKILL.md`, root `package.json` scripts, and every package-local `.env.example`;
-then update the user-owned documentation explicitly with the developer's
-approval.
-
-For manual projects without a trustworthy schema-v5 `anhedral.json`, add modules with the manual reference instead. Never fabricate manifest ownership records, template provenance, UI installation records, or hashes. A manually authored workspace is valid as an application workspace but is not CLI-managed until it has been regenerated by a matching Anhedral version.
-
-## Add UI components
-
-Use the unified UI wrapper for source-owned components:
-
-```sh
-pnpm dlx anhedral@latest ui add button dialog
-pnpm dlx anhedral@latest ui add select --target mobile
-pnpm dlx anhedral@latest ui add data-table --target web --dry-run
-```
-
-Anhedral routes web, desktop, and extension targets to shadcn/ui. It routes Expo mobile to React Native Reusables using the manifest's NativeWind or Uniwind selection. Omit `--target` to add the provider-specific implementation to every selected UI client. Provider writes occur in transaction staging and must pass the same ownership checks as module additions.
-
-## Diagnose
-
-Dry-runs never perform transaction recovery. If a recovery journal is pending, rerun the original command without `--dry-run` before requesting a new preview.
-
-Check recorded files and hashes with:
-
-```sh
-pnpm dlx anhedral@latest doctor
-pnpm dlx anhedral@latest doctor --json
-```
-
-Explain that warnings can represent mergeable or user-owned drift, while modified or missing managed files make the project unhealthy.
-
-## Configure the generated project
-
-Create only missing local environment files, fill selected provider values, and
-verify readiness:
-
-```sh
-pnpm install
-pnpm first-run
-pnpm ready
-pnpm verify
-```
-
-`first-run` copies only examples that exist for selected surfaces and never
-overwrites an existing file. Client packages use package-local runtime files
-(for example, `apps/web/.env.local` and `apps/desktop/.env`); the root
-`.env.example` is an inventory, not a runtime environment file.
-
-Common selected keys are:
-
-- Neon: `DATABASE_URL`
-- Clerk server: `CLERK_PUBLISHABLE_KEY`, `CLERK_SECRET_KEY`
-- Clerk clients: `NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY`, `EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY`, `VITE_CLERK_PUBLISHABLE_KEY`
-- RevenueCat: `RC_WEBHOOK_SECRET`, `RC_SECRET_API_KEY`, `RC_ENTITLEMENT_ID`, `EXPO_PUBLIC_RC_*`
-- Ably billing synchronization: server-only `ABLY_API_KEY`; clients obtain scoped tokens from the API
-- R2: `BASE_URL`, `R2_ACCOUNT_ID`, `R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`, `R2_BUCKET_NAME`, `R2_PREFIX=storage`, `R2_PROXY_READ_URL_TTL_SECONDS=600`; keep `CLOUDFLARE_API_TOKEN` operations/CI-only
-- Internal billing/storage jobs: high-entropy server-only `CRON_SECRET`
-- Electron updates: `DESKTOP_UPDATE_BASE_URL` in `apps/desktop/electron-builder.env`; the private R2 binding needs no credential in the packaged application
-
-Never commit real `.env` files. Keep `ANHEDRAL_DEMO=false` in production.
-
-Run only scripts present for installed modules. `pnpm dev` starts the primary
-product loop—web plus API when web is selected, otherwise the first selected
-surface. A multi-surface project also exposes `pnpm dev:all`; use it only when
-the user wants every selected development server. Typical focused commands
-include `dev:web`, `dev:mobile`, `dev:api`, `dev:desktop`, `dev:extension`,
-corresponding `verify:*` scripts, and database scripts for `db` projects.
-
-## Understand deployment
-
-Treat the root `vercel.json` as the only Vercel Services configuration. It uses the current `services` schema, declares `apps/api` and `apps/web` as independent service roots, and routes `/api/(.*)` before the web catch-all. Vercel preserves the original path, so Fastify mounts its routes under `/api` locally and in deployment. Select the Services framework preset before deploying.
-
-For billing, keep Neon authoritative: RevenueCat reconciliation writes the subscription revision and realtime outbox atomically, Ably carries only per-user invalidations, and every client refetches the entitlement. Schedule the authenticated outbox flush every five minutes and verify purchase, webhook, reconnect, and foreground recovery paths.
-
-The generated billing substrate does not implement Stripe Checkout, Stripe
-webhooks, or a web purchase screen. RevenueCat's Test Store can exercise the
-entitlement flow without Apple, Google, or Stripe accounts. Native purchases
-require `native-subscriptions` plus Apple/Google store setup. If the user wants
-web subscriptions through RevenueCat Billing or a manual Stripe integration,
-treat that as an explicit product feature with additional account, checkout,
-webhook, tax, and customer-portal work; do not claim the generated billing
-module already completed it.
-
-Use `apps/mobile` for EAS, `pnpm desktop:build` for a current-host Electron artifact, matching platform-specific desktop scripts in CI, and `pnpm extension:zip` for the WXT archive.
-
-For `electron-updater`, provision the generated private R2 bucket and
-`desktop-updater` Worker at `updates.<domain>`. Keep the Worker custom domain and
-`DESKTOP_UPDATE_BASE_URL` identical. Build signed artifacts on each native
-platform and publish artifacts before mutable channel metadata.
-
-For storage, generate `apps/assets-private-proxy` plus `cloudflare/r2-cors.template.json` and keep the R2 bucket private. The Worker must be named `assets-private-proxy`, bind the normalized `<project>-assets` bucket as `ASSETS`, disable `workers.dev`, and own `assets.<domain>` as a Worker Custom Domain. Presigned uploads continue on the R2 S3 API hostname. Root every key below `R2_PREFIX=storage`; expose only `storage/confirmed/` through the Worker and reject staging plus `generation-inputs`. Authenticated private reads must verify upload ownership and return a presigned GET URL bounded by `R2_PROXY_READ_URL_TTL_SECONDS`.
-
-When explaining domains, distinguish DNS delegation from registrar transfer. A domain can use Cloudflare authoritative nameservers while remaining with its current registrar; transferring registration/billing to Cloudflare Registrar is optional and subject to eligibility locks. Keep Vercel app/API A or CNAME records DNS-only in Cloudflare, while Worker Custom Domains stay Cloudflare-managed and proxied.
-
-## Verify outcomes
-
-After generation or repair, run the strongest practical checks:
-
-```sh
-pnpm typecheck
-pnpm verify
-pnpm build
-```
-
-Use `pnpm --filter ./apps/api test` when the API exists. If verification fails, report the exact package and command rather than replacing generated ownership records manually.
-
-For exact representative trees, consult `docs/output-tree-contract.md` in the Anhedral repository. During manual construction, also compare the finished workspace with the file matrix in [docs/references/manual-scaffolding.md](docs/references/manual-scaffolding.md); every selected conditional file must exist and every unselected provider integration must be absent.

package/assets/images/svg/ably-symbol-color.svg

@@ -1,8 +0,0 @@
-<svg width="78" height="64" viewBox="0 0 78 64" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M38.5717 0L6.29575 59.0738L0 54.6586L29.8639 0H38.5717ZM39.0214 0L71.2973 59.0738L77.5931 54.6586L47.7292 0H39.0214Z" fill="url(#ably-symbol-a)"/>
-<path d="M70.8477 59.4213L38.7966 34.3201L6.74548 59.4213L13.2865 64L38.7966 44.0294L64.3066 64L70.8477 59.4213Z" fill="url(#ably-symbol-b)"/>
-<defs>
-<linearGradient id="ably-symbol-a" x1="10.9472" y1="74.8439" x2="64.9206" y2="14.9005" gradientUnits="userSpaceOnUse"><stop stop-color="#FF5416"/><stop offset="0.461" stop-color="#FF4712"/><stop offset="1" stop-color="#FF0000"/></linearGradient>
-<linearGradient id="ably-symbol-b" x1="21.4169" y1="78.7187" x2="53.3166" y2="43.2904" gradientUnits="userSpaceOnUse"><stop stop-color="#FF5416"/><stop offset="0.461" stop-color="#FF4712"/><stop offset="1" stop-color="#FF0000"/></linearGradient>
-</defs>
-</svg>

package/bin/anhedral.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '../dist/bin.js';

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 { APP_MODULES, DEFAULT_MODULE_DEFINITIONS, DEFAULT_MODULE_REGISTRY, FEATURE_MODULES, MODULE_IDS, ModuleRegistryError, ModuleResolutionError, createModuleRegistry, isModuleId, resolveModules, } from './modules.js';
-export type { AppModule, DependencyEdge, FeatureModule, 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 { APP_MODULES, DEFAULT_MODULE_DEFINITIONS, DEFAULT_MODULE_REGISTRY, FEATURE_MODULES, 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;