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

package/dist/types/ultramodern-workspace/delivery-unit-schema/up-projection.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Canonical MicroVertical delivery contracts (W4) — v1 UP-projection.
+ *
+ * This module completes the round-trip that the down-projection in
+ * `./types.ts` opened. Where {@link projectDeliveryUnitToV1} maps a canonical
+ * {@link DeliveryUnitDescriptor} DOWN onto today's v1 `WorkspaceApp` +
+ * `DeliveryUnitRecord`, {@link projectV1ToDeliveryUnit} maps a v1
+ * `WorkspaceApp` UP into the canonical descriptor. The two compose so that
+ * "every current fixture round-trips v1 -> canonical -> v1" (MicroVertical
+ * Phase-1 exit criterion).
+ *
+ * Generator paths consume the projection helpers for grammar-safe surface
+ * identity and owner/representability checks; the schema functions themselves
+ * remain pure and side-effect free.
+ *
+ * Binding vocabulary: root `CONTEXT.md`, ADR-0019 (Federated Loading, Unified
+ * Delivery), ADR-0020 (Zoned Surface Versioning). See the SPEC §5 mapping
+ * table read in reverse.
+ *
+ * TS constraint: plain types + pure functions only. This file is scanned by
+ * `tsgo-boundary.test.ts`; it must never import TypeScript compiler APIs.
+ */
+import type { Ownership, WorkspaceApi, WorkspaceApp } from '../types';
+import type { ApiProtocol, ApiSurfaceDescriptor, BaselineCohort, ComponentSurfaceDescriptor, DeliveryUnitDescriptor, DeliveryUnitOwner, RouteSurfaceDescriptor, V1ProjectionMode } from './types';
+/**
+ * The identity-root and platform-baseline facts that a v1 `WorkspaceApp` does
+ * NOT carry but a canonical {@link DeliveryUnitDescriptor} requires. This is
+ * the mirror image of the down-projection's `V1ProjectionContext`: the down
+ * context supplies generator-only fields the descriptor deliberately does not
+ * own (port, directory, package identity, ownership); this up context supplies
+ * the canonical identity root the v1 app never had.
+ *
+ * Composition contract: given `record = createDeliveryUnitRecord(scope, app)`
+ * (or an existing `DeliveryUnitRecord`), thread `record.buildMarker`,
+ * `record.sourceRevision`, and the same `scope` through here so the descriptor
+ * this produces reconstructs `record.unitId` verbatim. `buildMarker`,
+ * `sourceRevision`, and `unitId` therefore survive a v1 -> canonical -> v1
+ * pass untouched (SPEC §5 invariant 5, marker preservation).
+ */
+export type V1UpProjectionContext = {
+    /**
+     * The v1 vocabulary being read. In `extended-v1`, additive fields already
+     * present on the WorkspaceApp are authoritative for kind/protocol; strict
+     * legacy mode deliberately ignores them and exposes their loss through the
+     * representability guard.
+     */
+    mode?: V1ProjectionMode;
+    /** Package/topology scope. `unitId` = `${scope}/${app.domain ?? app.id}`. */
+    scope: string;
+    /** Identity root: exact source revision, threaded, never regenerated. */
+    sourceRevision: string;
+    /** Identity root: exact build marker, threaded, never regenerated. */
+    buildMarker: string;
+    /**
+     * Composition-time platform baseline pins. v1 has no cohort concept (the
+     * cohort is advanced platform-wide, never per-vertical), so the caller must
+     * supply the resolved cohort this unit was composed against.
+     */
+    baselineCohort: BaselineCohort;
+    /**
+     * Protocol for the app's HTTP api surface, if any. Defaults to `rest`:
+     * today's v1 `WorkspaceApi` is only ever an HTTP REST prefix, so `rest` is
+     * the faithful reading of current reality (SPEC §1: api surfaces carry a
+     * protocol; v1 cannot distinguish rpc/graphql).
+     */
+    apiProtocol?: ApiProtocol;
+};
+/**
+ * Map a v1 {@link Ownership} block onto the canonical single {@link
+ * DeliveryUnitOwner}.
+ *
+ * Owner honouring (G3): when the v1 `Ownership` carries an explicit `owner`
+ * attribution (opt-in — the way v1 records an `agent` / `agent-team` owner),
+ * that attribution IS the canonical owner and is passed through verbatim
+ * (`kind` + `id` + optional `contact`). Only when no explicit owner was set
+ * does this fall back to the neutral human-team default: `kind: 'team'`, `id`
+ * from `ownership.team`, `contact` from `ownership.slack`. The down-projection
+ * writes a non-team owner back into `ownership.owner`, so agent / agent-team
+ * owners round-trip faithfully through the projection pair.
+ */
+export declare function ownershipToOwner(ownership: Ownership): DeliveryUnitOwner;
+/** Derive a canonical, SurfaceRef-valid `surfaceId` from an MF expose key. */
+export declare function exposeSurfaceId(key: string): string;
+/**
+ * Map a single v1 expose onto a component-or-route surface.
+ *
+ * Route heuristic: an expose whose key or local module path mentions `route`
+ * is a `route` surface; everything else is a `component`. The exposed local
+ * module path (e.g. `./src/...`) is a build detail the canonical model
+ * deliberately abstracts away, so it is dropped; the surface's single
+ * `browser-mf` location points at the app's MF manifest (derived from
+ * `app.port`, the only address a v1 app exposes for its browser bundle).
+ */
+export declare function exposeSurface(app: WorkspaceApp, key: string, value: string): ComponentSurfaceDescriptor | RouteSurfaceDescriptor;
+/**
+ * Map a v1 API descriptor onto the canonical API surface vocabulary.
+ *
+ * `stem` -> `surfaceId`; `prefix` -> a single `http` location `address`;
+ * `protocol` from context (default `rest`). `consumedBy` has no canonical
+ * home: it is a v1 emergent graph fact (SPEC §5 marks it non-projected), so it
+ * is dropped here and the down-projection re-zeroes it to `[]`.
+ *
+ * Callers that know the concrete transport mount (for example RPC, which is
+ * mounted below the API prefix) may provide its address explicitly. Keeping
+ * the surface id/protocol/location construction here prevents generator
+ * paths from re-deriving a second canonical API surface shape.
+ */
+export declare function apiSurface(api: WorkspaceApi, protocol: ApiProtocol, address?: string): ApiSurfaceDescriptor;
+/**
+ * Up-project a v1 `WorkspaceApp` into a canonical {@link
+ * DeliveryUnitDescriptor}. Pure and total: `WorkspaceApp.kind` is only
+ * `shell | vertical`, so this never throws and never produces the
+ * v1-unrepresentable `horizontal-remote` kind or the `external` zone.
+ *
+ * The `publicationZone` is always `{ zone: 'coordinated' }`: v1 has no way to
+ * express external publication (ADR-0020), so a v1 app is always coordinated.
+ *
+ * Marker preservation: `unitId` = `${context.scope}/${app.domain ?? app.id}`
+ * (identical to `createDeliveryUnitRecord`), and `buildMarker` /
+ * `sourceRevision` are threaded straight from `context`, never regenerated.
+ *
+ * Generator paths may consume this projection for canonical surface metadata;
+ * the projection remains pure and does not mutate the v1 app.
+ */
+export declare function projectV1ToDeliveryUnit(app: WorkspaceApp, context: V1UpProjectionContext): DeliveryUnitDescriptor;
+/**
+ * The reasons a canonical descriptor cannot be faithfully represented in v1.
+ * The down-projection in `./types.ts` degrades ALL of these silently, so this
+ * guard exhaustively detects every canonical construct the v1 shape cannot
+ * carry and lets callers fail loudly INSTEAD of degrading silently:
+ *
+ * - `horizontal-remote-kind`: v1 collapses `horizontal-remote` to `vertical`.
+ * - `external-zone`: v1 has no publication-zone field (ADR-0020).
+ * - `component-or-route-surface`: the down-projection reconstructs no
+ *   `exposes`, so every component/route surface is dropped.
+ * - `backend-surface`: v1 has no backend-surface vocabulary at all.
+ * - `multiple-api-surfaces`: v1 carries at most ONE `WorkspaceApi`; the
+ *   down-projection keeps the first api surface and drops the rest.
+ * - `non-rest-protocol`: v1 `WorkspaceApi` is an HTTP REST prefix; `rpc` /
+ *   `graphql` protocols are dropped (the up-projection re-defaults to
+ *   `rest`).
+ * - `unsupported-surface-shape`: an api surface whose shape v1 cannot carry —
+ *   anything other than exactly one `http` location, or per-surface
+ *   `externallyPublished` / `unknownFields` metadata.
+ * - `unknown-fields`: the descriptor carries top-level `unknownFields`. v1 has
+ *   nowhere to store them in-band — the down-projection returns them
+ *   out-of-band (`preservedUnknownFields`), so a v1 shape cannot reproduce the
+ *   descriptor byte-for-byte in a single canonical value.
+ * - `non-canonical-zone`: the descriptor's `publicationZone` is not exactly the
+ *   canonical `{ zone: 'coordinated' }` the up-projection always re-emits. A
+ *   descriptor with NO `publicationZone` (down drops the field, up re-adds an
+ *   explicit coordinated zone) or a `coordinated` zone carrying extra fields is
+ *   therefore not round-trip-faithful.
+ */
+export type V1UnrepresentableReason = 'horizontal-remote-kind' | 'external-zone' | 'component-or-route-surface' | 'backend-surface' | 'multiple-api-surfaces' | 'non-rest-protocol' | 'unsupported-surface-shape' | 'unknown-fields' | 'non-canonical-zone';
+export type V1RepresentabilityResult = {
+    representable: true;
+} | {
+    representable: false;
+    code: 'unrepresentable-in-v1';
+    reason: V1UnrepresentableReason;
+};
+/**
+ * A typed error for v1-unrepresentable cases. `code` is always
+ * `'unrepresentable-in-v1'`; `reason` narrows which invariant was violated.
+ */
+export declare class V1UnrepresentableError extends Error {
+    readonly code: 'unrepresentable-in-v1';
+    readonly reason: V1UnrepresentableReason;
+    constructor(reason: V1UnrepresentableReason);
+}
+/**
+ * Total check: is a canonical descriptor faithfully representable in v1?
+ * Returns a typed result rather than throwing. Exhaustive over the loss set
+ * of `projectDeliveryUnitToV1` (see {@link V1UnrepresentableReason}); the
+ * first detected reason is reported, in a deterministic order (unit-level
+ * kind, unknown-fields, zone, then surfaces in declaration order).
+ *
+ * The round-trip law rests on this guard: for descriptors this function
+ * accepts, canonical -> v1 -> canonical is lossless on every
+ * representability-covered field.
+ */
+export declare function checkV1Representable(descriptor: DeliveryUnitDescriptor, mode?: V1ProjectionMode): V1RepresentabilityResult;
+/**
+ * Assert v1 representability, throwing a typed {@link V1UnrepresentableError}
+ * for any descriptor carrying a construct the v1 shape cannot represent,
+ * rather than letting the down-projection degrade it silently.
+ */
+export declare function assertV1Representable(descriptor: DeliveryUnitDescriptor, mode?: V1ProjectionMode): void;

