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

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-removal.d.ts

@@ -0,0 +1,4 @@
+import { type UltramodernToolingConfig } from '../../config';
+import { type MigrationIo } from './io';
+export declare function removeGeneratedFileIfExists(io: MigrationIo, relativePath: string): boolean;
+export declare function removeStaleBackendFederationArtifacts(io: MigrationIo, config: UltramodernToolingConfig): boolean;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-typescript.d.ts

@@ -0,0 +1,3 @@
+import { type UltramodernToolingConfig } from '../../config';
+import { type MigrationIo } from './io';
+export declare function updateGeneratedTypeScriptSurfaces(io: MigrationIo, config: UltramodernToolingConfig): void;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-zerops.d.ts

@@ -0,0 +1,3 @@
+import { type UltramodernToolingConfig } from '../../config';
+import { type MigrationIo } from './io';
+export declare function updateGeneratedZeropsArtifacts(io: MigrationIo, config: UltramodernToolingConfig): void;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts.d.ts

@@ -0,0 +1,8 @@
+export { updateGeneratedBackendFederationContractFiles } from './generated-artifacts-backend-federation';
+export { updateGeneratedBuildIdentityModules } from './generated-artifacts-build-identity';
+export { updateGeneratedModernConfigs } from './generated-artifacts-modern-configs';
+export { ensureGeneratedOxfmtIgnorePatterns } from './generated-artifacts-oxfmt';
+export { ensureGeneratedOxlintComponentStyle } from './generated-artifacts-oxlint';
+export { removeGeneratedFileIfExists, removeStaleBackendFederationArtifacts, } from './generated-artifacts-removal';
+export { updateGeneratedTypeScriptSurfaces } from './generated-artifacts-typescript';
+export { updateGeneratedZeropsArtifacts } from './generated-artifacts-zerops';

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/generated-patches.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationIo } from './io';
+export declare function ensureGeneratedPatchFile(io: MigrationIo, relativePatchPath: string, sourcePatchPath: string): boolean;
+export declare function removeGeneratedPatchFileIfUnchanged(io: MigrationIo, relativePatchPath: string, sourcePatchPath: string): boolean;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/generated-ui-source.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationIo } from './io';
+export declare function generatedUiSourceRequiresRewrite(existingSource: string, nextSource: string): boolean;
+export declare function writeGeneratedUiSourceIfChanged(io: MigrationIo, filePath: string, nextSource: string): boolean;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/help.d.ts

@@ -0,0 +1 @@
+export declare const migrateStrictEffectHelp = "Usage:\n  ultramodern-create ultramodern migrate-strict-effect --version <version> [--dry-run] [--skip-install]\n\nUpdates generated UltraModern package-source metadata, Modern package aliases,\nframework-owned toolchain pins, direct Effect API topology metadata, strict\nEffect pnpm overrides/trust policy, framework-owned TypeScript config\nsurfaces, and the pnpm lockfile. Source code still has to pass pnpm api:check\nand pnpm contract:check.\n\nExisting Modern configs are treated as consumer-owned unless generated\nownership can be proven. Package scripts and TypeScript configs are merged at\ntheir framework-owned boundaries so consumer command segments, includes,\nreferences, plugins, and diagnostic overrides survive. An ambiguous Module\nFederation config that requires a bridge update is refused before any file is\nwritten, with the config path and the manual resolution required.\n\nThe obsolete react-router dependency is dropped from every generated app that\ndoes not import React Router in its own source. Each generated Module\nFederation config then declares bridge.enableBridgeRouter from what its app\nstill depends on: true where the app declares react-router or react-router-dom,\nthe router-free false everywhere else.\n\nWhen the compact config is absent but legacy UltraModern 3.2 metadata is\npresent, the compact config is synthesized from it first. Shell-only\nworkspaces skip the backend-federation and Zerops runtime stages. Pass\n--dry-run to print the planned filesystem changes without writing anything\n(including preserved consumer overlays; implies --skip-install).\n";

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/install.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from '../context';
+export declare function runPnpmLockfileRefresh(context: CommandContext): number;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/io.d.ts

