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

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

@@ -0,0 +1,41 @@
+import type { WorkspaceApi } from '../types';
+type ApiService = {
+    id: string;
+    api?: WorkspaceApi;
+};
+/** Export name of the generated `RpcGroup` for a service. */
+export declare function verticalRpcGroupExport(service: ApiService): string;
+/** Export name of the generated RPC contract metadata for a service. */
+export declare function verticalRpcContractExport(service: ApiService): string;
+/** Canonical RPC mount path for a service (under its API prefix). */
+export declare function rpcPath(service: ApiService): string;
+/** Path after the BFF prefix has been stripped by the Effect adapter. */
+export declare const RPC_ROUTE_PATH: '/rpc';
+/**
+ * Generate the `shared/rpc.ts` RPC contract: an `RpcGroup` of `list` / `get`
+ * RPCs plus contract metadata. Mirrors `EffectRpcBffDefinition.group`.
+ */
+export declare function createRpcContractFile(service: ApiService): string;
+/**
+ * Service-entry wiring for an RPC service. Returns snippets the RPC-only
+ * service entry splices into `defineEffectBff(...)`. Empty strings for REST
+ * services.
+ */
+export declare function rpcServiceEntryWiring(service: ApiService): {
+    imports: string;
+    layer: string;
+    field: string;
+};
+/**
+ * Generate the RPC-only BFF entry. `defineEffectBff` is retained as the outer
+ * public entry shape so the strict Effect adapter applies its validator and
+ * lifecycle handling. The transport HttpApi has no endpoints; all callable
+ * surface is mounted by the `rpc` definition.
+ */
+export declare function createRpcApiServiceEntry(service: ApiService): string;
+/**
+ * Generate the RPC client file (`src/api/${stem}-rpc-client.ts`) built from the
+ * shared `RpcGroup` through Effect BFF's public HTTP RPC client primitive.
+ */
+export declare function createRpcClientFile(service: ApiService): string;
+export {};

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

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

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

@@ -0,0 +1,5 @@
+import type { WorkspaceApi } from '../types';
+export declare function createSharedApi(service: {
+    id: string;
+    api?: WorkspaceApi;
+}): string;

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

@@ -0,0 +1,6 @@
+export { createApiClient, createShellApiClient } from './api/client';
+export { apiTopologyMetadata } from './api/contracts';
+export { verticalApiCreatePayloadSchemaExport, verticalApiErrorStem, verticalApiExport, verticalApiGroupName, verticalApiMarkerSchemaExport, verticalApiName, verticalApiNotFoundErrorExport, verticalApiNotFoundSchemaExport, verticalApiReadinessSchemaExport, verticalApiSchemaExport, } from './api/names';
+export { createRpcApiServiceEntry, createRpcClientFile, createRpcContractFile, rpcPath, verticalRpcContractExport, verticalRpcGroupExport, } from './api/rpc';
+export { createApiServiceEntry, createBackendEffectApiExpose, } from './api/service';
+export { createSharedApi } from './api/shared';

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

@@ -0,0 +1,8 @@
+import type { WorkspaceApp } from './types';
+export declare function createAppEnvDts(app: WorkspaceApp, remotes: WorkspaceApp[], scope: string): string;
+export declare function createAppRuntimeConfig(app: WorkspaceApp, scope: string, remotes?: WorkspaceApp[], emitsUi?: boolean): string;
+export declare function createAppStyles(enableTailwind: boolean, scope: string, app: WorkspaceApp): string;
+export declare function createTailwindConfig(): string;
+export declare function createSharedDesignTokensCss(): string;
+export declare function createRouteHeadModule(app: WorkspaceApp): string;
+export declare function createShellFrameComponent(shell?: WorkspaceApp): string;

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

