@zodmire/core 0.1.0

package/mod.d.mts

@@ -0,0 +1,812 @@
+import { a as contextArtifactOwnership, c as mergeGeneratedArtifacts, d as sliceArtifactOwnership, f as withArtifactOwnership, i as applyOwnershipIfMissing, l as resolveArtifactOwnership, n as GeneratedArtifact, o as createGeneratedArtifact, r as OwnershipScope, s as inferArtifactOwnership, t as ArtifactOwnership, u as sharedArtifactOwnership } from "./artifacts-QqCpfT50.mjs";
+import { MaterializationScope } from "./materialize.mjs";
+import { CodegenMeta, CommandEffect, CompositionConfig, ComputedFieldSpec, ContextConfig, FilterOperator, InvariantRule, ProjectionRebuildMeta, ProjectionSourceMeta, ProjectionSubscriptionMeta, ReadModelIndexMeta, ReadModelUniqueConstraintMeta } from "@zodmire/config";
+
+//#region packages/core/naming.d.ts
+declare function buildArtifactPath(root: string, context: string, file: string): string;
+declare function wordsFromName(value: string): string[];
+declare function pascalCase(value: string): string;
+declare function camelCase(value: string): string;
+declare function kebabCase(value: string): string;
+declare function snakeCase(str: string): string;
+declare function snakeUpperCase(value: string): string;
+/** Alias for snakeUpperCase — UPPER_SNAKE_CASE conversion. */
+declare const toUpperSnakeCase: typeof snakeUpperCase;
+declare function normalizeModulePath(modulePath: string): string;
+declare function contractFileName(schemaRef: string): string;
+declare function repositoryPortFileName(portName: string): string;
+declare function repositoryPortTypeName(portName: string): string;
+//#endregion
+//#region packages/core/init.d.ts
+/** Describes a vendored file: output name and its source path relative to repo root. */
+interface VendoredFileEntry {
+  outputName: string;
+  sourceRelativePath: string;
+}
+/** The manifest of config files to vendor into end-user projects. */
+declare const VENDORED_FILE_MANIFEST: readonly VendoredFileEntry[];
+/** Rewrite Deno-style `npm:zod@*` imports to bare `"zod"` for end-user consumption. */
+declare function rewriteImports(content: string): string;
+/** Apply import rewriting and prepend a version header. */
+declare function prepareVendoredFile(content: string, generatorVersion: string): string;
+/** A resolved vendored file ready for persistence or disk write. */
+interface PreparedVendoredFile {
+  outputName: string;
+  content: string;
+}
+/**
+ * Prepare all vendored files from pre-read source contents.
+ * @param sourceContents Map from `sourceRelativePath` to raw file content.
+ * @param generatorVersion Version string stamped into the file header.
+ */
+declare function prepareAllVendoredFiles(sourceContents: ReadonlyMap<string, string>, generatorVersion: string): PreparedVendoredFile[];
+//#endregion
+//#region packages/core/tree_helpers.d.ts
+type NormalizedEntityWithChildren = {
+  name: string;
+  collectionFieldName: string;
+  fields: {
+    name: string;
+    type: string;
+    optional: boolean;
+    array: boolean;
+  }[];
+  idField: string;
+  idType: string;
+  tableName: string;
+  children: NormalizedEntityWithChildren[];
+  rehydrationStateName?: string;
+  persistenceStateName?: string;
+};
+type NormalizedAggregateWithChildren = {
+  name: string;
+  fields: {
+    name: string;
+    type: string;
+    optional: boolean;
+    array: boolean;
+  }[];
+  idField: string;
+  idType: string;
+  tableName: string;
+  invariants: any[];
+  children: NormalizedEntityWithChildren[];
+};
+type EntityVisitor = (entity: NormalizedEntityWithChildren, context: {
+  depth: number;
+  parent: NormalizedAggregateWithChildren | NormalizedEntityWithChildren;
+  parentField: string;
+  path: string[];
+}) => void;
+declare function flattenEntities(aggregate: NormalizedAggregateWithChildren): NormalizedEntityWithChildren[];
+declare function walkEntityTree(aggregate: NormalizedAggregateWithChildren, visitor: EntityVisitor): void;
+//#endregion
+//#region packages/core/schema_pipeline.d.ts
+type IntrospectedField = {
+  name: string;
+  type: string;
+  optional: boolean;
+  array: boolean;
+  nestedFields?: IntrospectedField[];
+  columnType?: string;
+};
+type SchemaReadResult = {
+  aggregates: Array<{
+    name: string;
+    fields: IntrospectedField[];
+    idField: string;
+    idType: string;
+    tableName: string;
+    invariants: InvariantRule[];
+    children: NormalizedEntityWithChildren[];
+  }>;
+  entities: Array<{
+    name: string;
+    fields: IntrospectedField[];
+    idField: string;
+    idType: string;
+    tableName: string;
+  }>;
+  valueObjects: Array<{
+    name: string;
+    fields: IntrospectedField[];
+    declaredInFile?: string;
+  }>;
+  commands: Array<{
+    name: string;
+    inputFields: IntrospectedField[];
+    targetAggregate: string;
+    commandKind: "create" | "update";
+    lifecycle?: "create" | "mutate";
+    loadBy?: string;
+    preconditions: string[];
+    emits: string[];
+    effects: CommandEffect[];
+  }>;
+  queries: Array<{
+    name: string;
+    inputFields?: IntrospectedField[];
+    outputFields: IntrospectedField[];
+    outputSchemaPath: string;
+    outputSchemaExportName: string;
+    targetAggregate?: string;
+    readModelName?: string;
+    queryKind: "findById" | "list";
+    pagination?: {
+      style: "offset" | "cursor";
+    };
+    filters?: Record<string, FilterOperator[]>;
+    sorting?: {
+      sortableFields: string[];
+      defaultSort: {
+        field: string;
+        direction: "asc" | "desc";
+      };
+    };
+    computedFields?: Record<string, ComputedFieldSpec>;
+  }>;
+  readModels: Array<{
+    name: string;
+    fields: IntrospectedField[];
+    schemaPath: string;
+    schemaExportName: string;
+    ownerContext: string;
+    ownerAggregate: string;
+    tableName: string;
+    primaryKey: string[];
+    indexes: ReadModelIndexMeta[];
+    uniqueConstraints: ReadModelUniqueConstraintMeta[];
+    servesQueries?: string[];
+  }>;
+  projections: Array<{
+    name: string;
+    readModelName: string;
+    sources: ProjectionSourceMeta[];
+    rebuild?: ProjectionRebuildMeta;
+    subscription?: ProjectionSubscriptionMeta;
+    schemaPath: string;
+    schemaExportName: string;
+  }>;
+  domainEvents: Array<{
+    name: string;
+    fields: IntrospectedField[];
+  }>;
+};
+type CodegenRegistry = {
+  get(schema: unknown): CodegenMeta | undefined;
+};
+declare function unwrapFieldType(schema: unknown): {
+  type: string;
+  optional: boolean;
+  array: boolean;
+};
+declare function introspectObjectShape(schema: unknown, registry: CodegenRegistry, exportName?: string): IntrospectedField[];
+declare function isRegisteredEntity(schema: unknown, registry: CodegenRegistry): boolean;
+declare function introspectSchema(schema: unknown, registry: CodegenRegistry, exportName?: string): {
+  fields: IntrospectedField[];
+  children: NormalizedEntityWithChildren[];
+};
+declare function readSchemaFile(filePath: string, registry: CodegenRegistry): Promise<SchemaReadResult>;
+declare function mergeSchemaReadResults(results: SchemaReadResult[]): SchemaReadResult;
+//#endregion
+//#region packages/core/normalizer.d.ts
+type DomainErrorDef = {
+  invariantName: string;
+  errorTypeName: string;
+  factoryName: string;
+  defaultMessage: string;
+};
+type ApplicationErrorDef = {
+  errorTypeName: string;
+  factoryName: string;
+  aggregateName: string;
+};
+type NormalizedAggregate = {
+  name: string;
+  fields: IntrospectedField[];
+  idField: string;
+  idType: string;
+  tableName: string;
+  invariants: InvariantRule[];
+  children: NormalizedEntityWithChildren[];
+  domainErrors: DomainErrorDef[];
+  applicationErrors: ApplicationErrorDef[];
+  rehydrationStateName: string;
+  persistenceStateName: string;
+};
+type NormalizedCommand = {
+  name: string;
+  inputFields: IntrospectedField[];
+  targetAggregate: string;
+  commandKind: "create" | "update";
+  lifecycle: "create" | "mutate";
+  loadBy?: string;
+  preconditions: string[];
+  emits: string[];
+  effects: CommandEffect[];
+};
+type NormalizedComputedField = {
+  kind: "builtin";
+  fn: "count" | "exists";
+  childTableName: string;
+  childFkColumn: string;
+  outputFieldType: "number" | "boolean";
+} | {
+  kind: "builtin";
+  fn: "sum";
+  childTableName: string;
+  childFkColumn: string;
+  childFieldColumn: string;
+  outputFieldType: "number";
+};
+type NormalizedQueryReadSide = {
+  readModelName: string;
+  searchFields: string[];
+  pagination?: {
+    style: "offset";
+  };
+  filters?: Record<string, FilterOperator[]>;
+  sorting?: {
+    sortableFields: string[];
+    defaultSort: {
+      field: string;
+      direction: "asc" | "desc";
+    };
+  };
+};
+type NormalizedFindByIdQuery = {
+  queryKind: "findById";
+  name: string;
+  targetAggregate: string;
+  inputFields: IntrospectedField[];
+  outputFields: IntrospectedField[];
+  outputSchemaPath: string;
+  outputSchemaExportName: string;
+  readModelName?: string;
+  readSide: NormalizedQueryReadSide;
+};
+type NormalizedListQuery = {
+  queryKind: "list";
+  name: string;
+  targetAggregate: string;
+  inputFields: IntrospectedField[];
+  outputFields: IntrospectedField[];
+  outputSchemaPath: string;
+  outputSchemaExportName: string;
+  readModelName?: string;
+  readSide: NormalizedQueryReadSide;
+  pagination: {
+    style: "offset";
+  };
+  filters: Record<string, FilterOperator[]>;
+  sorting: {
+    sortableFields: string[];
+    defaultSort: {
+      field: string;
+      direction: "asc" | "desc";
+    };
+  };
+  computedFields: Record<string, NormalizedComputedField>;
+};
+type NormalizedQuery = NormalizedFindByIdQuery | NormalizedListQuery;
+type NormalizedReadModel = {
+  name: string;
+  normalizedId: string;
+  logicalPathKey: string;
+  ownerContext: string;
+  ownerAggregate: string;
+  fields: IntrospectedField[];
+  schemaPath: string;
+  schemaExportName: string;
+  tableName: string;
+  primaryKey: string[];
+  indexes: SchemaReadResult["readModels"][number]["indexes"];
+  uniqueConstraints: SchemaReadResult["readModels"][number]["uniqueConstraints"];
+  servesQueries: string[];
+};
+type NormalizedProjectionSource = SchemaReadResult["projections"][number]["sources"][number] & {
+  locality: "local" | "external";
+};
+type NormalizedProjection = {
+  name: string;
+  normalizedId: string;
+  logicalPathKey: string;
+  readModelName: string;
+  ownerContext: string;
+  ownerAggregate: string;
+  mode: "event-driven";
+  rebuild: Exclude<SchemaReadResult["projections"][number]["rebuild"], undefined> | {
+    enabled: false;
+  };
+  subscription?: SchemaReadResult["projections"][number]["subscription"];
+  sources: NormalizedProjectionSource[];
+};
+type NormalizedDomainEvent = {
+  name: string;
+  fields: IntrospectedField[];
+  sourceAggregate: string;
+};
+type NormalizedEntity = NormalizedEntityWithChildren;
+type NormalizedValueObject = {
+  name: string;
+  fields: IntrospectedField[];
+  declaredInFile: string;
+};
+type NormalizedSpec = {
+  context: {
+    name: string;
+    modulePath: string;
+  };
+  aggregate: NormalizedAggregate;
+  entities: NormalizedEntity[];
+  valueObjects: NormalizedValueObject[];
+  commands: NormalizedCommand[];
+  queries: NormalizedQuery[];
+  readModels: NormalizedReadModel[];
+  projections: NormalizedProjection[];
+  domainEvents: NormalizedDomainEvent[];
+  ports: ContextConfig["ports"];
+  adapters: ContextConfig["adapters"];
+  presentation: ContextConfig["presentation"];
+  materialization: ContextConfig["materialization"];
+};
+type ContextNormalizedSpec = {
+  context: {
+    name: string;
+    modulePath: string;
+  };
+  aggregates: NormalizedAggregate[];
+  commands: NormalizedCommand[];
+  queries: NormalizedQuery[];
+  readModels: NormalizedReadModel[];
+  projections: NormalizedProjection[];
+  domainEvents: NormalizedDomainEvent[];
+  entities: NormalizedEntity[];
+  valueObjects: NormalizedValueObject[];
+  ports: ContextConfig["ports"];
+  adapters: ContextConfig["adapters"];
+  acls: ContextConfig["acls"];
+  presentation: ContextConfig["presentation"];
+  materialization: ContextConfig["materialization"];
+};
+declare function buildContextNormalizedSpec(schemaResult: SchemaReadResult, config: ContextConfig): ContextNormalizedSpec;
+declare function buildNormalizedSpec(schemaResult: SchemaReadResult, config: ContextConfig): NormalizedSpec;
+//#endregion
+//#region packages/core/composition_normalizer.d.ts
+type ResolvedSubscription = {
+  targetContext: string;
+  targetModulePath: string;
+  action: string;
+  handlerName: string;
+  handlerFactoryName: string;
+};
+type ResolvedCrossContextEvent = {
+  eventType: string;
+  sourceContext: string;
+  sourceModulePath: string;
+  payloadSchema: unknown;
+  payloadTypeName: string;
+  subscriptions: ResolvedSubscription[];
+};
+type NormalizedAclMapping = {
+  targetPath: string;
+  kind: "from";
+  sourcePath: string;
+} | {
+  targetPath: string;
+  kind: "const";
+  value: string | number | boolean | null;
+};
+type NormalizedAclSymbols = {
+  requestContractName: string;
+  responseContractName: string;
+  adapterName: string;
+  containerRegistrationToken: string;
+};
+type ResolvedPublishedBoundary<TProcedureKind extends "query" | "command"> = {
+  procedureName: string;
+  operationName: string;
+  kind: TProcedureKind;
+};
+type NormalizedReadAcl = {
+  kind: "read";
+  name: string;
+  port: string;
+  consumerContext: {
+    name: string;
+    modulePath: string;
+  };
+  sourceContext: {
+    name: string;
+    modulePath: string;
+  };
+  sourceBoundary: ResolvedPublishedBoundary<"query">;
+  sourceQuery: NormalizedQuery;
+  requestMappings: NormalizedAclMapping[];
+  responseMappings: NormalizedAclMapping[];
+  symbols: NormalizedAclSymbols;
+};
+type NormalizedWriteAcl = {
+  kind: "write" | "ack";
+  name: string;
+  port: string;
+  consumerContext: {
+    name: string;
+    modulePath: string;
+  };
+  targetContext: {
+    name: string;
+    modulePath: string;
+  };
+  targetBoundary: ResolvedPublishedBoundary<"command">;
+  targetCommand: NormalizedCommand;
+  requestMappings: NormalizedAclMapping[];
+  responseMappings: NormalizedAclMapping[];
+  acknowledgeMappings: NormalizedAclMapping[];
+  symbols: NormalizedAclSymbols;
+};
+type NormalizedCompositionAcl = NormalizedReadAcl | NormalizedWriteAcl;
+type NormalizedCompositionSpec = {
+  name: string;
+  contexts: Array<{
+    name: string;
+    modulePath: string;
+  }>;
+  crossContextEvents: ResolvedCrossContextEvent[];
+  acls: NormalizedCompositionAcl[];
+  materialization: {
+    targetRoot: string;
+  };
+};
+declare function buildNormalizedCompositionSpec(config: CompositionConfig, contextSpecs: ContextNormalizedSpec[]): NormalizedCompositionSpec;
+//#endregion
+//#region packages/core/slicer.d.ts
+type AggregateNormalizedSpecView = NormalizedSpec & {
+  /** VOs referenced by this aggregate but owned by another aggregate. Needed for import generation. */externalValueObjects: Array<{
+    name: string;
+    ownerAggregate: string;
+  }>;
+};
+declare function discoverReferencedVos(aggregate: NormalizedAggregate, contextSpec: ContextNormalizedSpec): Set<string>;
+declare function resolveVoOwner(vo: NormalizedValueObject, contextSpec: ContextNormalizedSpec): string;
+declare function collectOwnedValueObjects(aggregate: NormalizedAggregate, contextSpec: ContextNormalizedSpec): NormalizedValueObject[];
+declare function sliceContextIntoAggregateViews(contextSpec: ContextNormalizedSpec): AggregateNormalizedSpecView[];
+//#endregion
+//#region packages/core/orchestrator.d.ts
+declare function generateContextArtifacts(contextSpec: ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/spec_artifact.d.ts
+declare const SPEC_ARTIFACT_SCHEMA_VERSION = 1;
+declare function serializeContextSpec(spec: ContextNormalizedSpec, generatorVersion: string): string;
+declare function serializeCompositionSpec(spec: NormalizedCompositionSpec, generatorVersion: string): string;
+//#endregion
+//#region packages/core/spec_diff.d.ts
+declare const SPEC_DIFF_SCHEMA_VERSION = 1;
+type DiffBucket = {
+  added: string[];
+  removed: string[];
+  changed: string[];
+};
+type SpecDiffArtifact = {
+  artifactType: "spec-diff";
+  schemaVersion: number;
+  generatorVersion: string;
+  basis: "context" | "composition";
+  targetName: string;
+  hasPrevious: boolean;
+  hasChanges: boolean;
+  hasBreakingChanges: boolean;
+  schemaRelevantChanges: boolean;
+  changes: {
+    contexts: DiffBucket;
+    aggregates: DiffBucket;
+    commands: DiffBucket;
+    queries: DiffBucket;
+    domainEvents: DiffBucket;
+    valueObjects: DiffBucket;
+    crossContextEvents: DiffBucket;
+    acls: DiffBucket;
+  };
+};
+declare function buildContextSpecDiff(previous: ContextNormalizedSpec | null, current: ContextNormalizedSpec, generatorVersion: string): SpecDiffArtifact;
+declare function buildCompositionSpecDiff(previous: NormalizedCompositionSpec | null, current: NormalizedCompositionSpec, generatorVersion: string): SpecDiffArtifact;
+declare function contextSpecDiffDataName(modulePath: string): string;
+declare function compositionSpecDiffDataName(name: string): string;
+//#endregion
+//#region packages/core/data_tags.d.ts
+type Producer = "swamp" | "cli";
+type Basis = "context" | "composition" | "migration" | "init";
+type BaseTagInput = {
+  generatorVersion: string;
+  generationRunId: string;
+  methodName: string;
+  producer: Producer;
+  producerName?: string;
+  basis: Basis;
+  contextName?: string;
+  compositionName?: string;
+};
+declare function buildFileArtifactTags(input: BaseTagInput & {
+  logicalPath: string;
+  ownershipScope?: GeneratedArtifact["ownershipScope"];
+  scopeKey?: string;
+}): Record<string, string>;
+declare function buildSummaryTags(input: BaseTagInput): Record<string, string>;
+declare function buildNormalizedSpecTags(input: BaseTagInput): Record<string, string>;
+declare function buildMaterializationManifestTags(input: BaseTagInput): Record<string, string>;
+declare function buildSpecDiffTags(input: BaseTagInput & {
+  hasChanges: boolean;
+  hasBreakingChanges: boolean;
+  schemaRelevantChanges: boolean;
+}): Record<string, string>;
+declare function buildVendoredFileTags(input: BaseTagInput & {
+  outputFileName: string;
+}): Record<string, string>;
+declare function buildMigrationResultTags(input: Omit<BaseTagInput, "basis"> & {
+  mode: "dry-run" | "apply";
+  applied: boolean;
+  skipped: boolean;
+  schemaRelevantChanges: boolean;
+  contextNames: string[];
+  compositionName?: string;
+}): Record<string, string>;
+//#endregion
+//#region packages/core/migrate.d.ts
+/**
+ * migrate.ts — Migration pipeline module for bounded context codegen v5.
+ *
+ * Self-contained; no Swamp dependencies. Consumed by the `migrate` model method (Task 4).
+ */
+type MigrationPlan = {
+  tablesToCreate: string[];
+  tablesToAlter: Array<{
+    table: string;
+    changes: string[];
+  }>;
+  tablesToDrop: string[];
+  rawSummary?: string[];
+};
+type MigrationResult = {
+  engine: "drizzle-kit";
+  mode: "dry-run" | "apply";
+  success: boolean;
+  generationRunId: string;
+  plan: MigrationPlan;
+  sqlPreview: string[];
+  applied: boolean;
+  warnings: string[];
+  errors: string[];
+  targetDatabase: {
+    host: string;
+    database: string;
+    port?: number;
+    schema?: string;
+  };
+  contextNames: string[];
+  compositionName?: string;
+};
+declare const GENERATED_READ_SIDE_SCHEMA_LOGICAL_PATH = "infrastructure/view-models/drizzle/schema.ts";
+declare function resolveGeneratedMigrationSchemaPath(workspaceRoot: string): string;
+/**
+ * Parse a PostgreSQL connection string into structured metadata.
+ *
+ * @example
+ * parseConnectionString("postgresql://user:pass@localhost:5432/mydb?schema=public")
+ * // → { host: "localhost", database: "mydb", port: 5432, schema: "public" }
+ */
+declare function parseConnectionString(url: string): MigrationResult["targetDatabase"];
+/**
+ * Generate the content of a drizzle.config.ts file.
+ */
+declare function buildDrizzleConfig(schemaPath: string, databaseUrl: string): string;
+/**
+ * Parse drizzle-kit push stdout/stderr into structured plan data.
+ */
+declare function parseDrizzleKitOutput(stdout: string, stderr: string): {
+  plan: MigrationPlan;
+  sqlPreview: string[];
+  warnings: string[];
+};
+type RunMigrationOptions = {
+  /** Absolute path to the generated schema file (or barrel) to migrate. */schemaPath: string; /** PostgreSQL connection string. */
+  databaseUrl: string; /** When false, appends --dry-run to the drizzle-kit command. */
+  execute: boolean; /** Unique ID for this generation run (used in MigrationResult). */
+  generationRunId: string; /** Names of the bounded contexts being migrated. */
+  contextNames: string[]; /** Optional composition name. */
+  compositionName?: string;
+};
+/**
+ * Orchestrate a drizzle-kit push migration.
+ *
+ * Steps:
+ * 1. Parse connection string → targetDatabase metadata.
+ * 2. Create a temp workspace directory.
+ * 3. Copy (symlink) or reference the schema file; write drizzle.config.ts.
+ * 4. Run `drizzle-kit push [--dry-run]`.
+ * 5. Parse stdout/stderr into a structured MigrationPlan.
+ * 6. Remove temp workspace.
+ * 7. Return MigrationResult.
+ */
+declare function runMigration(opts: RunMigrationOptions): Promise<MigrationResult>;
+//#endregion
+//#region packages/core/config_resolver.d.ts
+type ContextConfigLike = {
+  schemaFiles?: string[];
+  _codegenSupportPath?: string;
+  materialization?: {
+    targetRoot?: string;
+  };
+};
+type ResolvedContextInputs = {
+  contextConfigPath: string;
+  codegenSupportPath: string;
+  config: ContextConfigLike;
+};
+declare function toImportURL(pathOrUrl: string): string;
+declare function resolveFactoryPath(baseDir: string, relativePath: string): string;
+declare function inferCodegenSupportPathFromSchemaFile(configDir: string, schemaFile: string): string;
+declare function inferCodegenSupportPathForContext(resolvedContextConfigPath: string, schemaFiles: string[]): string;
+declare function loadContextConfig(contextConfigPath: string): Promise<ContextConfigLike>;
+declare function resolveAbsoluteContextInputs(contextConfigPath: string): Promise<ResolvedContextInputs>;
+declare function resolveContextInputs(baseDir: string, contextConfig: string): Promise<ResolvedContextInputs>;
+declare function resolveSchemaFilePathsForContext(resolvedContextConfigPath: string, schemaFiles: string[]): string[];
+//#endregion
+//#region packages/core/checks.d.ts
+type MethodArgsSource = {
+  getMethodArguments(methodName: string): Record<string, unknown>;
+};
+type CheckContextLike = {
+  globalArgs?: Record<string, unknown>;
+  methodName: string;
+  methodArgs?: Record<string, unknown>;
+  modelType?: unknown;
+  modelId?: unknown;
+  definitionRepository?: {
+    findById(type: unknown, id: unknown): Promise<MethodArgsSource | null>;
+  };
+};
+type CheckResult = {
+  pass: boolean;
+  errors?: string[];
+};
+type ResolvedCheckMethodInputs = {
+  contextConfigs: ResolvedContextInputs[];
+  compositionConfigPath?: string;
+};
+declare function resolveMethodContextInputsForCheck(context: CheckContextLike): Promise<ResolvedCheckMethodInputs>;
+declare function ensureContextSupportFilesExist(resolved: ResolvedContextInputs): Promise<void>;
+declare function validateContextImports(resolved: ResolvedContextInputs): Promise<void>;
+declare function buildContextInputChecks(): {
+  "context-inputs-resolve": {
+    description: string;
+    appliesTo: string[];
+    execute: (context: CheckContextLike) => Promise<CheckResult>;
+  };
+  "schema-files-exist": {
+    description: string;
+    appliesTo: string[];
+    execute: (context: CheckContextLike) => Promise<CheckResult>;
+  };
+  "schema-imports-parse": {
+    description: string;
+    appliesTo: string[];
+    execute: (context: CheckContextLike) => Promise<CheckResult>;
+  };
+  "composition-inputs-resolve": {
+    description: string;
+    appliesTo: string[];
+    execute: (context: CheckContextLike) => Promise<CheckResult>;
+  };
+};
+//#endregion
+//#region packages/core/composition_filter.d.ts
+declare function filterPerContextArtifactsForComposition(artifacts: GeneratedArtifact[]): GeneratedArtifact[];
+//#endregion
+//#region packages/core/materialization_scopes.d.ts
+type ScopeCarrier = {
+  ownershipScope?: string;
+  scopeKey?: string;
+};
+declare function inferReconcileScopes(artifacts: ScopeCarrier[], seedScopes?: MaterializationScope[]): MaterializationScope[];
+//#endregion
+//#region packages/core/pipeline.d.ts
+declare function buildNormalizedSpecFromConfig(input: {
+  contextConfigPath: string;
+  codegenSupportPath: string;
+}): Promise<NormalizedSpec>;
+declare function buildContextNormalizedSpecFromConfig(input: {
+  contextConfigPath: string;
+  codegenSupportPath: string;
+}): Promise<ContextNormalizedSpec>;
+declare function buildV5ContextArtifacts(input: {
+  contextConfigPath: string;
+  codegenSupportPath: string;
+}): Promise<GeneratedArtifact[]>;
+declare function buildV5Artifacts(input: {
+  contextConfigPath: string;
+  codegenSupportPath: string;
+}): Promise<GeneratedArtifact[]>;
+declare function buildCompositionArtifacts(compositionConfigPath: string, contextSpecs: ContextNormalizedSpec[]): Promise<GeneratedArtifact[]>;
+//#endregion
+//#region packages/core/generators/lib.d.ts
+declare function buildV5LibArtifacts(): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/shared_kernel.d.ts
+declare function buildV5SharedKernelArtifacts(spec?: NormalizedSpec | ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/ports.d.ts
+declare function buildV5PortArtifacts(): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/domain.d.ts
+declare function buildV5DomainArtifacts(spec: NormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/application.d.ts
+type ApplicationArtifactOptions = {
+  /** Skip context-wide artifacts (handler-deps, handler-map) when generating per-aggregate. */skipContextWideArtifacts?: boolean;
+};
+declare function buildV5ApplicationArtifacts(spec: NormalizedSpec, options?: ApplicationArtifactOptions): GeneratedArtifact[];
+declare function buildV5ApplicationContextArtifacts(contextSpec: ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/infrastructure.d.ts
+type InfrastructureArtifactOptions = {
+  /** Skip context-wide artifacts (tables.ts) when generating per-aggregate. */skipContextWideArtifacts?: boolean;
+};
+declare function buildV5InfrastructureArtifacts(spec: NormalizedSpec, options?: InfrastructureArtifactOptions): GeneratedArtifact[];
+declare function buildReadModelCompositionArtifacts(contextSpecs: ContextNormalizedSpec[]): GeneratedArtifact[];
+declare function buildV5InfrastructureContextArtifacts(contextSpec: ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/projections.d.ts
+declare function buildProjectionArtifacts(contextSpec: ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/presentation.d.ts
+declare function buildV5PresentationArtifacts(spec: NormalizedSpec | ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/tests.d.ts
+declare function buildV5TestArtifacts(spec: NormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/routes.d.ts
+type RouteSpec = NormalizedSpec | ContextNormalizedSpec;
+declare function buildV5RouteArtifacts(spec: RouteSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/consumer_acls.d.ts
+declare function buildConsumerAclArtifacts(contextSpec: ContextNormalizedSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_container.d.ts
+/**
+ * Build the DI container and RepositoryFactory artifacts that wire all contexts
+ * together with their command/query handlers and repository adapters.
+ */
+declare function buildCompositionContainerArtifacts(compositionSpec: NormalizedCompositionSpec, contextSpecs: ContextNormalizedSpec[]): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_router.d.ts
+/**
+ * Build the root tRPC router artifact that merges all per-context routers.
+ */
+declare function buildCompositionRouterArtifacts(_compositionSpec: NormalizedCompositionSpec, contextSpecs: ContextNormalizedSpec[]): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_subscriptions.d.ts
+/**
+ * Build subscription registry, per-subscription event handler factories,
+ * and integration event payload types for all cross-context events.
+ */
+declare function buildCompositionSubscriptionArtifacts(compositionSpec: NormalizedCompositionSpec): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_outbox.d.ts
+declare function buildCompositionOutboxArtifacts(): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_bus.d.ts
+declare function buildCompositionBusArtifacts(): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_types.d.ts
+declare function buildCompositionTypeArtifacts(): GeneratedArtifact[];
+//#endregion
+//#region packages/core/generators/composition_acls.d.ts
+type CollisionSafeModulePathNames = {
+  symbolStem: string;
+  propertyStem: string;
+  pathSegment: string;
+};
+declare function buildCollisionSafeModulePathNames(modulePaths: string[]): Map<string, CollisionSafeModulePathNames>;
+declare function buildCompositionAclArtifacts(compositionSpec: NormalizedCompositionSpec): GeneratedArtifact[];
+//#endregion
+export { AggregateNormalizedSpecView, ApplicationArtifactOptions, ApplicationErrorDef, ArtifactOwnership, CollisionSafeModulePathNames, ContextConfigLike, ContextNormalizedSpec, DiffBucket, DomainErrorDef, EntityVisitor, GENERATED_READ_SIDE_SCHEMA_LOGICAL_PATH, GeneratedArtifact, InfrastructureArtifactOptions, IntrospectedField, MigrationPlan, MigrationResult, NormalizedAggregate, NormalizedAggregateWithChildren, NormalizedCommand, NormalizedCompositionAcl, NormalizedCompositionSpec, NormalizedComputedField, NormalizedDomainEvent, NormalizedEntity, NormalizedEntityWithChildren, NormalizedFindByIdQuery, NormalizedListQuery, NormalizedProjection, NormalizedProjectionSource, NormalizedQuery, NormalizedQueryReadSide, NormalizedReadAcl, NormalizedReadModel, NormalizedSpec, NormalizedValueObject, NormalizedWriteAcl, OwnershipScope, PreparedVendoredFile, ResolvedContextInputs, ResolvedCrossContextEvent, ResolvedSubscription, RunMigrationOptions, SPEC_ARTIFACT_SCHEMA_VERSION, SPEC_DIFF_SCHEMA_VERSION, SchemaReadResult, SpecDiffArtifact, VENDORED_FILE_MANIFEST, VendoredFileEntry, applyOwnershipIfMissing, buildArtifactPath, buildCollisionSafeModulePathNames, buildCompositionAclArtifacts, buildCompositionArtifacts, buildCompositionBusArtifacts, buildCompositionContainerArtifacts, buildCompositionOutboxArtifacts, buildCompositionRouterArtifacts, buildCompositionSpecDiff, buildCompositionSubscriptionArtifacts, buildCompositionTypeArtifacts, buildConsumerAclArtifacts, buildContextInputChecks, buildContextNormalizedSpec, buildContextNormalizedSpecFromConfig, buildContextSpecDiff, buildDrizzleConfig, buildFileArtifactTags, buildMaterializationManifestTags, buildMigrationResultTags, buildNormalizedCompositionSpec, buildNormalizedSpec, buildNormalizedSpecFromConfig, buildNormalizedSpecTags, buildProjectionArtifacts, buildReadModelCompositionArtifacts, buildSpecDiffTags, buildSummaryTags, buildV5ApplicationArtifacts, buildV5ApplicationContextArtifacts, buildV5Artifacts, buildV5ContextArtifacts, buildV5DomainArtifacts, buildV5InfrastructureArtifacts, buildV5InfrastructureContextArtifacts, buildV5LibArtifacts, buildV5PortArtifacts, buildV5PresentationArtifacts, buildV5RouteArtifacts, buildV5SharedKernelArtifacts, buildV5TestArtifacts, buildVendoredFileTags, camelCase, collectOwnedValueObjects, compositionSpecDiffDataName, contextArtifactOwnership, contextSpecDiffDataName, contractFileName, createGeneratedArtifact, discoverReferencedVos, ensureContextSupportFilesExist, filterPerContextArtifactsForComposition, flattenEntities, generateContextArtifacts, inferArtifactOwnership, inferCodegenSupportPathForContext, inferCodegenSupportPathFromSchemaFile, inferReconcileScopes, introspectObjectShape, introspectSchema, isRegisteredEntity, kebabCase, loadContextConfig, mergeGeneratedArtifacts, mergeSchemaReadResults, normalizeModulePath, parseConnectionString, parseDrizzleKitOutput, pascalCase, prepareAllVendoredFiles, prepareVendoredFile, readSchemaFile, repositoryPortFileName, repositoryPortTypeName, resolveAbsoluteContextInputs, resolveArtifactOwnership, resolveContextInputs, resolveFactoryPath, resolveGeneratedMigrationSchemaPath, resolveMethodContextInputsForCheck, resolveSchemaFilePathsForContext, resolveVoOwner, rewriteImports, runMigration, serializeCompositionSpec, serializeContextSpec, sharedArtifactOwnership, sliceArtifactOwnership, sliceContextIntoAggregateViews, snakeCase, snakeUpperCase, toImportURL, toUpperSnakeCase, unwrapFieldType, validateContextImports, walkEntityTree, withArtifactOwnership, wordsFromName };