@@ -0,0 +1,26 @@
+type MigrationTransactionOptions<T> = {
+    commitWhen?: (result: T) => boolean;
+};
+export type MigrationIo = {
+    workspaceRoot: string;
+    dryRun: boolean;
+    plan: string[];
+    write(filePath: string, content: string): boolean;
+    writeGenerated(filePath: string, content: string): boolean;
+    remove(filePath: string): boolean;
+    log(message: string): void;
+    transaction<T>(operation: () => T, options?: MigrationTransactionOptions<Awaited<T>>): T;
+    withStagedWorkspace<T>(operation: (stagedWorkspaceRoot: string) => T): T;
+};
+export declare function createMigrationIo(workspaceRoot: string, dryRun: boolean): MigrationIo;
+/**
+ * Runs a dry-run against an owned, disposable workspace clone. The returned
+ * IO still records a dry-run plan, but materializes that plan only inside the
+ * clone so direct filesystem reads observe the same state as an applied
+ * migration. Callers cannot opt an arbitrary workspace into this behavior.
+ */
+export declare function withStagedDryRunMigrationIo<T>(workspaceRoot: string, operation: (io: MigrationIo) => T): T;
+export declare function readJsonFile(filePath: string): any;
+export declare function writeJsonFile(io: MigrationIo, filePath: string, value: unknown): boolean;
+export declare function listWorkspacePackageFiles(workspaceRoot: string): string[];
+export {};

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/package-cohort.d.ts

@@ -0,0 +1,25 @@
+import { type ResolvedUltramodernPackageSource } from '../../../ultramodern-package-source';
+import type { WorkspaceApp } from '../../../ultramodern-workspace/types';
+export declare function updateModernDependencies(packageJson: Record<string, any>, packageSource: ResolvedUltramodernPackageSource): boolean;
+export declare function updateGeneratedToolingDependencies(packageJson: Record<string, any>, options?: {
+    ownsGeneratedScripts?: boolean;
+}): boolean;
+/**
+ * `@modern-js/plugin-bff` declares `effect` and `@effect/opentelemetry` as
+ * OPTIONAL peers, so whoever depends on plugin-bff has to supply them. A
+ * workspace generated before that change declares neither, and nothing else
+ * pulls Effect in — so on migration the BFF lane has no Effect to load, and the
+ * `effect@<version>` entry this command writes into `patchedDependencies`
+ * matches no package, which pnpm rejects with ERR_PNPM_UNUSED_PATCH.
+ *
+ * Unlike `updateGeneratedToolingDependencies`, this adds the pins when they are
+ * missing rather than only re-pinning what is already declared.
+ */
+export declare function ensureBffEffectDependencies(packageJson: Record<string, any>): boolean;
+export declare function updateGeneratedPackageScripts(packageJson: Record<string, any>, options?: {
+    relativePackageFile?: string;
+    apps?: WorkspaceApp[];
+    shellOnly?: boolean;
+    canRetireLegacyOxfmtCliExclusion?: boolean;
+    onPreserveScript?: (scriptName: string) => void;
+}): boolean;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/package-source.d.ts

@@ -0,0 +1,3 @@
+import { type ResolvedUltramodernPackageSource } from '../../../ultramodern-package-source';
+import { readUltramodernConfig } from '../../config';
+export declare function createMigrationPackageSource(args: string[], current: ReturnType<typeof readUltramodernConfig>): ResolvedUltramodernPackageSource;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/pnpm-policy.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedUltramodernPackageSource } from '../../../ultramodern-package-source';
+import { type UltramodernReleaseCohort } from '../../../ultramodern-release-cohort';
+import type { MigrationIo } from './io';
+type RegistryResponse = {
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+};
+export type ReleaseAgeRegistryFetch = (url: URL, init: {
+    headers: Record<string, string>;
+    redirect: 'error';
+}) => Promise<RegistryResponse>;
+export declare function updateGeneratedPnpmWorkspacePolicy(io: MigrationIo, packageSource: ResolvedUltramodernPackageSource, options?: {
+    now?: Date;
+    releaseCohort?: UltramodernReleaseCohort;
+}): boolean;
+export declare function validateGeneratedPnpmLockReleaseAgePolicy(workspaceRoot: string, packageSource: ResolvedUltramodernPackageSource, options?: {
+    fetchImpl?: ReleaseAgeRegistryFetch;
+    now?: Date;
+    registryUrl?: string;
+    releaseCohort?: UltramodernReleaseCohort;
+}): Promise<{
+    reviewCandidates: import("../../../ultramodern-workspace/policy").UltramodernReleaseAgeCandidate[];
+    minimumReleaseAgeExclude: string[];
+}>;
+export {};

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/pnpm-yaml.d.ts