@@ -0,0 +1,11 @@
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from '@modern-js/utils/universal';
+import type { JsonValue, WorkspaceApp } from './types';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, };
+export declare function createWorkerBindingName(app: WorkspaceApp): string;
+export declare function createWorkerBindingEnv(app: WorkspaceApp): string;
+export declare function createDispatchWorkerNameEnv(app: WorkspaceApp): string;
+export declare function createServerExecutionOverlay(scope: string, app: WorkspaceApp): JsonValue | undefined;
+export declare function createBackendFederationContract(scope: string, app: WorkspaceApp): JsonValue | undefined;
+export declare function createBackendFederationMetadata(scope: string, app: WorkspaceApp): JsonValue | undefined;
+export declare function createBackendFederationContractFile(app: WorkspaceApp): string;
+export declare function createBackendFederationSummary(scope: string, app: WorkspaceApp): JsonValue | undefined;

package/dist/types/ultramodern-workspace/bridge-config/cli.d.ts

@@ -0,0 +1,3 @@
+import { type UltramodernBridgeConfig } from './schema';
+export declare function hasUltramodernBridgeCliOptions(args: string[]): boolean;
+export declare function parseUltramodernBridgeCliOptions(args: string[]): UltramodernBridgeConfig | undefined;

package/dist/types/ultramodern-workspace/bridge-config/defaults.d.ts

@@ -0,0 +1 @@
+export declare const defaultReactSingletons: readonly ['react', 'react-dom', 'react-dom/client'];

package/dist/types/ultramodern-workspace/bridge-config/gates.d.ts

@@ -0,0 +1,3 @@
+import { type UltramodernBridgeGate, type UltramodernBridgeGateInput } from './schema';
+export declare function readBridgeGates(args: string[]): UltramodernBridgeGate[];
+export declare function normalizeBridgeGates(gates: readonly UltramodernBridgeGateInput[]): UltramodernBridgeGate[];

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

@@ -0,0 +1,4 @@
+export { hasUltramodernBridgeCliOptions, parseUltramodernBridgeCliOptions, } from './cli';
+export { normalizeUltramodernBridgeConfig } from './normalize';
+export type { UltramodernBridgeConfig, UltramodernBridgeConfigInput, UltramodernBridgeGate, UltramodernBridgeGateInput, UltramodernBridgeLockfilePolicy, UltramodernBridgeTestAlias, UltramodernBridgeWorkspacePackage, UltramodernBridgeWorkspacePackageInput, UltramodernEnabledBridgeConfigInput, } from './schema';
+export { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags, ultramodernBridgeLockfilePolicies, } from './schema';

package/dist/types/ultramodern-workspace/bridge-config/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { UltramodernBridgeConfig, UltramodernBridgeConfigInput } from './schema';
+export declare function normalizeUltramodernBridgeConfig(bridge: UltramodernBridgeConfigInput | undefined): UltramodernBridgeConfig | undefined;

package/dist/types/ultramodern-workspace/bridge-config/schema.d.ts

