@pattern-stack/codegen 0.15.1 → 0.15.2

package/dist/chunk-32DOFN3T.js

@@ -0,0 +1,4042 @@
+import {
+  DetectionConfigSchema
+} from "./chunk-3NMCDN7L.js";
+
+// src/parser/load-entities.ts
+import { resolve as resolve2 } from "path";
+
+// src/utils/find-yaml-files.ts
+import { readdirSync } from "fs";
+import { join, resolve } from "path";
+function isYaml(name) {
+  return name.endsWith(".yaml") || name.endsWith(".yml");
+}
+function findYamlFiles(dir, opts) {
+  const root = resolve(dir);
+  const out = [];
+  const excluded = new Set((opts?.excludeDirs ?? []).map((d) => resolve(d)));
+  const walk = (current) => {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".")) continue;
+        const child = join(current, entry.name);
+        if (excluded.has(resolve(child))) continue;
+        walk(child);
+      } else if (isYaml(entry.name)) {
+        out.push(join(current, entry.name));
+      }
+    }
+  };
+  walk(root);
+  return out.sort();
+}
+
+// src/utils/yaml-loader.ts
+import { readFileSync, existsSync } from "fs";
+import { parse as parseYaml } from "yaml";
+
+// src/schema/entity-definition.schema.ts
+import { z } from "zod";
+var FieldTypeSchema = z.enum([
+  "string",
+  "integer",
+  "decimal",
+  "boolean",
+  "uuid",
+  "date",
+  "datetime",
+  "json",
+  "entity_ref",
+  // Polymorphic reference: generates {field}EntityType + {field}EntityId columns
+  "string_array",
+  // Array of strings: generates text[] column
+  "enum"
+  // Enum type with choices or choices_from
+]);
+var UiTypeSchema = z.enum([
+  "text",
+  "textarea",
+  "number",
+  "money",
+  "percentage",
+  "email",
+  "url",
+  "date",
+  "datetime",
+  "boolean",
+  "enum",
+  "reference",
+  "json",
+  "badge",
+  "password"
+]);
+var UiImportanceSchema = z.enum(["primary", "secondary", "tertiary"]);
+var AnalyticsAggregationSchema = z.enum([
+  "sum",
+  "min",
+  "max",
+  "count",
+  "count_distinct",
+  "average",
+  "median",
+  "percentile",
+  "sum_boolean"
+]);
+var AnalyticsDimensionTypeSchema = z.enum(["categorical", "time"]);
+var AnalyticsEntityTypeSchema = z.enum(["primary", "unique", "foreign", "natural"]);
+var AnalyticsTimeGranularitySchema = z.enum(["day", "week", "month", "quarter", "year"]);
+var AnalyticsVisibilitySchema = z.enum(["internal", "agent", "public"]);
+var NonAdditiveDimensionSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string(),
+    window_choice: z.string().optional(),
+    window_groupings: z.array(z.string()).optional()
+  })
+]);
+var SemanticMetadataSchema = z.object({
+  measure: z.boolean().optional(),
+  analytics_aggregation: AnalyticsAggregationSchema.optional(),
+  agg_time_dimension: z.string().optional(),
+  non_additive_dimension: NonAdditiveDimensionSchema.optional(),
+  dimension: z.boolean().optional(),
+  dimension_type: AnalyticsDimensionTypeSchema.optional(),
+  time_granularity: AnalyticsTimeGranularitySchema.optional(),
+  is_partition: z.boolean().optional(),
+  entity: z.boolean().optional(),
+  entity_type: AnalyticsEntityTypeSchema.optional(),
+  entity_role: z.string().optional(),
+  analytics_visibility: AnalyticsVisibilitySchema.optional(),
+  semantic_expr: z.string().optional(),
+  semantic_label: z.string().optional()
+});
+var UiMetadataSchema = z.object({
+  ui_label: z.string().optional(),
+  ui_type: UiTypeSchema.optional(),
+  ui_importance: UiImportanceSchema.optional(),
+  ui_group: z.string().optional(),
+  ui_sortable: z.boolean().optional(),
+  ui_filterable: z.boolean().optional(),
+  ui_visible: z.boolean().optional(),
+  ui_placeholder: z.string().optional(),
+  ui_help: z.string().optional(),
+  ui_format: z.record(z.unknown()).optional()
+});
+var BaseFieldSchema = z.object({
+  type: FieldTypeSchema,
+  required: z.boolean().optional().default(false),
+  nullable: z.boolean().optional().default(false),
+  // String constraints
+  max_length: z.number().int().positive().optional(),
+  min_length: z.number().int().nonnegative().optional(),
+  // Numeric constraints
+  min: z.number().optional(),
+  max: z.number().optional(),
+  // Enum/choices (inline definition)
+  choices: z.array(z.string()).optional(),
+  // Enum/choices from external file (e.g., "relationship_types.yaml")
+  // Mutually exclusive with choices - parser loads file and extracts keys
+  choices_from: z.string().optional(),
+  // Entity reference: allowed entity types for polymorphic refs
+  // Required when type is 'entity_ref'
+  allowed_types: z.array(z.string()).optional(),
+  // Default value
+  default: z.unknown().optional(),
+  // Indexing
+  index: z.boolean().optional(),
+  unique: z.boolean().optional(),
+  // Foreign key reference (e.g., "accounts.id")
+  foreign_key: z.string().optional()
+});
+var FieldDefinitionSchema = BaseFieldSchema.merge(UiMetadataSchema).merge(SemanticMetadataSchema).refine((data) => !(data.required === true && data.nullable === true), {
+  message: "'required: true' and 'nullable: true' cannot both be set. A required field cannot be null.",
+  path: ["required"]
+}).refine(
+  (data) => {
+    if (data.min_length !== void 0 && data.type !== "string") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'min_length' can only be used with type 'string'",
+    path: ["min_length"]
+  }
+).refine(
+  (data) => {
+    if (data.max_length !== void 0 && data.type !== "string") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'max_length' can only be used with type 'string'",
+    path: ["max_length"]
+  }
+).refine(
+  (data) => {
+    if (data.min !== void 0 && !["integer", "decimal"].includes(data.type)) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'min' can only be used with numeric types",
+    path: ["min"]
+  }
+).refine(
+  (data) => {
+    if (data.max !== void 0 && !["integer", "decimal"].includes(data.type)) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'max' can only be used with numeric types",
+    path: ["max"]
+  }
+).refine(
+  (data) => {
+    if (data.type === "entity_ref" && !data.allowed_types?.length) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'entity_ref' type requires 'allowed_types' to be specified",
+    path: ["allowed_types"]
+  }
+).refine(
+  (data) => {
+    if (data.allowed_types !== void 0 && data.type !== "entity_ref") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'allowed_types' can only be used with type 'entity_ref'",
+    path: ["allowed_types"]
+  }
+).refine(
+  (data) => {
+    if (data.choices !== void 0 && data.choices_from !== void 0) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'choices' and 'choices_from' cannot both be specified",
+    path: ["choices_from"]
+  }
+).refine(
+  (data) => {
+    if (data.type === "enum" && !data.choices?.length && !data.choices_from) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'enum' type requires either 'choices' or 'choices_from'",
+    path: ["choices"]
+  }
+).refine(
+  (data) => {
+    if (data.measure === true && !data.analytics_aggregation) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "When 'measure' is true, 'analytics_aggregation' must be specified",
+    path: ["analytics_aggregation"]
+  }
+);
+var RelationshipTypeSchema = z.enum(["belongs_to", "has_many", "has_one"]);
+var OnDeleteSchema = z.enum(["restrict", "cascade", "set_null", "no_action"]);
+var RelationshipSchema = z.object({
+  type: RelationshipTypeSchema,
+  target: z.string(),
+  // Target entity name (e.g., "account")
+  foreign_key: z.string(),
+  // FK field name (e.g., "account_id")
+  through: z.string().optional(),
+  // For transitive: "owned_opportunities.updates"
+  inverse: z.string().optional(),
+  // Name of inverse relationship on target entity
+  nullable: z.boolean().optional(),
+  // Whether the FK column allows NULL
+  on_delete: OnDeleteSchema.optional().default("restrict")
+  // FK cascade action (belongs_to only; hard-delete only)
+}).strict().refine(
+  (data) => {
+    if (data.on_delete === "set_null" && data.nullable !== true) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "'on_delete: set_null' requires 'nullable: true' \u2014 Postgres cannot null a NOT NULL FK column.",
+    path: ["on_delete"]
+  }
+);
+var BehaviorConfigSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string(),
+    options: z.record(z.unknown()).optional()
+  })
+]);
+var BehaviorStrategySchema = z.enum(["base_class", "inline"]);
+var FolderStructureSchema = z.enum(["nested", "flat"]).default("nested");
+var FileGroupingSchema = z.enum(["separate", "grouped"]).default("separate");
+var ExposeLayerSchema = z.enum(["repository", "rest", "trpc", "electric"]);
+var EntityConfigSchema = z.object({
+  name: z.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "Entity name must be lowercase with underscores (e.g., 'opportunity')"
+  ),
+  plural: z.string().regex(/^[a-z][a-z0-9_]*$/, "Plural must be lowercase"),
+  table: z.string().regex(/^[a-z][a-z0-9_]*$/, "Table must be lowercase"),
+  // Layout options (orthogonal concerns)
+  // folder_structure: controls directory nesting
+  // file_grouping: controls file organization
+  folder_structure: FolderStructureSchema.optional(),
+  file_grouping: FileGroupingSchema.optional(),
+  // Per-entity behavior strategy override (overrides codegen.config.yaml)
+  behavior_strategy: BehaviorStrategySchema.optional(),
+  // Which layers to generate (default: all)
+  expose: z.array(ExposeLayerSchema).optional().default(["repository", "rest", "trpc"]),
+  // App-defined patterns (ADR-031, supersedes ADR-005 family:).
+  // `pattern:` and `patterns:` are mutually exclusive — use `pattern:`
+  // for a single pattern and `patterns:` for multi-pattern composition.
+  // Pattern names resolve against the registry at codegen time.
+  pattern: z.string().optional(),
+  patterns: z.array(z.string()).optional(),
+  // Per-pattern config, keyed by pattern name. Each value is validated
+  // against the pattern's `configSchema` in composition validation
+  // (src/patterns/validate-composition.ts — PATTERN-4).
+  config: z.record(z.string(), z.unknown()).optional(),
+  // JOB-7: marks this entity as a valid scope target for job scoping.
+  // Drives the generated ScopeEntityType union in
+  // runtime/subsystems/jobs/generated/scope-entity-type.ts.
+  scopeable: z.boolean().optional(),
+  // RFC-0001 §1/§8: the integration *surface* this entity belongs to
+  // (e.g. 'calendar', 'mail', 'crm'). Surfaces span provider contexts
+  // (ADR-0006) — one Google OAuth feeds calendar+mail+transcript. The union
+  // of `surface:` values across all entity YAML is the closed set that a
+  // provider's `surfaces:` must be a subset of (cross-checked in
+  // src/parser/validate-providers.ts). Optional: entities without an
+  // integration surface omit it. The surface-package *emission* convention
+  // is Track C (#329); this field is only the declarative input both tracks
+  // read. Lives inside the `entity:` block (next to `pattern:`/`name:`/`table:`).
+  surface: z.string().optional(),
+  // Bounded-context declaration (ADR-0004) — "which bounded context this
+  // entity belongs to". This is the DURABLE decision; it is a plain
+  // bounded-context slug, NOT a folder knob. Different features consume it:
+  //
+  //   - #403 (the FIRST consumer): drives the generated code's
+  //     module output folder. clean-lite-ps nests the entity's module under
+  //     `<modules>/<context>/<entity>/` so same-context entities group
+  //     together; untagged entities stay flat (`<modules>/<entity>/`).
+  //   - ADR-0004 (deferred): a later `naming: prefix | schema` knob reads
+  //     this SAME field to drive the Postgres physical layout —
+  //     `prefix` → `pgTable('<context>__<table>')`, then the flip to
+  //     `schema` → `pgSchema('<context>').table('<table>')`. NOT wired here.
+  //
+  // Sibling to `surface:` and orthogonal to it (ADR-0006): context = model
+  // cohesion (which domain), surface = vendor composition (which integration).
+  // Lives inside the `entity:` block (next to `pattern:`/`name:`/`table:`).
+  context: z.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "context must be lowercase snake_case (e.g. 'integration')"
+  ).optional()
+}).strict().refine((d) => !(d.pattern && d.patterns), {
+  message: "'pattern' and 'patterns' are mutually exclusive"
+});
+var QueryDeclarationSchema = z.object({
+  by: z.array(z.string()).min(1),
+  unique: z.boolean().optional(),
+  select: z.array(z.string()).optional(),
+  order: z.string().optional(),
+  limit: z.boolean().optional(),
+  via: z.string().optional()
+});
+var SearchQueryDeclarationSchema = z.object({
+  name: z.literal("search"),
+  filters: z.array(z.string()).min(1),
+  search: z.string().optional(),
+  paginate: z.boolean().optional().default(true),
+  order: z.string().optional()
+});
+var AnyQueryDeclarationSchema = z.union([
+  SearchQueryDeclarationSchema,
+  QueryDeclarationSchema
+]);
+var IntegrationDirectionSchema = z.enum([
+  "inbound",
+  "outbound",
+  "bidirectional"
+]);
+var ProviderIntegrationSchema = z.object({
+  remote_entity: z.string(),
+  direction: IntegrationDirectionSchema,
+  cdc: z.boolean().optional().default(false),
+  field_mapping: z.record(z.string(), z.string()).optional(),
+  read_only_fields: z.array(z.string()).optional()
+});
+var IntegrationConfigSchema = z.object({
+  electric: z.boolean().optional().default(false),
+  providers: z.record(z.string(), ProviderIntegrationSchema).optional()
+});
+var EventDeclarationSchema = z.object({
+  name: z.string().regex(/^[a-z][a-z0-9_]*$/, "Event name must be snake_case"),
+  queue: z.string(),
+  body: z.record(z.string(), z.string()),
+  generate_handler: z.boolean().optional().default(false)
+});
+var SimpleMetricSchema = z.object({
+  type: z.literal("simple"),
+  measure: z.string(),
+  agg: AnalyticsAggregationSchema.optional(),
+  filter: z.string().optional(),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var DerivedMetricSchema = z.object({
+  type: z.literal("derived"),
+  expr: z.string(),
+  metrics: z.array(z.string()),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var RatioMetricSchema = z.object({
+  type: z.literal("ratio"),
+  numerator: z.union([z.string(), SimpleMetricSchema]),
+  denominator: z.union([z.string(), SimpleMetricSchema]),
+  filter: z.string().optional(),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var CumulativeMetricSchema = z.object({
+  type: z.literal("cumulative"),
+  measure: z.string(),
+  window: z.string().optional(),
+  grain_to_date: AnalyticsTimeGranularitySchema.optional(),
+  description: z.string().optional(),
+  label: z.string().optional()
+});
+var MetricDefinitionSchema = z.discriminatedUnion("type", [
+  SimpleMetricSchema,
+  DerivedMetricSchema,
+  RatioMetricSchema,
+  CumulativeMetricSchema
+]);
+var AnalyticsBlockSchema = z.object({
+  measure_packs: z.array(z.string()).optional(),
+  cube_name: z.string().optional(),
+  metrics: z.record(z.string(), MetricDefinitionSchema).optional()
+});
+var GenerateConfigSchema = z.object({
+  writes: z.boolean().optional().default(true)
+}).strict();
+var EntityDefinitionSchema = z.object({
+  entity: EntityConfigSchema,
+  fields: z.record(z.string(), FieldDefinitionSchema),
+  relationships: z.record(z.string(), RelationshipSchema).optional(),
+  // Behaviors add cross-cutting concerns (timestamps, soft_delete, user_tracking, etc.)
+  behaviors: z.array(BehaviorConfigSchema).optional().default([]),
+  // Per-entity generation toggles (e.g. disable write-side emission)
+  generate: GenerateConfigSchema.optional(),
+  // EAV (entity-attribute-value) dual-write + paired reads (ADR-13).
+  // When `true`, codegen emits:
+  //   - FindXWithFieldsUseCase + ListXWithFieldsUseCase (paired reads)
+  //   - CreateX / UpdateX use cases in transactional compound-write shape
+  //     (composes entity service + FieldValueService in one db.transaction,
+  //     splits `{ fields, ...core }` from the DTO)
+  //   - GET /:id/with-fields + GET /with-fields controller routes
+  //   - Service with injected FieldValueRepository + findByIdWithFields /
+  //     listWithFields paired read methods
+  //
+  // Consumer contract (must be in place before regen):
+  //   - BaseService.create/update/delete accept optional `tx` parameter
+  //   - `@shared/eav-helpers` exports `toEavRows(entityId, entityType, fields)`
+  //     and `mergeEavRows(rows)`
+  //   - FieldValueService exposes `upsertMany(rows, tx?)` (inherited from
+  //     MetadataEntityService)
+  //   - DRIZZLE_DB injection token available via `@shared/constants/tokens`
+  //
+  // Defaults to `false` — opt in per entity that needs dynamic/custom fields.
+  eav: z.boolean().optional().default(false),
+  // Declare this entity IS an EAV value table. When `true`, codegen emits
+  // the compound EAV methods (upsertFieldsTransactional, findMergedByEntity)
+  // on the service and the upsertCurrentValues method on the repository —
+  // no hand extension required. Companion flag `eav_definition_table`
+  // identifies the sibling entity that stores the field-key ↔ id lookup.
+  //
+  // Mutually exclusive with `eav: true` in practice — a value table holds
+  // OTHER entities' dynamic fields, it isn't itself an EAV-opt-in entity.
+  //
+  // Assumption (v1): value tables have a `user_id` column. Future
+  // `eav_user_scoped: false` flag will relax this for audit/system EAV.
+  eav_value_table: z.boolean().optional().default(false),
+  // Singular entity name of the field-definitions entity that pairs with
+  // this value table (matches the `target:` convention in relationship
+  // YAMLs). Required when `eav_value_table: true`; ignored otherwise.
+  eav_definition_table: z.string().optional(),
+  // v2: Declarative query generation (ADR-005)
+  // Generates repository + service + use case methods from declarations
+  queries: z.array(AnyQueryDeclarationSchema).optional(),
+  // v2: Integration integration configuration (CODEGEN-EVOLUTION-PLAN Phase 2)
+  // Electric SQL + provider integration (Salesforce, HubSpot, etc.)
+  integration: IntegrationConfigSchema.optional(),
+  // ADR-033.1: Provider-keyed change-source detection.
+  //
+  // Map of provider name → DetectionConfig. Single-provider entities use
+  // a one-key map; multi-provider entities list each provider as a
+  // separate key. Each value is an independent `DetectionConfig` (its
+  // own mode/cursor/mapping/filters) sourced from the canonical schema
+  // in `runtime/subsystems/integration` so this validator and the runtime
+  // parser stay in lockstep.
+  //
+  // Within-file cross-check (ADR-033.1 §6): every key here must also
+  // appear in `integration.providers` — see the superRefine on
+  // `EntityDefinitionSchema` below.
+  detection: z.record(z.string(), DetectionConfigSchema).optional(),
+  // NOTE: `surface:` and `context:` moved INTO EntityConfigSchema (the
+  // `entity:` block) in 0.12.2 — consumers write them next to
+  // `pattern:`/`name:`/`table:`, which is the natural place. They are
+  // read via `entity.surface` / `entity.context`. Clean break: no
+  // root-level placement is accepted.
+  // v2: Domain event declarations (CODEGEN-EVOLUTION-PLAN Phase 2)
+  // Generates typed event classes, handlers, and queue registration
+  events: z.array(EventDeclarationSchema).optional(),
+  // EVT-7: Opt-in typed event emission. Each entry names an `EventDefinition`
+  // (top-level `events/<type>.yaml` or an inline `events:` block entry) that
+  // the generated use-cases should publish via `TypedEventBus.publish(...)`
+  // inside a Drizzle transaction.
+  //
+  //   emits: [contact_created, contact_updated]
+  //
+  // Cross-validated in `validateEntityEmits()` against the merged event
+  // registry. `undefined` ⇒ fallback to untyped lifecycle-events + warning;
+  // `[]` ⇒ explicit opt-out, no warning, no typed emission.
+  emits: z.array(
+    z.string().regex(/^[a-z][a-z0-9_]*$/, "emits entries must be snake_case event type names")
+  ).optional(),
+  // v2: Analytics / semantic layer configuration
+  // Cube.js measure packs, custom cube name, and metric definitions
+  analytics: AnalyticsBlockSchema.optional(),
+  // Composite (multi-column) unique indexes (#356). Single-column uniqueness
+  // is `unique: true` on the field itself; this declares constraints that
+  // span 2+ columns, e.g. UNIQUE (conversation_id, sequence). Emitted as a
+  // `uniqueIndex(...).on(...)` entry in the generated entity's pgTable
+  // extra-config callback. `name` defaults to <table>_<col1>_<col2>_uniq.
+  unique_indexes: z.array(
+    z.object({
+      fields: z.array(z.string()).min(2, "unique_indexes entries span 2+ columns \u2014 use `unique: true` on the field for single-column uniqueness"),
+      name: z.string().optional()
+    }).strict()
+  ).optional()
+}).strict().refine(
+  (data) => !data.eav_value_table || typeof data.eav_definition_table === "string",
+  {
+    message: "`eav_definition_table` is required when `eav_value_table: true` \u2014 declare the singular entity name of the paired field-definitions entity (e.g. `eav_definition_table: 'field_definition'`).",
+    path: ["eav_definition_table"]
+  }
+).superRefine((entity, ctx) => {
+  if (!entity.detection) return;
+  const declared = new Set(Object.keys(entity.integration?.providers ?? {}));
+  for (const provider of Object.keys(entity.detection)) {
+    if (!declared.has(provider)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["detection", provider],
+        message: `Provider '${provider}' used in detection: but not declared in integration.providers. Known providers: ${[...declared].join(", ")}`
+      });
+    }
+  }
+});
+
+// src/schema/event-definition.schema.ts
+import { z as z2 } from "zod";
+var EVENT_DIRECTIONS = ["inbound", "change", "outbound"];
+var EVENT_TIERS = ["domain", "audit"];
+var EVENT_FIELD_TYPES = [
+  "uuid",
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "json",
+  "array"
+];
+var EVENT_ARRAY_ITEM_TYPES = [
+  "uuid",
+  "string",
+  "number",
+  "boolean",
+  "date"
+];
+var RESERVED_EVENT_POOLS = [
+  "events_inbound",
+  "events_change",
+  "events_outbound"
+];
+var EVENT_BACKOFF_STRATEGIES = ["linear", "exponential"];
+var DIRECTION_TO_POOL = {
+  inbound: "events_inbound",
+  change: "events_change",
+  outbound: "events_outbound"
+};
+var EventDirectionSchema = z2.enum(EVENT_DIRECTIONS);
+var EventTierSchema = z2.enum(EVENT_TIERS);
+var EventFieldTypeSchema = z2.enum(EVENT_FIELD_TYPES);
+var EventArrayItemTypeSchema = z2.enum(EVENT_ARRAY_ITEM_TYPES);
+var EventPoolSchema = z2.enum(RESERVED_EVENT_POOLS);
+var EventPayloadFieldSchema = z2.object({
+  type: EventFieldTypeSchema,
+  items: EventArrayItemTypeSchema.optional(),
+  nullable: z2.boolean().optional().default(false),
+  description: z2.string().optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.type === "array" && data.items === void 0) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "'items' is required when type is 'array'",
+      path: ["items"]
+    });
+  }
+  if (data.type !== "array" && data.items !== void 0) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: `'items' is only valid when type is 'array' (got '${data.type}')`,
+      path: ["items"]
+    });
+  }
+});
+var RetrySchema = z2.object({
+  attempts: z2.number().int().min(0).max(20),
+  backoff: z2.enum(EVENT_BACKOFF_STRATEGIES)
+}).strict();
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*$/;
+var EventDefinitionSchemaCore = z2.object({
+  type: z2.string().regex(
+    SNAKE_CASE_RE,
+    "Event type must be snake_case starting with a letter"
+  ),
+  tier: EventTierSchema.optional().default("domain"),
+  direction: EventDirectionSchema.optional(),
+  pool: EventPoolSchema.optional(),
+  aggregate: z2.string().regex(SNAKE_CASE_RE).optional(),
+  source: z2.string().min(1).optional(),
+  destination: z2.string().min(1).optional(),
+  payload: z2.record(
+    z2.string().regex(SNAKE_CASE_RE, "Payload keys must be snake_case"),
+    EventPayloadFieldSchema
+  ).default({}),
+  retry: RetrySchema.optional().default({
+    attempts: 3,
+    backoff: "exponential"
+  }),
+  version: z2.number().int().min(1).optional().default(1),
+  description: z2.string().optional()
+}).strict();
+var EventDefinitionSchemaRefined = EventDefinitionSchemaCore.superRefine(
+  (data, ctx) => {
+    if (data.tier === "audit") {
+      if (data.pool !== void 0) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: `Event '${data.type}' is tier:audit; pool MUST be omitted (got '${data.pool}'). Audit events have no pool. See ai-docs/specs/issue-242/plan.md \xA7AUDIT-2.`,
+          path: ["pool"]
+        });
+      }
+      if (data.direction !== void 0) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: `Event '${data.type}' is tier:audit; direction MUST be omitted (got '${data.direction}'). Audit events have no direction. See ai-docs/specs/issue-242/plan.md \xA7AUDIT-2.`,
+          path: ["direction"]
+        });
+      }
+      return;
+    }
+    if (data.direction === void 0) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "'direction' is required when tier is 'domain'",
+        path: ["direction"]
+      });
+      return;
+    }
+    if (data.direction === "change" && !data.aggregate) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "'aggregate' is required when direction is 'change'",
+        path: ["aggregate"]
+      });
+    }
+    if (data.source !== void 0 && data.direction !== "inbound") {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: `'source' is only valid when direction is 'inbound' (got '${data.direction}')`,
+        path: ["source"]
+      });
+    }
+    if (data.destination !== void 0 && data.direction !== "outbound") {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: `'destination' is only valid when direction is 'outbound' (got '${data.direction}')`,
+        path: ["destination"]
+      });
+    }
+    if (data.pool !== void 0) {
+      const expected = DIRECTION_TO_POOL[data.direction];
+      if (data.pool !== expected) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: `pool '${data.pool}' is inconsistent with direction '${data.direction}' (expected '${expected}')`,
+          path: ["pool"]
+        });
+      }
+    }
+  }
+);
+var EventDefinitionSchema = EventDefinitionSchemaRefined.transform(
+  (parsed) => {
+    if (parsed.tier === "audit") {
+      return parsed;
+    }
+    const direction = parsed.direction;
+    return {
+      ...parsed,
+      pool: parsed.pool ?? DIRECTION_TO_POOL[direction]
+    };
+  }
+);
+
+// src/schema/relationship-definition.schema.ts
+import { z as z3 } from "zod";
+var TypeDirectionSchema = z3.object({
+  /** Name of the inverse type when viewed from the other direction */
+  inverse: z3.string().optional(),
+  /** Both directions are equivalent — queries should check both FK columns */
+  bidirectional: z3.boolean().optional(),
+  /** Explicitly directed, no named inverse (default behavior) */
+  directed: z3.boolean().optional()
+}).refine(
+  (data) => {
+    const set = [data.inverse, data.bidirectional, data.directed].filter(
+      (v) => v !== void 0
+    );
+    return set.length === 1;
+  },
+  {
+    message: "Exactly one of inverse, bidirectional, or directed must be specified"
+  }
+);
+var RelationshipTypesSchema = z3.union([
+  // Simple list: all types are directed from→to
+  z3.array(z3.string().regex(/^[a-z][a-z0-9_]*$/, "Type must be snake_case")),
+  // Object map: each type has direction metadata
+  z3.record(
+    z3.string().regex(/^[a-z][a-z0-9_]*$/, "Type key must be snake_case"),
+    TypeDirectionSchema
+  )
+]);
+var OnDeleteActionSchema = z3.enum(["restrict", "cascade", "set_null", "no_action"]).default("restrict");
+var RelationshipConfigSchema = z3.object({
+  /** Relationship name (snake_case). Used for class/file naming. */
+  name: z3.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "Relationship name must be snake_case"
+  ),
+  /** Database table name. Defaults to {name}s if not specified. */
+  table: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Table must be snake_case").optional(),
+  /** The "from" entity — generates {entity}_id FK column (subject). */
+  from: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Entity name must be snake_case"),
+  /** The "to" entity — generates {entity}_id FK column (object). */
+  to: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Entity name must be snake_case"),
+  /**
+   * Relationship subtypes. Optional — omit for untyped junctions.
+   * When present, generates a `type` enum column on the junction table.
+   *
+   * Simple list: all types are directed (from→to). Use for cross-type
+   * relationships where entity asymmetry makes direction obvious.
+   *
+   * Object map: each type declares its own direction metadata.
+   * Required for self-referential relationships (from === to).
+   */
+  types: RelationshipTypesSchema.optional(),
+  /**
+   * Generate temporal validity fields: valid_from (date), valid_to (date?),
+   * is_current (boolean, denormalized for query performance).
+   * Default: true
+   */
+  temporal: z3.boolean().default(true),
+  /**
+   * Generate source tracking fields: source (enum), confidence (decimal 0-1).
+   * Default: true
+   */
+  sourced: z3.boolean().default(true),
+  /** on_delete action for the "from" endpoint FK. Default: restrict */
+  on_delete_from: OnDeleteActionSchema.optional(),
+  /** on_delete action for the "to" endpoint FK. Default: restrict */
+  on_delete_to: OnDeleteActionSchema.optional(),
+  /**
+   * Override the default unique constraint columns.
+   *
+   * Defaults:
+   * - Typed: [from_id, to_id, type]
+   * - Typed + temporal: [from_id, to_id, type, valid_from]
+   * - Untyped: [from_id, to_id]
+   *
+   * Use this when the default doesn't fit — e.g., allowing multiple
+   * relationships of the same type between the same entities at different times.
+   */
+  unique_on: z3.array(z3.string()).optional()
+}).strict();
+var RelationshipQuerySchema = z3.object({
+  by: z3.array(z3.string()).min(1),
+  unique: z3.boolean().optional(),
+  select: z3.array(z3.string()).optional(),
+  order: z3.string().optional(),
+  limit: z3.boolean().optional()
+});
+var RelationshipDefinitionSchema = z3.object({
+  /** Relationship configuration block */
+  relationship: RelationshipConfigSchema,
+  /**
+   * Additional fields beyond auto-generated ones.
+   * These describe the relationship, not either endpoint entity.
+   * Uses the same field definition schema as entity fields.
+   */
+  fields: z3.record(z3.string(), z3.any()).optional(),
+  /** Declarative queries — same syntax as entity queries. */
+  queries: z3.array(RelationshipQuerySchema).optional()
+}).strict().refine(
+  (data) => {
+    if (data.relationship.from === data.relationship.to && data.relationship.types) {
+      return !Array.isArray(data.relationship.types);
+    }
+    return true;
+  },
+  {
+    message: "Self-referential relationships must use the object map form for types (with inverse/bidirectional/directed metadata), not a simple list",
+    path: ["relationship", "types"]
+  }
+).refine(
+  (data) => {
+    if (!data.fields) return true;
+    const reserved = getReservedColumnNames(data.relationship);
+    const collisions = Object.keys(data.fields).filter(
+      (key) => reserved.has(key)
+    );
+    return collisions.length === 0;
+  },
+  {
+    message: "fields: contains keys that collide with auto-generated columns. Reserved names depend on config (type, valid_from, valid_to, is_current, source, confidence, id, created_at, updated_at, and FK columns).",
+    path: ["fields"]
+  }
+);
+function getReservedColumnNames(config) {
+  const { fromColumn, toColumn } = deriveRelationshipFKColumns(config);
+  const reserved = /* @__PURE__ */ new Set([
+    "id",
+    "created_at",
+    "updated_at",
+    fromColumn,
+    toColumn
+  ]);
+  if (config.types) {
+    reserved.add("type");
+  }
+  if (config.temporal) {
+    reserved.add("valid_from");
+    reserved.add("valid_to");
+    reserved.add("is_current");
+  }
+  if (config.sourced) {
+    reserved.add("source");
+    reserved.add("confidence");
+  }
+  return reserved;
+}
+function deriveRelationshipFKColumns(config) {
+  if (config.from === config.to) {
+    return {
+      fromColumn: `from_${config.from}_id`,
+      toColumn: `to_${config.to}_id`
+    };
+  }
+  return {
+    fromColumn: `${config.from}_id`,
+    toColumn: `${config.to}_id`
+  };
+}
+function deriveTableName(config) {
+  return config.table ?? `${config.name}s`;
+}
+function deriveUniqueConstraint(config) {
+  if (config.unique_on) return config.unique_on;
+  const { fromColumn, toColumn } = deriveRelationshipFKColumns(config);
+  const columns = [fromColumn, toColumn];
+  if (config.types) {
+    columns.push("type");
+  }
+  if (config.temporal && config.types) {
+    columns.push("valid_from");
+  }
+  return columns;
+}
+
+// src/schema/junction-definition.schema.ts
+import { z as z4 } from "zod";
+
+// src/patterns/library/base-junction-fields.ts
+var BaseJunctionFields = [
+  { name: "is_primary", type: "boolean" },
+  { name: "started_at", type: "timestamp" },
+  { name: "ended_at", type: "timestamp" },
+  { name: "sourced_from", type: "text" },
+  { name: "confidence", type: "numeric(5,4)" },
+  { name: "matched_at", type: "timestamp" }
+];
+var BASE_JUNCTION_FIELD_NAMES = new Set(
+  BaseJunctionFields.map((c) => c.name)
+);
+
+// src/schema/junction-definition.schema.ts
+var EntityNameSchema = z4.string().regex(/^[a-z][a-z0-9_]*$/, "Entity reference must be snake_case");
+var JunctionDefinitionSchema = z4.object({
+  /** Discriminator literal — `pattern: Junction`. */
+  pattern: z4.literal("Junction"),
+  /**
+   * Exactly two endpoint entity names. Both intra- and cross-domain
+   * pairings are accepted; entity existence is validated by the
+   * analyzer in a later leaf.
+   */
+  between: z4.tuple([EntityNameSchema, EntityNameSchema]),
+  /**
+   * Emit BaseJunctionFields temporal columns (`started_at`, `ended_at`,
+   * `matched_at`). Default true. Matches Relationship's `temporal` toggle.
+   */
+  temporal: z4.boolean().optional().default(true),
+  /**
+   * Emit BaseJunctionFields sourcing columns (`sourced_from`,
+   * `confidence`). Default true. Matches Relationship's `sourced` toggle.
+   */
+  sourced: z4.boolean().optional().default(true),
+  /**
+   * Junction-specific fields beyond `BaseJunctionFields`. Includes the
+   * per-pairing role enum (declared inline; never shared across
+   * pairings). Shape is validated downstream by the codegen layer
+   * using the existing entity FieldDefinitionSchema.
+   */
+  fields: z4.record(z4.string(), z4.any()).optional(),
+  /**
+   * Declarative queries — same syntax as entity queries. Shape is
+   * validated downstream by the codegen layer.
+   */
+  queries: z4.array(z4.any()).optional(),
+  /**
+   * Per-side opt-out for parent-service fan-out (CGP-60). When a side
+   * is `false`, the `_inject-parent-service-*` templates emit nothing
+   * on that side (and the corresponding module wiring is skipped).
+   * The junction service body is always emitted regardless. Defaults
+   * to `{ left: true, right: true }`.
+   */
+  expose_on_parent: z4.object({
+    left: z4.boolean().optional().default(true),
+    right: z4.boolean().optional().default(true)
+  }).optional().default({ left: true, right: true })
+}).strict().refine((d) => d.between[0] !== d.between[1], {
+  message: "`between` endpoints must be distinct",
+  path: ["between"]
+}).refine(
+  (d) => {
+    const fieldNames = Object.keys(d.fields ?? {});
+    return !fieldNames.some((n) => BASE_JUNCTION_FIELD_NAMES.has(n));
+  },
+  {
+    message: "`fields:` block redeclares a reserved BaseJunctionFields column (is_primary, started_at, ended_at, sourced_from, confidence, matched_at)",
+    path: ["fields"]
+  }
+);
+function validateJunctionDefinition(data) {
+  return JunctionDefinitionSchema.parse(data);
+}
+function safeValidateJunctionDefinition(data) {
+  const result = JunctionDefinitionSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+
+// src/schema/provider-definition.schema.ts
+import { z as z5 } from "zod";
+var IMPORT_REF_RE = /^[^#\s]+#[A-Za-z_$][A-Za-z0-9_$]*$/;
+var ImportRefSchema = z5.string().regex(
+  IMPORT_REF_RE,
+  "must be an 'import-path#Export' reference (e.g. '@app/foo/bar.strategy#BarStrategy')"
+);
+function parseImportRef(ref) {
+  const hash = ref.indexOf("#");
+  return { path: ref.slice(0, hash), exportName: ref.slice(hash + 1) };
+}
+var AuthTypeSchema = z5.enum(["oauth2", "api-key", "app-password"]);
+var AuthSchema = z5.object({
+  type: AuthTypeSchema,
+  // Class implementing the auth subsystem's strategy contract (ADR-031).
+  // Pre-flight verified against a real export at codegen time.
+  strategy: ImportRefSchema,
+  // Required (and non-empty) iff type === 'oauth2'; see refine below.
+  scopes: z5.array(z5.string()).optional()
+}).strict().refine(
+  (a) => a.type !== "oauth2" || a.scopes !== void 0 && a.scopes.length > 0,
+  {
+    message: "auth.scopes is required and must be non-empty when auth.type is 'oauth2'",
+    path: ["scopes"]
+  }
+);
+var ClientSchema = z5.object({
+  // API client class. Pre-flight verified against a real export.
+  class: ImportRefSchema,
+  base_url: z5.string().url("client.base_url must be an absolute URL")
+}).strict();
+var ProviderDefinitionSchema = z5.object({
+  // Provider id — the canonical string used as detection: keys, audit rows,
+  // subscription rows. kebab/lower; unique across definitions/providers/
+  // (uniqueness is a cross-file check in validate-providers.ts).
+  slug: z5.string().regex(
+    /^[a-z][a-z0-9-]*$/,
+    "slug must be kebab-case lower (e.g. 'google', 'hubspot')"
+  ),
+  display_name: z5.string().optional(),
+  auth: AuthSchema,
+  client: ClientSchema,
+  // Surfaces this provider serves (ADR-0006: surfaces span contexts — one
+  // Google OAuth feeds calendar+mail+transcript). Each must reference a real
+  // `surface:` declared on some entity; that cross-check is in
+  // validate-providers.ts. Non-empty enforced here.
+  surfaces: z5.array(z5.string()).min(1, "surfaces must list at least one surface"),
+  // Optional auth lifecycle hints consumed by provider-module emission (D2).
+  // `refresh_behavior` is left as a free string in D1 — its domain firms up
+  // when D2 consumes it; carrying it now keeps the YAML lossless.
+  token_lifetime: z5.number().int().positive().optional(),
+  refresh_behavior: z5.string().optional()
+}).strict();
+
+// src/utils/yaml-loader.ts
+function loadEntityFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = EntityDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function formatZodErrors(error) {
+  return error.errors.map((err) => {
+    const path2 = err.path.join(".");
+    const location = path2 ? `at '${path2}'` : "at root";
+    return `${err.message} ${location}`;
+  });
+}
+function loadEntitiesFromYaml(filePaths) {
+  const successes = [];
+  const failures = [];
+  for (const filePath of filePaths) {
+    const result = loadEntityFromYaml(filePath);
+    if (result.success) {
+      successes.push(result);
+    } else {
+      failures.push(result);
+    }
+  }
+  return { successes, failures };
+}
+function loadRelationshipFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = RelationshipDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function loadEventFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = EventDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function loadJunctionFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = JunctionDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function loadProviderFromYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = ProviderDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
+function loadProvidersFromYaml(filePaths) {
+  const successes = [];
+  const failures = [];
+  for (const filePath of filePaths) {
+    const result = loadProviderFromYaml(filePath);
+    if (result.success) {
+      successes.push(result);
+    } else {
+      failures.push(result);
+    }
+  }
+  return { successes, failures };
+}
+function detectYamlType(filePath) {
+  if (!existsSync(filePath)) return "unknown";
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseYaml(content);
+    if (parsed && typeof parsed === "object") {
+      if (parsed.pattern === "Junction") return "junction";
+      if ("entity" in parsed) return "entity";
+      if ("relationship" in parsed) return "relationship";
+    }
+  } catch {
+  }
+  return "unknown";
+}
+
+// src/parser/load-entities.ts
+function transformToEntity(result) {
+  const { definition, filePath } = result;
+  const queries = definition.queries?.filter((q) => "by" in q).map((q) => ({
+    by: q.by,
+    unique: q.unique,
+    select: q.select,
+    order: q.order,
+    limit: q.limit,
+    via: q.via
+  }));
+  const entity = {
+    name: definition.entity.name,
+    plural: definition.entity.plural,
+    table: definition.entity.table,
+    pattern: definition.entity.pattern,
+    patterns: definition.entity.patterns,
+    patternConfig: definition.entity.config,
+    scopeable: definition.entity.scopeable ?? false,
+    folderStructure: definition.entity.folder_structure ?? "nested",
+    fields: /* @__PURE__ */ new Map(),
+    relationships: /* @__PURE__ */ new Map(),
+    behaviors: definition.behaviors.map((b) => typeof b === "string" ? b : b.name),
+    queries,
+    sourcePath: filePath
+  };
+  for (const [name, fieldDef] of Object.entries(definition.fields)) {
+    const field = {
+      name,
+      type: fieldDef.type,
+      required: fieldDef.required ?? false,
+      nullable: fieldDef.nullable ?? false,
+      unique: fieldDef.unique ?? false,
+      index: fieldDef.index ?? false,
+      foreignKey: fieldDef.foreign_key ? parseForeignKey(fieldDef.foreign_key) : void 0,
+      choices: fieldDef.choices,
+      constraints: {
+        minLength: fieldDef.min_length,
+        maxLength: fieldDef.max_length,
+        min: fieldDef.min,
+        max: fieldDef.max
+      },
+      ui: {
+        label: fieldDef.ui_label,
+        type: fieldDef.ui_type,
+        importance: fieldDef.ui_importance,
+        group: fieldDef.ui_group,
+        sortable: fieldDef.ui_sortable,
+        filterable: fieldDef.ui_filterable,
+        visible: fieldDef.ui_visible
+      }
+    };
+    entity.fields.set(name, field);
+  }
+  if (definition.relationships) {
+    for (const [name, relDef] of Object.entries(definition.relationships)) {
+      const relationship = {
+        name,
+        type: relDef.type,
+        target: relDef.target,
+        foreignKey: relDef.foreign_key,
+        inverse: relDef.inverse,
+        through: relDef.through,
+        resolved: false
+      };
+      entity.relationships.set(name, relationship);
+    }
+  }
+  if (definition.integration) {
+    const integrationDef = definition.integration;
+    const parsedIntegration = {
+      electric: integrationDef.electric ?? false
+    };
+    if (integrationDef.providers) {
+      parsedIntegration.providers = {};
+      for (const [providerName, providerDef] of Object.entries(integrationDef.providers)) {
+        const parsedProvider = {
+          remoteEntity: providerDef.remote_entity,
+          direction: providerDef.direction,
+          cdc: providerDef.cdc ?? false
+        };
+        if (providerDef.field_mapping) {
+          parsedProvider.fieldMapping = providerDef.field_mapping;
+        }
+        if (providerDef.read_only_fields) {
+          parsedProvider.readOnlyFields = providerDef.read_only_fields;
+        }
+        parsedIntegration.providers[providerName] = parsedProvider;
+      }
+    }
+    entity.integration = parsedIntegration;
+  }
+  if (definition.events) {
+    entity.events = definition.events.map((ev) => ({
+      name: ev.name,
+      queue: ev.queue,
+      body: ev.body,
+      generateHandler: ev.generate_handler
+    }));
+  }
+  if (definition.emits !== void 0) {
+    entity.emits = definition.emits;
+  }
+  return entity;
+}
+function parseForeignKey(fk) {
+  const [table, column] = fk.split(".");
+  return { table, column: column ?? "id" };
+}
+function loadErrorToIssue(error) {
+  const issues = [];
+  issues.push({
+    severity: "error",
+    type: "parse_error",
+    message: error.error,
+    path: error.filePath
+  });
+  if (error.details) {
+    for (const detail of error.details) {
+      issues.push({
+        severity: "error",
+        type: "schema_error",
+        message: detail,
+        path: error.filePath
+      });
+    }
+  }
+  return issues;
+}
+function loadEntities(entitiesDir, opts) {
+  const entities = [];
+  const issues = [];
+  const resolvedDir = resolve2(entitiesDir);
+  let files;
+  try {
+    files = findYamlFiles(resolvedDir, { excludeDirs: opts?.excludeDirs });
+  } catch (err) {
+    issues.push({
+      severity: "error",
+      type: "parse_error",
+      message: `Failed to read directory: ${resolvedDir}`,
+      path: resolvedDir
+    });
+    return { entities, issues };
+  }
+  if (files.length === 0) {
+    issues.push({
+      severity: "warning",
+      type: "no_files",
+      message: `No YAML files found in directory: ${resolvedDir}`,
+      path: resolvedDir
+    });
+    return { entities, issues };
+  }
+  for (const filePath of files) {
+    const result = loadEntityFromYaml(filePath);
+    if (result.success) {
+      entities.push(transformToEntity(result));
+    } else {
+      issues.push(...loadErrorToIssue(result));
+    }
+  }
+  return { entities, issues };
+}
+function resolveReferences(entities) {
+  const issues = [];
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    if (entityMap.has(entity.name)) {
+      issues.push({
+        severity: "error",
+        type: "duplicate_entity",
+        entity: entity.name,
+        message: `Duplicate entity name: ${entity.name}`,
+        path: entity.sourcePath
+      });
+    }
+    entityMap.set(entity.name, entity);
+  }
+  for (const entity of entities) {
+    for (const [relName, rel] of entity.relationships) {
+      const targetEntity = entityMap.get(rel.target);
+      if (targetEntity) {
+        rel.resolved = true;
+      } else {
+        issues.push({
+          severity: "error",
+          type: "missing_target",
+          entity: entity.name,
+          field: relName,
+          message: `Relationship '${relName}' references unknown entity '${rel.target}'`,
+          path: entity.sourcePath,
+          suggestion: `Define entity '${rel.target}' or fix the target name`
+        });
+      }
+    }
+    for (const [fieldName, field] of entity.fields) {
+      if (field.foreignKey) {
+        const targetTable = field.foreignKey.table;
+        const targetEntity = Array.from(entityMap.values()).find(
+          (e) => e.table === targetTable
+        );
+        if (!targetEntity) {
+          issues.push({
+            severity: "warning",
+            type: "missing_fk_target",
+            entity: entity.name,
+            field: fieldName,
+            message: `Foreign key references unknown table '${targetTable}'`,
+            path: entity.sourcePath,
+            suggestion: `Define entity with table '${targetTable}' or fix the foreign_key reference`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function transformToRelationshipDefinition(result) {
+  const { definition, filePath } = result;
+  const config = definition.relationship;
+  const { fromColumn, toColumn } = deriveRelationshipFKColumns(config);
+  const table = deriveTableName(config);
+  const uniqueOn = deriveUniqueConstraint(config);
+  const types = resolveTypeDirections(config.types);
+  const fields = /* @__PURE__ */ new Map();
+  if (definition.fields) {
+    for (const [name, fieldDef] of Object.entries(definition.fields)) {
+      const field = {
+        name,
+        type: fieldDef.type,
+        required: fieldDef.required ?? false,
+        nullable: fieldDef.nullable ?? false,
+        unique: fieldDef.unique ?? false,
+        index: fieldDef.index ?? false,
+        foreignKey: fieldDef.foreign_key ? parseForeignKey(fieldDef.foreign_key) : void 0,
+        choices: fieldDef.choices,
+        constraints: {
+          minLength: fieldDef.min_length,
+          maxLength: fieldDef.max_length,
+          min: fieldDef.min,
+          max: fieldDef.max
+        },
+        ui: {
+          label: fieldDef.ui_label,
+          type: fieldDef.ui_type,
+          importance: fieldDef.ui_importance,
+          group: fieldDef.ui_group,
+          sortable: fieldDef.ui_sortable,
+          filterable: fieldDef.ui_filterable,
+          visible: fieldDef.ui_visible
+        }
+      };
+      fields.set(name, field);
+    }
+  }
+  const queries = definition.queries?.filter((q) => "by" in q).map((q) => ({
+    by: q.by,
+    unique: q.unique,
+    select: q.select,
+    order: q.order,
+    limit: q.limit
+  }));
+  return {
+    name: config.name,
+    table,
+    from: config.from,
+    to: config.to,
+    selfReferential: config.from === config.to,
+    fromColumn,
+    toColumn,
+    types,
+    hasTypes: types.length > 0,
+    temporal: config.temporal,
+    sourced: config.sourced,
+    onDeleteFrom: config.on_delete_from ?? "restrict",
+    onDeleteTo: config.on_delete_to ?? "restrict",
+    uniqueOn,
+    fields,
+    queries,
+    sourcePath: filePath
+  };
+}
+function resolveTypeDirections(types) {
+  if (!types) return [];
+  if (Array.isArray(types)) {
+    return types.map((name) => ({
+      name,
+      bidirectional: false,
+      directed: true
+    }));
+  }
+  return Object.entries(types).map(([name, dir]) => {
+    const direction = dir;
+    return {
+      name,
+      inverse: direction.inverse,
+      bidirectional: direction.bidirectional ?? false,
+      directed: direction.directed ?? (!direction.bidirectional && !direction.inverse)
+    };
+  });
+}
+function loadRelationships(relationshipsDir) {
+  const relationships = [];
+  const issues = [];
+  const resolvedDir = resolve2(relationshipsDir);
+  let files;
+  try {
+    files = findYamlFiles(resolvedDir);
+  } catch {
+    return { relationships, issues };
+  }
+  if (files.length === 0) {
+    return { relationships, issues };
+  }
+  for (const filePath of files) {
+    const result = loadRelationshipFromYaml(filePath);
+    if (result.success) {
+      relationships.push(transformToRelationshipDefinition(result));
+    } else {
+      issues.push(...loadErrorToIssue(result));
+    }
+  }
+  return { relationships, issues };
+}
+function resolveRelationshipReferences(relationshipDefs, entities) {
+  const issues = [];
+  const entityNames = new Set(entities.map((e) => e.name));
+  for (const relDef of relationshipDefs) {
+    if (!entityNames.has(relDef.from)) {
+      issues.push({
+        severity: "warning",
+        type: "missing_relationship_endpoint",
+        entity: relDef.name,
+        message: `Relationship '${relDef.name}' references unknown 'from' entity '${relDef.from}'`,
+        path: relDef.sourcePath,
+        suggestion: `Define entity '${relDef.from}' or fix the 'from' value`
+      });
+    }
+    if (!entityNames.has(relDef.to)) {
+      issues.push({
+        severity: "warning",
+        type: "missing_relationship_endpoint",
+        entity: relDef.name,
+        message: `Relationship '${relDef.name}' references unknown 'to' entity '${relDef.to}'`,
+        path: relDef.sourcePath,
+        suggestion: `Define entity '${relDef.to}' or fix the 'to' value`
+      });
+    }
+    const dupes = relationshipDefs.filter((r) => r.name === relDef.name);
+    if (dupes.length > 1) {
+      issues.push({
+        severity: "error",
+        type: "duplicate_relationship",
+        entity: relDef.name,
+        message: `Duplicate relationship name: ${relDef.name}`,
+        path: relDef.sourcePath
+      });
+    }
+  }
+  return issues;
+}
+
+// src/parser/validate-providers.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { isAbsolute, join as join2, resolve as resolve3 } from "path";
+import ts from "typescript";
+function collectEntitySurfaces(entities) {
+  const surfaces = /* @__PURE__ */ new Set();
+  for (const e of entities) {
+    if (e.entity.surface) surfaces.add(e.entity.surface);
+  }
+  return surfaces;
+}
+function resolveImportRef(ref, opts) {
+  const { path: path2, exportName } = parseImportRef(ref);
+  const file = resolveModuleFile(path2, opts);
+  if (!file) {
+    return { status: "module-not-found", resolvedFrom: opts.sourceRoot };
+  }
+  const content = readFileSync2(file, "utf-8");
+  const { names, hasWildcard } = collectExportedNames(file, content);
+  if (names.has(exportName) || hasWildcard) {
+    return { status: "ok", file };
+  }
+  return { status: "export-not-found", file };
+}
+function resolveModuleFile(importPath, opts) {
+  let base = null;
+  for (const [alias, target] of Object.entries(opts.aliases ?? {})) {
+    if (importPath === alias || importPath.startsWith(`${alias}/`)) {
+      const rest = importPath.slice(alias.length);
+      base = join2(target, rest);
+      break;
+    }
+  }
+  if (base === null) {
+    base = isAbsolute(importPath) ? importPath : resolve3(opts.sourceRoot, importPath);
+  }
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    join2(base, "index.ts"),
+    join2(base, "index.tsx")
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c) && statSync(c).isFile()) return c;
+  }
+  return null;
+}
+function collectExportedNames(fileName, content) {
+  const sf = ts.createSourceFile(
+    fileName,
+    content,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    true
+  );
+  const names = /* @__PURE__ */ new Set();
+  let hasWildcard = false;
+  const hasExportModifier = (node) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+  sf.forEachChild((node) => {
+    if (hasExportModifier(node)) {
+      if ((ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) && node.name && ts.isIdentifier(node.name)) {
+        names.add(node.name.text);
+      } else if (ts.isVariableStatement(node)) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name)) names.add(decl.name.text);
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node)) {
+      if (!node.exportClause) {
+        hasWildcard = true;
+      } else if (ts.isNamedExports(node.exportClause)) {
+        for (const el of node.exportClause.elements) names.add(el.name.text);
+      } else if (ts.isNamespaceExport(node.exportClause)) {
+        names.add(node.exportClause.name.text);
+      }
+    }
+  });
+  return { names, hasWildcard };
+}
+function validateProviders(providers, opts) {
+  const issues = [];
+  const knownSurfaces = new Set(opts.entitySurfaces);
+  const slugToFiles = /* @__PURE__ */ new Map();
+  for (const p of providers) {
+    const files = slugToFiles.get(p.definition.slug) ?? [];
+    files.push(p.filePath);
+    slugToFiles.set(p.definition.slug, files);
+  }
+  for (const [slug, files] of slugToFiles) {
+    if (files.length > 1) {
+      for (const file of files) {
+        const others = files.filter((f) => f !== file);
+        issues.push({
+          severity: "error",
+          type: "provider_duplicate_slug",
+          message: `provider slug '${slug}' is declared more than once (also in: ${others.join(", ")})`,
+          path: file
+        });
+      }
+    }
+  }
+  for (const { definition, filePath } of providers) {
+    const { slug } = definition;
+    for (const surface of definition.surfaces) {
+      if (!knownSurfaces.has(surface)) {
+        const known = [...knownSurfaces].sort().join(", ") || "(none declared)";
+        issues.push({
+          severity: "error",
+          type: "provider_unknown_surface",
+          message: `provider ${slug}: surface '${surface}' is not declared by any entity (known surfaces: ${known})`,
+          path: filePath
+        });
+      }
+    }
+    if (!opts.skipImportCheck) {
+      if (!opts.sourceRoot) {
+        throw new Error(
+          "validateProviders: sourceRoot is required for the import pre-flight check (or set skipImportCheck: true)"
+        );
+      }
+      const resolveOpts = {
+        sourceRoot: opts.sourceRoot,
+        aliases: opts.aliases
+      };
+      const refs = [
+        { field: "auth.strategy", ref: definition.auth.strategy },
+        { field: "client.class", ref: definition.client.class }
+      ];
+      for (const { field, ref } of refs) {
+        const result = resolveImportRef(ref, resolveOpts);
+        if (result.status === "module-not-found") {
+          issues.push({
+            severity: "error",
+            type: "provider_import_unresolved",
+            message: `provider ${slug}: ${field} '${ref}' not found \u2014 module could not be resolved from ${result.resolvedFrom}`,
+            path: filePath
+          });
+        } else if (result.status === "export-not-found") {
+          const { exportName } = parseImportRef(ref);
+          issues.push({
+            severity: "error",
+            type: "provider_import_unresolved",
+            message: `provider ${slug}: ${field} '${ref}' not found \u2014 export '${exportName}' is missing from ${result.file}`,
+            path: filePath
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+// src/analyzer/graph-builder.ts
+function inferCardinality(type) {
+  switch (type) {
+    case "belongs_to":
+      return "N:1";
+    case "has_many":
+      return "1:N";
+    case "has_one":
+      return "1:1";
+    default:
+      return "1:N";
+  }
+}
+function hasReverseEdge(edges, from, to) {
+  return edges.find((e) => e.from === to && e.to === from);
+}
+function buildDomainGraph(entities, relationshipDefinitions = []) {
+  const entityMap = /* @__PURE__ */ new Map();
+  const relDefMap = /* @__PURE__ */ new Map();
+  const edges = [];
+  for (const entity of entities) {
+    entityMap.set(entity.name, entity);
+  }
+  for (const relDef of relationshipDefinitions) {
+    relDefMap.set(relDef.name, relDef);
+  }
+  for (const entity of entities) {
+    for (const [relName, rel] of entity.relationships) {
+      if (!rel.resolved) continue;
+      const reverseEdge = hasReverseEdge(edges, entity.name, rel.target);
+      const edge = {
+        from: entity.name,
+        to: rel.target,
+        relationship: rel,
+        cardinality: inferCardinality(rel.type),
+        bidirectional: reverseEdge !== void 0
+      };
+      if (reverseEdge) {
+        reverseEdge.bidirectional = true;
+      }
+      edges.push(edge);
+    }
+  }
+  for (const relDef of relationshipDefinitions) {
+    const fromExists = entityMap.has(relDef.from);
+    const toExists = entityMap.has(relDef.to);
+    if (fromExists && toExists) {
+      const edge = {
+        from: relDef.from,
+        to: relDef.to,
+        relationship: {
+          name: relDef.name,
+          type: "has_many",
+          target: relDef.to,
+          foreignKey: relDef.fromColumn,
+          resolved: true
+        },
+        cardinality: "N:M",
+        bidirectional: relDef.types.some((t) => t.bidirectional)
+      };
+      edges.push(edge);
+    }
+  }
+  return { entities: entityMap, relationshipDefinitions: relDefMap, edges };
+}
+function getRelatedEntities(graph, entityName, depth = 1) {
+  const related = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [
+    { name: entityName, currentDepth: 0 }
+  ];
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (!item) continue;
+    const { name, currentDepth } = item;
+    if (visited.has(name) || currentDepth > depth) continue;
+    visited.add(name);
+    for (const edge of graph.edges) {
+      if (edge.from === name && !visited.has(edge.to)) {
+        related.add(edge.to);
+        queue.push({ name: edge.to, currentDepth: currentDepth + 1 });
+      }
+      if (edge.to === name && !visited.has(edge.from)) {
+        related.add(edge.from);
+        queue.push({ name: edge.from, currentDepth: currentDepth + 1 });
+      }
+    }
+  }
+  return related;
+}
+function findOrphanEntities(graph) {
+  const orphans = [];
+  for (const [name] of graph.entities) {
+    const hasRelationship = graph.edges.some((e) => e.from === name || e.to === name);
+    if (!hasRelationship) {
+      orphans.push(name);
+    }
+  }
+  return orphans;
+}
+function findCircularDependencies(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(node, path2) {
+    visited.add(node);
+    recursionStack.add(node);
+    const outgoingEdges = graph.edges.filter((e) => e.from === node);
+    for (const edge of outgoingEdges) {
+      if (!visited.has(edge.to)) {
+        dfs(edge.to, [...path2, edge.to]);
+      } else if (recursionStack.has(edge.to)) {
+        const cycleStart = path2.indexOf(edge.to);
+        if (cycleStart !== -1) {
+          cycles.push([...path2.slice(cycleStart), edge.to]);
+        } else {
+          cycles.push([...path2, edge.to]);
+        }
+      }
+    }
+    recursionStack.delete(node);
+  }
+  for (const [name] of graph.entities) {
+    if (!visited.has(name)) {
+      dfs(name, [name]);
+    }
+  }
+  const uniqueCycles = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const cycle of cycles) {
+    const minIndex = cycle.indexOf(
+      cycle.reduce((min, val) => val < min ? val : min, cycle[0])
+    );
+    const normalized = [...cycle.slice(minIndex), ...cycle.slice(0, minIndex)];
+    const key = normalized.join("->");
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueCycles.push(cycle);
+    }
+  }
+  return uniqueCycles;
+}
+
+// src/behaviors/external-id-tracking.ts
+var externalIdTrackingBehavior = {
+  name: "external_id_tracking",
+  description: "Adds external_id, provider, and provider_metadata fields for external system sync tracking",
+  fields: [
+    {
+      name: "external_id",
+      camelName: "externalId",
+      type: "string",
+      tsType: "string | null",
+      drizzleType: "varchar",
+      drizzleImports: ["varchar", "index"],
+      zodType: "z.string().nullable()",
+      nullable: true,
+      ui: {
+        label: "External ID",
+        type: "text",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "provider",
+      camelName: "provider",
+      type: "string",
+      tsType: "string | null",
+      drizzleType: "varchar",
+      drizzleImports: ["varchar"],
+      zodType: "z.string().nullable()",
+      nullable: true,
+      ui: {
+        label: "Provider",
+        type: "text",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "provider_metadata",
+      camelName: "providerMetadata",
+      type: "json",
+      tsType: "unknown | null",
+      drizzleType: "jsonb",
+      drizzleImports: ["jsonb"],
+      zodType: "z.unknown().nullable()",
+      nullable: true,
+      ui: {
+        label: "Provider Metadata",
+        type: "json",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["varchar", "jsonb", "index"],
+  configKey: "externalIdTracking"
+};
+
+// src/behaviors/soft-delete.ts
+var softDeleteBehavior = {
+  name: "soft_delete",
+  description: "Adds deleted_at field for soft delete functionality",
+  fields: [
+    {
+      name: "deleted_at",
+      camelName: "deletedAt",
+      type: "datetime",
+      tsType: "Date | null",
+      drizzleType: "timestamp",
+      drizzleImports: ["timestamp"],
+      zodType: "z.coerce.date().nullable()",
+      nullable: true,
+      ui: {
+        label: "Deleted At",
+        type: "datetime",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["timestamp"],
+  methods: [
+    "softDelete",
+    "restore",
+    "findWithDeleted",
+    "findOnlyDeleted",
+    "baseQuery"
+    // Modified to filter deleted records
+  ],
+  configKey: "softDelete"
+};
+
+// src/behaviors/timestamps.ts
+var timestampsBehavior = {
+  name: "timestamps",
+  description: "Adds created_at and updated_at timestamp fields",
+  fields: [
+    {
+      name: "created_at",
+      camelName: "createdAt",
+      type: "datetime",
+      tsType: "Date",
+      drizzleType: "timestamp",
+      drizzleImports: ["timestamp"],
+      zodType: "z.coerce.date()",
+      nullable: false,
+      default: "now()",
+      ui: {
+        label: "Created At",
+        type: "datetime",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "updated_at",
+      camelName: "updatedAt",
+      type: "datetime",
+      tsType: "Date",
+      drizzleType: "timestamp",
+      drizzleImports: ["timestamp"],
+      zodType: "z.coerce.date()",
+      nullable: false,
+      default: "now()",
+      ui: {
+        label: "Updated At",
+        type: "datetime",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["timestamp"],
+  methods: ["applyTimestampsOnCreate", "applyTimestampsOnUpdate"],
+  configKey: "timestamps"
+};
+
+// src/behaviors/user-tracking.ts
+var userTrackingBehavior = {
+  name: "user_tracking",
+  description: "Adds created_by and updated_by user reference fields",
+  fields: [
+    {
+      name: "created_by",
+      camelName: "createdBy",
+      type: "uuid",
+      tsType: "string | null",
+      drizzleType: "uuid",
+      drizzleImports: ["uuid"],
+      zodType: "z.string().uuid().nullable()",
+      nullable: true,
+      foreignKey: "users.id",
+      ui: {
+        label: "Created By",
+        type: "reference",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    },
+    {
+      name: "updated_by",
+      camelName: "updatedBy",
+      type: "uuid",
+      tsType: "string | null",
+      drizzleType: "uuid",
+      drizzleImports: ["uuid"],
+      zodType: "z.string().uuid().nullable()",
+      nullable: true,
+      foreignKey: "users.id",
+      ui: {
+        label: "Updated By",
+        type: "reference",
+        importance: "tertiary",
+        group: "metadata",
+        visible: false
+      }
+    }
+  ],
+  drizzleImports: ["uuid"],
+  methods: ["applyUserTrackingOnCreate", "applyUserTrackingOnUpdate"],
+  configKey: "userTracking"
+};
+
+// src/behaviors/index.ts
+var behaviorRegistry = /* @__PURE__ */ new Map([
+  ["timestamps", timestampsBehavior],
+  ["soft_delete", softDeleteBehavior],
+  ["user_tracking", userTrackingBehavior],
+  ["external_id_tracking", externalIdTrackingBehavior]
+]);
+function getBehavior(name) {
+  return behaviorRegistry.get(name);
+}
+function normalizeBehaviorConfig(config) {
+  if (typeof config === "string") {
+    return { name: config, options: {} };
+  }
+  return { name: config.name, options: config.options ?? {} };
+}
+function normalizeBehaviorConfigs(configs) {
+  return configs.map(normalizeBehaviorConfig);
+}
+function resolveBehaviorFields(configs) {
+  const normalized = normalizeBehaviorConfigs(configs);
+  const fields = [];
+  const addedFieldNames = /* @__PURE__ */ new Set();
+  for (const config of normalized) {
+    const behavior = getBehavior(config.name);
+    if (!behavior) continue;
+    for (const field of behavior.fields) {
+      if (!addedFieldNames.has(field.name)) {
+        fields.push(field);
+        addedFieldNames.add(field.name);
+      }
+    }
+  }
+  return fields;
+}
+
+// src/analyzer/consistency-checker.ts
+function checkConsistency(graph) {
+  const issues = [];
+  for (const [name, entity] of graph.entities) {
+    issues.push(...checkEntityConsistency(entity));
+    issues.push(...checkRelationshipConsistency(entity, graph));
+    issues.push(...checkNamingConventions(entity));
+    issues.push(...checkMissingIndexes(entity));
+    issues.push(...checkUiMetadata(entity));
+    if (entity.queries !== void 0) {
+      issues.push(...checkQueryFieldReferences(entity));
+    }
+    if (entity.integration !== void 0) {
+      issues.push(...checkIntegrationFieldMappingReferences(entity));
+      issues.push(...checkExternalIdTrackingCollision(entity));
+    }
+  }
+  issues.push(...checkOrphanEntities(graph));
+  issues.push(...checkCircularReferences(graph));
+  issues.push(...checkMissingInverses(graph));
+  return issues;
+}
+function checkEntityConsistency(entity) {
+  const issues = [];
+  if (!entity.fields.has("id")) {
+    issues.push({
+      severity: "info",
+      type: "missing_id",
+      entity: entity.name,
+      message: 'Entity missing standard "id" field',
+      suggestion: 'Add an "id" field with type "uuid"'
+    });
+  }
+  const hasCreatedAt = entity.fields.has("created_at");
+  const hasTimestampsBehavior = entity.behaviors.includes("timestamps");
+  if (!hasCreatedAt && !hasTimestampsBehavior) {
+    issues.push({
+      severity: "info",
+      type: "missing_timestamps",
+      entity: entity.name,
+      message: 'Entity missing "created_at" field and "timestamps" behavior',
+      suggestion: 'Add "timestamps" to behaviors or add created_at/updated_at fields'
+    });
+  }
+  return issues;
+}
+function checkRelationshipConsistency(entity, graph) {
+  const issues = [];
+  for (const [relName, rel] of entity.relationships) {
+    if (rel.type === "belongs_to") {
+      const fkField = entity.fields.get(rel.foreignKey);
+      if (!fkField) {
+        issues.push({
+          severity: "warning",
+          type: "missing_fk_field",
+          entity: entity.name,
+          field: relName,
+          message: `Relationship "${relName}" references foreign key "${rel.foreignKey}" but field doesn't exist`,
+          suggestion: `Add field "${rel.foreignKey}" with foreign_key reference`
+        });
+      }
+    }
+    if (rel.type === "has_many" || rel.type === "has_one") {
+      const targetEntity = graph.entities.get(rel.target);
+      if (targetEntity) {
+        const targetFkField = targetEntity.fields.get(rel.foreignKey);
+        if (!targetFkField) {
+          issues.push({
+            severity: "warning",
+            type: "missing_target_fk",
+            entity: entity.name,
+            field: relName,
+            message: `Relationship "${relName}" expects foreign key "${rel.foreignKey}" on "${rel.target}" but field doesn't exist`,
+            suggestion: `Add field "${rel.foreignKey}" to "${rel.target}" entity`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkNamingConventions(entity) {
+  const issues = [];
+  if (entity.name !== entity.name.toLowerCase()) {
+    issues.push({
+      severity: "warning",
+      type: "naming_convention",
+      entity: entity.name,
+      message: "Entity name should be lowercase",
+      suggestion: `Use "${entity.name.toLowerCase()}"`
+    });
+  }
+  for (const [fieldName] of entity.fields) {
+    if (fieldName !== fieldName.toLowerCase()) {
+      issues.push({
+        severity: "warning",
+        type: "naming_convention",
+        entity: entity.name,
+        field: fieldName,
+        message: "Field name should be snake_case",
+        suggestion: `Use "${toSnakeCase(fieldName)}"`
+      });
+    }
+  }
+  for (const [relName] of entity.relationships) {
+    if (relName !== relName.toLowerCase()) {
+      issues.push({
+        severity: "warning",
+        type: "naming_convention",
+        entity: entity.name,
+        field: relName,
+        message: "Relationship name should be snake_case",
+        suggestion: `Use "${toSnakeCase(relName)}"`
+      });
+    }
+  }
+  return issues;
+}
+function checkMissingIndexes(entity) {
+  const issues = [];
+  for (const [fieldName, field] of entity.fields) {
+    if (field.ui.filterable && !field.index && !field.unique) {
+      issues.push({
+        severity: "warning",
+        type: "missing_index",
+        entity: entity.name,
+        field: fieldName,
+        message: `Field "${fieldName}" is filterable but has no index`,
+        suggestion: 'Add "index: true" to improve query performance'
+      });
+    }
+    if (field.foreignKey && !field.index && !field.unique) {
+      issues.push({
+        severity: "info",
+        type: "missing_fk_index",
+        entity: entity.name,
+        field: fieldName,
+        message: `Foreign key field "${fieldName}" has no index`,
+        suggestion: 'Add "index: true" for better join performance'
+      });
+    }
+  }
+  return issues;
+}
+function checkUiMetadata(entity) {
+  const issues = [];
+  const systemFields = /* @__PURE__ */ new Set(["id", "created_at", "updated_at", "deleted_at", "tenant_id"]);
+  for (const [fieldName, field] of entity.fields) {
+    if (systemFields.has(fieldName)) continue;
+    const hasAnyUiMeta = field.ui.label !== void 0 || field.ui.type !== void 0 || field.ui.group !== void 0;
+    if (!hasAnyUiMeta) {
+      issues.push({
+        severity: "info",
+        type: "missing_ui_metadata",
+        entity: entity.name,
+        field: fieldName,
+        message: `Field "${fieldName}" has no UI metadata`,
+        suggestion: "Add ui_label, ui_type, ui_group for better admin panel display"
+      });
+    }
+  }
+  return issues;
+}
+function checkOrphanEntities(graph) {
+  const orphans = findOrphanEntities(graph);
+  return orphans.map((name) => ({
+    severity: "info",
+    type: "orphan_entity",
+    entity: name,
+    message: `Entity "${name}" has no relationships to other entities`,
+    suggestion: "Consider if this entity should be related to others"
+  }));
+}
+function checkCircularReferences(graph) {
+  const cycles = findCircularDependencies(graph);
+  return cycles.map((cycle) => ({
+    severity: "info",
+    type: "circular_dependency",
+    entity: cycle[0],
+    message: `Circular reference detected: ${cycle.join(" -> ")}`,
+    suggestion: "Verify this is intentional (e.g., self-referential hierarchy)"
+  }));
+}
+function checkMissingInverses(graph) {
+  const issues = [];
+  for (const edge of graph.edges) {
+    const { from, to, relationship } = edge;
+    const targetEntity = graph.entities.get(to);
+    if (!targetEntity) continue;
+    const hasInverse = Array.from(targetEntity.relationships.values()).some(
+      (rel) => rel.target === from
+    );
+    if (!hasInverse && relationship.type !== "belongs_to") {
+      issues.push({
+        severity: "info",
+        type: "missing_inverse",
+        entity: from,
+        field: relationship.name,
+        message: `Relationship "${relationship.name}" to "${to}" has no inverse defined on target`,
+        suggestion: `Add inverse relationship on "${to}" pointing back to "${from}"`
+      });
+    }
+  }
+  return issues;
+}
+function getAvailableFieldNames(entity) {
+  const entityFieldNames = Array.from(entity.fields.keys());
+  const behaviorFields = resolveBehaviorFields(entity.behaviors);
+  const behaviorFieldNames = behaviorFields.map((f) => f.name);
+  const belongsToFkNames = [];
+  for (const rel of entity.relationships.values()) {
+    if (rel.type === "belongs_to" && rel.foreignKey) {
+      belongsToFkNames.push(rel.foreignKey);
+    }
+  }
+  return [.../* @__PURE__ */ new Set([...entityFieldNames, ...behaviorFieldNames, ...belongsToFkNames])];
+}
+function checkQueryFieldReferences(entity) {
+  const issues = [];
+  const availableFields = getAvailableFieldNames(entity);
+  const availableSet = new Set(availableFields);
+  for (const query of entity.queries ?? []) {
+    if (!query.via) {
+      for (const fieldName of query.by) {
+        if (!availableSet.has(fieldName)) {
+          issues.push({
+            severity: "error",
+            type: "unknown_query_field",
+            entity: entity.name,
+            field: fieldName,
+            message: `Query references unknown field "${fieldName}" in entity "${entity.name}". Available fields: ${availableFields.join(", ")}`
+          });
+        }
+      }
+    }
+    for (const fieldName of query.select ?? []) {
+      if (!availableSet.has(fieldName)) {
+        issues.push({
+          severity: "error",
+          type: "unknown_query_field",
+          entity: entity.name,
+          field: fieldName,
+          message: `Query references unknown field "${fieldName}" in entity "${entity.name}". Available fields: ${availableFields.join(", ")}`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkIntegrationFieldMappingReferences(entity) {
+  const issues = [];
+  const availableFields = getAvailableFieldNames(entity);
+  const availableSet = new Set(availableFields);
+  for (const [providerName, provider] of Object.entries(entity.integration?.providers ?? {})) {
+    for (const fieldName of Object.keys(provider.fieldMapping ?? {})) {
+      if (!availableSet.has(fieldName)) {
+        issues.push({
+          severity: "warning",
+          type: "unknown_integration_field_mapping",
+          entity: entity.name,
+          field: fieldName,
+          message: `Integration field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+        });
+      }
+    }
+    for (const fieldName of provider.readOnlyFields ?? []) {
+      if (!availableSet.has(fieldName)) {
+        issues.push({
+          severity: "warning",
+          type: "unknown_integration_field_mapping",
+          entity: entity.name,
+          field: fieldName,
+          message: `Integration field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkExternalIdTrackingCollision(entity) {
+  const issues = [];
+  const hasExternalIdTracking = entity.behaviors.includes("external_id_tracking");
+  if (!hasExternalIdTracking) return issues;
+  for (const [providerName, provider] of Object.entries(entity.integration?.providers ?? {})) {
+    if (provider.fieldMapping && "external_id" in provider.fieldMapping) {
+      issues.push({
+        severity: "warning",
+        type: "external_id_tracking_collision",
+        entity: entity.name,
+        field: "external_id",
+        message: `Entity "${entity.name}" has external_id_tracking behavior and also maps "external_id" in integration field_mapping for provider "${providerName}". The behavior-added field may collide with the mapped field.`
+      });
+    }
+  }
+  return issues;
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+
+// src/analyzer/statistics.ts
+function computeStatistics(graph) {
+  const entities = Array.from(graph.entities.values());
+  const fieldsByType = {};
+  const relationshipsByType = {};
+  let totalFields = 0;
+  let totalRelationships = 0;
+  let entitiesWithBehaviors = 0;
+  for (const entity of entities) {
+    totalFields += entity.fields.size;
+    totalRelationships += entity.relationships.size;
+    if (entity.behaviors.length > 0) {
+      entitiesWithBehaviors++;
+    }
+    for (const field of entity.fields.values()) {
+      fieldsByType[field.type] = (fieldsByType[field.type] ?? 0) + 1;
+    }
+    for (const rel of entity.relationships.values()) {
+      relationshipsByType[rel.type] = (relationshipsByType[rel.type] ?? 0) + 1;
+    }
+  }
+  return {
+    totalEntities: entities.length,
+    totalFields,
+    totalRelationships,
+    fieldsByType,
+    relationshipsByType,
+    entitiesWithBehaviors,
+    averageFieldsPerEntity: entities.length > 0 ? totalFields / entities.length : 0
+  };
+}
+
+// src/analyzer/transitive-suggester.ts
+var DEFAULT_OPTIONS = {
+  maxDepth: 3,
+  excludeEntities: ["workspace", "tenant"],
+  excludePatterns: [/_audit$/, /_log$/, /_history$/]
+};
+function suggestTransitiveRelationships(graph, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const suggestions = [];
+  for (const [entityName, entity] of graph.entities) {
+    if (shouldExcludeEntity(entityName, opts)) continue;
+    const paths = findTransitivePaths(graph, entityName, opts);
+    for (const path2 of paths) {
+      suggestions.push(createSuggestion(path2));
+    }
+  }
+  return suggestions;
+}
+function shouldExcludeEntity(entityName, opts) {
+  if (opts.excludeEntities.includes(entityName)) {
+    return true;
+  }
+  for (const pattern of opts.excludePatterns) {
+    if (pattern.test(entityName)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findTransitivePaths(graph, sourceEntity, opts) {
+  const paths = [];
+  const sourceEntityData = graph.entities.get(sourceEntity);
+  if (!sourceEntityData) return paths;
+  const queue = [
+    {
+      entity: sourceEntity,
+      depth: 0,
+      path: [],
+      visited: /* @__PURE__ */ new Set([sourceEntity])
+    }
+  ];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) continue;
+    const { entity, depth, path: path2, visited } = current;
+    if (depth >= opts.maxDepth) continue;
+    const currentEntity = graph.entities.get(entity);
+    if (!currentEntity) continue;
+    for (const [relName, rel] of currentEntity.relationships) {
+      if (rel.through) continue;
+      if (rel.type !== "has_many" && rel.type !== "has_one") continue;
+      const target = rel.target;
+      if (shouldExcludeEntity(target, opts)) continue;
+      if (visited.has(target)) continue;
+      const newPath = [
+        ...path2,
+        {
+          via: entity,
+          relationship: relName,
+          foreignKey: rel.foreignKey
+        }
+      ];
+      if (depth >= 1) {
+        if (!hasDirectRelationship(sourceEntityData, target)) {
+          const transitivePath = buildTransitivePath(
+            sourceEntity,
+            target,
+            newPath
+          );
+          if (transitivePath) {
+            paths.push(transitivePath);
+          }
+        }
+      }
+      if (depth + 1 < opts.maxDepth) {
+        queue.push({
+          entity: target,
+          depth: depth + 1,
+          path: newPath,
+          visited: /* @__PURE__ */ new Set([...visited, target])
+        });
+      }
+    }
+  }
+  return paths;
+}
+function hasDirectRelationship(sourceEntity, targetName) {
+  for (const rel of sourceEntity.relationships.values()) {
+    if (rel.target === targetName && !rel.through) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildTransitivePath(source, target, hops) {
+  if (hops.length === 0) return null;
+  const throughPath = hops.map((hop) => hop.relationship).join(".");
+  const suggestedName = generateSemanticName(source, target, hops);
+  const yamlSnippet = generateYamlSnippet(suggestedName, target, throughPath);
+  return {
+    source,
+    target,
+    hops,
+    suggestedName,
+    throughPath,
+    yamlSnippet
+  };
+}
+function generateSemanticName(source, target, hops) {
+  const firstHop = hops[0].relationship;
+  if (hops.length === 2) {
+    const prefix = firstHop.replace(/s$/, "");
+    return `${prefix}_${target}`;
+  }
+  const parts = [firstHop.replace(/s$/, ""), target];
+  return parts.join("_");
+}
+function generateYamlSnippet(name, target, throughPath) {
+  return `  ${name}:
+    type: has_many
+    target: ${target}
+    through: "${throughPath}"`;
+}
+function createSuggestion(path2) {
+  const pathDescription = [path2.source, ...path2.hops.map((h) => h.via), path2.target].join(" -> ");
+  return {
+    severity: "info",
+    type: "transitive_suggestion",
+    entity: path2.source,
+    message: `Potential transitive relationship: ${pathDescription}`,
+    suggestion: `Add "${path2.suggestedName}" relationship via "${path2.throughPath}"`,
+    path: path2
+  };
+}
+
+// src/analyzer/manifest.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+var MANIFEST_FILE = "manifest.json";
+var MANIFEST_VERSION = 1;
+function getManifestDir() {
+  return process.env.CODEGEN_MANIFEST_DIR || ".codegen";
+}
+function getManifestPaths(projectRoot) {
+  const dir = join3(projectRoot, getManifestDir());
+  const file = join3(dir, MANIFEST_FILE);
+  return { dir, file };
+}
+async function computeEntityFilesHash(entitiesDir) {
+  if (!existsSync3(entitiesDir)) {
+    return createHash("sha256").update("").digest("hex");
+  }
+  const yamlFiles = [];
+  function walkDir(dir) {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry);
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        walkDir(fullPath);
+      } else if (stat.isFile() && (entry.endsWith(".yaml") || entry.endsWith(".yml"))) {
+        yamlFiles.push(fullPath);
+      }
+    }
+  }
+  walkDir(entitiesDir);
+  yamlFiles.sort();
+  const hash = createHash("sha256");
+  for (const file of yamlFiles) {
+    const content = readFileSync3(file, "utf-8");
+    hash.update(file);
+    hash.update(content);
+  }
+  return hash.digest("hex");
+}
+function readManifest(projectRoot) {
+  const { file } = getManifestPaths(projectRoot);
+  if (!existsSync3(file)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(file, "utf-8");
+    const manifest = JSON.parse(content);
+    if (manifest.version !== MANIFEST_VERSION) {
+      return null;
+    }
+    return manifest;
+  } catch (error) {
+    return null;
+  }
+}
+function writeManifest(projectRoot, manifest) {
+  const { dir, file } = getManifestPaths(projectRoot);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const content = JSON.stringify(manifest, null, 2);
+  writeFileSync(file, content, "utf-8");
+}
+async function isManifestStale(projectRoot, entitiesDir) {
+  const manifest = readManifest(projectRoot);
+  if (!manifest) {
+    return true;
+  }
+  const currentHash = await computeEntityFilesHash(entitiesDir);
+  return manifest.entityFilesHash !== currentHash;
+}
+function toManifestEntity(entity) {
+  const fields = {};
+  for (const [name, field] of entity.fields) {
+    fields[name] = {
+      name: field.name,
+      type: field.type,
+      required: field.required,
+      nullable: field.nullable,
+      unique: field.unique,
+      index: field.index,
+      foreignKey: field.foreignKey,
+      choices: field.choices
+    };
+  }
+  const relationships = {};
+  for (const [name, rel] of entity.relationships) {
+    relationships[name] = {
+      type: rel.type,
+      target: rel.target,
+      foreignKey: rel.foreignKey,
+      through: rel.through,
+      inverse: rel.inverse
+    };
+  }
+  return {
+    sourcePath: entity.sourcePath,
+    table: entity.table,
+    plural: entity.plural,
+    fields,
+    relationships,
+    behaviors: entity.behaviors
+  };
+}
+function mergeSuggestions(newSuggestions, existingManifest) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingSuggestions = existingManifest?.suggestions.transitive || [];
+  const existingMap = /* @__PURE__ */ new Map();
+  for (const existing of existingSuggestions) {
+    existingMap.set(existing.id, existing);
+  }
+  const merged = [];
+  for (const suggestion of newSuggestions) {
+    const id = `${suggestion.path.source}->${suggestion.path.target}`;
+    const existing = existingMap.get(id);
+    if (existing) {
+      merged.push({
+        id,
+        source: suggestion.path.source,
+        target: suggestion.path.target,
+        throughPath: suggestion.path.throughPath,
+        suggestedName: suggestion.path.suggestedName,
+        yamlSnippet: suggestion.path.yamlSnippet,
+        status: existing.status,
+        // Preserve status
+        detectedAt: existing.detectedAt,
+        // Preserve original detection time
+        resolvedAt: existing.resolvedAt
+      });
+      existingMap.delete(id);
+    } else {
+      merged.push({
+        id,
+        source: suggestion.path.source,
+        target: suggestion.path.target,
+        throughPath: suggestion.path.throughPath,
+        suggestedName: suggestion.path.suggestedName,
+        yamlSnippet: suggestion.path.yamlSnippet,
+        status: "pending",
+        detectedAt: now
+      });
+    }
+  }
+  for (const [id, existing] of existingMap) {
+    if (existing.status !== "pending") {
+      merged.push(existing);
+    }
+  }
+  return merged;
+}
+async function buildManifest(analysis, transitiveSuggestions, entitiesDir, existingManifest) {
+  const entities = {};
+  for (const entity of analysis.entities) {
+    entities[entity.name] = toManifestEntity(entity);
+  }
+  const orphans = findOrphanEntities(analysis.graph);
+  const cycles = findCircularDependencies(analysis.graph);
+  const mergedSuggestions = mergeSuggestions(transitiveSuggestions, existingManifest);
+  const entityFilesHash = await computeEntityFilesHash(entitiesDir);
+  const manifest = {
+    version: MANIFEST_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entityFilesHash,
+    entities,
+    graph: {
+      edges: analysis.graph.edges.map((edge) => ({
+        from: edge.from,
+        to: edge.to,
+        relationship: edge.relationship.name,
+        cardinality: edge.cardinality === "N:M" ? "1:N" : edge.cardinality,
+        bidirectional: edge.bidirectional
+      })),
+      orphans,
+      cycles
+    },
+    suggestions: {
+      transitive: mergedSuggestions
+    },
+    statistics: {
+      totalEntities: analysis.statistics.totalEntities,
+      totalFields: analysis.statistics.totalFields,
+      totalRelationships: analysis.statistics.totalRelationships,
+      transitivePathsDetected: transitiveSuggestions.length
+    }
+  };
+  return manifest;
+}
+function updateSuggestionStatus(projectRoot, suggestionId, status) {
+  const manifest = readManifest(projectRoot);
+  if (!manifest) {
+    return false;
+  }
+  const suggestion = manifest.suggestions.transitive.find((s) => s.id === suggestionId);
+  if (!suggestion) {
+    return false;
+  }
+  suggestion.status = status;
+  suggestion.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeManifest(projectRoot, manifest);
+  return true;
+}
+function updateAllSuggestionStatus(projectRoot, status) {
+  const manifest = readManifest(projectRoot);
+  if (!manifest) {
+    return 0;
+  }
+  let count = 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const suggestion of manifest.suggestions.transitive) {
+    if (suggestion.status === "pending") {
+      suggestion.status = status;
+      suggestion.resolvedAt = now;
+      count++;
+    }
+  }
+  if (count > 0) {
+    writeManifest(projectRoot, manifest);
+  }
+  return count;
+}
+function getPendingSuggestions(projectRoot) {
+  const manifest = readManifest(projectRoot);
+  if (!manifest) {
+    return [];
+  }
+  return manifest.suggestions.transitive.filter((s) => s.status === "pending");
+}
+
+// src/analyzer/serialize-graph.ts
+function serializeFields(fields) {
+  const result = {};
+  for (const [key, f] of fields) {
+    result[key] = {
+      name: f.name,
+      type: f.type,
+      required: f.required,
+      nullable: f.nullable,
+      unique: f.unique,
+      index: f.index,
+      foreignKey: f.foreignKey,
+      choices: f.choices
+    };
+  }
+  return result;
+}
+function serializeRelationships(rels) {
+  const result = {};
+  for (const [key, r] of rels) {
+    result[key] = {
+      name: r.name,
+      type: r.type,
+      target: r.target,
+      foreignKey: r.foreignKey,
+      inverse: r.inverse,
+      through: r.through,
+      resolved: r.resolved
+    };
+  }
+  return result;
+}
+function serializeDomainGraph(graph) {
+  const entities = {};
+  for (const [key, entity] of graph.entities) {
+    entities[key] = {
+      name: entity.name,
+      plural: entity.plural,
+      table: entity.table,
+      pattern: entity.pattern,
+      patterns: entity.patterns,
+      patternConfig: entity.patternConfig,
+      fields: serializeFields(entity.fields),
+      relationships: serializeRelationships(entity.relationships),
+      behaviors: entity.behaviors,
+      queries: entity.queries?.map((q) => ({
+        by: q.by,
+        unique: q.unique,
+        order: q.order
+      })),
+      sourcePath: entity.sourcePath
+    };
+  }
+  const relationshipDefinitions = {};
+  for (const [key, relDef] of graph.relationshipDefinitions) {
+    relationshipDefinitions[key] = {
+      name: relDef.name,
+      table: relDef.table,
+      from: relDef.from,
+      to: relDef.to,
+      selfReferential: relDef.selfReferential,
+      fromColumn: relDef.fromColumn,
+      toColumn: relDef.toColumn,
+      types: relDef.types,
+      hasTypes: relDef.hasTypes,
+      temporal: relDef.temporal,
+      sourced: relDef.sourced,
+      onDeleteFrom: relDef.onDeleteFrom,
+      onDeleteTo: relDef.onDeleteTo,
+      uniqueOn: relDef.uniqueOn,
+      fields: serializeFields(relDef.fields),
+      queries: relDef.queries?.map((q) => ({
+        by: q.by,
+        unique: q.unique,
+        order: q.order
+      })),
+      sourcePath: relDef.sourcePath
+    };
+  }
+  return {
+    entities,
+    relationshipDefinitions,
+    edges: graph.edges.map((e) => ({
+      from: e.from,
+      to: e.to,
+      relationship: {
+        name: e.relationship.name,
+        type: e.relationship.type,
+        target: e.relationship.target,
+        foreignKey: e.relationship.foreignKey,
+        inverse: e.relationship.inverse,
+        through: e.relationship.through,
+        resolved: e.relationship.resolved
+      },
+      cardinality: e.cardinality,
+      bidirectional: e.bidirectional
+    }))
+  };
+}
+
+// src/patterns/registry.ts
+import { glob } from "glob";
+import path from "path";
+import { pathToFileURL } from "url";
+
+// src/patterns/pattern-definition.ts
+function definePattern(def) {
+  return def;
+}
+function isPatternDefinition(val) {
+  return typeof val === "object" && val !== null && "name" in val && typeof val.name === "string";
+}
+function isOrchestrationPattern(def) {
+  return def.kind === "orchestration";
+}
+function isDomainPattern(def) {
+  return !isOrchestrationPattern(def);
+}
+function defineOrchestrationPattern(def) {
+  return def;
+}
+
+// src/patterns/registry.ts
+var LIBRARY_PATTERNS = /* @__PURE__ */ new Map();
+var APP_PATTERNS = /* @__PURE__ */ new Map();
+var ORCHESTRATION_APP_PATTERNS = /* @__PURE__ */ new Map();
+function assertHasContribution(def) {
+  const hasColumns = Array.isArray(def.columns) && def.columns.length > 0;
+  const hasRepo = typeof def.repositoryClass === "string" && def.repositoryClass.length > 0;
+  const hasService = typeof def.serviceClass === "string" && def.serviceClass.length > 0;
+  if (!hasColumns && !hasRepo && !hasService) {
+    throw new Error(
+      `Pattern '${def.name}' contributes nothing \u2014 at least one of \`columns\`, \`repositoryClass\`, or \`serviceClass\` is required.`
+    );
+  }
+}
+function assertOrchestrationContribution(def) {
+  if (!def.registry || typeof def.registry !== "object") {
+    throw new Error(
+      `Orchestration pattern '${def.name}' is missing a 'registry' field.`
+    );
+  }
+  if (typeof def.registry.keyType !== "string" || def.registry.keyType.length === 0) {
+    throw new Error(
+      `Orchestration pattern '${def.name}' registry.keyType must be a non-empty string.`
+    );
+  }
+  if (typeof def.registry.valueType !== "string" || def.registry.valueType.length === 0) {
+    throw new Error(
+      `Orchestration pattern '${def.name}' registry.valueType must be a non-empty string.`
+    );
+  }
+  if (!Array.isArray(def.registry.entries) || def.registry.entries.length === 0) {
+    throw new Error(
+      `Orchestration pattern '${def.name}' registry.entries must contain at least one entry.`
+    );
+  }
+}
+function registerLibraryPattern(def) {
+  assertHasContribution(def);
+  LIBRARY_PATTERNS.set(def.name, def);
+}
+function getPattern(name) {
+  return APP_PATTERNS.get(name) ?? LIBRARY_PATTERNS.get(name);
+}
+function getAllPatternNames() {
+  const set = /* @__PURE__ */ new Set([
+    ...LIBRARY_PATTERNS.keys(),
+    ...APP_PATTERNS.keys()
+  ]);
+  return [...set].sort();
+}
+function getLibraryPatternNames() {
+  return [...LIBRARY_PATTERNS.keys()].sort();
+}
+function getAppPatternNames() {
+  return [...APP_PATTERNS.keys()].sort();
+}
+function getOrchestrationPattern(name) {
+  return ORCHESTRATION_APP_PATTERNS.get(name);
+}
+function getOrchestrationPatternNames() {
+  return [...ORCHESTRATION_APP_PATTERNS.keys()].sort();
+}
+function getAllOrchestrationPatterns() {
+  return getOrchestrationPatternNames().map(
+    (n) => ORCHESTRATION_APP_PATTERNS.get(n)
+  );
+}
+async function loadAppPatterns(manifestPaths, cwd) {
+  const loaded = /* @__PURE__ */ new Set();
+  const errors = [];
+  const files = /* @__PURE__ */ new Set();
+  for (const raw of manifestPaths) {
+    try {
+      const expanded = await glob(raw, { cwd, absolute: true, nodir: true });
+      for (const filePath of expanded) {
+        files.add(filePath);
+      }
+    } catch (err) {
+      errors.push(
+        `Failed to expand pattern glob '${raw}': ${stringifyError(err)}`
+      );
+    }
+  }
+  const sortedFiles = [...files].sort();
+  for (const filePath of sortedFiles) {
+    try {
+      const mod = await import(pathToFileURL(filePath).href);
+      for (const [key, val] of Object.entries(mod)) {
+        if (!key.endsWith("Pattern")) continue;
+        if (!isPatternDefinition(val)) continue;
+        if (isOrchestrationPattern(val)) {
+          const orch = val;
+          try {
+            assertOrchestrationContribution(orch);
+          } catch (assertErr) {
+            errors.push(
+              `Orchestration pattern '${orch.name}' in ${relPath(filePath, cwd)} is invalid: ${stringifyError(assertErr)}`
+            );
+            continue;
+          }
+          const existingOrch = ORCHESTRATION_APP_PATTERNS.get(orch.name);
+          if (existingOrch && existingOrch !== orch) {
+            errors.push(
+              `Orchestration pattern '${orch.name}' in ${relPath(filePath, cwd)} duplicates a previously loaded orchestration pattern. Pattern names must be unique.`
+            );
+            continue;
+          }
+          ORCHESTRATION_APP_PATTERNS.set(orch.name, orch);
+          loaded.add(orch.name);
+        } else {
+          try {
+            assertHasContribution(val);
+          } catch (assertErr) {
+            errors.push(
+              `Pattern '${val.name}' in ${relPath(filePath, cwd)} is invalid: ${stringifyError(assertErr)}`
+            );
+            continue;
+          }
+          const existingDom = APP_PATTERNS.get(val.name);
+          if (existingDom && existingDom !== val) {
+            errors.push(
+              `Pattern '${val.name}' in ${relPath(filePath, cwd)} duplicates a previously loaded app pattern. Pattern names must be unique.`
+            );
+            continue;
+          }
+          APP_PATTERNS.set(val.name, val);
+          loaded.add(val.name);
+        }
+      }
+    } catch (err) {
+      errors.push(
+        `Failed to load pattern file '${relPath(filePath, cwd)}': ${stringifyError(err)}`
+      );
+    }
+  }
+  return {
+    loaded: [...loaded].sort(),
+    errors
+  };
+}
+function _resetRegistryForTests(opts = {}) {
+  APP_PATTERNS.clear();
+  ORCHESTRATION_APP_PATTERNS.clear();
+  if (opts.includeLibrary) {
+    LIBRARY_PATTERNS.clear();
+  }
+}
+function stringifyError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function relPath(abs, cwd) {
+  try {
+    return path.relative(cwd, abs) || abs;
+  } catch {
+    return abs;
+  }
+}
+
+// src/patterns/validate-composition.ts
+function validatePatternComposition(entity) {
+  const issues = [];
+  const patternNames = entity.patterns ?? (entity.pattern ? [entity.pattern] : []);
+  if (patternNames.length === 0) return issues;
+  const columnSources = /* @__PURE__ */ new Map();
+  for (const [name] of entity.fields) {
+    columnSources.set(name, `entity field '${name}'`);
+  }
+  const behaviorFields = resolveBehaviorFields(entity.behaviors);
+  for (const bf of behaviorFields) {
+    const existing = columnSources.get(bf.name);
+    if (existing) {
+      issues.push({
+        severity: "error",
+        type: "pattern_column_conflict",
+        entity: entity.name,
+        message: `Behavior-contributed field '${bf.name}' conflicts with ${existing}.`
+      });
+      continue;
+    }
+    columnSources.set(bf.name, `behavior field '${bf.name}'`);
+  }
+  const impliedBehaviors = new Set(entity.behaviors);
+  for (const patternName of patternNames) {
+    const def = getPattern(patternName);
+    if (!def) {
+      issues.push({
+        severity: "error",
+        type: "pattern_unknown",
+        entity: entity.name,
+        message: `Unknown pattern '${patternName}'. Library patterns are pre-registered; app patterns are loaded from globs in codegen.config.yaml 'patterns:' (default 'src/patterns/*.pattern.ts').`
+      });
+      continue;
+    }
+    if (def.configSchema) {
+      const rawConfig = entity.patternConfig?.[patternName];
+      const result = def.configSchema.safeParse(rawConfig ?? {});
+      if (!result.success) {
+        const detail = result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join(", ");
+        issues.push({
+          severity: "error",
+          type: "pattern_config_invalid",
+          entity: entity.name,
+          message: `Pattern '${patternName}' config failed validation: ${detail}`
+        });
+      }
+    }
+    for (const col of def.columns ?? []) {
+      const existing = columnSources.get(col.name);
+      if (existing) {
+        issues.push({
+          severity: "error",
+          type: "pattern_column_conflict",
+          entity: entity.name,
+          message: `Pattern '${patternName}' contributes column '${col.name}' which conflicts with ${existing}.`
+        });
+        continue;
+      }
+      columnSources.set(col.name, `pattern '${patternName}'`);
+    }
+    for (const b of def.impliedBehaviors ?? []) {
+      impliedBehaviors.add(b);
+    }
+  }
+  if (entity.patternConfig) {
+    const declared = new Set(patternNames);
+    for (const key of Object.keys(entity.patternConfig)) {
+      if (!declared.has(key)) {
+        issues.push({
+          severity: "warning",
+          type: "pattern_config_unused",
+          entity: entity.name,
+          message: `Config block has key '${key}' but pattern '${key}' is not declared in 'pattern:' or 'patterns:'. Remove the entry or add the pattern.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function validatePatternProject(ctx) {
+  const issues = [];
+  if (ctx.architecture === "clean") {
+    const withPatterns = ctx.entities.filter(
+      (e) => e.patterns && e.patterns.length > 0 || !!e.pattern
+    );
+    for (const e of withPatterns) {
+      issues.push({
+        severity: "warning",
+        type: "pattern_clean_pipeline_noop",
+        entity: e.name,
+        message: `'pattern:' is declared but 'generate.architecture: clean' does not yet consume patterns. This declaration is a no-op. Patterns are consumed by 'clean-lite-ps' today; 'clean' integration is Phase 3+ additive work (ADR-031).`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/patterns/validate-orchestration.ts
+var PROJECT_SENTINEL = "<project>";
+function validateOrchestrationProject(ctx) {
+  const issues = [];
+  const domainNameSet = new Set(ctx.domainPatternNames);
+  for (const orch of ctx.orchestrationPatterns) {
+    if (domainNameSet.has(orch.name)) {
+      issues.push({
+        severity: "error",
+        type: "pattern_name_collision",
+        entity: PROJECT_SENTINEL,
+        message: `Orchestration pattern '${orch.name}' shares a name with a domain pattern. Pattern names are globally unique across kinds (ADR-032 \xA7Composition rules).`
+      });
+    }
+  }
+  for (const orch of ctx.orchestrationPatterns) {
+    const allRegistries = [
+      orch.registry,
+      ...orch.coKeyedRegistries ?? []
+    ];
+    for (const reg of allRegistries) {
+      if (!Array.isArray(reg.entries) || reg.entries.length === 0) {
+        issues.push({
+          severity: "error",
+          type: "pattern_entries_empty",
+          entity: PROJECT_SENTINEL,
+          message: `Orchestration pattern '${orch.name}' declares a registry with no entries. Provide at least one { key, provider } pair.`
+        });
+        continue;
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const entry of reg.entries) {
+        if (typeof entry.key !== "string" || entry.key.length === 0) {
+          issues.push({
+            severity: "error",
+            type: "pattern_entry_malformed",
+            entity: PROJECT_SENTINEL,
+            message: `Orchestration pattern '${orch.name}' has an entry with a missing or non-string 'key'.`
+          });
+          continue;
+        }
+        if (typeof entry.provider !== "string" || entry.provider.length === 0) {
+          issues.push({
+            severity: "error",
+            type: "pattern_entry_malformed",
+            entity: PROJECT_SENTINEL,
+            message: `Orchestration pattern '${orch.name}' entry '${entry.key}' has a missing or non-string 'provider'.`
+          });
+          continue;
+        }
+        if (seen.has(entry.key)) {
+          issues.push({
+            severity: "error",
+            type: "pattern_entry_key_duplicate",
+            entity: PROJECT_SENTINEL,
+            message: `Orchestration pattern '${orch.name}' has duplicate entry key '${entry.key}'. Keys must be unique within a registry.`
+          });
+          continue;
+        }
+        seen.add(entry.key);
+      }
+    }
+    if (orch.coKeyedRegistries && orch.coKeyedRegistries.length > 0) {
+      const primaryKeyType = orch.registry.keyType;
+      for (const reg of orch.coKeyedRegistries) {
+        if (reg.keyType !== primaryKeyType) {
+          issues.push({
+            severity: "error",
+            type: "pattern_cokeyed_keytype_mismatch",
+            entity: PROJECT_SENTINEL,
+            message: `Orchestration pattern '${orch.name}' co-keyed registry has keyType '${reg.keyType}', expected '${primaryKeyType}'. Co-keyed registries must share the primary registry's key space (ADR-032 Decision 2).`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+// src/formatters/console-formatter.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m"
+};
+function color(text, ...styles) {
+  return `${styles.join("")}${text}${colors.reset}`;
+}
+function severityColor(severity) {
+  switch (severity) {
+    case "error":
+      return colors.red;
+    case "warning":
+      return colors.yellow;
+    case "info":
+      return colors.cyan;
+  }
+}
+function severityIcon(severity) {
+  switch (severity) {
+    case "error":
+      return "X";
+    case "warning":
+      return "!";
+    case "info":
+      return "i";
+  }
+}
+function formatConsole(result) {
+  const lines = [];
+  lines.push("");
+  lines.push(color("=".repeat(60), colors.dim));
+  lines.push(color("  Domain Analysis Report", colors.bold, colors.cyan));
+  lines.push(color("=".repeat(60), colors.dim));
+  lines.push("");
+  lines.push(...formatStatistics(result));
+  lines.push(...formatEntities(result));
+  lines.push(...formatRelationships(result));
+  if (result.issues.length > 0) {
+    lines.push(...formatIssues(result.issues));
+  }
+  lines.push("");
+  lines.push(color("-".repeat(60), colors.dim));
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  if (result.isValid) {
+    lines.push(
+      color(
+        `[OK] Domain is valid (${warnings.length} warnings, ${infos.length} info)`,
+        colors.green
+      )
+    );
+  } else {
+    lines.push(color(`[FAIL] Domain has ${errors.length} errors`, colors.red));
+  }
+  lines.push(color("-".repeat(60), colors.dim));
+  lines.push("");
+  return lines.join("\n");
+}
+function formatStatistics(result) {
+  const lines = [];
+  const stats = result.statistics;
+  lines.push(color("Statistics:", colors.bold));
+  lines.push("");
+  lines.push(`   Entities:        ${stats.totalEntities}`);
+  lines.push(
+    `   Fields:          ${stats.totalFields} (avg ${stats.averageFieldsPerEntity.toFixed(1)}/entity)`
+  );
+  lines.push(`   Relationships:   ${stats.totalRelationships}`);
+  lines.push(`   With behaviors:  ${stats.entitiesWithBehaviors}`);
+  lines.push("");
+  lines.push("   Field types:");
+  const sortedTypes = Object.entries(stats.fieldsByType).sort((a, b) => b[1] - a[1]);
+  for (const [type, count] of sortedTypes) {
+    const bar = color("|".repeat(Math.min(count, 20)), colors.blue);
+    lines.push(`     ${type.padEnd(12)} ${bar} ${count}`);
+  }
+  lines.push("");
+  if (stats.totalRelationships > 0) {
+    lines.push("   Relationship types:");
+    const sortedRels = Object.entries(stats.relationshipsByType).sort((a, b) => b[1] - a[1]);
+    for (const [type, count] of sortedRels) {
+      const bar = color("|".repeat(Math.min(count, 20)), colors.magenta);
+      lines.push(`     ${type.padEnd(12)} ${bar} ${count}`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function formatEntities(result) {
+  const lines = [];
+  lines.push(color("Entities:", colors.bold));
+  lines.push("");
+  for (const entity of result.entities) {
+    const fieldCount = entity.fields.size;
+    const relCount = entity.relationships.size;
+    lines.push(
+      `   ${color(entity.name, colors.cyan)} (${fieldCount} fields, ${relCount} relationships)`
+    );
+    if (entity.behaviors.length > 0) {
+      lines.push(color(`      behaviors: ${entity.behaviors.join(", ")}`, colors.dim));
+    }
+  }
+  lines.push("");
+  return lines;
+}
+function formatRelationships(result) {
+  const lines = [];
+  if (result.graph.edges.length === 0) {
+    return lines;
+  }
+  lines.push(color("Relationships:", colors.bold));
+  lines.push("");
+  for (const edge of result.graph.edges) {
+    const arrow = getCardinalityArrow(edge.cardinality);
+    const bidir = edge.bidirectional ? color(" (bidirectional)", colors.dim) : "";
+    lines.push(
+      `   ${edge.from.padEnd(20)} ${arrow} ${edge.to} ${color(`(${edge.relationship.type})`, colors.dim)}${bidir}`
+    );
+  }
+  lines.push("");
+  return lines;
+}
+function getCardinalityArrow(cardinality) {
+  switch (cardinality) {
+    case "1:N":
+      return color("--<", colors.magenta);
+    case "N:1":
+      return color(">--", colors.magenta);
+    case "1:1":
+      return color("---", colors.magenta);
+    case "N:M":
+      return color(">-<", colors.magenta);
+    default:
+      return color("-->", colors.magenta);
+  }
+}
+function formatIssues(issues) {
+  const lines = [];
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  const infos = issues.filter((i) => i.severity === "info");
+  if (errors.length > 0) {
+    lines.push(color(`Errors (${errors.length}):`, colors.bold, colors.red));
+    lines.push("");
+    lines.push(...formatIssueList(errors, "error"));
+    lines.push("");
+  }
+  if (warnings.length > 0) {
+    lines.push(color(`Warnings (${warnings.length}):`, colors.bold, colors.yellow));
+    lines.push("");
+    lines.push(...formatIssueList(warnings, "warning"));
+    lines.push("");
+  }
+  if (infos.length > 0) {
+    lines.push(color(`Info (${infos.length}):`, colors.bold, colors.cyan));
+    lines.push("");
+    lines.push(...formatIssueList(infos, "info", 5));
+    lines.push("");
+  }
+  return lines;
+}
+function formatIssueList(issues, severity, limit) {
+  const lines = [];
+  const displayIssues = limit ? issues.slice(0, limit) : issues;
+  const byType = /* @__PURE__ */ new Map();
+  for (const issue of displayIssues) {
+    const list = byType.get(issue.type) ?? [];
+    list.push(issue);
+    byType.set(issue.type, list);
+  }
+  for (const [type, typeIssues] of byType) {
+    lines.push(color(`   ${type} (${typeIssues.length}):`, colors.dim));
+    for (const issue of typeIssues.slice(0, 5)) {
+      const location = issue.entity ? `${issue.entity}${issue.field ? "." + issue.field : ""}` : issue.path ?? "unknown";
+      const icon = color(`[${severityIcon(severity)}]`, severityColor(severity));
+      lines.push(`     ${icon} ${color(location, colors.bold)}: ${issue.message}`);
+      if (issue.suggestion) {
+        lines.push(color(`        -> ${issue.suggestion}`, colors.dim));
+      }
+    }
+    if (typeIssues.length > 5) {
+      lines.push(color(`     ... and ${typeIssues.length - 5} more`, colors.dim));
+    }
+  }
+  if (limit && issues.length > limit) {
+    lines.push(color(`   ... and ${issues.length - limit} more info messages`, colors.dim));
+  }
+  return lines;
+}
+
+// src/formatters/json-formatter.ts
+function mapToObject(map) {
+  const obj = {};
+  for (const [key, value] of map) {
+    obj[key] = value;
+  }
+  return obj;
+}
+function serializeEntity(entity) {
+  return {
+    name: entity.name,
+    plural: entity.plural,
+    table: entity.table,
+    folderStructure: entity.folderStructure,
+    fields: mapToObject(entity.fields),
+    relationships: mapToObject(entity.relationships),
+    behaviors: entity.behaviors,
+    sourcePath: entity.sourcePath
+  };
+}
+function serializeGraph(graph) {
+  const entities = {};
+  for (const [name, entity] of graph.entities) {
+    entities[name] = serializeEntity(entity);
+  }
+  return {
+    entities,
+    edges: graph.edges
+  };
+}
+function formatJson(result, pretty = true) {
+  const output = {
+    isValid: result.isValid,
+    summary: {
+      entities: result.statistics.totalEntities,
+      fields: result.statistics.totalFields,
+      relationships: result.statistics.totalRelationships,
+      errors: result.issues.filter((i) => i.severity === "error").length,
+      warnings: result.issues.filter((i) => i.severity === "warning").length,
+      info: result.issues.filter((i) => i.severity === "info").length
+    },
+    entities: result.entities.map(serializeEntity),
+    graph: serializeGraph(result.graph),
+    issues: result.issues,
+    statistics: result.statistics,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+}
+function formatStatsJson(result, pretty = true) {
+  const output = {
+    statistics: result.statistics,
+    isValid: result.isValid,
+    issueCount: {
+      errors: result.issues.filter((i) => i.severity === "error").length,
+      warnings: result.issues.filter((i) => i.severity === "warning").length,
+      info: result.issues.filter((i) => i.severity === "info").length
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+}
+
+// src/formatters/markdown-formatter.ts
+function formatMarkdown(result) {
+  const lines = [];
+  lines.push("# Domain Model Documentation");
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Entities | ${result.statistics.totalEntities} |`);
+  lines.push(`| Total Fields | ${result.statistics.totalFields} |`);
+  lines.push(`| Total Relationships | ${result.statistics.totalRelationships} |`);
+  lines.push(
+    `| Avg Fields/Entity | ${result.statistics.averageFieldsPerEntity.toFixed(1)} |`
+  );
+  lines.push("");
+  lines.push("### Field Type Distribution");
+  lines.push("");
+  lines.push("| Type | Count |");
+  lines.push("|------|-------|");
+  const sortedTypes = Object.entries(result.statistics.fieldsByType).sort(
+    (a, b) => b[1] - a[1]
+  );
+  for (const [type, count] of sortedTypes) {
+    lines.push(`| ${type} | ${count} |`);
+  }
+  lines.push("");
+  if (result.statistics.totalRelationships > 0) {
+    lines.push("### Relationship Type Distribution");
+    lines.push("");
+    lines.push("| Type | Count |");
+    lines.push("|------|-------|");
+    const sortedRels = Object.entries(result.statistics.relationshipsByType).sort(
+      (a, b) => b[1] - a[1]
+    );
+    for (const [type, count] of sortedRels) {
+      lines.push(`| ${type} | ${count} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Entity Relationship Diagram");
+  lines.push("");
+  lines.push("```mermaid");
+  lines.push(...generateMermaidErDiagram(result));
+  lines.push("```");
+  lines.push("");
+  lines.push("## Entities");
+  lines.push("");
+  for (const entity of result.entities) {
+    lines.push(...formatEntitySection(entity));
+  }
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  if (result.issues.length > 0) {
+    lines.push("## Analysis Issues");
+    lines.push("");
+    if (errors.length > 0) {
+      lines.push("### Errors");
+      lines.push("");
+      for (const issue of errors) {
+        const location = issue.entity ? `**${issue.entity}${issue.field ? "." + issue.field : ""}**` : issue.path ?? "unknown";
+        lines.push(`- [${issue.type}] ${location}: ${issue.message}`);
+        if (issue.suggestion) {
+          lines.push(`  - Suggestion: ${issue.suggestion}`);
+        }
+      }
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push("### Warnings");
+      lines.push("");
+      for (const issue of warnings) {
+        const location = issue.entity ? `**${issue.entity}${issue.field ? "." + issue.field : ""}**` : issue.path ?? "unknown";
+        lines.push(`- [${issue.type}] ${location}: ${issue.message}`);
+        if (issue.suggestion) {
+          lines.push(`  - Suggestion: ${issue.suggestion}`);
+        }
+      }
+      lines.push("");
+    }
+    if (infos.length > 0) {
+      lines.push("### Info");
+      lines.push("");
+      lines.push("<details>");
+      lines.push("<summary>Show info messages</summary>");
+      lines.push("");
+      for (const issue of infos) {
+        const location = issue.entity ? `**${issue.entity}${issue.field ? "." + issue.field : ""}**` : issue.path ?? "unknown";
+        lines.push(`- [${issue.type}] ${location}: ${issue.message}`);
+      }
+      lines.push("");
+      lines.push("</details>");
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function formatEntitySection(entity) {
+  const lines = [];
+  lines.push(`### ${entity.name}`);
+  lines.push("");
+  lines.push(`**Table:** \`${entity.table}\``);
+  lines.push(`**Plural:** ${entity.plural}`);
+  if (entity.behaviors.length > 0) {
+    lines.push(`**Behaviors:** ${entity.behaviors.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("#### Fields");
+  lines.push("");
+  lines.push("| Name | Type | Required | Nullable | Index | Foreign Key |");
+  lines.push("|------|------|----------|----------|-------|-------------|");
+  for (const [name, field] of entity.fields) {
+    const required = field.required ? "Yes" : "";
+    const nullable = field.nullable ? "Yes" : "";
+    const index = field.index ? "Yes" : field.unique ? "Unique" : "";
+    const fk = field.foreignKey ? `${field.foreignKey.table}.${field.foreignKey.column}` : "";
+    lines.push(`| ${name} | ${field.type} | ${required} | ${nullable} | ${index} | ${fk} |`);
+  }
+  lines.push("");
+  if (entity.relationships.size > 0) {
+    lines.push("#### Relationships");
+    lines.push("");
+    lines.push("| Name | Type | Target | Foreign Key |");
+    lines.push("|------|------|--------|-------------|");
+    for (const [name, rel] of entity.relationships) {
+      lines.push(`| ${name} | ${rel.type} | ${rel.target} | ${rel.foreignKey} |`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function generateMermaidErDiagram(result) {
+  const lines = [];
+  lines.push("erDiagram");
+  for (const entity of result.entities) {
+    const entityName = entity.name.toUpperCase();
+    lines.push(`    ${entityName} {`);
+    const keyFields = Array.from(entity.fields.entries()).filter(
+      ([name, field]) => field.foreignKey || field.unique || field.index || name === "id" || name === "name"
+    ).slice(0, 6);
+    for (const [name, field] of keyFields) {
+      const typeStr = field.type;
+      const pk = name === "id" ? "PK" : "";
+      const fk = field.foreignKey ? "FK" : "";
+      const marker = pk || fk ? ` "${pk}${fk}"` : "";
+      lines.push(`        ${typeStr} ${name}${marker}`);
+    }
+    if (entity.fields.size > keyFields.length) {
+      lines.push(`        string _more_fields`);
+    }
+    lines.push("    }");
+  }
+  for (const edge of result.graph.edges) {
+    const from = edge.from.toUpperCase();
+    const to = edge.to.toUpperCase();
+    const cardinalitySymbol = getCardinalitySymbol(edge.cardinality);
+    const label = edge.relationship.name;
+    lines.push(`    ${from} ${cardinalitySymbol} ${to} : "${label}"`);
+  }
+  return lines;
+}
+function getCardinalitySymbol(cardinality) {
+  switch (cardinality) {
+    case "1:N":
+      return "||--o{";
+    case "N:1":
+      return "}o--||";
+    case "1:1":
+      return "||--||";
+    case "N:M":
+      return "}o--o{";
+    default:
+      return "||--o{";
+  }
+}
+function formatMermaidGraph(result) {
+  const lines = [];
+  lines.push("```mermaid");
+  lines.push("graph LR");
+  lines.push("    classDef entity fill:#e1f5fe,stroke:#01579b");
+  for (const entity of result.entities) {
+    lines.push(`    ${entity.name}["${entity.name}\\n(${entity.fields.size} fields)"]`);
+  }
+  for (const edge of result.graph.edges) {
+    const style = edge.bidirectional ? "<-->" : "-->";
+    lines.push(`    ${edge.from} ${style}|${edge.relationship.type}| ${edge.to}`);
+  }
+  const entityList = result.entities.map((e) => e.name).join(",");
+  if (entityList) {
+    lines.push(`    class ${entityList} entity`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/patterns/library/activity.pattern.ts
+var ActivityPattern = definePattern({
+  name: "Activity",
+  extends: ["Base"],
+  repositoryClass: "ActivityEntityRepository",
+  serviceClass: "ActivityEntityService",
+  repositoryImport: "@shared/base-classes/activity-entity-repository",
+  serviceImport: "@shared/base-classes/activity-entity-service",
+  repositoryInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete, upsertMany",
+    "findByDateRange, findByUserId, findByOpportunityId, findRecentByOpportunityId"
+  ],
+  serviceInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete",
+    "findByDateRange, findByUserId, findByOpportunityId, findRecentByOpportunityId"
+  ],
+  description: "Time-bounded interaction entities \u2014 date-range + opportunity scoped lookups"
+});
+
+// src/patterns/library/base.pattern.ts
+var BasePattern = definePattern({
+  name: "Base",
+  repositoryClass: "BaseRepository",
+  serviceClass: "BaseService",
+  repositoryImport: "@shared/base-classes/base-repository",
+  serviceImport: "@shared/base-classes/base-service",
+  repositoryInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete, upsertMany"
+  ],
+  serviceInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete"
+  ],
+  description: "Identity pattern \u2014 base CRUD, no extra columns or methods"
+});
+
+// src/patterns/library/junction.pattern.ts
+import { z as z6 } from "zod";
+var JunctionPatternConfigSchema = z6.object({}).strict();
+var JunctionPattern = definePattern({
+  name: "Junction",
+  description: "Explicit many-to-many junction with role + temporal + sourcing metadata",
+  columns: [...BaseJunctionFields],
+  configSchema: JunctionPatternConfigSchema
+});
+
+// src/patterns/library/knowledge.pattern.ts
+var KnowledgePattern = definePattern({
+  name: "Knowledge",
+  extends: ["Base"],
+  repositoryClass: "KnowledgeEntityRepository",
+  serviceClass: "KnowledgeEntityService",
+  repositoryImport: "@shared/base-classes/knowledge-entity-repository",
+  serviceImport: "@shared/base-classes/knowledge-entity-service",
+  repositoryInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete, upsertMany",
+    "semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch"
+  ],
+  serviceInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete",
+    "semanticSearch, findPendingByOpportunityId, updateStatus, updateStatusBatch"
+  ],
+  description: "Knowledge entities \u2014 semantic search + workflow status"
+});
+
+// src/patterns/library/metadata.pattern.ts
+var MetadataPattern = definePattern({
+  name: "Metadata",
+  extends: ["Base"],
+  repositoryClass: "MetadataEntityRepository",
+  serviceClass: "MetadataEntityService",
+  repositoryImport: "@shared/base-classes/metadata-entity-repository",
+  serviceImport: "@shared/base-classes/metadata-entity-service",
+  repositoryInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete, upsertMany",
+    "findByEntityIdAndType, listByEntityId, listHistoryByEntityId"
+  ],
+  serviceInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete",
+    "findByEntityIdAndType, listByEntityId, listHistoryByEntityId"
+  ],
+  description: "History-tracked metadata rows \u2014 entity-id + type scoped lookups"
+});
+
+// src/patterns/library/integrated.pattern.ts
+var IntegratedPattern = definePattern({
+  name: "Integrated",
+  extends: ["Base"],
+  repositoryClass: "IntegratedEntityRepository",
+  serviceClass: "IntegratedEntityService",
+  repositoryImport: "@shared/base-classes/integrated-entity-repository",
+  serviceImport: "@shared/base-classes/integrated-entity-service",
+  repositoryInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete, upsertMany",
+    "findByExternalId, findManyByExternalIds, findAllByUserId, findVisibleByUserId",
+    "integrationUpsertOne, findByExternalIdProjected, softDeleteByExternalId, integrationUpsert"
+  ],
+  serviceInheritedMethods: [
+    "findById, findByIds, list, count, exists, create, update, delete",
+    "findByExternalId, findAllByUserId, findVisibleByUserId"
+  ],
+  impliedBehaviors: ["external_id_tracking"],
+  description: "External CRM/system integration columns and integrationUpsert methods"
+});
+
+// src/patterns/library/index.ts
+registerLibraryPattern(BasePattern);
+registerLibraryPattern(IntegratedPattern);
+registerLibraryPattern(ActivityPattern);
+registerLibraryPattern(KnowledgePattern);
+registerLibraryPattern(MetadataPattern);
+registerLibraryPattern(JunctionPattern);
+
+// src/index.ts
+async function analyzeDomain(entitiesDir, relationshipsOrOptions) {
+  const opts = typeof relationshipsOrOptions === "string" ? { relationshipsDir: relationshipsOrOptions } : relationshipsOrOptions ?? {};
+  const relationshipsDir = opts.relationshipsDir;
+  const { entities, issues: loadIssues } = loadEntities(entitiesDir);
+  const { relationships: relationshipDefinitions, issues: relLoadIssues } = relationshipsDir ? loadRelationships(relationshipsDir) : { relationships: [], issues: [] };
+  const resolveIssues = resolveReferences(entities);
+  const relResolveIssues = resolveRelationshipReferences(
+    relationshipDefinitions,
+    entities
+  );
+  const graph = buildDomainGraph(entities, relationshipDefinitions);
+  const consistencyIssues = checkConsistency(graph);
+  const patternIssues = entities.flatMap((e) => validatePatternComposition(e));
+  const patternProjectIssues = validatePatternProject({
+    entities,
+    architecture: opts.architecture
+  });
+  const orchestrationProjectIssues = validateOrchestrationProject({
+    orchestrationPatterns: getAllOrchestrationPatterns(),
+    domainPatternNames: getAllPatternNames()
+  });
+  const statistics = computeStatistics(graph);
+  const allIssues = [
+    ...loadIssues,
+    ...relLoadIssues,
+    ...resolveIssues,
+    ...relResolveIssues,
+    ...consistencyIssues,
+    ...patternIssues,
+    ...patternProjectIssues,
+    ...orchestrationProjectIssues
+  ];
+  const hasErrors = allIssues.some((i) => i.severity === "error");
+  return {
+    isValid: !hasErrors,
+    entities,
+    relationshipDefinitions,
+    graph,
+    issues: allIssues,
+    statistics
+  };
+}
+function validateEntities(entitiesDir) {
+  const { entities, issues } = loadEntities(entitiesDir);
+  const errors = issues.filter((i) => i.severity === "error").map((i) => i.message);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+export {
+  findYamlFiles,
+  EVENT_FIELD_TYPES,
+  DIRECTION_TO_POOL,
+  BaseJunctionFields,
+  BASE_JUNCTION_FIELD_NAMES,
+  JunctionDefinitionSchema,
+  validateJunctionDefinition,
+  safeValidateJunctionDefinition,
+  parseImportRef,
+  loadEntityFromYaml,
+  loadEntitiesFromYaml,
+  loadRelationshipFromYaml,
+  loadEventFromYaml,
+  loadJunctionFromYaml,
+  loadProvidersFromYaml,
+  detectYamlType,
+  loadEntities,
+  loadRelationships,
+  collectEntitySurfaces,
+  validateProviders,
+  buildDomainGraph,
+  getRelatedEntities,
+  findOrphanEntities,
+  findCircularDependencies,
+  checkConsistency,
+  computeStatistics,
+  suggestTransitiveRelationships,
+  getManifestDir,
+  readManifest,
+  writeManifest,
+  isManifestStale,
+  buildManifest,
+  updateSuggestionStatus,
+  updateAllSuggestionStatus,
+  getPendingSuggestions,
+  serializeDomainGraph,
+  definePattern,
+  isPatternDefinition,
+  isOrchestrationPattern,
+  isDomainPattern,
+  defineOrchestrationPattern,
+  registerLibraryPattern,
+  getPattern,
+  getAllPatternNames,
+  getLibraryPatternNames,
+  getAppPatternNames,
+  getOrchestrationPattern,
+  getOrchestrationPatternNames,
+  getAllOrchestrationPatterns,
+  loadAppPatterns,
+  _resetRegistryForTests,
+  validatePatternComposition,
+  validatePatternProject,
+  validateOrchestrationProject,
+  formatConsole,
+  formatJson,
+  formatStatsJson,
+  formatMarkdown,
+  formatMermaidGraph,
+  ActivityPattern,
+  BasePattern,
+  JunctionPattern,
+  KnowledgePattern,
+  MetadataPattern,
+  IntegratedPattern,
+  analyzeDomain,
+  validateEntities
+};
+//# sourceMappingURL=chunk-32DOFN3T.js.map