@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/types/ultramodern-workspace/types.d.ts

@@ -0,0 +1,334 @@
+import type { ResolvedUltramodernPackageSource, UltramodernPackageSourceStrategy } from '../ultramodern-package-source';
+import type { UltramodernBridgeConfigInput } from './bridge-config';
+import type { DeliveryUnitDescriptor } from './delivery-unit-schema/types';
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type RouteJsonLd = JsonObject | JsonObject[];
+export declare function sortJsonValue(value: JsonValue): JsonValue;
+/**
+ * Vertical generation preset (G2a). `full-stack` is the legacy default and
+ * produces byte-identical output. `api-only` omits every browser/UI artifact
+ * (routes, components, MF browser exposes, Tailwind) and keeps the API + BFF +
+ * backend-federation surfaces (a headless delivery unit). `ui-only` omits every
+ * API/BFF/backend artifact and keeps routes/components/exposes.
+ */
+export type VerticalPreset = 'full-stack' | 'api-only' | 'ui-only';
+/**
+ * API protocol SPI (G7a). `rest` is the legacy default (Effect HttpApi output,
+ * byte-identical). `rpc` generates an Effect RPC contract/handlers/client on
+ * plugin-bff's RPC runtime primitives. GraphQL is intentionally not implemented
+ * (the SPI shape leaves room to add it later).
+ */
+export type VerticalApiProtocol = 'rest' | 'rpc';
+export declare function isVerticalPreset(value: unknown): value is VerticalPreset;
+export declare function isVerticalApiProtocol(value: unknown): value is VerticalApiProtocol;
+/**
+ * The canonical kind of the generated delivery unit. `microvertical` is the
+ * default. `horizontal-remote` (G2H) is a components-only cross-vertical
+ * delivery unit that is not the frontend/backend half of a MicroVertical
+ * (CONTEXT.md: Horizontal Remote). It is unrepresentable in strict v1, so the
+ * on-disk v1 `WorkspaceApp.kind` stays `vertical` (lossy down-projection) while
+ * the true kind is carried additively on the topology entry and the canonical
+ * schemaVersion-2 delivery-unit descriptor.
+ */
+export type WorkspaceDeliveryUnitKind = 'microvertical' | 'horizontal-remote';
+export declare function isWorkspaceDeliveryUnitKind(value: unknown): value is WorkspaceDeliveryUnitKind;
+export type WorkspaceApp = {
+    id: string;
+    directory: string;
+    packageSuffix: string;
+    displayName: string;
+    kind: 'shell' | 'vertical';
+    domain?: string;
+    portEnv: string;
+    port: number;
+    mfName: string;
+    exposes?: Record<string, string>;
+    api?: WorkspaceApi;
+    verticalRefs?: string[];
+    ownership: Ownership;
+    /**
+     * Generation preset (G2a). Omitted for the legacy `full-stack` default so
+     * default descriptors and their serialized output stay byte-identical; only
+     * `api-only` / `ui-only` set it, gating the UI/API writers respectively.
+     */
+    surfaceProfile?: VerticalPreset;
+    /**
+     * Canonical delivery-unit kind (G2H). Omitted for the `microvertical`
+     * default. `horizontal-remote` marks a components-only unit; it never changes
+     * the v1 `kind` field (which stays `vertical`).
+     */
+    deliveryUnitKind?: WorkspaceDeliveryUnitKind;
+    /**
+     * Existing additional shells carry their stamped delivery-unit contract
+     * through regeneration (G28). Keeping this on the descriptor prevents a later
+     * add-vertical/migrate pass from minting a new build marker for an already
+     * generated shell.
+     */
+    deliveryUnit?: JsonObject;
+};
+export type WorkspaceApi = {
+    stem: string;
+    prefix: string;
+    consumedBy: string[];
+    /**
+     * API protocol (G7a). Omitted for the legacy `rest` default so default API
+     * output stays byte-identical; only `rpc` sets it.
+     */
+    protocol?: VerticalApiProtocol;
+};
+export type ResolvedPackageSource = ResolvedUltramodernPackageSource;
+/**
+ * Attribution of the single accountable owner of a delivery unit (G3). Kind +
+ * id mirror the canonical `DeliveryUnitOwner` (delivery-unit-schema) so an
+ * attribution is structurally assignable to it. CONTEXT.md: a MicroVertical
+ * never has more than one owner, and one owner may own many verticals — the
+ * attribution is keyed to the delivery unit, not the team org chart.
+ */
+export type OwnerAttribution = {
+    kind: 'team' | 'agent' | 'agent-team';
+    id: string;
+    contact?: string;
+};
+export type Ownership = {
+    team: string;
+    slack: string;
+    pagerDuty: string;
+    runbookRef: string;
+    adrRef: string;
+    blastRadius: {
+        tier: string;
+        references: string[];
+    };
+    /**
+     * Optional explicit owner attribution (G3). Omitted by default so generated
+     * ownership metadata stays byte-identical; callers opt in to record an
+     * `agent` / `agent-team` owner. When absent, {@link resolveOwnerAttribution}
+     * defaults to the neutral `team` owner derived from `team`.
+     */
+    owner?: OwnerAttribution;
+};
+/**
+ * Resolve the single owner attribution for an ownership record (G3). Returns
+ * the explicit `owner` when a caller opted in, otherwise the neutral default
+ * `{ kind: 'team', id: ownership.team }`. Pure; does not mutate or emit —
+ * legacy generation stays byte-identical because nothing serializes this
+ * unless `ownership.owner` was set.
+ */
+export declare function resolveOwnerAttribution(ownership: Ownership): OwnerAttribution;
+export declare const supportedWorkspaceLanguages: readonly ['en', 'cs'];
+export type SupportedWorkspaceLanguage = (typeof supportedWorkspaceLanguages)[number];
+type RoutePublicSurface = 'private-app-screen' | 'generated-public-surface' | 'explicit-public-input';
+export type RouteOwnedI18nPath = {
+    id: string;
+    canonicalPath: string;
+    localisedPaths: Record<SupportedWorkspaceLanguage, string>;
+    titleKey: string;
+    descriptionKey: string;
+    ownerAppId: string;
+    mfBoundaryId: string;
+    namespace: string;
+    public: boolean;
+    indexable: boolean;
+    publicSurface: RoutePublicSurface;
+    jsonLd?: RouteJsonLd;
+};
+export type PublicRouteMetadata = {
+    canonicalPath: string;
+    id: string;
+    localisedPaths: Record<SupportedWorkspaceLanguage, string>;
+    namespace: string;
+    ownerAppId: string;
+    titleKey: string;
+    descriptionKey: string;
+    jsonLd?: RouteJsonLd;
+};
+type PublicSitemapChangeFrequency = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+export type PublicSurfaceSitemapFields = {
+    lastModified?: string;
+    changeFrequency?: PublicSitemapChangeFrequency;
+    priority?: number;
+};
+export type UltramodernWorkspaceOptions = {
+    targetDir: string;
+    packageName: string;
+    modernVersion: string;
+    enableTailwind?: boolean;
+    generateAgentFiles?: boolean;
+    overlays?: UltramodernCodeSmithOverlay[];
+    bridge?: UltramodernBridgeConfigInput;
+    packageSource?: {
+        strategy?: UltramodernPackageSourceStrategy;
+        modernPackageVersion?: string;
+        registry?: string;
+        aliasScope?: string;
+        aliasPackageNamePrefix?: string;
+    };
+};
+export type AddUltramodernVerticalOptions = {
+    workspaceRoot: string;
+    name: string;
+    modernVersion: string;
+    enableTailwind?: boolean;
+    overlays?: UltramodernCodeSmithOverlay[];
+    packageSource?: UltramodernWorkspaceOptions['packageSource'];
+    /**
+     * Vertical generation preset (G2a). Defaults to `full-stack` (byte-identical
+     * legacy output). `api-only` / `ui-only` restrict the generated surfaces.
+     */
+    preset?: VerticalPreset;
+    /**
+     * API protocol (G7a). Defaults to `rest` (byte-identical Effect HttpApi
+     * output). `rpc` emits an Effect RPC contract/handlers/client. Ignored for a
+     * `ui-only` preset (no API surface) and for a horizontal remote.
+     */
+    apiProtocol?: VerticalApiProtocol;
+    /**
+     * Generate a components-only Horizontal Remote delivery unit (G2H) instead of
+     * a MicroVertical. Implies a UI-only surface set with no API.
+     */
+    horizontalRemote?: boolean;
+    /**
+     * Target shell id that should compose the new MicroVertical (G28). Defaults
+     * to the primary shell (`shell-super-app`) — the default keeps legacy
+     * single-shell behaviour byte-identical. An explicit id targets an additional
+     * shell; targeting an unknown shell is rejected in preflight.
+     */
+    shell?: string;
+};
+/**
+ * Options for adding an additional thin shell to an existing workspace (G28).
+ * The new shell is its own Delivery Unit that composes a chosen subset of the
+ * workspace's existing verticals.
+ */
+export type AddUltramodernShellOptions = {
+    workspaceRoot: string;
+    name: string;
+    modernVersion: string;
+    /**
+     * Ids of existing verticals the new shell should compose. Defaults to every
+     * vertical currently in the workspace.
+     */
+    verticals?: string[];
+    enableTailwind?: boolean;
+    packageSource?: UltramodernWorkspaceOptions['packageSource'];
+};
+export type UltramodernGenerationOperation = 'workspace' | 'vertical' | 'shell';
+/**
+ * Stable public descriptor for an app created by the UltraModern generator.
+ * Existing fields keep their meaning across patch/minor releases; new fields
+ * may be added as the generator records more contract data.
+ */
+export type UltramodernGeneratedAppDescriptor = {
+    id: string;
+    directory: string;
+    packageName: string;
+    packageSuffix: string;
+    displayName: string;
+    kind: WorkspaceApp['kind'];
+    portEnv: string;
+    port: number;
+    moduleFederationName: string;
+    exposes?: Record<string, string>;
+    apiPrefix?: string;
+};
+/**
+ * Stable public warning shape for non-fatal generator decisions.
+ */
+export type UltramodernGenerationWarning = {
+    code: string;
+    message: string;
+    path?: string;
+};
+/**
+ * Stable public result returned by workspace generation and MicroVertical
+ * addition. The CLI ignores this object, but automation can use it instead of
+ * re-reading the workspace to discover generated paths and integration data.
+ */
+export type UltramodernGenerationResult = {
+    operation: UltramodernGenerationOperation;
+    workspaceRoot: string;
+    packageScope: string;
+    packageSource: ResolvedPackageSource;
+    createdApps: UltramodernGeneratedAppDescriptor[];
+    createdPaths: string[];
+    rewrittenPaths: string[];
+    assignedPorts: Record<string, number>;
+    moduleFederationNames: Record<string, string>;
+    apiPrefixes: Record<string, string>;
+    generatedContractPath: string;
+    warnings: UltramodernGenerationWarning[];
+    /**
+     * Canonical delivery-unit descriptor per generated app (G1d). Additive and
+     * optional: existing fields are unchanged. Each descriptor's `unitId`,
+     * `buildMarker`, and `sourceRevision` match the emitted delivery-unit records
+     * (built from the same generator functions in the same process), so
+     * automation can consume the canonical shape without re-reading the
+     * workspace. Down-projecting a descriptor reproduces the v1 `WorkspaceApp`
+     * identity (see `projectDeliveryUnitToV1`).
+     */
+    deliveryUnits?: DeliveryUnitDescriptor[];
+};
+export type UltramodernCodeSmithOverlay = {
+    generator: string;
+    config?: Record<string, unknown>;
+};
+export type UltramodernCodeSmithOverlayRuntimeConfig = {
+    /** Logical final workspace path exposed to generated configuration. */
+    workspaceRoot: string;
+    /** Physical directory that the overlay must write into during generation. */
+    outputWorkspaceRoot: string;
+    packageScope: string;
+    operation: UltramodernGenerationOperation;
+    generatedApp?: UltramodernGeneratedAppDescriptor;
+    generatedApps: UltramodernGeneratedAppDescriptor[];
+    assignedPort?: number;
+    assignedPorts: Record<string, number>;
+    moduleFederationName?: string;
+    moduleFederationNames: Record<string, string>;
+    apiPrefix?: string;
+    apiPrefixes: Record<string, string>;
+    packageSource: ResolvedPackageSource;
+    generationResult: UltramodernGenerationResult;
+};
+export type UltramodernJsonMutation = {
+    path: string;
+    pointer: string;
+    description: string;
+    value?: JsonValue;
+};
+export type UltramodernShellDependencyChange = {
+    path: string;
+    section: 'dependencies' | 'zephyr:dependencies';
+    packageName: string;
+    version: string;
+};
+export type UltramodernGeneratedContractChange = {
+    path: string;
+    addedAppIds: string[];
+    shellVerticalRefs: string[];
+};
+/**
+ * Stable public dry-run result for MicroVertical addition. It includes the
+ * same operation summary as a real add, plus planned JSON mutations and
+ * integration metadata that automation can inspect before writing files.
+ */
+export type UltramodernVerticalPlan = UltramodernGenerationResult & {
+    dryRun: true;
+    selectedPort: number;
+    moduleFederationRemote: {
+        id: string;
+        name: string;
+        manifestUrl: string;
+    };
+    apiPrefix?: string;
+    jsonMutations: UltramodernJsonMutation[];
+    shellDependencyChanges: UltramodernShellDependencyChange[];
+    generatedContractChanges: UltramodernGeneratedContractChange[];
+};
+export declare function isRecord(value: unknown): value is Record<string, JsonValue>;
+export {};