@@ -0,0 +1,26 @@
+export type PnpmWorkspaceYaml = Record<string, any>;
+export type PnpmLockReleaseAgeCandidate = {
+    packageName: string;
+    version: string;
+    registry: {
+        dist: {
+            integrity: string;
+        };
+    };
+    path: string[];
+};
+export type PnpmLockReleaseAgeClosure = {
+    candidates: PnpmLockReleaseAgeCandidate[];
+    unresolved: Array<{
+        package?: string;
+        path: string[];
+        reason: string;
+    }>;
+};
+export declare function isYamlRecord(value: unknown): value is PnpmWorkspaceYaml;
+export declare function discoverReachablePnpmLockReleaseAgeClosure(lockfile: unknown): PnpmLockReleaseAgeClosure;
+export declare function parsePnpmWorkspaceYaml(source: string, filename?: string): {
+    document: PnpmWorkspaceYaml;
+    lineEnding: string;
+};
+export declare function stringifyPnpmWorkspaceYaml(document: PnpmWorkspaceYaml, lineEnding?: string): string;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/policy-constants.d.ts

@@ -0,0 +1,6 @@
+export declare const requiredGeneratedPatches: {
+    path: string;
+    sourcePath: string;
+}[];
+export declare const drizzleOrmDeclarationPatchPath: string;
+export declare const drizzleOrmDeclarationPatchSourcePath: string;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/react-router-retirement.d.ts

@@ -0,0 +1,37 @@
+import type { WorkspaceApp } from '../../../ultramodern-workspace/types';
+import type { MigrationIo } from './io';
+export declare function authoredSourceImportsReactRouter(packageDirectory: string): boolean;
+/**
+ * The single definition of "this app is a React Router consumer", shared by the
+ * generators, the migration and (mirrored) the generated workspace validator.
+ * `@module-federation/rspack` never inspects react-router when it decides
+ * whether to install the bridge router plugin — the app's own manifest is the
+ * only place that opting in can be declared, so it is the only place that is
+ * read. Accepts a package directory or an already parsed manifest.
+ */
+export declare function appDeclaresReactRouter(packageJsonOrDirectory: Record<string, any> | string): boolean;
+export type RetiredReactRouterOutcome = 'absent' | 'preserved' | 'removed';
+/**
+ * `react-router` was pinned into generated apps only to satisfy
+ * `@module-federation/bridge-react`, whose main entry statically imports
+ * `react-router-dom`. Generated Module Federation configs now opt out with
+ * `bridge.enableBridgeRouter: false`, which aliases bridge-react to its
+ * router-free base entry, so the pin is obsolete. Apps that genuinely import
+ * React Router themselves keep it — and keeping it is exactly what re-enables
+ * the bridge router for them, see `appDeclaresReactRouter`.
+ *
+ * Unlike `updateGeneratedToolingDependencies`, which only re-pins keys that are
+ * already declared, this removes a declared key — so it must never guess: an
+ * app with authored React Router imports is reported and left alone.
+ */
+export declare function removeRetiredReactRouterDependency(packageJson: Record<string, any>, packageDirectory: string): RetiredReactRouterOutcome;
+export declare function isGeneratedModuleFederationConfig(source: string): boolean;
+export declare function preflightModuleFederationBridgeRouter(workspaceRoot: string, apps: readonly Pick<WorkspaceApp, 'directory' | 'surfaceProfile'>[]): void;
+/**
+ * Returns the rewritten source, the unchanged source when a `bridge` block is
+ * already declared (a hand-written one is consumer-owned), or `undefined` when
+ * the config shape is not statically recognizable — in which case the caller
+ * must leave the file alone.
+ */
+export declare function insertBridgeRouterOptOut(source: string, enableBridgeRouter?: boolean): string | undefined;
+export declare function ensureGeneratedModuleFederationBridgeRouterOptOut(io: MigrationIo, apps: readonly Pick<WorkspaceApp, 'directory' | 'surfaceProfile'>[]): boolean;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect/toolchain-pins.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationIo } from './io';
+export declare function updateUltramodernConfigToolchain(config: Record<string, any>): void;
+export declare function updateRootPackageToolchain(packageJson: Record<string, any>): void;
+export declare function updateGeneratedToolchainFiles(io: MigrationIo): void;