package/dist/types/ultramodern-workspace/delivery-unit-stamp.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceApp } from './types';
+export declare function isPlainObject(value: unknown): value is Record<string, any>;
+/** Stamp one compact-config or reference-topology app with canonical identity. */
+export declare function stampDeliveryUnitIdentity(entry: Record<string, any>, scope: string, app: WorkspaceApp): void;

package/dist/types/ultramodern-workspace/delivery-unit-sync.d.ts

@@ -0,0 +1,6 @@
+type SyncContext = {
+    workspaceRoot: string;
+    invocationCwd: string;
+};
+export declare function runSyncDeliveryUnit(args: string[], context: SyncContext): number;
+export {};

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

@@ -0,0 +1,8 @@
+import { type DeliveryUnitRecord, deliveryUnitContractBlock } from '@modern-js/utils/universal';
+import type { WorkspaceApp } from './types';
+export declare function createBuildMarker(scope: string, app: {
+    id: string;
+    packageSuffix: string;
+}): string;
+export { deliveryUnitContractBlock };
+export declare function createDeliveryUnitRecord(scope: string, app: WorkspaceApp): DeliveryUnitRecord;

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

@@ -0,0 +1,19 @@
+import type { WorkspaceApp } from './types';
+export declare function createShellPage(shell: WorkspaceApp, remotes?: WorkspaceApp[]): string;
+export declare function createShellRemoteComponents(shell: WorkspaceApp, remotes?: WorkspaceApp[]): string;
+export declare function createShellWorkerRemoteComponents(shell: WorkspaceApp, remotes?: WorkspaceApp[]): string;
+/**
+ * Generates the environment-specific primitive registry used by custom hosts.
+ * The browser/Node file contains native MF loaders. Cloudflare's `.worker.tsx`
+ * resolution selects the sibling registry, which contains only distributed
+ * service-binding boundaries and therefore cannot bundle remote UI source.
+ */
+export declare function createFederatedComponentsRegistry(scope: string, host: WorkspaceApp, remotes: WorkspaceApp[], worker?: boolean): string;
+export declare function createRemotePage(app: WorkspaceApp): string;
+export declare function createLayout(appId: string): string;
+export declare function createRemoteEntry(app: WorkspaceApp): string;
+export declare function createRemoteExposeFragmentPage(app: WorkspaceApp, expose: string): string;
+export declare function createRemoteExposeComponent(app: WorkspaceApp, expose: string): string;
+export declare function remoteComponentOutputPath(app: WorkspaceApp, expose: string): string | undefined;
+export type GeneratedNavigationSurfaceKind = 'demo-component' | 'shell-frame';
+export declare function regenerateGeneratedNavigationSurface(source: string, kind: GeneratedNavigationSurfaceKind): string;

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