package/dist/types/ultramodern-workspace/versions.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Every version pin and skill-repo commit hash baked into generated
+ * UltraModern workspaces lives here. Values must stay in lockstep with the
+ * checked-in templates under templates/ and template-workspace/.
+ */
+export declare const TANSTACK_ROUTER_VERSION = "1.170.32";
+export declare const TANSTACK_ROUTER_CORE_VERSION = "1.171.27";
+export declare const TANSTACK_HISTORY_VERSION = "1.162.1";
+export declare const MODULE_FEDERATION_VERSION = "2.9.0";
+export declare const ZEPHYR_RSPACK_PLUGIN_VERSION = "1.2.1";
+export declare const ZEPHYR_AGENT_VERSION = "1.2.1";
+export declare const WRANGLER_VERSION = "4.116.0";
+export declare const CLOUDFLARE_COMPATIBILITY_DATE = "2026-06-02";
+export declare const TAILWIND_VERSION = "4.3.3";
+export declare const RSBUILD_PLUGIN_TAILWINDCSS_VERSION = "2.0.3";
+export declare const EFFECT_VERSION = "4.0.0-rc.112";
+export declare const EFFECT_VITEST_VERSION = "4.0.0-rc.112";
+export declare const EFFECT_TSGO_VERSION = "0.37.0";
+export declare const MSGPACKR_VERSION = "2.0.6";
+export declare const ZOD_VERSION = "4.4.3";
+export declare const DRIZZLE_ORM_VERSION = "1.0.0-rc.4";
+export declare const TYPESCRIPT_STABLE_VERSION = "7.0.2";
+export declare const TYPESCRIPT_VERSION = "7.0.2";
+export declare const TYPESCRIPT_NATIVE_PREVIEW_VERSION = "7.0.0-dev.20260707.2";
+export declare const OXLINT_VERSION = "1.80.0";
+export declare const OXFMT_VERSION = "0.65.0";
+export declare const ULTRACITE_VERSION = "7.10.6";
+export declare const CROSS_ENV_VERSION = "10.1.0";
+export declare const LEFTHOOK_VERSION = "^2.1.10";
+export declare const I18NEXT_VERSION = "26.3.6";
+export declare const MODULE_FEDERATION_NODE_VERSION = "2.7.50";
+export declare const MINIFLARE_VERSION = "4.20260730.0";
+export declare const WORKERD_VERSION = "1.20260730.1";
+export declare const CLOUDFLARE_WORKERS_TYPES_VERSION = "5.20260810.1";
+export declare const NODE_FETCH_VERSION = "^3.3.2";
+export declare const REACT_VERSION = "19.2.8";
+export declare const REACT_DOM_VERSION = "19.2.8";
+export declare const TYPES_NODE_VERSION = "^26.2.0";
+export declare const TYPES_REACT_VERSION = "^19.2.18";
+export declare const TYPES_REACT_DOM_VERSION = "^19.2.4";
+export declare const NODE_VERSION = "26.7.0";
+export declare const PNPM_VERSION = "11.24.0";

