@pattern-stack/codegen 0.15.1 → 0.15.3

package/dist/src/index.js

@@ -1,4174 +1,72 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index2, decorator) => (target, key) => decorator(target, key, index2);
-
-// 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 as z3 } from "zod";
-
-// runtime/subsystems/integration/integration-field-diff.protocol.ts
-import { z } from "zod";
-var FieldDiffValueSchema = z.object({
-  from: z.unknown(),
-  to: z.unknown()
-});
-var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
-
-// runtime/subsystems/integration/detection-config.schema.ts
-import { z as z2 } from "zod";
-var FieldMappingSchema = z2.object({
-  source: z2.string().min(1),
-  target: z2.string().min(1),
-  transform: z2.string().min(1).optional()
-});
-var ResolvedFilterSchema = z2.object({
-  field: z2.string().min(1),
-  op: z2.enum(["eq", "neq", "in", "nin", "gt", "gte", "lt", "lte"]),
-  value: z2.unknown()
-});
-var SystemModstampCursorSchema = z2.object({
-  kind: z2.literal("systemModstamp"),
-  field: z2.string().min(1)
-});
-var ReplayIdCursorSchema = z2.object({
-  kind: z2.literal("replayId"),
-  field: z2.string().min(1)
-});
-var TimestampCursorSchema = z2.object({
-  kind: z2.literal("timestamp"),
-  field: z2.string().min(1)
-});
-var EventIdCursorSchema = z2.object({
-  kind: z2.literal("eventId"),
-  field: z2.string().min(1)
-});
-var HistoryIdCursorSchema = z2.object({
-  kind: z2.literal("historyId"),
-  field: z2.string().min(1)
-});
-var SyncTokenCursorSchema = z2.object({
-  kind: z2.literal("syncToken"),
-  field: z2.string().min(1)
-});
-var CursorStrategySchema = z2.discriminatedUnion("kind", [
-  SystemModstampCursorSchema,
-  ReplayIdCursorSchema,
-  TimestampCursorSchema,
-  EventIdCursorSchema,
-  HistoryIdCursorSchema,
-  SyncTokenCursorSchema
-]);
-var PollDetectionSchema = z2.object({
-  cursor: CursorStrategySchema,
-  provenance: z2.enum(["poll", "cdc"]).optional()
-});
-var WebhookDetectionSchema = z2.object({
-  eventIdField: z2.string().min(1)
-});
-var PollModeSchema = z2.object({
-  mode: z2.literal("poll"),
-  poll: PollDetectionSchema,
-  mapping: z2.array(FieldMappingSchema).min(1),
-  filters: z2.array(ResolvedFilterSchema).default([])
-});
-var WebhookModeSchema = z2.object({
-  mode: z2.literal("webhook"),
-  webhook: WebhookDetectionSchema,
-  mapping: z2.array(FieldMappingSchema).min(1),
-  filters: z2.array(ResolvedFilterSchema).default([])
-});
-var DetectionConfigSchema = z2.discriminatedUnion("mode", [
-  PollModeSchema,
-  WebhookModeSchema
-]);
-
-// runtime/subsystems/integration/integration.tokens.ts
-var INTEGRATION_CHANGE_SOURCE = "INTEGRATION_CHANGE_SOURCE";
-var INTEGRATION_CURSOR_STORE = "INTEGRATION_CURSOR_STORE";
-var INTEGRATION_FIELD_DIFFER = "INTEGRATION_FIELD_DIFFER";
-var INTEGRATION_SINK = "INTEGRATION_SINK";
-var INTEGRATION_RUN_RECORDER = "INTEGRATION_RUN_RECORDER";
-var INTEGRATION_MODULE_OPTIONS = "INTEGRATION_MODULE_OPTIONS";
-var INTEGRATION_MULTI_TENANT = "INTEGRATION_MULTI_TENANT";
-
-// runtime/subsystems/integration/integration-errors.ts
-var MissingTenantIdError = class extends Error {
-  name = "MissingTenantIdError";
-  constructor(operation) {
-    super(
-      `Missing tenantId for integration operation '${operation}'. IntegrationModule is configured with multiTenant: true \u2014 every call must include a non-null tenantId. Either pass the tenantId or disable multi-tenancy on the module.`
-    );
-  }
-};
-function assertTenantId(tenantId, options) {
-  if (!options.multiTenant) return;
-  if (tenantId === void 0 || tenantId === null) {
-    throw new MissingTenantIdError(options.operation);
-  }
-}
-
-// runtime/subsystems/integration/integration-audit.schema.ts
 import {
-  pgEnum,
-  pgTable,
-  uuid,
-  text,
-  jsonb,
-  integer,
-  boolean,
-  timestamp,
-  index,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
-  "inbound",
-  "outbound"
-]);
-var integrationRunActionEnum = pgEnum("integration_run_action", [
-  "poll",
-  "cdc",
-  "webhook",
-  "manual",
-  "writeback"
-]);
-var integrationRunStatusEnum = pgEnum("integration_run_status", [
-  "running",
-  "success",
-  "no_changes",
-  "failed"
-]);
-var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
-  "created",
-  "updated",
-  "deleted",
-  "noop"
-]);
-var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
-  "success",
-  "failed",
-  "skipped"
-]);
-var integrationSubscriptions = pgTable(
-  "integration_subscriptions",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    connectionId: text("connection_id").notNull(),
-    adapter: text("adapter").notNull(),
-    domain: text("domain").notNull(),
-    externalRef: text("external_ref"),
-    enabled: boolean("enabled").notNull().default(true),
-    /**
-     * Per-subscription configuration bag. Strategies type it internally;
-     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.
-     */
-    config: jsonb("config").notNull().default({}).$type(),
-    /**
-     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
-     * successful run advances it.
-     */
-    cursor: jsonb("cursor").$type(),
-    lastIntegrationAt: timestamp("last_integration_at", { withTimezone: true }),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id"),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-  },
-  (t) => ({
-    /**
-     * Composite uniqueness per the epic shape. `external_ref` is nullable;
-     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
-     * two rows with the same `(connection_id, adapter, domain)` and NULL
-     * external_ref are allowed. That's intentional — a subscription with
-     * NULL external_ref covers the full domain, and duplicates there would
-     * be a consumer-layer modeling issue, not a schema concern.
-     */
-    uqIntegrationSubscriptionTuple: uniqueIndex("uq_integration_subscriptions_tuple").on(
-      t.connectionId,
-      t.adapter,
-      t.domain,
-      t.externalRef
-    ),
-    /** Scheduling query: list enabled subscriptions ordered by staleness. */
-    idxIntegrationSubscriptionsEnabledLastIntegration: index(
-      "idx_integration_subscriptions_enabled_last_integration"
-    ).on(t.enabled, t.lastIntegrationAt)
-  })
-);
-var integrationRuns = pgTable(
-  "integration_runs",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    subscriptionId: uuid("subscription_id").notNull().references(() => integrationSubscriptions.id, { onDelete: "cascade" }),
-    direction: integrationRunDirectionEnum("direction").notNull(),
-    action: integrationRunActionEnum("action").notNull(),
-    status: integrationRunStatusEnum("status").notNull().default("running"),
-    recordsFound: integer("records_found").notNull().default(0),
-    recordsProcessed: integer("records_processed").notNull().default(0),
-    cursorBefore: jsonb("cursor_before").$type(),
-    cursorAfter: jsonb("cursor_after").$type(),
-    durationMs: integer("duration_ms"),
-    error: text("error"),
-    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
-    completedAt: timestamp("completed_at", { withTimezone: true }),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Timeline read: "most recent runs for this subscription". */
-    idxIntegrationRunsSubscriptionStartedAt: index(
-      "idx_integration_runs_subscription_started_at"
-    ).on(t.subscriptionId, t.startedAt),
-    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
-    idxIntegrationRunsStatusStartedAt: index("idx_integration_runs_status_started_at").on(
-      t.status,
-      t.startedAt
-    )
-  })
-);
-var integrationRunItems = pgTable(
-  "integration_run_items",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    integrationRunId: uuid("integration_run_id").notNull().references(() => integrationRuns.id, { onDelete: "cascade" }),
-    entityType: text("entity_type").notNull(),
-    externalId: text("external_id").notNull(),
-    localId: text("local_id"),
-    operation: integrationRunItemOperationEnum("operation").notNull(),
-    status: integrationRunItemStatusEnum("status").notNull(),
-    /**
-     * Structured per-field diff — ADR-0003 shape enforced by
-     * `FieldDiffSchema.parse` at the recorder service layer.
-     *
-     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.
-     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`
-     * for created items; `{ [field]: { from: <value>, to: null } }` for
-     * deleted items.
-     */
-    changedFields: jsonb("changed_fields").notNull().default({}).$type(),
-    title: text("title"),
-    error: text("error"),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Ordered timeline within a run. */
-    idxIntegrationRunItemsRunCreatedAt: index("idx_integration_run_items_run_created_at").on(
-      t.integrationRunId,
-      t.createdAt
-    ),
-    /** Per-record history: "every integration that touched opportunity/$extId". */
-    idxIntegrationRunItemsEntityExternal: index(
-      "idx_integration_run_items_entity_external"
-    ).on(t.entityType, t.externalId)
-  })
-);
-
-// runtime/subsystems/integration/integration-cursor-store.memory-backend.ts
-import { Injectable } from "@nestjs/common";
-var MemoryCursorStore = class {
-  /**
-   * Subscription-id → last persisted cursor. Public so tests can inspect
-   * or pre-seed state; production callers MUST go through `get`/`put`.
-   */
-  cursors = /* @__PURE__ */ new Map();
-  /**
-   * Seedable subscription metadata for `listAll` — the memory backend
-   * stores only `subscriptionId → cursor` in its write path, so the
-   * snapshot shape (`connectionId`, `adapter`, `domain`, `externalRef`,
-   * timestamps) has no natural source without test seeding. Tests populate
-   * this map; unseeded entries get empty-string metadata and `new Date(0)`
-   * timestamps so the shape stays stable. Production paths go through the
-   * Drizzle backend.
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  async get(subscriptionId, _tenantId) {
-    const value = this.cursors.get(subscriptionId);
-    return value === void 0 ? null : value;
-  }
-  async put(subscriptionId, cursor, _tenantId) {
-    this.cursors.set(subscriptionId, cursor);
-  }
-  async listAll(_tenantId) {
-    const snapshots = [];
-    for (const [subscriptionId, cursor] of this.cursors.entries()) {
-      const meta = this.subscriptions.get(subscriptionId);
-      snapshots.push({
-        subscriptionId,
-        connectionId: meta?.connectionId ?? "",
-        adapter: meta?.adapter ?? "",
-        domain: meta?.domain ?? "",
-        externalRef: meta?.externalRef ?? null,
-        cursor: cursor ?? null,
-        lastIntegrationAt: meta?.lastIntegrationAt ?? null,
-        updatedAt: meta?.updatedAt ?? /* @__PURE__ */ new Date(0),
-        tenantId: null
-      });
-    }
-    return snapshots.sort(
-      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
-    );
-  }
-  /** Reset state. Tests call this in `beforeEach`. */
-  clear() {
-    this.cursors.clear();
-    this.subscriptions.clear();
-  }
-};
-MemoryCursorStore = __decorateClass([
-  Injectable()
-], MemoryCursorStore);
-
-// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
-import { Injectable as Injectable2 } from "@nestjs/common";
-var MemoryRunRecorder = class {
-  /**
-   * All started runs keyed by id. Public so tests can inspect lifecycle
-   * transitions without poking through recording methods.
-   */
-  runs = /* @__PURE__ */ new Map();
-  /**
-   * Items keyed by `integration_run_id`, array order matches insertion order —
-   * mirrors the timeline the `(integration_run_id, created_at)` index produces
-   * in Postgres.
-   */
-  items = /* @__PURE__ */ new Map();
-  /**
-   * Seedable subscription metadata — tests populate this to make
-   * `listRecent` return meaningful `connectionId` values. The memory
-   * backend doesn't track subscriptions on its own (only runs + items), so
-   * this map is the intentional extension point: tests write entries for
-   * the subscription ids they use, production code never touches it.
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  async startRun(input) {
-    const id = crypto.randomUUID();
-    this.runs.set(id, {
-      id,
-      subscriptionId: input.subscriptionId,
-      direction: input.direction,
-      action: input.action,
-      status: "running",
-      cursorBefore: input.cursorBefore ?? null,
-      cursorAfter: null,
-      recordsFound: 0,
-      recordsProcessed: 0,
-      durationMs: null,
-      error: null,
-      tenantId: input.tenantId ?? null,
-      startedAt: /* @__PURE__ */ new Date(),
-      completedAt: null
-    });
-    this.items.set(id, []);
-    return { id };
-  }
-  async recordItem(input) {
-    FieldDiffSchema.parse(input.changedFields);
-    const bucket = this.items.get(input.integrationRunId);
-    if (!bucket) {
-      throw new Error(
-        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
-      );
-    }
-    bucket.push(input);
-  }
-  async completeRun(runId, input) {
-    const run = this.runs.get(runId);
-    if (!run) {
-      throw new Error(
-        `MemoryRunRecorder.completeRun: no run started for id '${runId}'.`
-      );
-    }
-    run.status = input.status;
-    run.recordsFound = input.recordsFound;
-    run.recordsProcessed = input.recordsProcessed;
-    run.cursorAfter = input.cursorAfter ?? null;
-    run.durationMs = input.durationMs;
-    run.error = input.error ?? null;
-    run.completedAt = /* @__PURE__ */ new Date();
-  }
-  async listRecent(limit, subscriptionId, _tenantId) {
-    const all = Array.from(this.runs.values());
-    const filtered = subscriptionId === void 0 ? all : all.filter((r) => r.subscriptionId === subscriptionId);
-    return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).map((r) => ({
-      id: r.id,
-      subscriptionId: r.subscriptionId,
-      // connectionId is only knowable if the test seeded subscriptions
-      // metadata; empty string otherwise. The Drizzle backend resolves
-      // it via JOIN, which is the production path.
-      connectionId: this.subscriptions.get(r.subscriptionId)?.connectionId ?? "",
-      status: r.status,
-      startedAt: r.startedAt,
-      completedAt: r.completedAt,
-      recordsProcessed: r.recordsProcessed,
-      tenantId: r.tenantId
-    }));
-  }
-  /** Reset state. Tests call this in `beforeEach`. */
-  clear() {
-    this.runs.clear();
-    this.items.clear();
-    this.subscriptions.clear();
-  }
-  // ─── test ergonomics ─────────────────────────────────────────────────
-  /** All runs for a subscription, newest first. Timeline reads. */
-  getRunsForSubscription(subscriptionId) {
-    return Array.from(this.runs.values()).filter((r) => r.subscriptionId === subscriptionId).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
-  }
-  /** All item rows for a run, insertion-ordered. */
-  getItemsForRun(runId) {
-    return this.items.get(runId) ?? [];
-  }
-};
-MemoryRunRecorder = __decorateClass([
-  Injectable2()
-], MemoryRunRecorder);
-
-// runtime/subsystems/integration/deep-equal.differ.ts
-import { Injectable as Injectable3 } from "@nestjs/common";
-var DEFAULT_IGNORE_FIELDS = /* @__PURE__ */ new Set([
-  "id",
-  "createdAt",
-  "updatedAt",
-  "deletedAt",
-  "type",
-  "lastModifiedAt",
-  "fields",
-  "external_id",
-  "externalId",
-  "provider",
-  "provider_metadata",
-  "providerMetadata"
-]);
-var DeepEqualDiffer = class {
-  ignore;
-  constructor(opts = {}) {
-    if (opts.ignore && opts.ignore.length > 0) {
-      this.ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE_FIELDS, ...opts.ignore]);
-    } else {
-      this.ignore = DEFAULT_IGNORE_FIELDS;
-    }
-  }
-  diff(existing, incoming, providerChangedFields) {
-    if (existing === null) {
-      const out2 = {};
-      for (const key of Object.keys(incoming)) {
-        if (this.ignore.has(key)) continue;
-        const value = incoming[key];
-        if (value === null || value === void 0) continue;
-        out2[key] = { from: null, to: value };
-      }
-      return Object.keys(out2).length === 0 ? "noop" : out2;
-    }
-    const candidates = /* @__PURE__ */ new Set();
-    if (providerChangedFields && providerChangedFields.length > 0) {
-      for (const key of providerChangedFields) {
-        if (!this.ignore.has(key)) candidates.add(key);
-      }
-    } else {
-      for (const key of Object.keys(incoming)) {
-        if (!this.ignore.has(key)) candidates.add(key);
-      }
-      for (const key of Object.keys(existing)) {
-        if (this.ignore.has(key)) continue;
-        if (!(key in incoming)) continue;
-        candidates.add(key);
-      }
-    }
-    const out = {};
-    for (const key of candidates) {
-      const before = existing[key];
-      const after = incoming[key];
-      if (!isEqual(before, after)) {
-        out[key] = { from: before ?? null, to: after ?? null };
-      }
-    }
-    return Object.keys(out).length === 0 ? "noop" : out;
-  }
-};
-DeepEqualDiffer = __decorateClass([
-  Injectable3()
-], DeepEqualDiffer);
-function isEqual(a, b) {
-  if (a === b) return true;
-  const na = normalize(a);
-  const nb = normalize(b);
-  if (na === nb) return true;
-  if (typeof na === "object" && typeof nb === "object" && na !== null && nb !== null) {
-    return deepEqualObject(na, nb);
-  }
-  const numericEqual = maybeNumericEqual(na, nb) || maybeNumericEqual(nb, na);
-  return numericEqual;
-}
-function normalize(value) {
-  if (value instanceof Date) return value.toISOString();
-  return value;
-}
-function maybeNumericEqual(a, b) {
-  if (typeof a !== "string" || typeof b !== "number") return false;
-  if (a.trim() === "") return false;
-  const parsed = Number(a);
-  if (!Number.isFinite(parsed)) return false;
-  return parsed === b;
-}
-function deepEqualObject(a, b) {
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (!(key in b)) return false;
-    if (!isEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-
-// runtime/subsystems/integration/execute-integration.use-case.ts
-import { Inject, Injectable as Injectable4, Logger, Optional } from "@nestjs/common";
-var ExecuteIntegrationUseCase = class {
-  constructor(source, cursors, differ, sink, recorder, multiTenant = false) {
-    this.source = source;
-    this.cursors = cursors;
-    this.differ = differ;
-    this.sink = sink;
-    this.recorder = recorder;
-    this.multiTenant = multiTenant;
-  }
-  source;
-  cursors;
-  differ;
-  sink;
-  recorder;
-  multiTenant;
-  logger = new Logger(ExecuteIntegrationUseCase.name);
-  async execute(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "execute"
-    });
-    const source = input.sourceOverride ?? this.source;
-    const startedAt = Date.now();
-    const cursorBefore = await this.cursors.get(input.subscription.id, input.tenantId);
-    const { id: runId } = await this.recorder.startRun({
-      subscriptionId: input.subscription.id,
-      direction: input.direction,
-      action: input.action,
-      cursorBefore,
-      tenantId: input.tenantId
-    });
-    let recordsFound = 0;
-    let recordsProcessed = 0;
-    let recordsFailed = 0;
-    let latestCursor = cursorBefore;
-    let cursorAdvanced = false;
-    let runError = null;
-    let status = "no_changes";
-    try {
-      for await (const change of source.listChanges(input.subscription, cursorBefore)) {
-        recordsFound++;
-        latestCursor = change.cursor;
-        cursorAdvanced = true;
-        try {
-          await this.processChange(runId, input, change);
-          recordsProcessed++;
-        } catch (err) {
-          recordsFailed++;
-          const message = err instanceof Error ? err.message : String(err);
-          this.logger.warn(
-            `integration item failed: subscription=${input.subscription.id} externalId=${change.externalId}: ${message}`
-          );
-          await this.recorder.recordItem({
-            integrationRunId: runId,
-            entityType: input.subscription.domain,
-            externalId: change.externalId,
-            operation: change.operation === "deleted" ? "deleted" : "updated",
-            status: "failed",
-            changedFields: {},
-            error: message,
-            tenantId: input.tenantId
-          });
-        }
-      }
-      if (recordsFailed > 0 && recordsProcessed === 0 && recordsFound > 0) {
-        status = "failed";
-        runError = `all ${recordsFailed} records failed`;
-      } else if (recordsFound === 0) {
-        status = "no_changes";
-      } else {
-        status = "success";
-      }
-    } catch (err) {
-      status = "failed";
-      runError = err instanceof Error ? err.message : String(err);
-      this.logger.error(
-        `integration source failed: subscription=${input.subscription.id}: ${runError}`
-      );
-    }
-    if (cursorAdvanced && latestCursor !== null && latestCursor !== void 0) {
-      try {
-        await this.cursors.put(input.subscription.id, latestCursor, input.tenantId);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        this.logger.error(
-          `cursor put failed: subscription=${input.subscription.id}: ${message}`
-        );
-        if (status !== "failed") {
-          status = "failed";
-          runError = `cursor put failed: ${message}`;
-        }
-      }
-    }
-    const durationMs = Date.now() - startedAt;
-    await this.recorder.completeRun(runId, {
-      status,
-      recordsFound,
-      recordsProcessed,
-      cursorAfter: cursorAdvanced ? latestCursor : cursorBefore,
-      durationMs,
-      error: runError
-    });
-    return {
-      runId,
-      status,
-      recordsFound,
-      recordsProcessed,
-      recordsFailed,
-      cursorBefore,
-      cursorAfter: cursorAdvanced ? latestCursor : cursorBefore,
-      durationMs,
-      error: runError
-    };
-  }
-  async processChange(runId, input, change) {
-    if (change.operation === "deleted") {
-      const result = await this.sink.softDeleteByExternalId(
-        input.userId,
-        change.externalId
-      );
-      await this.recorder.recordItem({
-        integrationRunId: runId,
-        entityType: input.subscription.domain,
-        externalId: change.externalId,
-        localId: result?.id ?? null,
-        operation: result ? "deleted" : "noop",
-        status: "success",
-        changedFields: {},
-        tenantId: input.tenantId
-      });
-      return;
-    }
-    const existing = await this.sink.findByExternalId(
-      input.userId,
-      change.externalId
-    );
-    const diff = this.differ.diff(
-      existing,
-      change.record,
-      change.providerChangedFields
-    );
-    if (diff === "noop") {
-      if (!this.sink.reprojectsOnNoop) {
-        await this.recorder.recordItem({
-          integrationRunId: runId,
-          entityType: input.subscription.domain,
-          externalId: change.externalId,
-          localId: null,
-          operation: "noop",
-          status: "success",
-          changedFields: {},
-          tenantId: input.tenantId
-        });
-        return;
-      }
-      const { id: noopLocalId } = await this.sink.upsertByExternalId(
-        input.userId,
-        change.record,
-        input.provider
-      );
-      await this.recorder.recordItem({
-        integrationRunId: runId,
-        entityType: input.subscription.domain,
-        externalId: change.externalId,
-        localId: noopLocalId,
-        operation: "noop",
-        status: "success",
-        changedFields: {},
-        tenantId: input.tenantId
-      });
-      return;
-    }
-    const { id: localId } = await this.sink.upsertByExternalId(
-      input.userId,
-      change.record,
-      input.provider
-    );
-    await this.recorder.recordItem({
-      integrationRunId: runId,
-      entityType: input.subscription.domain,
-      externalId: change.externalId,
-      localId,
-      operation: existing === null ? "created" : "updated",
-      status: "success",
-      changedFields: diff,
-      tenantId: input.tenantId
-    });
-  }
-};
-ExecuteIntegrationUseCase = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject(INTEGRATION_CHANGE_SOURCE)),
-  __decorateParam(1, Inject(INTEGRATION_CURSOR_STORE)),
-  __decorateParam(2, Inject(INTEGRATION_FIELD_DIFFER)),
-  __decorateParam(3, Inject(INTEGRATION_SINK)),
-  __decorateParam(4, Inject(INTEGRATION_RUN_RECORDER)),
-  __decorateParam(5, Optional()),
-  __decorateParam(5, Inject(INTEGRATION_MULTI_TENANT))
-], ExecuteIntegrationUseCase);
-
-// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
-import { Inject as Inject2, Injectable as Injectable5, Optional as Optional2 } from "@nestjs/common";
-import { and, desc, eq } from "drizzle-orm";
-
-// runtime/constants/tokens.ts
-var DRIZZLE = "DRIZZLE";
-
-// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
-var PostgresCursorStore = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant ?? false;
-  }
-  db;
-  multiTenant;
-  async get(subscriptionId, tenantId) {
-    const where = this.buildWhere(subscriptionId, tenantId, "cursor.get");
-    const rows = await this.db.select({ cursor: integrationSubscriptions.cursor }).from(integrationSubscriptions).where(where).limit(1);
-    if (rows.length === 0) return null;
-    return rows[0]?.cursor ?? null;
-  }
-  async put(subscriptionId, cursor, tenantId) {
-    const where = this.buildWhere(subscriptionId, tenantId, "cursor.put");
-    await this.db.update(integrationSubscriptions).set({
-      cursor,
-      lastIntegrationAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(where);
-  }
-  async listAll(tenantId) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "cursor.listAll"
-    });
-    const where = this.multiTenant ? eq(integrationSubscriptions.tenantId, tenantId) : void 0;
-    const rows = await this.db.select({
-      id: integrationSubscriptions.id,
-      connectionId: integrationSubscriptions.connectionId,
-      adapter: integrationSubscriptions.adapter,
-      domain: integrationSubscriptions.domain,
-      externalRef: integrationSubscriptions.externalRef,
-      cursor: integrationSubscriptions.cursor,
-      lastIntegrationAt: integrationSubscriptions.lastIntegrationAt,
-      updatedAt: integrationSubscriptions.updatedAt,
-      tenantId: integrationSubscriptions.tenantId
-    }).from(integrationSubscriptions).where(where).orderBy(desc(integrationSubscriptions.updatedAt));
-    return rows.map((row) => ({
-      subscriptionId: row.id,
-      connectionId: row.connectionId,
-      adapter: row.adapter,
-      domain: row.domain,
-      externalRef: row.externalRef,
-      cursor: row.cursor ?? null,
-      lastIntegrationAt: row.lastIntegrationAt,
-      updatedAt: row.updatedAt,
-      tenantId: row.tenantId
-    }));
-  }
-  /**
-   * Centralized WHERE clause — `get` and `put` share identical semantics.
-   * Drift here would let a caller read under one tenancy rule and write
-   * under another.
-   */
-  buildWhere(subscriptionId, tenantId, operation) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation
-    });
-    if (this.multiTenant) {
-      return and(
-        eq(integrationSubscriptions.id, subscriptionId),
-        eq(integrationSubscriptions.tenantId, tenantId)
-      );
-    }
-    return eq(integrationSubscriptions.id, subscriptionId);
-  }
-};
-PostgresCursorStore = __decorateClass([
-  Injectable5(),
-  __decorateParam(0, Inject2(DRIZZLE)),
-  __decorateParam(1, Optional2()),
-  __decorateParam(1, Inject2(INTEGRATION_MULTI_TENANT))
-], PostgresCursorStore);
-
-// runtime/subsystems/integration/integration-run-recorder.drizzle-backend.ts
-import { Inject as Inject3, Injectable as Injectable6, Optional as Optional3 } from "@nestjs/common";
-import { and as and2, desc as desc2, eq as eq2 } from "drizzle-orm";
-var DrizzleIntegrationRunRecorder = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant ?? false;
-  }
-  db;
-  multiTenant;
-  async startRun(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "startRun"
-    });
-    const rows = await this.db.insert(integrationRuns).values({
-      subscriptionId: input.subscriptionId,
-      direction: input.direction,
-      action: input.action,
-      status: "running",
-      cursorBefore: input.cursorBefore ?? null,
-      tenantId: input.tenantId ?? null
-    }).returning({ id: integrationRuns.id });
-    const id = rows[0]?.id;
-    if (!id) {
-      throw new Error("DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id");
-    }
-    return { id };
-  }
-  async recordItem(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "recordItem"
-    });
-    FieldDiffSchema.parse(input.changedFields);
-    await this.db.insert(integrationRunItems).values({
-      integrationRunId: input.integrationRunId,
-      entityType: input.entityType,
-      externalId: input.externalId,
-      localId: input.localId ?? null,
-      operation: input.operation,
-      status: input.status,
-      changedFields: input.changedFields,
-      title: input.title ?? null,
-      error: input.error ?? null,
-      tenantId: input.tenantId ?? null
-    });
-  }
-  async listRecent(limit, subscriptionId, tenantId) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "listRecent"
-    });
-    const conditions = [];
-    if (subscriptionId !== void 0) {
-      conditions.push(eq2(integrationRuns.subscriptionId, subscriptionId));
-    }
-    if (this.multiTenant) {
-      conditions.push(eq2(integrationRuns.tenantId, tenantId));
-    }
-    const where = conditions.length === 0 ? void 0 : conditions.length === 1 ? conditions[0] : and2(...conditions);
-    const rows = await this.db.select({
-      id: integrationRuns.id,
-      subscriptionId: integrationRuns.subscriptionId,
-      connectionId: integrationSubscriptions.connectionId,
-      status: integrationRuns.status,
-      startedAt: integrationRuns.startedAt,
-      completedAt: integrationRuns.completedAt,
-      recordsProcessed: integrationRuns.recordsProcessed,
-      tenantId: integrationRuns.tenantId
-    }).from(integrationRuns).innerJoin(
-      integrationSubscriptions,
-      eq2(integrationRuns.subscriptionId, integrationSubscriptions.id)
-    ).where(where).orderBy(desc2(integrationRuns.startedAt)).limit(limit);
-    return rows.map((row) => ({
-      id: row.id,
-      subscriptionId: row.subscriptionId,
-      connectionId: row.connectionId,
-      status: row.status,
-      startedAt: row.startedAt,
-      completedAt: row.completedAt,
-      recordsProcessed: row.recordsProcessed,
-      tenantId: row.tenantId
-    }));
-  }
-  async completeRun(runId, input) {
-    await this.db.update(integrationRuns).set({
-      status: input.status,
-      recordsFound: input.recordsFound,
-      recordsProcessed: input.recordsProcessed,
-      cursorAfter: input.cursorAfter ?? null,
-      durationMs: input.durationMs,
-      error: input.error ?? null,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq2(integrationRuns.id, runId));
-  }
-};
-DrizzleIntegrationRunRecorder = __decorateClass([
-  Injectable6(),
-  __decorateParam(0, Inject3(DRIZZLE)),
-  __decorateParam(1, Optional3()),
-  __decorateParam(1, Inject3(INTEGRATION_MULTI_TENANT))
-], DrizzleIntegrationRunRecorder);
-
-// runtime/subsystems/integration/integration.module.ts
-import { Module } from "@nestjs/common";
-var IntegrationModule = class {
-  static forRoot(options) {
-    const multiTenant = options.multiTenant ?? false;
-    const sharedProviders = [
-      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },
-      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
-      // Default differ — consumers can override by binding a different
-      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
-      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
-    ];
-    const backendProviders = options.backend === "memory" ? [
-      // Wired as singletons via `useValue` so tests can pull
-      // them out via `moduleRef.get(MemoryCursorStore)` for
-      // direct assertions. Matches JOB-4 / MemoryJobStore shape.
-      { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },
-      {
-        provide: INTEGRATION_CURSOR_STORE,
-        useExisting: MemoryCursorStore
-      },
-      { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },
-      {
-        provide: INTEGRATION_RUN_RECORDER,
-        useExisting: MemoryRunRecorder
-      }
-    ] : [
-      // Drizzle backends — injected with DRIZZLE (provided by the
-      // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag
-      // we bound above.
-      { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },
-      { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder }
-    ];
-    return {
-      module: IntegrationModule,
-      global: true,
-      providers: [...sharedProviders, ...backendProviders],
-      exports: [
-        INTEGRATION_MODULE_OPTIONS,
-        INTEGRATION_MULTI_TENANT,
-        INTEGRATION_FIELD_DIFFER,
-        INTEGRATION_CURSOR_STORE,
-        INTEGRATION_RUN_RECORDER
-      ]
-    };
-  }
-};
-IntegrationModule = __decorateClass([
-  Module({})
-], IntegrationModule);
-
-// src/schema/entity-definition.schema.ts
-var FieldTypeSchema = z3.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 = z3.enum([
-  "text",
-  "textarea",
-  "number",
-  "money",
-  "percentage",
-  "email",
-  "url",
-  "date",
-  "datetime",
-  "boolean",
-  "enum",
-  "reference",
-  "json",
-  "badge",
-  "password"
-]);
-var UiImportanceSchema = z3.enum(["primary", "secondary", "tertiary"]);
-var AnalyticsAggregationSchema = z3.enum([
-  "sum",
-  "min",
-  "max",
-  "count",
-  "count_distinct",
-  "average",
-  "median",
-  "percentile",
-  "sum_boolean"
-]);
-var AnalyticsDimensionTypeSchema = z3.enum(["categorical", "time"]);
-var AnalyticsEntityTypeSchema = z3.enum(["primary", "unique", "foreign", "natural"]);
-var AnalyticsTimeGranularitySchema = z3.enum(["day", "week", "month", "quarter", "year"]);
-var AnalyticsVisibilitySchema = z3.enum(["internal", "agent", "public"]);
-var NonAdditiveDimensionSchema = z3.union([
-  z3.string(),
-  z3.object({
-    name: z3.string(),
-    window_choice: z3.string().optional(),
-    window_groupings: z3.array(z3.string()).optional()
-  })
-]);
-var SemanticMetadataSchema = z3.object({
-  measure: z3.boolean().optional(),
-  analytics_aggregation: AnalyticsAggregationSchema.optional(),
-  agg_time_dimension: z3.string().optional(),
-  non_additive_dimension: NonAdditiveDimensionSchema.optional(),
-  dimension: z3.boolean().optional(),
-  dimension_type: AnalyticsDimensionTypeSchema.optional(),
-  time_granularity: AnalyticsTimeGranularitySchema.optional(),
-  is_partition: z3.boolean().optional(),
-  entity: z3.boolean().optional(),
-  entity_type: AnalyticsEntityTypeSchema.optional(),
-  entity_role: z3.string().optional(),
-  analytics_visibility: AnalyticsVisibilitySchema.optional(),
-  semantic_expr: z3.string().optional(),
-  semantic_label: z3.string().optional()
-});
-var UiMetadataSchema = z3.object({
-  ui_label: z3.string().optional(),
-  ui_type: UiTypeSchema.optional(),
-  ui_importance: UiImportanceSchema.optional(),
-  ui_group: z3.string().optional(),
-  ui_sortable: z3.boolean().optional(),
-  ui_filterable: z3.boolean().optional(),
-  ui_visible: z3.boolean().optional(),
-  ui_placeholder: z3.string().optional(),
-  ui_help: z3.string().optional(),
-  ui_format: z3.record(z3.unknown()).optional()
-});
-var BaseFieldSchema = z3.object({
-  type: FieldTypeSchema,
-  required: z3.boolean().optional().default(false),
-  nullable: z3.boolean().optional().default(false),
-  // String constraints
-  max_length: z3.number().int().positive().optional(),
-  min_length: z3.number().int().nonnegative().optional(),
-  // Numeric constraints
-  min: z3.number().optional(),
-  max: z3.number().optional(),
-  // Enum/choices (inline definition)
-  choices: z3.array(z3.string()).optional(),
-  // Enum/choices from external file (e.g., "relationship_types.yaml")
-  // Mutually exclusive with choices - parser loads file and extracts keys
-  choices_from: z3.string().optional(),
-  // Entity reference: allowed entity types for polymorphic refs
-  // Required when type is 'entity_ref'
-  allowed_types: z3.array(z3.string()).optional(),
-  // Default value
-  default: z3.unknown().optional(),
-  // Indexing
-  index: z3.boolean().optional(),
-  unique: z3.boolean().optional(),
-  // Foreign key reference (e.g., "accounts.id")
-  foreign_key: z3.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 = z3.enum(["belongs_to", "has_many", "has_one"]);
-var OnDeleteSchema = z3.enum(["restrict", "cascade", "set_null", "no_action"]);
-var RelationshipSchema = z3.object({
-  type: RelationshipTypeSchema,
-  target: z3.string(),
-  // Target entity name (e.g., "account")
-  foreign_key: z3.string(),
-  // FK field name (e.g., "account_id")
-  through: z3.string().optional(),
-  // For transitive: "owned_opportunities.updates"
-  inverse: z3.string().optional(),
-  // Name of inverse relationship on target entity
-  nullable: z3.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 = z3.union([
-  z3.string(),
-  z3.object({
-    name: z3.string(),
-    options: z3.record(z3.unknown()).optional()
-  })
-]);
-var BehaviorStrategySchema = z3.enum(["base_class", "inline"]);
-var FolderStructureSchema = z3.enum(["nested", "flat"]).default("nested");
-var FileGroupingSchema = z3.enum(["separate", "grouped"]).default("separate");
-var ExposeLayerSchema = z3.enum(["repository", "rest", "trpc", "electric"]);
-var EntityConfigSchema = z3.object({
-  name: z3.string().regex(
-    /^[a-z][a-z0-9_]*$/,
-    "Entity name must be lowercase with underscores (e.g., 'opportunity')"
-  ),
-  plural: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Plural must be lowercase"),
-  table: z3.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: z3.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: z3.string().optional(),
-  patterns: z3.array(z3.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: z3.record(z3.string(), z3.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: z3.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: z3.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: z3.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 = 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(),
-  via: z3.string().optional()
-});
-var SearchQueryDeclarationSchema = z3.object({
-  name: z3.literal("search"),
-  filters: z3.array(z3.string()).min(1),
-  search: z3.string().optional(),
-  paginate: z3.boolean().optional().default(true),
-  order: z3.string().optional()
-});
-var AnyQueryDeclarationSchema = z3.union([
-  SearchQueryDeclarationSchema,
-  QueryDeclarationSchema
-]);
-var IntegrationDirectionSchema = z3.enum([
-  "inbound",
-  "outbound",
-  "bidirectional"
-]);
-var ProviderIntegrationSchema = z3.object({
-  remote_entity: z3.string(),
-  direction: IntegrationDirectionSchema,
-  cdc: z3.boolean().optional().default(false),
-  field_mapping: z3.record(z3.string(), z3.string()).optional(),
-  read_only_fields: z3.array(z3.string()).optional()
-});
-var IntegrationConfigSchema = z3.object({
-  electric: z3.boolean().optional().default(false),
-  providers: z3.record(z3.string(), ProviderIntegrationSchema).optional()
-});
-var EventDeclarationSchema = z3.object({
-  name: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Event name must be snake_case"),
-  queue: z3.string(),
-  body: z3.record(z3.string(), z3.string()),
-  generate_handler: z3.boolean().optional().default(false)
-});
-var SimpleMetricSchema = z3.object({
-  type: z3.literal("simple"),
-  measure: z3.string(),
-  agg: AnalyticsAggregationSchema.optional(),
-  filter: z3.string().optional(),
-  description: z3.string().optional(),
-  label: z3.string().optional()
-});
-var DerivedMetricSchema = z3.object({
-  type: z3.literal("derived"),
-  expr: z3.string(),
-  metrics: z3.array(z3.string()),
-  description: z3.string().optional(),
-  label: z3.string().optional()
-});
-var RatioMetricSchema = z3.object({
-  type: z3.literal("ratio"),
-  numerator: z3.union([z3.string(), SimpleMetricSchema]),
-  denominator: z3.union([z3.string(), SimpleMetricSchema]),
-  filter: z3.string().optional(),
-  description: z3.string().optional(),
-  label: z3.string().optional()
-});
-var CumulativeMetricSchema = z3.object({
-  type: z3.literal("cumulative"),
-  measure: z3.string(),
-  window: z3.string().optional(),
-  grain_to_date: AnalyticsTimeGranularitySchema.optional(),
-  description: z3.string().optional(),
-  label: z3.string().optional()
-});
-var MetricDefinitionSchema = z3.discriminatedUnion("type", [
-  SimpleMetricSchema,
-  DerivedMetricSchema,
-  RatioMetricSchema,
-  CumulativeMetricSchema
-]);
-var AnalyticsBlockSchema = z3.object({
-  measure_packs: z3.array(z3.string()).optional(),
-  cube_name: z3.string().optional(),
-  metrics: z3.record(z3.string(), MetricDefinitionSchema).optional()
-});
-var GenerateConfigSchema = z3.object({
-  writes: z3.boolean().optional().default(true)
-}).strict();
-var EntityDefinitionSchema = z3.object({
-  entity: EntityConfigSchema,
-  fields: z3.record(z3.string(), FieldDefinitionSchema),
-  relationships: z3.record(z3.string(), RelationshipSchema).optional(),
-  // Behaviors add cross-cutting concerns (timestamps, soft_delete, user_tracking, etc.)
-  behaviors: z3.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: z3.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: z3.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: z3.string().optional(),
-  // v2: Declarative query generation (ADR-005)
-  // Generates repository + service + use case methods from declarations
-  queries: z3.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: z3.record(z3.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: z3.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: z3.array(
-    z3.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: z3.array(
-    z3.object({
-      fields: z3.array(z3.string()).min(2, "unique_indexes entries span 2+ columns \u2014 use `unique: true` on the field for single-column uniqueness"),
-      name: z3.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 z4 } 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 = z4.enum(EVENT_DIRECTIONS);
-var EventTierSchema = z4.enum(EVENT_TIERS);
-var EventFieldTypeSchema = z4.enum(EVENT_FIELD_TYPES);
-var EventArrayItemTypeSchema = z4.enum(EVENT_ARRAY_ITEM_TYPES);
-var EventPoolSchema = z4.enum(RESERVED_EVENT_POOLS);
-var EventPayloadFieldSchema = z4.object({
-  type: EventFieldTypeSchema,
-  items: EventArrayItemTypeSchema.optional(),
-  nullable: z4.boolean().optional().default(false),
-  description: z4.string().optional()
-}).strict().superRefine((data, ctx) => {
-  if (data.type === "array" && data.items === void 0) {
-    ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
-      message: "'items' is required when type is 'array'",
-      path: ["items"]
-    });
-  }
-  if (data.type !== "array" && data.items !== void 0) {
-    ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
-      message: `'items' is only valid when type is 'array' (got '${data.type}')`,
-      path: ["items"]
-    });
-  }
-});
-var RetrySchema = z4.object({
-  attempts: z4.number().int().min(0).max(20),
-  backoff: z4.enum(EVENT_BACKOFF_STRATEGIES)
-}).strict();
-var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*$/;
-var EventDefinitionSchemaCore = z4.object({
-  type: z4.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: z4.string().regex(SNAKE_CASE_RE).optional(),
-  source: z4.string().min(1).optional(),
-  destination: z4.string().min(1).optional(),
-  payload: z4.record(
-    z4.string().regex(SNAKE_CASE_RE, "Payload keys must be snake_case"),
-    EventPayloadFieldSchema
-  ).default({}),
-  retry: RetrySchema.optional().default({
-    attempts: 3,
-    backoff: "exponential"
-  }),
-  version: z4.number().int().min(1).optional().default(1),
-  description: z4.string().optional()
-}).strict();
-var EventDefinitionSchemaRefined = EventDefinitionSchemaCore.superRefine(
-  (data, ctx) => {
-    if (data.tier === "audit") {
-      if (data.pool !== void 0) {
-        ctx.addIssue({
-          code: z4.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: z4.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: z4.ZodIssueCode.custom,
-        message: "'direction' is required when tier is 'domain'",
-        path: ["direction"]
-      });
-      return;
-    }
-    if (data.direction === "change" && !data.aggregate) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "'aggregate' is required when direction is 'change'",
-        path: ["aggregate"]
-      });
-    }
-    if (data.source !== void 0 && data.direction !== "inbound") {
-      ctx.addIssue({
-        code: z4.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: z4.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: z4.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 z5 } from "zod";
-var TypeDirectionSchema = z5.object({
-  /** Name of the inverse type when viewed from the other direction */
-  inverse: z5.string().optional(),
-  /** Both directions are equivalent — queries should check both FK columns */
-  bidirectional: z5.boolean().optional(),
-  /** Explicitly directed, no named inverse (default behavior) */
-  directed: z5.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 = z5.union([
-  // Simple list: all types are directed from→to
-  z5.array(z5.string().regex(/^[a-z][a-z0-9_]*$/, "Type must be snake_case")),
-  // Object map: each type has direction metadata
-  z5.record(
-    z5.string().regex(/^[a-z][a-z0-9_]*$/, "Type key must be snake_case"),
-    TypeDirectionSchema
-  )
-]);
-var OnDeleteActionSchema = z5.enum(["restrict", "cascade", "set_null", "no_action"]).default("restrict");
-var RelationshipConfigSchema = z5.object({
-  /** Relationship name (snake_case). Used for class/file naming. */
-  name: z5.string().regex(
-    /^[a-z][a-z0-9_]*$/,
-    "Relationship name must be snake_case"
-  ),
-  /** Database table name. Defaults to {name}s if not specified. */
-  table: z5.string().regex(/^[a-z][a-z0-9_]*$/, "Table must be snake_case").optional(),
-  /** The "from" entity — generates {entity}_id FK column (subject). */
-  from: z5.string().regex(/^[a-z][a-z0-9_]*$/, "Entity name must be snake_case"),
-  /** The "to" entity — generates {entity}_id FK column (object). */
-  to: z5.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: z5.boolean().default(true),
-  /**
-   * Generate source tracking fields: source (enum), confidence (decimal 0-1).
-   * Default: true
-   */
-  sourced: z5.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: z5.array(z5.string()).optional()
-}).strict();
-var RelationshipQuerySchema = z5.object({
-  by: z5.array(z5.string()).min(1),
-  unique: z5.boolean().optional(),
-  select: z5.array(z5.string()).optional(),
-  order: z5.string().optional(),
-  limit: z5.boolean().optional()
-});
-var RelationshipDefinitionSchema = z5.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: z5.record(z5.string(), z5.any()).optional(),
-  /** Declarative queries — same syntax as entity queries. */
-  queries: z5.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 z6 } 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 = z6.string().regex(/^[a-z][a-z0-9_]*$/, "Entity reference must be snake_case");
-var JunctionDefinitionSchema = z6.object({
-  /** Discriminator literal — `pattern: Junction`. */
-  pattern: z6.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: z6.tuple([EntityNameSchema, EntityNameSchema]),
-  /**
-   * Emit BaseJunctionFields temporal columns (`started_at`, `ended_at`,
-   * `matched_at`). Default true. Matches Relationship's `temporal` toggle.
-   */
-  temporal: z6.boolean().optional().default(true),
-  /**
-   * Emit BaseJunctionFields sourcing columns (`sourced_from`,
-   * `confidence`). Default true. Matches Relationship's `sourced` toggle.
-   */
-  sourced: z6.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: z6.record(z6.string(), z6.any()).optional(),
-  /**
-   * Declarative queries — same syntax as entity queries. Shape is
-   * validated downstream by the codegen layer.
-   */
-  queries: z6.array(z6.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: z6.object({
-    left: z6.boolean().optional().default(true),
-    right: z6.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 z7 } from "zod";
-var IMPORT_REF_RE = /^[^#\s]+#[A-Za-z_$][A-Za-z0-9_$]*$/;
-var ImportRefSchema = z7.string().regex(
-  IMPORT_REF_RE,
-  "must be an 'import-path#Export' reference (e.g. '@app/foo/bar.strategy#BarStrategy')"
-);
-var AuthTypeSchema = z7.enum(["oauth2", "api-key", "app-password"]);
-var AuthSchema = z7.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: z7.array(z7.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 = z7.object({
-  // API client class. Pre-flight verified against a real export.
-  class: ImportRefSchema,
-  base_url: z7.string().url("client.base_url must be an absolute URL")
-}).strict();
-var ProviderDefinitionSchema = z7.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: z7.string().regex(
-    /^[a-z][a-z0-9-]*$/,
-    "slug must be kebab-case lower (e.g. 'google', 'hubspot')"
-  ),
-  display_name: z7.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: z7.array(z7.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: z7.number().int().positive().optional(),
-  refresh_behavior: z7.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 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 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
-  };
-}
-
-// 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";
-
-// 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/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 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(text2, ...styles) {
-  return `${styles.join("")}${text2}${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);
-}
-
-// 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 index2 = field.index ? "Yes" : field.unique ? "Unique" : "";
-    const fk = field.foreignKey ? `${field.foreignKey.table}.${field.foreignKey.column}` : "";
-    lines.push(`| ${name} | ${field.type} | ${required} | ${nullable} | ${index2} | ${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 z8 } from "zod";
-var JunctionPatternConfigSchema = z8.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
-  };
-}
+  ActivityPattern,
+  BASE_JUNCTION_FIELD_NAMES,
+  BaseJunctionFields,
+  BasePattern,
+  IntegratedPattern,
+  JunctionDefinitionSchema,
+  JunctionPattern,
+  KnowledgePattern,
+  MetadataPattern,
+  analyzeDomain,
+  buildDomainGraph,
+  checkConsistency,
+  computeStatistics,
+  defineOrchestrationPattern,
+  definePattern,
+  findCircularDependencies,
+  findOrphanEntities,
+  formatConsole,
+  formatJson,
+  formatMarkdown,
+  formatMermaidGraph,
+  getAllOrchestrationPatterns,
+  getAllPatternNames,
+  getAppPatternNames,
+  getLibraryPatternNames,
+  getOrchestrationPattern,
+  getOrchestrationPatternNames,
+  getPattern,
+  getRelatedEntities,
+  isDomainPattern,
+  isOrchestrationPattern,
+  isPatternDefinition,
+  loadAppPatterns,
+  loadEntities,
+  loadEntityFromYaml,
+  loadJunctionFromYaml,
+  loadRelationshipFromYaml,
+  loadRelationships,
+  registerLibraryPattern,
+  safeValidateJunctionDefinition,
+  validateEntities,
+  validateJunctionDefinition,
+  validateOrchestrationProject,
+  validatePatternComposition,
+  validatePatternProject
+} from "../chunk-32DOFN3T.js";
+import "../chunk-KVOWSC5S.js";
+import "../chunk-GCYKMF22.js";
+import "../chunk-EO2QPOKH.js";
+import "../chunk-PRWIX6UW.js";
+import "../chunk-DCCZB4UC.js";
+import "../chunk-AHV4GDYM.js";
+import "../chunk-SR7F3TJY.js";
+import "../chunk-SQDOBLBP.js";
+import "../chunk-3NMCDN7L.js";
+import "../chunk-4KNXX6TI.js";
+import "../chunk-3CJFPU6Q.js";
+import "../chunk-OGIZXGPY.js";
+import "../chunk-MZ6GV4YF.js";
+import "../chunk-LG57S2SC.js";
+import "../chunk-HNWZFNKP.js";
+import "../chunk-WWGYCIJX.js";
+import "../chunk-4MF3HKJA.js";
+import "../chunk-YLPAPPLW.js";
+import "../chunk-36U5UGIO.js";
+import "../chunk-S7C6TIIF.js";
+import "../chunk-U64T4YZE.js";
+import "../chunk-2E224ZSN.js";
 export {
   ActivityPattern,
   BASE_JUNCTION_FIELD_NAMES,