@@ -0,0 +1,63 @@
+import type { Ownership, VerticalApiProtocol, VerticalPreset, WorkspaceApi, WorkspaceApp } from './types';
+export declare const ULTRAMODERN_CONFIG_PATH = ".modernjs/ultramodern.json";
+export declare function distributedSsrExposes(app: WorkspaceApp): string[];
+export declare function distributedSsrFragmentSlug(expose: string): string;
+export declare function distributedSsrFragmentRoute(expose: string): string;
+export declare const shellApp: WorkspaceApp;
+export declare function createShellHost(remotes?: WorkspaceApp[], verticalRefs?: string[]): WorkspaceApp;
+export declare const sharedPackages: {
+    id: string;
+    directory: string;
+    description: string;
+}[];
+export declare function createNeutralOwnership(id: string, tier?: string): Ownership;
+export type CreateVerticalDescriptorOptions = {
+    /** Generation preset (G2a). Defaults to `full-stack`. */
+    preset?: VerticalPreset;
+    /** API protocol (G7a). Defaults to `rest`. */
+    apiProtocol?: VerticalApiProtocol;
+    /** Generate a Horizontal Remote delivery unit (G2H) instead of a vertical. */
+    horizontalRemote?: boolean;
+};
+export declare function createVerticalDescriptor(name: string, port: number, options?: CreateVerticalDescriptorOptions): WorkspaceApp;
+export declare function appHasApi(app: WorkspaceApp): app is WorkspaceApp & {
+    api: WorkspaceApi;
+};
+/**
+ * Whether an app emits browser/UI artifacts (routes, page/layout, public-web
+ * surfaces, Tailwind, browser Module Federation). True for the shell and for
+ * `full-stack` / `ui-only` verticals; false only for an `api-only` (headless)
+ * vertical (G2a).
+ */
+export declare function appEmitsBrowserUi(app: WorkspaceApp): boolean;
+/** The API protocol for an app's API surface (G7a). Defaults to `rest`. */
+export declare function resolveApiProtocol(app: WorkspaceApp): VerticalApiProtocol;
+export declare function resolveApiPrefix(target: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function resolveApiStem(target: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiApps(remotes?: WorkspaceApp[]): (WorkspaceApp & {
+    api: WorkspaceApi;
+})[];
+export declare function remoteDependencyAlias(remote: WorkspaceApp): string;
+export declare function zephyrRemoteDependency(scope: string, remote: WorkspaceApp): string;
+export declare function resolveRemoteRefs(app: WorkspaceApp, remotes?: WorkspaceApp[]): WorkspaceApp[];
+export declare function createRemoteManifestEnv(remote: WorkspaceApp): string;
+export declare function createBackendFederationManifestEnv(remote: WorkspaceApp): string;
+export declare function createBackendFederationName(app: WorkspaceApp): string;
+export declare function createBackendFederationManifestUrl(app: WorkspaceApp): string;
+export declare function createBackendFederationContainerEntry(app: WorkspaceApp): string;
+export declare function createModuleFederationRemoteContracts(app: WorkspaceApp, remotes?: WorkspaceApp[]): {
+    id: string;
+    alias: string;
+    name: string;
+    manifestEnv: string;
+    manifestUrl: string;
+}[];
+export declare function createCloudflareWorkerName(scope: string, app: WorkspaceApp): string;
+export declare function createCloudflarePublicUrlEnv(app: WorkspaceApp): string;
+export declare function appI18nNamespace(app: WorkspaceApp): string;

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

@@ -0,0 +1 @@
+export declare const effectDiagnostics: string[];

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

@@ -0,0 +1,14 @@
+import type { JsonValue } from './types';
+export declare const createPackageRoot: string;
+export declare const workspaceTemplateDir: string;
+export declare function readFileTemplate(relativePath: string): string;
+export declare function renderFileTemplate(relativePath: string, data: Record<string, string>): string;
+export declare function writeFile(targetDir: string, relativePath: string, content: string): void;
+export declare function writeFileReplacing(targetDir: string, relativePath: string, content: string): void;
+export declare function writeJson(targetDir: string, relativePath: string, value: JsonValue): void;
+export declare function formatGeneratedSourceCandidates(sources: readonly (readonly [relativePath: string, source: string])[]): string[];
+export declare function formatGeneratedWorkspaceFiles(targetDir: string, relativePaths?: readonly string[]): void;
+export declare function renderTemplate(template: string, data: Record<string, string>): string;
+export declare function copyRootTemplate(targetDir: string, data: Record<string, string>, excludedRelativePaths?: ReadonlySet<string>): void;
+export declare function readJsonFile(filePath: string): Record<string, any>;
+export declare function writeJsonFile(filePath: string, value: JsonValue): void;

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

@@ -0,0 +1,16 @@
+import type { ResolvedPackageSource, UltramodernGenerationOperation, UltramodernGenerationResult, UltramodernGenerationWarning, WorkspaceApp } from './types';
+export declare const ignoredSnapshotDirectories: Set<string>;
+type FileSnapshot = Map<string, string>;
+export declare function createFileSnapshot(root: string): FileSnapshot;
+export declare function diffFileSnapshots(before: FileSnapshot, after: FileSnapshot): Pick<UltramodernGenerationResult, 'createdPaths' | 'rewrittenPaths'>;
+export declare function createGenerationResult(options: {
+    operation: UltramodernGenerationOperation;
+    workspaceRoot: string;
+    packageScope: string;
+    packageSource: ResolvedPackageSource;
+    createdApps: WorkspaceApp[];
+    createdPaths: string[];
+    rewrittenPaths: string[];
+    warnings?: UltramodernGenerationWarning[];
+}): UltramodernGenerationResult;
+export {};

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

@@ -0,0 +1,10 @@
+export { addUltramodernShell, planUltramodernShell } from './add-shell';
+export { addUltramodernVertical, planUltramodernVertical, } from './add-vertical';
+export type { UltramodernBridgeConfig, UltramodernBridgeConfigInput, UltramodernBridgeGate, UltramodernBridgeGateInput, UltramodernBridgeLockfilePolicy, UltramodernBridgeTestAlias, UltramodernBridgeWorkspacePackage, UltramodernBridgeWorkspacePackageInput, UltramodernEnabledBridgeConfigInput, } from './bridge-config';
+export { normalizeUltramodernBridgeConfig } from './bridge-config';
+export type { OverlayBaselineViolation } from './overlay-baseline-guard';
+export { BASELINE_DEPENDENCY_PINS, OverlayBaselineRelaxationError, } from './overlay-baseline-guard';
+export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES } from './shared-patches';
+export { createShellDescriptor, PRIMARY_SHELL_ID, resolveConfiguredAdditionalShells, } from './shells';
+export type { AddUltramodernShellOptions, AddUltramodernVerticalOptions, UltramodernCodeSmithOverlay, UltramodernCodeSmithOverlayRuntimeConfig, UltramodernGeneratedAppDescriptor, UltramodernGeneratedContractChange, UltramodernGenerationOperation, UltramodernGenerationResult, UltramodernGenerationWarning, UltramodernJsonMutation, UltramodernShellDependencyChange, UltramodernVerticalPlan, UltramodernWorkspaceOptions, } from './types';
+export { generateUltramodernWorkspace } from './write-workspace';

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

@@ -0,0 +1,51 @@
+import type { WorkspaceApp } from './types';
+export declare function createAppPublicLocaleMessages(app: WorkspaceApp, language: 'en' | 'cs', _remotes?: WorkspaceApp[]): {
+    [x: string]: {
+        boundaries: {
+            toggle: string;
+        };
+        hero: {
+            cardOne: string;
+            cardOneKicker: string;
+            cardTwo: string;
+            cardTwoKicker: string;
+            empty: string;
+            eyebrow: string;
+            lede: string;
+            primary: string;
+            secondary: string;
+        };
+        language: {
+            cs: string;
+            en: string;
+            switcher: string;
+        };
+        remoteUnavailable: string;
+        remotes: {};
+        routes: {
+            home: string;
+        };
+        seo: {
+            description: string;
+        };
+        title: string;
+    } | {
+        language: {
+            cs: string;
+            en: string;
+            switcher: string;
+        };
+        routes: {
+            home: string;
+        };
+        seo: {
+            description: string;
+        };
+        federatedSurface: "Federated surface owned by this vertical." | "Federovaná plocha vlastněná tímto verticalem.";
+        remoteUnavailable: "Remote vertical je nedostupný" | "Remote vertical unavailable";
+        role: string;
+        routeSurface: "Route surface owned by this vertical." | "Routovaná plocha vlastněná tímto verticalem.";
+        title: string;
+        widgetBody: "Owns a vertical route surface." | "Vlastní routovanou plochu verticalu.";
+    };
+};

package/dist/types/ultramodern-workspace/mf-validation/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const moduleFederationConfigFile = "module-federation.config.ts";
+export declare const mfTypesArchive = "dist/@mf-types.zip";
+export declare const generatedMetadataPaths: string[];
+export declare const defaultAppRootDirs: string[];
+export declare const skippedScanDirs: Set<string>;

package/dist/types/ultramodern-workspace/mf-validation/discovery.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleFederationDiscoveredConfig, ModuleFederationValidationOptions } from './types';
+export declare function discoverModuleFederationConfigs(options: ModuleFederationValidationOptions): ModuleFederationDiscoveredConfig[];