package/dist/types/ultramodern-workspace/workspace-script-plan.d.ts

@@ -0,0 +1,63 @@
+import type { WorkspaceApp } from './types';
+export declare const GENERATED_POSTINSTALL_SCRIPT = "node ./scripts/bootstrap-agent-skills.mts --postinstall && oxfmt .";
+export interface WorkspaceRootScriptPlan {
+    build: string;
+    cloudflareBuild: string;
+    cloudflareDeploy: string;
+    cloudflareProof: string;
+    cloudflareSsrProof: string;
+    cloudflareOutputVerify: string;
+    backendFederationGenerate: string;
+    nodeProof: string;
+    mfTypes: string;
+    performanceReadiness: string;
+    migrateStrictEffect: string;
+    zeropsMaterialize: string;
+    contractCheck: string;
+    typecheck: string;
+    check: string;
+}
+declare const workspaceRootPackageScriptNames: {
+    readonly build: 'build';
+    readonly cloudflareBuild: 'cloudflare:build';
+    readonly cloudflareDeploy: 'cloudflare:deploy';
+    readonly cloudflareProof: string;
+    readonly cloudflareSsrProof: 'cloudflare:ssr-proof';
+    readonly cloudflareOutputVerify: string;
+    readonly backendFederationGenerate: string;
+    readonly nodeProof: string;
+    readonly mfTypes: string;
+    readonly performanceReadiness: string;
+    readonly migrateStrictEffect: string;
+    readonly zeropsMaterialize: 'zerops:materialize';
+    readonly contractCheck: string;
+    readonly typecheck: 'typecheck';
+    readonly check: 'check';
+};
+type WorkspaceRootPackageScriptName = (typeof workspaceRootPackageScriptNames)[keyof typeof workspaceRootPackageScriptNames];
+type WorkspaceRootPackageScripts = Partial<Record<WorkspaceRootPackageScriptName, string>>;
+declare const workspaceAppPackageScriptNames: {
+    readonly dev: 'dev';
+    readonly build: 'build';
+    readonly cloudflareBuild: 'cloudflare:build';
+    readonly cloudflareDeploy: 'cloudflare:deploy';
+    readonly cloudflarePreview: 'cloudflare:preview';
+    readonly cloudflareProof: 'cloudflare:proof';
+    readonly serve: 'serve';
+    readonly typecheck: 'typecheck';
+};
+type WorkspaceAppPackageScriptName = (typeof workspaceAppPackageScriptNames)[keyof typeof workspaceAppPackageScriptNames];
+type WorkspaceAppPackageScripts = Record<WorkspaceAppPackageScriptName, string>;
+export declare const createStrictTsgoTypecheckCommand: (packageDir: string) => string;
+export declare function createWorkspaceAppPackageScripts(app: WorkspaceApp): WorkspaceAppPackageScripts;
+export declare function createWorkspaceRootScriptPlan(remotes?: WorkspaceApp[], options?: {
+    bridgeCheck?: string;
+    typecheck?: string;
+    shells?: WorkspaceApp[];
+}): WorkspaceRootScriptPlan;
+export declare function createWorkspaceRootPackageScripts(remotes?: WorkspaceApp[], options?: {
+    bridgeCheck?: string;
+    typecheck?: string;
+    shells?: WorkspaceApp[];
+}): WorkspaceRootPackageScripts;
+export {};