@@ -0,0 +1,61 @@
+export declare const ultramodernBridgeCliFlags: {
+    readonly enabled: '--bridge';
+    readonly parentRoot: '--bridge-parent-root';
+    readonly workspacePackage: '--bridge-workspace-package';
+    readonly workspacePackageName: '--bridge-workspace-package-name';
+    readonly testAlias: '--bridge-test-alias';
+    readonly dependency: '--bridge-dependency';
+    readonly lockfilePolicy: '--bridge-lockfile-policy';
+    readonly gate: '--bridge-gate';
+    readonly gateCwd: '--bridge-gate-cwd';
+    readonly reactSingleton: '--bridge-react-singleton';
+};
+export declare const ultramodernBridgeCliValueFlags: readonly ["--bridge-parent-root", "--bridge-workspace-package", "--bridge-workspace-package-name", "--bridge-test-alias", "--bridge-dependency", "--bridge-lockfile-policy", "--bridge-gate", "--bridge-gate-cwd", "--bridge-react-singleton"];
+export declare const ultramodernBridgeCliBooleanFlags: readonly ["--bridge"];
+export declare const ultramodernBridgeLockfilePolicies: readonly ['nested', 'parent'];
+export type UltramodernBridgeLockfilePolicy = (typeof ultramodernBridgeLockfilePolicies)[number];
+export type UltramodernBridgeTestAlias = {
+    alias: string;
+    target: string;
+};
+export type UltramodernBridgeWorkspacePackage = {
+    pattern: string;
+    packageNames?: string[];
+    testAliases?: UltramodernBridgeTestAlias[];
+};
+export type UltramodernBridgeGate = {
+    name: string;
+    command: string;
+    cwd?: string;
+};
+export type UltramodernBridgeConfig = {
+    enabled: true;
+    parentRoot: string;
+    workspacePackages: UltramodernBridgeWorkspacePackage[];
+    dependencies: string[];
+    lockfilePolicy: UltramodernBridgeLockfilePolicy;
+    gates: UltramodernBridgeGate[];
+    reactSingletons: string[];
+};
+export type UltramodernBridgeWorkspacePackageInput = {
+    pattern: string;
+    packageNames?: readonly string[];
+    testAliases?: readonly UltramodernBridgeTestAlias[];
+};
+export type UltramodernBridgeGateInput = {
+    name: string;
+    command: string;
+    cwd?: string;
+};
+export type UltramodernEnabledBridgeConfigInput = {
+    enabled?: true;
+    parentRoot: string;
+    workspacePackages: readonly UltramodernBridgeWorkspacePackageInput[];
+    dependencies: readonly string[];
+    lockfilePolicy?: UltramodernBridgeLockfilePolicy;
+    gates: readonly UltramodernBridgeGateInput[];
+    reactSingletons?: readonly string[];
+};
+export type UltramodernBridgeConfigInput = UltramodernEnabledBridgeConfigInput | {
+    enabled: false;
+};

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

@@ -0,0 +1,12 @@
+import type { UltramodernBridgeLockfilePolicy } from './schema';
+export declare function rejectBooleanFlagValues(args: string[]): void;
+export declare function readRepeatedOptionValues(args: string[], flag: string): string[];
+export declare function readSingleValue(args: string[], flag: string): string | undefined;
+export declare function readCsvOptionValues(args: string[], flag: string): string[];
+export declare function requireNonEmptyValue(value: unknown, label: string): string;
+export declare function parseLockfilePolicy(value: string): UltramodernBridgeLockfilePolicy;
+export declare function splitAssignment(value: string, flag: string, usage: string): {
+    left: string;
+    right: string;
+};
+export declare function uniqueNonEmptyValues(values: readonly string[], label: string): string[];

package/dist/types/ultramodern-workspace/bridge-config/validation.d.ts

@@ -0,0 +1,3 @@
+import type { UltramodernBridgeWorkspacePackage } from './schema';
+export declare function validateParentPackageCoverage(workspacePackages: readonly UltramodernBridgeWorkspacePackage[], dependencies: readonly string[]): void;
+export declare function validateReactSingletons(reactSingletons: readonly string[]): void;

package/dist/types/ultramodern-workspace/bridge-config/workspace-packages.d.ts

@@ -0,0 +1,3 @@
+import { type UltramodernBridgeWorkspacePackage, type UltramodernBridgeWorkspacePackageInput } from './schema';
+export declare function readWorkspacePackages(args: string[]): UltramodernBridgeWorkspacePackage[];
+export declare function normalizeWorkspacePackages(workspacePackages: readonly UltramodernBridgeWorkspacePackageInput[]): UltramodernBridgeWorkspacePackage[];

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

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

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