package/dist/types/ultramodern-workspace/mf-validation/inspect.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleFederationConfigInspection } from './types';
+export declare function inspectModuleFederationConfigSource(source: string, appDir: string, configPath: string): ModuleFederationConfigInspection;

package/dist/types/ultramodern-workspace/mf-validation/object-literal.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedObjectLiteral } from './types';
+export declare function parseLiteralString(source: string | undefined): string | undefined;
+export declare function parseObjectLiteral(source: string | undefined): ParsedObjectLiteral | undefined;
+export declare function parseArrayLiteral(source: string | undefined): string[] | undefined;

package/dist/types/ultramodern-workspace/mf-validation/path-utils.d.ts

@@ -0,0 +1,11 @@
+import type { JsonRecord } from './types';
+export declare function isRecord(value: unknown): value is JsonRecord;
+export declare function toPosixPath(value: string): string;
+export declare function normalizeRelativePath(value: string): string;
+export declare function relativePath(root: string, target: string): string;
+export declare function readJsonIfExists(filePath: string): unknown;
+export declare function collectMetadataAppDirs(value: unknown, appDirs: Set<string>, hint?: string): void;
+export declare function collectBridgeScanRoots(value: unknown, roots: Set<string>): void;
+export declare function readGeneratedMetadata(workspaceRoot: string): unknown[];
+export declare function firstSegment(appDir: string): string | undefined;
+export declare function scanForModuleFederationConfigs(workspaceRoot: string, scanRoot: string, appDirs: Set<string>): void;