package/dist/types/ultramodern-tooling/commands/migrate-strict-effect.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from './context';
+export declare function runMigrateStrictEffect(args: string[], context: CommandContext): number | Promise<number>;

package/dist/types/ultramodern-tooling/commands/options.d.ts

@@ -0,0 +1,2 @@
+export declare function readOption(args: string[], name: string): string | undefined;
+export declare function hasFlag(args: string[], name: string): boolean;

package/dist/types/ultramodern-tooling/commands/routes-generate.d.ts

@@ -0,0 +1,2 @@
+import { type CommandContext } from './context';
+export declare function runRoutesGenerate(args: string[], context: CommandContext): number;

package/dist/types/ultramodern-tooling/commands/skills.d.ts

@@ -0,0 +1,2 @@
+import { type CommandContext } from './context';
+export declare function runSkills(args: string[], context: CommandContext): number;

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

@@ -0,0 +1 @@
+export { runSyncDeliveryUnit } from '../../ultramodern-workspace/delivery-unit-sync';

package/dist/types/ultramodern-tooling/commands/validate.d.ts

@@ -0,0 +1,2 @@
+import { type CommandContext } from './context';
+export declare function runValidate(context: CommandContext): number;

package/dist/types/ultramodern-tooling/commands.d.ts

@@ -0,0 +1 @@
+export declare function runUltramodernToolingCli(args: string[], workspaceRoot?: string): Promise<number>;

package/dist/types/ultramodern-tooling/config/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const LEGACY_GENERATED_CONTRACT_PATH = ".modernjs/ultramodern-generated-contract.json";
+export declare const LEGACY_PACKAGE_SOURCE_METADATA_PATH = ".modernjs/ultramodern-package-source.json";
+export declare const LEGACY_DEVELOPMENT_OVERLAY_PATH = "topology/local-overlays/development.json";

package/dist/types/ultramodern-tooling/config/index.d.ts

@@ -0,0 +1,7 @@
+export * from './constants';
+export * from './json';
+export * from './load';
+export * from './metadata';
+export * from './normalize';
+export * from './synthesize';
+export * from './types';

package/dist/types/ultramodern-tooling/config/json.d.ts

@@ -0,0 +1,2 @@
+export declare function readJsonObject(filePath: string): Record<string, any>;
+export declare function readOptionalJsonObject(filePath: string): Record<string, any>;

package/dist/types/ultramodern-tooling/config/load.d.ts

@@ -0,0 +1,2 @@
+import type { UltramodernToolingConfig } from './types';
+export declare function readUltramodernConfig(workspaceRoot?: string): UltramodernToolingConfig;

package/dist/types/ultramodern-tooling/config/metadata.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedPackageSource } from '../../ultramodern-workspace/types';
+export declare function packageScopeFromRoot(workspaceRoot: string): string;
+export declare function packageSourceFromMetadata(workspaceRoot: string): ResolvedPackageSource | undefined;
+export declare function readOverlayPorts(workspaceRoot: string): Record<string, number>;

package/dist/types/ultramodern-tooling/config/normalize.d.ts

@@ -0,0 +1,22 @@
+import type { WorkspaceApp } from '../../ultramodern-workspace/types';
+import type { UltramodernToolingConfig } from './types';
+type UnsupportedUltramodernConfigIssue = {
+    field: 'schemaVersion';
+    value: unknown;
+    reason: 'missing' | 'non-integer' | 'unsupported';
+} | {
+    field: 'topology.apps.kind';
+    index: number;
+    value: unknown;
+};
+export declare class UnsupportedUltramodernConfigError extends Error {
+    readonly sourcePath: string;
+    readonly issue: UnsupportedUltramodernConfigIssue;
+    constructor(sourcePath: string, issue: UnsupportedUltramodernConfigIssue);
+}
+export declare function normalizeCompactConfig(workspaceRoot: string, sourcePath: string, config: Record<string, any>): UltramodernToolingConfig;
+export declare function normalizeCompactUltramodernConfig(workspaceRoot: string, compact: Record<string, any>): UltramodernToolingConfig;
+export declare function workspaceAppsFromToolingConfig(config: UltramodernToolingConfig): WorkspaceApp[];
+export declare function additionalShellsFromToolingConfig(config: UltramodernToolingConfig): WorkspaceApp[];
+export declare function allWorkspaceAppsFromToolingConfig(config: UltramodernToolingConfig): WorkspaceApp[];
+export {};