@@ -0,0 +1,60 @@
+import type { UltramodernGenerationResult, UltramodernVerticalPlan, UltramodernWorkspaceOptions, VerticalApiProtocol, VerticalPreset } from './public-api';
+type UltramodernCodeSmithMode = 'workspace' | 'vertical';
+type UltramodernCodeSmithConfig = {
+    mode?: UltramodernCodeSmithMode;
+    name?: string;
+    targetName?: string;
+    packageName?: string;
+    targetDir?: string;
+    workspaceRoot?: string;
+    modernVersion?: string;
+    enableTailwind?: boolean;
+    tailwind?: boolean;
+    dryRun?: boolean;
+    logResult?: boolean;
+    bridge?: UltramodernWorkspaceOptions['bridge'];
+    overlays?: UltramodernWorkspaceOptions['overlays'];
+    packageSource?: UltramodernWorkspaceOptions['packageSource'];
+    /** Vertical generation preset (G2a). Vertical mode only. */
+    preset?: VerticalPreset;
+    /** API protocol (G7a). Vertical mode only. */
+    apiProtocol?: VerticalApiProtocol;
+    /** Generate a components-only Horizontal Remote unit (G2H). Vertical mode. */
+    horizontalRemote?: boolean;
+    packageSourceStrategy?: NonNullable<UltramodernWorkspaceOptions['packageSource']>['strategy'];
+    modernPackageVersion?: string;
+    registry?: string;
+    aliasScope?: string;
+    aliasPackageNamePrefix?: string;
+};
+type UltramodernCodeSmithResult = UltramodernGenerationResult | UltramodernVerticalPlan;
+type CodeSmithPromptQuestion = {
+    type: 'input' | 'list';
+    name: string;
+    message: string;
+    choices?: string[];
+};
+type CodeSmithPrompt = (questions: CodeSmithPromptQuestion[]) => Promise<Record<string, unknown>>;
+type CodeSmithLogger = {
+    info?: (...messages: unknown[]) => void;
+};
+type UltramodernCodeSmithContext = {
+    config?: UltramodernCodeSmithConfig;
+    data?: Record<string, unknown>;
+    materials?: {
+        default?: {
+            basePath?: string;
+        };
+    };
+    prompt?: CodeSmithPrompt;
+    inquirer?: {
+        prompt?: CodeSmithPrompt;
+    };
+    logger?: CodeSmithLogger;
+};
+type UltramodernCodeSmithRuntime = {
+    outputPath?: string;
+    logger?: CodeSmithLogger;
+};
+export default function ultramodernCodeSmithAdapter(context: UltramodernCodeSmithContext, runtime?: UltramodernCodeSmithRuntime): Promise<UltramodernCodeSmithResult>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
+import type { JsonValue, ResolvedPackageSource, WorkspaceApp } from './types';
+export declare function createTopology(scope: string, remotes?: WorkspaceApp[], primaryShell?: WorkspaceApp): JsonValue;
+export declare function createOwnership(scope: string, remotes?: WorkspaceApp[]): JsonValue;
+export declare function createDevelopmentOverlay(scope: string, remotes?: WorkspaceApp[]): JsonValue;
+export declare function createUltramodernConfig(scope: string, modernVersion: string, packageSource: ResolvedPackageSource, apps?: WorkspaceApp[], enableTailwind?: boolean, bridge?: UltramodernBridgeConfig, additionalShells?: WorkspaceApp[], primaryShell?: WorkspaceApp): JsonValue;

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