package/dist/types/ultramodern-workspace/mf-validation/syntax.d.ts

@@ -0,0 +1,6 @@
+import type { BalancedBlock, LocatedObjectLiteral } from './types';
+export declare function skipSyntax(source: string, index: number): number;
+export declare function locateCreateModuleFederationConfigObject(source: string): LocatedObjectLiteral | undefined;
+export declare function findCreateModuleFederationConfigObject(source: string): string | undefined;
+export declare function findExportDefaultObject(source: string): string | undefined;
+export declare function getOuterBlock(source: string, open: '{' | '[', close: '}' | ']'): BalancedBlock | undefined;

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

@@ -0,0 +1,38 @@
+export type JsonRecord = Record<string, unknown>;
+export type ModuleFederationConfigInspection = {
+    appDir: string;
+    configPath: string;
+    dts: {
+        compilerInstance?: string;
+        tsConfigPath?: string;
+    };
+    exposes: string[];
+    hostOnlyNoExposes: boolean;
+};
+export type ModuleFederationDiscoveredConfig = {
+    appDir: string;
+    configPath: string;
+};
+export type ModuleFederationValidationResult = {
+    configCount: number;
+    exposedAppCount: number;
+    hostOnlyAppCount: number;
+    apps: ModuleFederationConfigInspection[];
+};
+export type ModuleFederationValidationOptions = {
+    workspaceRoot: string;
+    appDirs?: string[];
+};
+export type BalancedBlock = {
+    inner: string;
+    suffix: string;
+};
+export type LocatedObjectLiteral = {
+    end: number;
+    source: string;
+    start: number;
+};
+export type ParsedObjectLiteral = {
+    hasSpread: boolean;
+    properties: Map<string, string>;
+};