package/dist/types/ultramodern-tooling/config/synthesize.d.ts

@@ -0,0 +1,5 @@
+export declare function synthesizeCompactUltramodernConfig(workspaceRoot: string): {
+    compact: Record<string, any>;
+    missing: string[];
+    sources: string[];
+} | undefined;

package/dist/types/ultramodern-tooling/config/types.d.ts

@@ -0,0 +1,45 @@
+import type { UltramodernBridgeConfig } from '../../ultramodern-workspace/bridge-config';
+import type { ResolvedPackageSource, VerticalPreset, WorkspaceApi, WorkspaceApp, WorkspaceDeliveryUnitKind } from '../../ultramodern-workspace/types';
+export type UltramodernToolingConfigSource = 'compact';
+export type UltramodernToolingConfigApp = {
+    id: string;
+    kind: WorkspaceApp['kind'];
+    path: string;
+    package?: string;
+    packageSuffix?: string;
+    displayName?: string;
+    domain?: string;
+    surfaceProfile?: VerticalPreset;
+    deliveryUnitKind?: WorkspaceDeliveryUnitKind;
+    port?: number;
+    portEnv?: string;
+    moduleFederation?: {
+        role?: 'host' | 'remote';
+        name?: string;
+        exposes?: string[];
+        exposePaths?: Record<string, string>;
+        verticalRefs?: string[];
+        hostOnly?: boolean;
+        noExposes?: boolean;
+    };
+    api?: WorkspaceApi;
+};
+export type UltramodernToolingConfig = {
+    schemaVersion: number;
+    profile?: string;
+    source: UltramodernToolingConfigSource;
+    sourcePath: string;
+    workspace: {
+        packageScope: string;
+    };
+    packageSource?: ResolvedPackageSource;
+    features: {
+        tailwind: boolean;
+    };
+    bridge?: UltramodernBridgeConfig;
+    topology: {
+        apps: UltramodernToolingConfigApp[];
+    };
+    /** Additional shells live in the additive compact-config collection. */
+    shells?: Array<Record<string, unknown>>;
+};

package/dist/types/ultramodern-tooling/config.d.ts

@@ -0,0 +1 @@
+export * from './config/index';

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

@@ -0,0 +1,14 @@
+import type { AddUltramodernShellOptions, UltramodernGenerationResult, UltramodernVerticalPlan } from './types';
+/**
+ * Add an additional thin shell to an existing workspace (G28). Transactional:
+ * the whole write-set is applied inside {@link runWorkspaceTransaction}; any
+ * failure restores the workspace byte-identical to its pre-call state.
+ */
+export declare function addUltramodernShell(options: AddUltramodernShellOptions): UltramodernGenerationResult;
+/**
+ * Dry-run parity for {@link addUltramodernShell} (G28). Applies the operation
+ * against a throwaway copy of the workspace and returns the planned result
+ * (created/rewritten paths, delivery-unit identity) without touching the real
+ * workspace.
+ */
+export declare function planUltramodernShell(options: AddUltramodernShellOptions): UltramodernVerticalPlan;

package/dist/types/ultramodern-workspace/add-vertical/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const FIRST_VERTICAL_PORT = 4101;
+export declare const TOPOLOGY_PATH = "topology/reference-topology.json";
+export declare const OWNERSHIP_PATH = "topology/ownership.json";
+export declare const DEVELOPMENT_OVERLAY_PATH = "topology/local-overlays/development.json";

package/dist/types/ultramodern-workspace/add-vertical/execute.d.ts

@@ -0,0 +1,9 @@
+import type { AddUltramodernVerticalOptions, UltramodernGenerationResult } from '../types';
+/**
+ * Add a MicroVertical to an existing workspace. Transactional (G1c): the
+ * whole write-set is applied inside {@link runWorkspaceTransaction}; if any
+ * step throws (preflight rejection, write failure, overlay failure,
+ * formatting failure) the workspace is restored byte-identical to its
+ * pre-call state and the error is rethrown.
+ */
+export declare function addUltramodernVertical(options: AddUltramodernVerticalOptions): UltramodernGenerationResult;

package/dist/types/ultramodern-workspace/add-vertical/plan.d.ts