package/dist/types/ultramodern-workspace/workspace-scripts.d.ts

@@ -0,0 +1,16 @@
+import type { UltramodernReleaseCohort } from '../ultramodern-release-cohort';
+import type { WorkspaceApp } from './types';
+export declare function createWorkspaceValidationScript(scope: string, enableTailwind: boolean, remotes?: WorkspaceApp[], releaseCohort?: UltramodernReleaseCohort, additionalShells?: WorkspaceApp[], primaryShell?: WorkspaceApp, compactConfigOverride?: Record<string, unknown>, ownershipOverride?: Record<string, unknown>, developmentOverlayOverride?: Record<string, unknown>): string;
+export declare function createZeropsRuntimeMaterializationScript(): string;
+export declare function writeGeneratedWorkspaceScripts(targetDir: string, scope: string, enableTailwind: boolean, remotes?: WorkspaceApp[], releaseCohort?: UltramodernReleaseCohort, additionalShells?: WorkspaceApp[], primaryShell?: WorkspaceApp): void;
+interface MigratedWorkspaceScriptArtifact {
+    relativePath: string;
+    content: string;
+    legacyPath?: string;
+}
+export declare function migratedWorkspaceScriptArtifacts(options: {
+    shellOnly: boolean;
+    hasBackendSurface?: boolean;
+}): MigratedWorkspaceScriptArtifact[];
+export declare const migratedWorkspaceScriptBasenames: readonly string[];
+export {};