package/dist/types/ultramodern-workspace/mf-validation/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleFederationConfigInspection, ModuleFederationValidationOptions, ModuleFederationValidationResult } from './types';
+export declare function assertExposedAppDtsSettings(app: ModuleFederationConfigInspection): void;
+export declare function assertTypesArchive(workspaceRoot: string, appDir: string): void;
+export declare function validateModuleFederationTypes(options: ModuleFederationValidationOptions): ModuleFederationValidationResult;

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

@@ -0,0 +1,4 @@
+export { discoverModuleFederationConfigs } from './mf-validation/discovery';
+export { inspectModuleFederationConfigSource } from './mf-validation/inspect';
+export type { ModuleFederationConfigInspection, ModuleFederationDiscoveredConfig, ModuleFederationValidationOptions, ModuleFederationValidationResult, } from './mf-validation/types';
+export { validateModuleFederationTypes } from './mf-validation/validate';

package/dist/types/ultramodern-workspace/module-federation/config.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceApp } from '../types';
+export declare function createAppModernConfig(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[], enableTailwind?: boolean, configuredDevPorts?: number[]): string;
+export declare function createShellModuleFederationConfig(scope: string, shell: WorkspaceApp, remotes?: WorkspaceApp[], enableBridgeRouter?: boolean): string;
+export declare function createBackendModuleFederationConfig(app: WorkspaceApp): string;
+export declare function createRemoteModuleFederationConfig(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[], enableBridgeRouter?: boolean): string;