@@ -0,0 +1,2 @@
+import type { AddUltramodernVerticalOptions, UltramodernVerticalPlan } from '../types';
+export declare function planUltramodernVertical(options: AddUltramodernVerticalOptions): UltramodernVerticalPlan;

package/dist/types/ultramodern-workspace/add-vertical/preflight.d.ts

@@ -0,0 +1,42 @@
+import type { UltramodernBridgeConfig } from '../bridge-config';
+import type { AddUltramodernVerticalOptions, ResolvedPackageSource, WorkspaceApp } from '../types';
+export type AddUltramodernVerticalPreflight = {
+    name: string;
+    scope: string;
+    topologyPath: string;
+    ownershipPath: string;
+    overlayPath: string;
+    rootPackage: Record<string, any>;
+    topology: Record<string, any>;
+    ownership: Record<string, any>;
+    overlay: Record<string, any>;
+    packageSource: ResolvedPackageSource;
+    enableTailwind: boolean;
+    bridge?: UltramodernBridgeConfig;
+    config: Record<string, any>;
+    primaryShell: WorkspaceApp;
+    additionalShells: WorkspaceApp[];
+    targetShell: WorkspaceApp;
+    targetVerticals: WorkspaceApp[];
+    vertical: WorkspaceApp;
+    updatedVerticals: WorkspaceApp[];
+};
+export type UnknownUltramodernShellIssue = {
+    field: 'shell';
+    value: string;
+    reason: 'unknown';
+    available: string[];
+};
+/**
+ * Typed preflight rejection for an add-vertical request whose shell target is
+ * not present in the workspace's additive config.shells collection.
+ */
+export declare class UnknownUltramodernShellError extends Error {
+    readonly sourcePath: string;
+    readonly code = "ULTRAMODERN_UNKNOWN_TARGET_SHELL";
+    readonly issue: UnknownUltramodernShellIssue;
+    constructor(sourcePath: string, requestedShellId: string, available: string[]);
+}
+export declare function prepareAddUltramodernVertical(options: AddUltramodernVerticalOptions): AddUltramodernVerticalPreflight;
+export declare function createPrimaryShellDescriptor(topology: Record<string, any>, config: Record<string, any>): WorkspaceApp;
+export declare function assertNonEmptyString(value: unknown, label: string): void;

package/dist/types/ultramodern-workspace/add-vertical/shell-files.d.ts

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

package/dist/types/ultramodern-workspace/add-vertical/topology.d.ts

@@ -0,0 +1,9 @@
+import type { JsonValue, Ownership, WorkspaceApp } from '../types';
+export declare function verticalTopologyEntry(scope: string, vertical: WorkspaceApp, remotes?: WorkspaceApp[]): JsonValue;
+export declare function ownershipEntry(scope: string, owner: {
+    id: string;
+    packageSuffix: string;
+    directory: string;
+    ownership: Ownership;
+}): JsonValue;
+export declare function verticalsFromTopology(topology: Record<string, any>, ports: Record<string, unknown>): WorkspaceApp[];

package/dist/types/ultramodern-workspace/add-vertical/transaction.d.ts