package/dist/types/ultramodern-workspace/workspace-validation-contract.d.ts

@@ -0,0 +1,217 @@
+import type { UltramodernReleaseCohort } from '../ultramodern-release-cohort';
+import type { WorkspaceApp } from './types';
+export declare function createWorkspaceValidationContract(scope: string, enableTailwind: boolean, remotes?: WorkspaceApp[], releaseCohort?: UltramodernReleaseCohort, additionalShells?: WorkspaceApp[], primaryShell?: WorkspaceApp, compactConfigOverride?: Record<string, unknown>, ownershipOverride?: Record<string, unknown>, developmentOverlayOverride?: Record<string, unknown>): {
+    schemaVersion: number;
+    kind: string;
+    metadata: {
+        compactConfig: {
+            path: string;
+            schemaVersion: number;
+        };
+        referenceTopology: {
+            path: string;
+            schemaVersion: number;
+        };
+        ownership: {
+            path: string;
+            schemaVersion: number;
+        };
+        developmentOverlay: {
+            path: string;
+            schemaVersion: number;
+        };
+        releaseCohort?: {
+            path: string;
+            schemaVersion: number;
+        } | undefined;
+    };
+    cohort: {
+        modernPackages: ("@modern-js/app-tools" | "@modern-js/code-tools" | "@modern-js/plugin-bff" | "@modern-js/plugin-i18n" | "@modern-js/plugin-tanstack" | "@modern-js/runtime" | "@modern-js/ultramodern-create")[];
+        releaseCohort?: UltramodernReleaseCohort | undefined;
+        appIds: string[];
+        additionalShellIds?: string[] | undefined;
+        additionalShellOwnerIds?: string[] | undefined;
+        additionalShellDeliveryUnitIds?: string[] | undefined;
+        additionalShellDegradedStateIds?: string[] | undefined;
+        additionalShellBuildMarkerIds?: string[] | undefined;
+        backendAppIds: string[];
+        verticalIds: string[];
+        sharedPackageIds: string[];
+        ownerIds: string[];
+        packageManifests: {
+            id: string;
+            packageName: string;
+            path: string;
+            role: string;
+        }[];
+        additionalShellManifests?: {
+            id: string;
+            packageName: string;
+            path: string;
+            role: string;
+        }[] | undefined;
+    };
+    topology: {
+        compactConfig: unknown;
+        referenceTopology: {
+            shell: {
+                moduleFederation: {
+                    remotes?: {
+                        id: unknown;
+                        manifestUrl: unknown;
+                        name: unknown;
+                    }[] | undefined;
+                };
+            };
+            verticals: unknown;
+        };
+        ownership: string | number | boolean | import("./types").JsonValue[] | Record<string, unknown> | null;
+        developmentOverlay: string | number | boolean | import("./types").JsonValue[] | Record<string, unknown> | null;
+    };
+    policy: {
+        compactConfig: {
+            schemaVersion: unknown;
+            profile: unknown;
+            workspace: unknown;
+            features: unknown;
+            deploy: unknown;
+            moduleFederation: unknown;
+            backendFederation: unknown;
+            agentSkills: unknown;
+            tooling: unknown;
+        };
+    };
+    legacy: {
+        retiredMetadataPaths: string[];
+        forbiddenCompactConfigFields: string[];
+        forbiddenPackageSourceFields: string[];
+        forbiddenTopologyFields: string[];
+    };
+    validationEvidencePolicy: {
+        readonly schemaVersion: 1;
+        readonly required: readonly [{
+            readonly id: 'typescript-compiler';
+            readonly kind: 'compiler';
+        }, {
+            readonly id: 'architecture-compiler';
+            readonly kind: 'compiler';
+        }, {
+            readonly id: 'executable-modern-config';
+            readonly kind: 'runtime';
+        }, {
+            readonly id: 'executable-runtime-config';
+            readonly kind: 'runtime';
+        }, {
+            readonly id: 'executable-module-federation-config';
+            readonly kind: 'runtime';
+        }, {
+            readonly id: 'executable-build-facade';
+            readonly kind: 'runtime';
+        }, {
+            readonly id: 'structured-package-config';
+            readonly kind: 'structured';
+        }, {
+            readonly id: 'structured-deploy-config';
+            readonly kind: 'structured';
+        }, {
+            readonly id: 'public-behavior-gates';
+            readonly kind: 'behavior';
+        }];
+    };
+    packageScope: string;
+    node: {
+        version: string;
+        engineRange: string;
+    };
+    versions: {
+        cloudflareCompatibilityDate: string;
+        crossEnv: string;
+        effect: string;
+        effectVitest: string;
+        moduleFederation: string;
+        node: string;
+        pnpm: string;
+        tanstackHistory: string;
+    };
+    tailwindEnabled: boolean;
+    structuralShellPolicy: {
+        schemaVersion: number;
+        shells: {
+            id: string;
+            packageDir: string;
+            srcDir: string;
+        }[];
+        forbiddenPathClasses: {
+            id: string;
+            path: string;
+            diagnostic: string;
+        }[];
+    };
+    federatedCompositionPolicy: {
+        schemaVersion: number;
+        hosts: {
+            id: string;
+            srcDir: string;
+            remotes: {
+                id: string;
+                directory: string;
+                packageName: string;
+            }[];
+        }[];
+    };
+    additionalShells?: {
+        id: string;
+        path: string;
+        packageName: string;
+        port: number;
+        portEnv: string;
+        mfName: string;
+        tailwindPrefix: string;
+        verticalRefs: string[];
+        owner: import("./types").OwnerAttribution;
+        deliveryUnit: import("./types").JsonValue;
+        degradedState: {
+            required: boolean;
+            appId: string;
+            status: string;
+        };
+        moduleFederation: import("./types").JsonValue;
+    }[] | undefined;
+    fullStackVerticals: {
+        id: string;
+        domain: string | undefined;
+        path: string;
+        port: number;
+        mfName: string;
+        emitsApi: boolean;
+        emitsUi: boolean;
+        surfaceProfile: import("./types").VerticalPreset;
+        stem?: string | undefined;
+        group?: string | undefined;
+        apiPrefix?: string | undefined;
+        apiProtocol?: import("./types").VerticalApiProtocol | undefined;
+        apiContractExport?: string | undefined;
+        apiClientExport?: string | undefined;
+        apiContractPath?: string | undefined;
+        apiClientPath?: string | undefined;
+        backendFederation?: import("./types").JsonValue | undefined;
+        tailwindPrefix: string;
+        zephyrAlias: string;
+        packageName: string;
+        deliveryUnit: import("@modern-js/utils/universal").DeliveryUnitRecord;
+        exposes: string[];
+        componentPaths: string[];
+        namespace: string;
+        routePagePaths: string[];
+        routeMetaPaths: string[];
+        localisedUrls: Record<string, import("./types").JsonValue>;
+        verticalRefs: string[];
+    }[];
+    shellNamespace: string;
+    oldRemotePaths: string[];
+    scripts: import("./workspace-script-plan").WorkspaceRootScriptPlan;
+    packageScripts: Partial<Record<string, string>>;
+    cloudflareSecurity: import("./types").JsonValue;
+    publicSurfaceManagedSourceAssetPaths: ("config/public/robots.txt" | "config/public/site.webmanifest" | "config/public/sitemap.xml")[];
+    shellRouteMetaPaths: string[];
+};