package/dist/types/ultramodern-workspace/module-federation/reexport-module.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceApp } from '../types';
+export declare function createUltramodernBuildArtifactJson(scope: string, app: WorkspaceApp): string;
+export declare function createUltramodernBuildModule(scope: string, app: WorkspaceApp): string;
+export declare function createUltramodernBuildReexportModule(): string;

package/dist/types/ultramodern-workspace/module-federation/remote-refs.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceApp } from '../types';
+export declare function createModuleFederationRemoteUrlHelpers(app: WorkspaceApp, remotes?: WorkspaceApp[], includeAppToolsImport?: boolean): string;
+export declare function createModuleFederationRemotesConfig(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[]): string;

package/dist/types/ultramodern-workspace/module-federation/shared-config.d.ts

@@ -0,0 +1,2 @@
+export declare function createSharedModuleFederationConfig(): string;
+export declare function formatTsObjectLiteral(value: Record<string, string>): string;

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

@@ -0,0 +1,5 @@
+export { createBuildMarker } from './delivery-unit';
+export { createAppModernConfig, createBackendModuleFederationConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig, } from './module-federation/config';
+export { createUltramodernBuildArtifactJson, createUltramodernBuildModule, createUltramodernBuildReexportModule, } from './module-federation/reexport-module';
+export { createModuleFederationRemotesConfig, createModuleFederationRemoteUrlHelpers, } from './module-federation/remote-refs';
+export { createSharedModuleFederationConfig, formatTsObjectLiteral, } from './module-federation/shared-config';

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

@@ -0,0 +1,14 @@
+import type { WorkspaceApp } from './types';
+export declare function normalizePath(filePath: string): string;
+export declare function toPackageScope(packageName: string): string;
+export declare function toKebabCase(value: string): string;
+export declare function toCamelCase(value: string): string;
+export declare function toEnvSegment(value: string): string;
+export declare function createRspackUniqueName(app: WorkspaceApp): string;
+export declare function createRspackChunkLoadingGlobal(app: WorkspaceApp): string;
+export declare function packageName(scope: string, suffix: string): string;
+export declare function relativeRootFor(packageDir: string): string;
+export declare function tailwindPrefixForApp(app: WorkspaceApp): string;
+export declare function assertUniqueTailwindPrefixes(apps: WorkspaceApp[]): void;
+export declare function createTw(prefix: string): (classList: string) => string;
+export declare function toPascalCase(value: string): string;