@@ -0,0 +1,290 @@
+/**
+ * Canonical MicroVertical delivery contracts (W4).
+ *
+ * This module DEFINES the canonical shapes only. It is intentionally UNWIRED:
+ * no generator, normalizer, or runtime path imports it, and it does not change
+ * any emitted output. The v1 down-projection here is a pure, tested function;
+ * it is not invoked by any generation path.
+ *
+ * Binding vocabulary: root `CONTEXT.md`, ADR-0019 (Federated Loading, Unified
+ * Delivery), ADR-0020 (Zoned Surface Versioning). See `packages/toolkit/ultramodern-create/delivery-unit-schema-SPEC.md` for the
+ * SurfaceRef grammar, invariants, and the v1 mapping table.
+ *
+ * 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 DeliveryUnitRecord } from '@modern-js/utils/universal';
+import { type JsonObject, type Ownership, type WorkspaceApp } from '../types';
+/**
+ * The single accountable owner of a delivery unit. Exactly one owner per unit
+ * (CONTEXT.md: "MicroVertical never [has more than] one owner").
+ */
+export type DeliveryUnitOwner = {
+    kind: 'team' | 'agent' | 'agent-team';
+    id: string;
+    contact?: string;
+};
+/**
+ * Exact platform-baseline pins resolved for this unit. Composition-time
+ * singletons only (CONTEXT.md: Platform Baseline). Verticals never pick their
+ * own version; the cohort is advanced platform-wide.
+ */
+export type BaselineCohortResolved = {
+    react: string;
+    tanstackRouter: string;
+    effect: string;
+    tailwind: string;
+};
+/**
+ * A baseline cohort is an opaque, stable id plus the exact record it resolves
+ * to. The id is the unit of comparison; the resolved record is the evidence.
+ */
+export type BaselineCohort = {
+    cohortId: string;
+    resolved: BaselineCohortResolved;
+};
+export type ExternalRetirement = {
+    /** SurfaceRef (canonical string) of the successor major, when known. */
+    supersededBy?: string;
+    /** Opaque retirement marker (window id / date string), owner-defined. */
+    sunsetAfter?: string;
+};
+/**
+ * External-publication terms. A breaking change ships as a new major exposed
+ * side by side with the previous major until known consumers migrate.
+ */
+export type ExternalPublication = {
+    surfaceMajor: number;
+    /** Opaque compatible-baseline descriptor (e.g. a cohort range id). */
+    baselineCompatibility: string;
+    retirement?: ExternalRetirement;
+};
+/**
+ * Zone discriminated union. `external` carries its terms atomically: it is a
+ * type error to be in the external zone without an {@link ExternalPublication}
+ * record. Default is `coordinated` (see {@link resolvePublicationZone}).
+ */
+export type PublicationZone = {
+    zone: 'coordinated';
+} | {
+    zone: 'external';
+    external: ExternalPublication;
+};
+/**
+ * A concrete per-platform location for a surface. Discriminated on `platform`
+ * so each platform carries only the address shape it can actually resolve.
+ * (ADR-0019 §3: UI/API/backend addresses are derived, platform-appropriate.)
+ */
+export type SurfaceLocation = {
+    platform: 'browser-mf';
+    manifestUrl: string;
+} | {
+    platform: 'node-mf';
+    manifestUrl: string;
+} | {
+    platform: 'http';
+    address: string;
+} | {
+    platform: 'cloudflare-binding';
+    serviceBinding: string;
+};
+export type SurfaceKind = 'component' | 'route' | 'api' | 'backend';
+export type ApiProtocol = 'rest' | 'rpc' | 'graphql';
+type SurfaceCommon = {
+    surfaceId: string;
+    /** Per-platform locations. Never mixed across delivery-unit build markers. */
+    locations: SurfaceLocation[];
+    /**
+     * Marks a surface as externally consumable. It inherits the unit's zone:
+     * only meaningful when the unit's {@link PublicationZone} is `external`.
+     */
+    externallyPublished?: boolean;
+    /** Unknown/forward-compatible fields preserved verbatim on round-trip. */
+    unknownFields?: JsonObject;
+};
+export type ComponentSurfaceDescriptor = SurfaceCommon & {
+    kind: 'component';
+};
+export type RouteSurfaceDescriptor = SurfaceCommon & {
+    kind: 'route';
+};
+export type ApiSurfaceDescriptor = SurfaceCommon & {
+    kind: 'api';
+    protocol: ApiProtocol;
+};
+export type BackendSurfaceDescriptor = SurfaceCommon & {
+    kind: 'backend';
+};
+export type SurfaceDescriptor = ComponentSurfaceDescriptor | RouteSurfaceDescriptor | ApiSurfaceDescriptor | BackendSurfaceDescriptor;
+export type DeliveryUnitKind = 'microvertical' | 'shell' | 'horizontal-remote';
+/**
+ * The canonical authoring shape for one indivisible delivery unit. All surfaces
+ * derive from the single `sourceRevision` / `buildMarker` identity root
+ * (ADR-0019 invariants 1-2). This is a superset of today's v1 `WorkspaceApp`;
+ * see {@link projectDeliveryUnitToV1} for the lossy down-projection.
+ */
+export type DeliveryUnitDescriptor = {
+    unitId: string;
+    kind: DeliveryUnitKind;
+    owner: DeliveryUnitOwner;
+    sourceRevision: string;
+    buildMarker: string;
+    baselineCohort: BaselineCohort;
+    /** Defaults to `{ zone: 'coordinated' }` when omitted. */
+    publicationZone?: PublicationZone;
+    surfaces: SurfaceDescriptor[];
+    /** Unknown/forward-compatible fields preserved verbatim on round-trip. */
+    unknownFields?: JsonObject;
+};
+/**
+ * A resolved surface. It carries NO build marker of its own: the marker lives
+ * once on the {@link ResolvedDeliveryUnit}, so a resolver structurally cannot
+ * mix locations from different markers (ADR-0019 §3, invariant 3).
+ */
+export type ResolvedSurface = {
+    surfaceId: string;
+    kind: SurfaceKind;
+    locations: SurfaceLocation[];
+};
+export type CompatibilityStatus = 'compatible' | 'incompatible' | 'degraded';
+export type CompatibilityVerdict = {
+    status: CompatibilityStatus;
+    /** Baseline cohort id the verdict was computed against. */
+    baselineCohortId: string;
+    reason?: string;
+};
+/**
+ * Atomic resolution result. Every platform location for the unit is resolved
+ * together against ONE `buildMarker` / `sourceRevision`. There is no partial
+ * shape: a resolver returns a whole {@link ResolvedDeliveryUnit} or a typed
+ * failure — never a per-surface mix of markers. This shape is the W5/W7
+ * contract checkpoint.
+ */
+export type ResolvedDeliveryUnit = {
+    unitId: string;
+    buildMarker: string;
+    sourceRevision: string;
+    baselineCohortId: string;
+    surfaces: ResolvedSurface[];
+    compatibility: CompatibilityVerdict;
+};
+/**
+ * Parsed form of a SurfaceRef. Canonical string form is `unitId#surfaceId`
+ * with an optional `@vN` major suffix. See `packages/toolkit/ultramodern-create/delivery-unit-schema-SPEC.md` for the EBNF.
+ */
+export type ParsedSurfaceRef = {
+    unitId: string;
+    surfaceId: string;
+    /** External-major selector. Absent means "the coordinated-zone surface". */
+    major?: number;
+};
+export type SurfaceRefParseError = {
+    code: 'empty';
+} | {
+    code: 'missing-surface-separator';
+} | {
+    code: 'multiple-surface-separators';
+} | {
+    code: 'empty-unit-id';
+} | {
+    code: 'invalid-unit-id';
+    segment: string;
+} | {
+    code: 'empty-surface-id';
+} | {
+    code: 'invalid-surface-id';
+} | {
+    code: 'empty-major';
+} | {
+    code: 'invalid-major';
+    value: string;
+};
+export type SurfaceRefParseResult = {
+    ok: true;
+    ref: ParsedSurfaceRef;
+} | {
+    ok: false;
+    error: SurfaceRefParseError;
+};
+/**
+ * Parse a canonical SurfaceRef string. Total function: every rejection is a
+ * typed {@link SurfaceRefParseError}; never throws.
+ */
+export declare function parseSurfaceRef(input: string): SurfaceRefParseResult;
+/**
+ * Render a {@link ParsedSurfaceRef} back to its canonical string form.
+ *
+ * Direct inputs are checked against the same invariant as parsed references,
+ * so this formatter cannot emit a string that {@link parseSurfaceRef} rejects.
+ */
+export declare function formatSurfaceRef(ref: ParsedSurfaceRef): string;
+/** Apply the zone default (coordinated) invariant. */
+export declare function resolvePublicationZone(zone: PublicationZone | undefined): PublicationZone;
+/**
+ * Parse a JSON object into a {@link DeliveryUnitDescriptor}, capturing any
+ * unrecognised top-level and per-surface keys into `unknownFields` so a later
+ * {@link serializeDeliveryUnitDescriptor} can round-trip them verbatim.
+ *
+ * This is contract-shape capture, not strict validation (that is W3's job);
+ * known fields are trusted to already have their declared shapes.
+ */
+export declare function parseDeliveryUnitDescriptor(source: JsonObject): DeliveryUnitDescriptor;
+/**
+ * Serialize a {@link DeliveryUnitDescriptor} back to a JSON object. Preserved
+ * `unknownFields` are spread back at their original level; known keys always
+ * win over a colliding unknown key.
+ */
+export declare function serializeDeliveryUnitDescriptor(descriptor: DeliveryUnitDescriptor): JsonObject;
+/**
+ * Generator-only fields that have no source in the canonical descriptor (port
+ * assignment, directory layout, package identity, ownership metadata). The
+ * descriptor deliberately does not own these; the v1 projection needs them to
+ * reconstruct today's `WorkspaceApp` / `DeliveryUnitRecord`.
+ */
+export type V1ProjectionContext = {
+    /**
+     * Which v1 wire vocabulary is being projected onto. Strict legacy v1 only
+     * carries the historical WorkspaceApp fields; extended-v1 also carries the
+     * additive delivery-unit discriminators introduced by the workspace
+     * topology format.
+     */
+    mode?: V1ProjectionMode;
+    directory: string;
+    packageSuffix: string;
+    displayName: string;
+    portEnv: string;
+    port: number;
+    mfName: string;
+    ownership: Ownership;
+    packageName: string;
+    version: string;
+};
+/**
+ * The two v1 wire vocabularies understood by the projection pair.
+ *
+ * `strict-legacy` is the original v1 shape and intentionally rejects values
+ * that would be silently collapsed by it. `extended-v1` is still schema
+ * version 1, but permits the additive `deliveryUnitKind` and `api.protocol`
+ * fields used by the UltraModern topology/config readers.
+ */
+export type V1ProjectionMode = 'strict-legacy' | 'extended-v1';
+export type DeliveryUnitV1Projection = {
+    app: WorkspaceApp;
+    deliveryUnitRecord: DeliveryUnitRecord;
+    /** Unknown descriptor-level fields, preserved for lossless re-serialization. */
+    preservedUnknownFields: JsonObject;
+};
+/**
+ * Down-project a canonical {@link DeliveryUnitDescriptor} onto today's v1
+ * `WorkspaceApp` + `DeliveryUnitRecord` shapes. Pure and total.
+ *
+ * Invariant (schema-only migration preserves markers): `buildMarker`,
+ * `sourceRevision`, and `unitId` flow straight through from the descriptor and
+ * are never regenerated here. See `packages/toolkit/ultramodern-create/delivery-unit-schema-SPEC.md` for the field-by-field table.
+ *
+ * NOT wired into any generator path.
+ */
+export declare function projectDeliveryUnitToV1(descriptor: DeliveryUnitDescriptor, context: V1ProjectionContext): DeliveryUnitV1Projection;
+/** Compile-time exhaustiveness guard for discriminated-union switches. */
+export declare function assertNever(value: never): never;
+export {};