package/dist/types/ultramodern-workspace/write-app.d.ts

@@ -0,0 +1,4 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
+import type { ResolvedPackageSource, WorkspaceApp } from './types';
+export declare function writeApp(targetDir: string, scope: string, app: WorkspaceApp, packageSource: ResolvedPackageSource, enableTailwind: boolean, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig, devPorts?: number[]): void;
+export declare function rewriteAppModernConfig(targetDir: string, scope: string, app: WorkspaceApp, remotes: WorkspaceApp[], enableTailwind: boolean, devPorts?: number[]): void;

package/dist/types/ultramodern-workspace/write-workspace.d.ts

@@ -0,0 +1,6 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
+import type { JsonValue, ResolvedPackageSource, UltramodernGenerationResult, UltramodernWorkspaceOptions, WorkspaceApp } from './types';
+import { writeApp } from './write-app';
+export { writeApp };
+export declare function createCompactUltramodernConfig(scope: string, modernVersion: string, packageSource: ResolvedPackageSource, apps?: WorkspaceApp[], enableTailwind?: boolean, bridge?: UltramodernBridgeConfig, additionalShells?: WorkspaceApp[], primaryShell?: WorkspaceApp): JsonValue;
+export declare function generateUltramodernWorkspace(options: UltramodernWorkspaceOptions): UltramodernGenerationResult;