package/dist/types/ultramodern-workspace/overlay-baseline-guard.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Platform Baseline producer pins (G21 / CONTEXT.md "Platform Baseline").
+ * A Platform Overlay (overlays.ts) may only *narrow* choices — it must never
+ * relax the baseline. The concrete, structurally-checkable meaning of "must not
+ * relax" is: an overlay's output must not change the pinned version of any
+ * baseline dependency (React, TanStack Router, Effect, Tailwind) in any
+ * generated package manifest, and must not (re)introduce a package that pins a
+ * baseline dependency to a version other than the platform pin.
+ *
+ * These names match the specifiers emitted into generated `package.json`
+ * manifests. `@tanstack/react-router` and `@tanstack/router-core` are the two
+ * router producers; `tailwindcss` is the Tailwind producer; `effect` is the
+ * Effect producer; `react`/`react-dom` are the React producers.
+ */
+export declare const BASELINE_DEPENDENCY_PINS: Readonly<Record<string, string>>;
+export type OverlayBaselineViolation = {
+    kind: 'baseline-version-relaxation' | 'forbidden-shell-artifact';
+    path: string;
+    detail: string;
+};
+/**
+ * Typed error raised BEFORE an overlaid workspace is accepted when a CodeSmith
+ * overlay relaxes the Platform Baseline (G21). Carries the exact violations so
+ * callers can surface which baseline pin or forbidden artifact the overlay
+ * changed.
+ */
+export declare class OverlayBaselineRelaxationError extends Error {
+    readonly code = "ULTRAMODERN_OVERLAY_BASELINE_RELAXATION";
+    readonly generator: string;
+    readonly violations: OverlayBaselineViolation[];
+    constructor(generator: string, violations: OverlayBaselineViolation[]);
+}
+/**
+ * Snapshot of the baseline-relevant workspace state taken BEFORE an overlay
+ * runs. Compared against the post-overlay state to prove non-relaxation.
+ */
+export type OverlayBaselineSnapshot = {
+    baselinePinsByManifest: Record<string, Record<string, string>>;
+    baselinePolicyPinsByManifest?: Record<string, Record<string, string>>;
+    baselineWorkspacePolicyPins?: Record<string, string>;
+    shellPackageDirectories: string[];
+    shellFiles: Set<string>;
+};
+export declare function captureOverlayBaselineSnapshot(workspaceRoot: string, shellPackageDirectories: string[]): OverlayBaselineSnapshot;
+/**
+ * Validate that an applied CodeSmith overlay did not relax the Platform
+ * Baseline (G21). Compares the post-overlay workspace against the pre-overlay
+ * {@link OverlayBaselineSnapshot}; throws {@link OverlayBaselineRelaxationError}
+ * when the overlay changed a baseline pin or reintroduced a forbidden thin-shell
+ * artifact. Pure read + throw: it never writes, so a relaxing overlay fails
+ * before its output is accepted by the generator.
+ */
+export declare function assertOverlayPreservedBaseline(options: {
+    workspaceRoot: string;
+    generator: string;
+    snapshot: OverlayBaselineSnapshot;
+}): void;

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

@@ -0,0 +1,6 @@
+import type { UltramodernCodeSmithOverlay, UltramodernGenerationResult } from './types';
+export declare function runCodeSmithOverlays(options: {
+    workspaceRoot: string;
+    overlays?: UltramodernCodeSmithOverlay[];
+    result: UltramodernGenerationResult;
+}): void;

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

@@ -0,0 +1,8 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
+import type { JsonValue, ResolvedPackageSource, WorkspaceApp } from './types';
+export declare function appDependencies(scope: string, packageSource: ResolvedPackageSource, app: WorkspaceApp, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig): Record<string, string>;
+export declare function createRootPackageJson(scope: string, packageSource: ResolvedPackageSource, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig, additionalShells?: WorkspaceApp[]): JsonValue;
+export { createAppMfTypesTsConfig, createAppTsConfig, createPackageTsConfig, createRootTsConfig, createSharedPackageTsConfig, createTsConfigBase, } from './tsconfigs';
+export declare function createAppPackage(scope: string, app: WorkspaceApp, packageSource: ResolvedPackageSource, enableTailwind: boolean, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig): JsonValue;
+export declare function createSharedPackage(scope: string, id: string, description: string): JsonValue;
+export declare function createSharedContractsIndex(): string;

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

@@ -0,0 +1,3 @@
+import type { ResolvedPackageSource, UltramodernWorkspaceOptions } from './types';
+export declare function resolvePackageSource(options: UltramodernWorkspaceOptions): ResolvedPackageSource;
+export declare function resolveWorkspacePackageLinkingPolicy(packageSource: Pick<ResolvedPackageSource, 'strategy'>): Partial<Record<'injectWorkspacePackages' | 'linkWorkspacePackages', true>>;