@@ -0,0 +1,49 @@
+export declare class WorkspaceTransactionConflictError extends Error {
+    readonly code: 'workspace-transaction-conflict';
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Deterministic fault/concurrency seams used only by focused tests. */
+export declare const __transactionTestHooks: {
+    beforePublish?: (details: {
+        workspaceRoot: string;
+        stagingRoot: string;
+        changedPaths: readonly string[];
+    }) => void;
+    beforePublishPath?: (details: {
+        workspaceRoot: string;
+        relativePath: string;
+        index: number;
+    }) => void;
+    afterPreimageCheck?: (details: {
+        workspaceRoot: string;
+        relativePath: string;
+    }) => void;
+    beforeFreshPublish?: (details: {
+        workspaceRoot: string;
+    }) => void;
+};
+/**
+ * Overlays may persist their physical workspace root. The staged directory is
+ * moved after they finish, so relocate those exact references before planning
+ * or publishing; leaving a private temporary path in generated output would be
+ * observably wrong after a successful transaction.
+ */
+export declare function relocateStagedWorkspaceReferences(stagingRoot: string, workspaceRoot: string): void;
+/**
+ * Run an existing-workspace mutation against a private sibling. Only the
+ * semantic file changes produced there are published, and every owned target
+ * must still match its exact preimage. Unrelated workspace files are never
+ * copied back, so concurrent consumer work is conserved without a lock.
+ */
+export declare function runWorkspaceTransaction<T>(root: string, mutate: (stagingRoot: string) => T): T;
+/**
+ * Fully stage a fresh workspace beside its resolved target and publish the
+ * complete tree with one directory rename. An already-empty target needs a
+ * narrow empty-directory swap (the canonical path is briefly absent) so CLI
+ * generation in an empty cwd retains its contract without exposing a partial
+ * tree. Node has no portable no-replace directory rename, so an external
+ * process can still win the narrow final preflight-to-rename race.
+ */
+export declare function runFreshWorkspaceTransaction<T>(targetDir: string, generate: (stagingRoot: string) => T): T;

package/dist/types/ultramodern-workspace/add-vertical/workspace-state.d.ts

@@ -0,0 +1,15 @@
+import type { UltramodernBridgeConfig } from '../bridge-config';
+import type { ResolvedPackageSource, UltramodernWorkspaceOptions, WorkspaceApp } from '../types';
+export declare function existingPackageSource(workspaceRoot: string, modernVersion: string, packageSource?: UltramodernWorkspaceOptions['packageSource']): ResolvedPackageSource;
+export declare function existingTailwindEnabled(workspaceRoot: string): boolean;
+export declare function existingBridgeConfig(workspaceRoot: string): UltramodernBridgeConfig | undefined;
+export declare function assertValidVerticalName(name: string): string;
+export declare function configuredDevelopmentPorts(ports: Record<string, unknown>, additionalShells?: WorkspaceApp[]): number[];
+export declare function assertGlobalPortUniqueness(ports: Record<string, unknown>, additionalShells?: WorkspaceApp[]): void;
+/**
+ * Allocate from the one workspace-wide port set. The caller supplies the
+ * lower bound for its app class (verticals start at 4101; additional shells at
+ * 3120), while existing overlay and shell ports always participate.
+ */
+export declare function nextAvailablePort(ports: Record<string, unknown>, additionalShells?: WorkspaceApp[], minimumPort?: number): number;
+export declare function assertCanCreate(workspaceRoot: string, relativePath: string): void;

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

@@ -0,0 +1,7 @@
+export { addUltramodernVertical } from './add-vertical/execute';
+export { planUltramodernVertical } from './add-vertical/plan';
+export type { AddUltramodernVerticalPreflight } from './add-vertical/preflight';
+export { prepareAddUltramodernVertical } from './add-vertical/preflight';
+export { rewriteShellAppFiles, updateRootWorkspaceScripts, } from './add-vertical/shell-files';
+export { ownershipEntry, verticalsFromTopology, verticalTopologyEntry, } from './add-vertical/topology';
+export { assertCanCreate, assertValidVerticalName, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort, } from './add-vertical/workspace-state';

package/dist/types/ultramodern-workspace/api/checkout-cart.d.ts

@@ -0,0 +1,33 @@
+import type { WorkspaceApi } from '../types';
+export declare function serviceHasCheckoutCartState(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): boolean;
+export declare function createCheckoutCartSharedSchemas(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function createCheckoutCartEndpointDefinitions(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function createCheckoutCartOperationContexts(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function createCheckoutCartApiContractFields(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function createCheckoutCartServerState(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function createCheckoutCartServerHandlers(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function createCheckoutCartClientExports(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;

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

@@ -0,0 +1,6 @@
+import type { WorkspaceApi, WorkspaceApp } from '../types';
+export declare function createApiClient(service: {
+    id: string;
+    api?: WorkspaceApi;
+}, contractImportPath: string): string;
+export declare function createShellApiClient(scope: string, remotes?: WorkspaceApp[]): string;

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

@@ -0,0 +1,2 @@
+import type { JsonValue, WorkspaceApp } from '../types';
+export declare function apiTopologyMetadata(app: WorkspaceApp): JsonValue | undefined;

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

@@ -0,0 +1,41 @@
+import type { WorkspaceApi } from '../types';
+export declare function verticalApiExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiGroupName(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiName(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiSchemaExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiMarkerSchemaExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiReadinessSchemaExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiErrorStem(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiCreatePayloadSchemaExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiNotFoundErrorExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;
+export declare function verticalApiNotFoundSchemaExport(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;