@maykonpaulo/maestro-core 0.2.1 → 0.3.0-next.1

package/dist/index.js

@@ -70,6 +70,52 @@ var ConsoleLogger = class {
   }
 };
 
+// src/logging/ConsoleStructuredLogger.ts
+var ConsoleStructuredLogger = class {
+  constructor(minLevel = "info") {
+    this.minLevel = minLevel;
+  }
+  minLevel;
+  debug(entry) {
+    this.log("debug", entry);
+  }
+  info(entry) {
+    this.log("info", entry);
+  }
+  warn(entry) {
+    this.log("warn", entry);
+  }
+  error(entry) {
+    this.log("error", entry);
+  }
+  log(level, entry) {
+    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.minLevel]) return;
+    const output = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level
+    };
+    if (entry.correlationId !== void 0) output["correlationId"] = entry.correlationId;
+    if (entry.operation !== void 0) output["operation"] = entry.operation;
+    if (entry.entity !== void 0) output["entity"] = entry.entity;
+    if (entry.entityId !== void 0) output["entityId"] = entry.entityId;
+    if (entry.actor !== void 0) output["actor"] = entry.actor;
+    if (entry.durationMs !== void 0) output["durationMs"] = entry.durationMs;
+    if (entry.status !== void 0) output["status"] = entry.status;
+    if (entry.severity !== void 0) output["severity"] = entry.severity;
+    if (entry.message !== void 0) output["message"] = entry.message;
+    if (entry.metadata !== void 0) output["metadata"] = entry.metadata;
+    if (entry.error !== void 0) output["error"] = this.serializeError(entry.error);
+    const consoleFn = level === "error" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.info;
+    consoleFn(JSON.stringify(output));
+  }
+  serializeError(error) {
+    if (error instanceof Error) {
+      return { name: error.name, message: error.message };
+    }
+    return error;
+  }
+};
+
 // src/audit/InMemoryAuditRepository.ts
 var InMemoryAuditRepository = class {
   store = /* @__PURE__ */ new Map();
@@ -85,6 +131,12 @@ var InMemoryAuditRepository = class {
     if (filter.action !== void 0) {
       events = events.filter((e) => e.action === filter.action);
     }
+    if (filter.entity !== void 0) {
+      events = events.filter((e) => e.entity === filter.entity);
+    }
+    if (filter.entityId !== void 0) {
+      events = events.filter((e) => e.entityId === filter.entityId);
+    }
     if (filter.resourceType !== void 0) {
       events = events.filter((e) => e.resource?.type === filter.resourceType);
     }
@@ -107,6 +159,9 @@ var InMemoryAuditRepository = class {
     }
     return events;
   }
+  async query(filter) {
+    return this.list(filter);
+  }
 };
 
 // src/audit/AuditRecorder.ts
@@ -124,6 +179,8 @@ var AuditRecorder = class {
       actor: input.actor,
       level: input.level ?? "info",
       resource: input.resource,
+      entity: input.entity,
+      entityId: input.entityId,
       before: input.before,
       after: input.after,
       metadata: input.metadata,
@@ -232,15 +289,2388 @@ var InMemoryEventBus = class {
     this.handlers.get(eventType)?.delete(handler);
   }
 };
+
+// src/metadata/EntityCapabilities.ts
+var DEFAULT_CAPABILITIES = {
+  list: true,
+  detail: true,
+  create: false,
+  update: false,
+  clone: false,
+  delete: false,
+  softDelete: false,
+  export: false,
+  bulkActions: false
+};
+
+// src/datasource/DatasourceRegistry.ts
+var DatasourceRegistry = class {
+  registry = /* @__PURE__ */ new Map();
+  register(id, provider) {
+    this.registry.set(id, provider);
+  }
+  get(id) {
+    const provider = this.registry.get(id);
+    if (!provider) {
+      throw new MaestroError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        `Datasource '${id}' not found. Registered datasources: [${this.ids().join(", ")}]`
+      );
+    }
+    return provider;
+  }
+  has(id) {
+    return this.registry.has(id);
+  }
+  ids() {
+    return Array.from(this.registry.keys());
+  }
+};
+
+// src/datasource/InMemoryDatasourceProvider.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var InMemoryDatasourceProvider = class {
+  tables = /* @__PURE__ */ new Map();
+  seed(table, records, primaryKey = "id") {
+    if (!this.tables.has(table)) {
+      this.tables.set(table, /* @__PURE__ */ new Map());
+    }
+    const store = this.tables.get(table);
+    for (const record of records) {
+      const id = String(record[primaryKey] ?? randomUUID2());
+      store.set(id, { ...record, [primaryKey]: id });
+    }
+  }
+  async list(context) {
+    const store = this.getStore(context.table);
+    let records = Array.from(store.values());
+    if (context.search?.term) {
+      const term = context.search.term.toLowerCase();
+      records = records.filter(
+        (r) => context.search.fields.some(
+          (field) => String(r[field] ?? "").toLowerCase().includes(term)
+        )
+      );
+    }
+    if (context.filters?.length) {
+      records = this.applyFilters(records, context.filters);
+    }
+    if (context.sort?.length) {
+      records = this.applySort(records, context.sort);
+    }
+    const total = records.length;
+    if (context.pagination) {
+      const p = context.pagination;
+      if (p.strategy === "page") {
+        const start = (p.page - 1) * p.pageSize;
+        records = records.slice(start, start + p.pageSize);
+        return { records, total, page: p.page, pageSize: p.pageSize, totalPages: Math.ceil(total / p.pageSize) };
+      }
+      if (p.strategy === "offset") {
+        records = records.slice(p.offset, p.offset + p.limit);
+      }
+      if (p.strategy === "cursor") {
+        const from = p.cursor ? parseInt(p.cursor, 10) : 0;
+        const sliced = records.slice(from, from + p.limit);
+        const nextIndex = from + p.limit;
+        return { records: sliced, total, nextCursor: nextIndex < total ? String(nextIndex) : void 0 };
+      }
+    }
+    return { records, total };
+  }
+  async findById(context) {
+    return this.getStore(context.table).get(context.id) ?? null;
+  }
+  async create(context) {
+    const store = this.getStore(context.table);
+    const id = String(context.data[context.primaryKey] ?? randomUUID2());
+    const record = { ...context.data, [context.primaryKey]: id };
+    store.set(id, record);
+    return record;
+  }
+  async update(context) {
+    const store = this.getStore(context.table);
+    const existing = store.get(context.id);
+    if (!existing) {
+      throw new MaestroError(
+        "NOT_FOUND" /* NOT_FOUND */,
+        `Record '${context.id}' not found in table '${context.table}'.`
+      );
+    }
+    const updated = { ...existing, ...context.data, [context.primaryKey]: context.id };
+    store.set(context.id, updated);
+    return updated;
+  }
+  async delete(context) {
+    const store = this.getStore(context.table);
+    if (!store.has(context.id)) {
+      throw new MaestroError(
+        "NOT_FOUND" /* NOT_FOUND */,
+        `Record '${context.id}' not found in table '${context.table}'.`
+      );
+    }
+    store.delete(context.id);
+  }
+  async count(context) {
+    const result = await this.list({ ...context, pagination: void 0 });
+    return result.total;
+  }
+  getStore(table) {
+    if (!this.tables.has(table)) {
+      this.tables.set(table, /* @__PURE__ */ new Map());
+    }
+    return this.tables.get(table);
+  }
+  applyFilters(records, filters) {
+    return records.filter((record) => filters.every((f) => this.matchFilter(record, f)));
+  }
+  matchFilter(record, filter) {
+    const val = record[filter.field];
+    switch (filter.operator) {
+      case "equals":
+        return val === filter.value;
+      case "notEquals":
+        return val !== filter.value;
+      case "contains":
+        return String(val ?? "").toLowerCase().includes(String(filter.value ?? "").toLowerCase());
+      case "startsWith":
+        return String(val ?? "").startsWith(String(filter.value ?? ""));
+      case "endsWith":
+        return String(val ?? "").endsWith(String(filter.value ?? ""));
+      case "in":
+        return Array.isArray(filter.value) && filter.value.includes(val);
+      case "notIn":
+        return Array.isArray(filter.value) && !filter.value.includes(val);
+      case "gt":
+        return val > filter.value;
+      case "gte":
+        return val >= filter.value;
+      case "lt":
+        return val < filter.value;
+      case "lte":
+        return val <= filter.value;
+      case "between": {
+        const [min, max] = filter.value;
+        return val >= min && val <= max;
+      }
+      case "isNull":
+        return val === null || val === void 0;
+      case "isNotNull":
+        return val !== null && val !== void 0;
+      case "isTrue":
+        return val === true;
+      case "isFalse":
+        return val === false;
+      default:
+        return true;
+    }
+  }
+  applySort(records, sort) {
+    return [...records].sort((a, b) => {
+      for (const { field, direction } of sort) {
+        const aVal = a[field];
+        const bVal = b[field];
+        let cmp = 0;
+        if (aVal === null || aVal === void 0) cmp = 1;
+        else if (bVal === null || bVal === void 0) cmp = -1;
+        else if (aVal < bVal) cmp = -1;
+        else if (aVal > bVal) cmp = 1;
+        if (cmp !== 0) return direction === "desc" ? -cmp : cmp;
+      }
+      return 0;
+    });
+  }
+};
+
+// src/operation/OperationRegistry.ts
+var OperationRegistry = class {
+  operations = /* @__PURE__ */ new Map();
+  register(operation) {
+    if (this.operations.has(operation.id)) {
+      throw new MaestroError(
+        "CONFLICT" /* CONFLICT */,
+        `Operation '${operation.id}' is already registered.`
+      );
+    }
+    this.operations.set(operation.id, operation);
+  }
+  get(id) {
+    const op = this.operations.get(id);
+    if (!op) {
+      throw new MaestroError("NOT_FOUND" /* NOT_FOUND */, `Operation '${id}' not found.`);
+    }
+    return op;
+  }
+  find(id) {
+    return this.operations.get(id);
+  }
+  forEntity(entityId, scope) {
+    return Array.from(this.operations.values()).filter(
+      (op) => op.entity === entityId && (scope === void 0 || op.scope === scope)
+    );
+  }
+  all() {
+    return Array.from(this.operations.values());
+  }
+};
+
+// src/schema/SchemaValidator.ts
+function validateMaestroConfig(config) {
+  const errors = [];
+  if (!config.datasources || Object.keys(config.datasources).length === 0) {
+    errors.push({ path: "datasources", message: "At least one datasource is required." });
+  }
+  if (!config.entities || config.entities.length === 0) {
+    errors.push({ path: "entities", message: "At least one entity is required." });
+  }
+  const entityIds = /* @__PURE__ */ new Set();
+  for (const entity of config.entities ?? []) {
+    validateEntity(entity, config, entityIds, errors);
+    if (entity.id) entityIds.add(entity.id);
+  }
+  for (const relation of config.relations ?? []) {
+    validateRelation(relation, entityIds, errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateEntity(entity, config, existingIds, errors) {
+  const prefix = `entities[${entity.id ?? "?"}]`;
+  if (!entity.id) {
+    errors.push({ path: prefix, message: "Entity id is required." });
+    return;
+  }
+  if (existingIds.has(entity.id)) {
+    errors.push({ path: prefix, message: `Duplicate entity id '${entity.id}'.` });
+  }
+  if (!entity.label?.singular || !entity.label?.plural) {
+    errors.push({ path: `${prefix}.label`, message: "Entity label.singular and label.plural are required." });
+  }
+  if (!entity.source?.datasource) {
+    errors.push({ path: `${prefix}.source.datasource`, message: "Entity source.datasource is required." });
+  } else if (!config.datasources[entity.source.datasource]) {
+    errors.push({
+      path: `${prefix}.source.datasource`,
+      message: `Datasource '${entity.source.datasource}' referenced by entity '${entity.id}' is not configured.`
+    });
+  }
+  if (!entity.source?.table) {
+    errors.push({ path: `${prefix}.source.table`, message: "Entity source.table is required." });
+  }
+  if (!entity.fields || entity.fields.length === 0) {
+    errors.push({ path: `${prefix}.fields`, message: "Entity must have at least one field." });
+    return;
+  }
+  const fieldNames = /* @__PURE__ */ new Set();
+  for (const field of entity.fields) {
+    const fp = `${prefix}.fields[${field.name ?? "?"}]`;
+    if (!field.name) {
+      errors.push({ path: fp, message: "Field name is required." });
+      continue;
+    }
+    if (fieldNames.has(field.name)) {
+      errors.push({ path: fp, message: `Duplicate field name '${field.name}'.` });
+    } else {
+      fieldNames.add(field.name);
+    }
+    if (!field.label) {
+      errors.push({ path: `${fp}.label`, message: "Field label is required." });
+    }
+    if (!field.type) {
+      errors.push({ path: `${fp}.type`, message: "Field type is required." });
+    }
+  }
+}
+function validateRelation(relation, entityIds, errors) {
+  const prefix = `relations[${relation.id ?? "?"}]`;
+  if (!relation.id) {
+    errors.push({ path: prefix, message: "Relation id is required." });
+  }
+  if (!relation.from?.entity) {
+    errors.push({ path: `${prefix}.from.entity`, message: "Relation from.entity is required." });
+  } else if (!entityIds.has(relation.from.entity)) {
+    errors.push({ path: `${prefix}.from.entity`, message: `Entity '${relation.from.entity}' not found.` });
+  }
+  if (!relation.to?.entity) {
+    errors.push({ path: `${prefix}.to.entity`, message: "Relation to.entity is required." });
+  } else if (!entityIds.has(relation.to.entity)) {
+    errors.push({ path: `${prefix}.to.entity`, message: `Entity '${relation.to.entity}' not found.` });
+  }
+}
+
+// src/engine/MetadataEngine.ts
+var STRING_OPERATORS = [
+  "equals",
+  "notEquals",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "in",
+  "notIn",
+  "isNull",
+  "isNotNull"
+];
+var NUMERIC_OPERATORS = [
+  "equals",
+  "notEquals",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "between",
+  "in",
+  "notIn",
+  "isNull",
+  "isNotNull"
+];
+var DATE_OPERATORS = [
+  "equals",
+  "notEquals",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "between",
+  "isNull",
+  "isNotNull"
+];
+var ENUM_OPERATORS = ["equals", "notEquals", "in", "notIn", "isNull", "isNotNull"];
+var BOOLEAN_OPERATORS = ["isTrue", "isFalse", "isNull", "isNotNull"];
+var NULL_OPERATORS = ["isNull", "isNotNull"];
+function filterOperatorsForType(type) {
+  switch (type) {
+    case "string":
+    case "text":
+    case "email":
+    case "phone":
+    case "url":
+    case "document":
+      return STRING_OPERATORS;
+    case "number":
+    case "integer":
+    case "decimal":
+    case "currency":
+      return NUMERIC_OPERATORS;
+    case "boolean":
+      return BOOLEAN_OPERATORS;
+    case "date":
+    case "datetime":
+    case "time":
+      return DATE_OPERATORS;
+    case "enum":
+      return ENUM_OPERATORS;
+    case "uuid":
+      return ENUM_OPERATORS;
+    case "json":
+    case "array":
+    case "relation":
+      return NULL_OPERATORS;
+    default:
+      return ["equals", "notEquals", "isNull", "isNotNull"];
+  }
+}
+function buildContextActions(entity, operations) {
+  const caps = { ...DEFAULT_CAPABILITIES, ...entity.capabilities };
+  const actions = [];
+  if (caps.update) {
+    actions.push({ id: "edit", label: "Edit", permission: `entity.${entity.id}.update` });
+  }
+  if (caps.clone) {
+    actions.push({ id: "clone", label: "Clone", permission: `entity.${entity.id}.clone` });
+  }
+  if (caps.softDelete) {
+    actions.push({
+      id: "soft-delete",
+      label: "Deactivate",
+      permission: `entity.${entity.id}.softDelete`,
+      condition: "when-active",
+      style: "warning"
+    });
+    actions.push({
+      id: "restore",
+      label: "Restore",
+      permission: `entity.${entity.id}.restore`,
+      condition: "when-inactive"
+    });
+  }
+  if (caps.delete) {
+    actions.push({
+      id: "hard-delete",
+      label: "Delete permanently",
+      permission: `entity.${entity.id}.delete`,
+      style: "danger"
+    });
+  }
+  for (const op of operations) {
+    if (op.entity === entity.id && op.scope === "record") {
+      actions.push({
+        id: op.id,
+        label: op.label,
+        permission: op.requiredPermission ?? `operation.${op.id}`,
+        operationId: op.id
+      });
+    }
+  }
+  return actions;
+}
+function buildBulkOperations(entity, operations) {
+  return operations.filter((op) => op.entity === entity.id && op.scope === "bulk").map((op) => op.id);
+}
+var MetadataEngine = class {
+  normalize(config) {
+    const operations = config.operations ?? [];
+    const entities = config.entities.map((e) => this.normalizeEntity(e, operations));
+    const relations = config.relations ?? [];
+    const entityRelationMap = /* @__PURE__ */ new Map();
+    for (const rel of relations) {
+      const addToMap = (entityId) => {
+        if (!entityRelationMap.has(entityId)) entityRelationMap.set(entityId, []);
+        entityRelationMap.get(entityId).push(rel.id);
+      };
+      addToMap(rel.from.entity);
+      if (rel.to.entity !== rel.from.entity) addToMap(rel.to.entity);
+    }
+    const enrichedEntities = entities.map((e) => ({
+      ...e,
+      relations: entityRelationMap.get(e.id) ?? []
+    }));
+    const normalizedOps = operations.map((op) => ({
+      id: op.id,
+      label: op.label,
+      description: op.description,
+      entity: op.entity,
+      scope: op.scope,
+      requiresConfirmation: op.requiresConfirmation ?? false,
+      confirmationMessage: op.confirmationMessage,
+      requiresTypedConfirmation: op.requiresTypedConfirmation ?? false,
+      requiredPermission: op.requiredPermission
+    }));
+    return {
+      entities: enrichedEntities,
+      relations,
+      operations: normalizedOps,
+      policies: config.policies ?? { roles: {} }
+    };
+  }
+  normalizeEntity(schema, operations) {
+    const capabilities = { ...DEFAULT_CAPABILITIES, ...schema.capabilities };
+    const primaryKey = schema.source.primaryKey ?? "id";
+    const displayField = schema.displayField ?? schema.fields.find((f) => !f.hidden)?.name ?? primaryKey;
+    return {
+      id: schema.id,
+      label: schema.label,
+      description: schema.description,
+      datasource: schema.source.datasource,
+      table: schema.source.table,
+      primaryKey,
+      displayField,
+      fields: schema.fields.map((f) => this.normalizeField(f)),
+      capabilities,
+      softDelete: schema.softDelete,
+      defaultSort: schema.defaultSort,
+      search: schema.search,
+      relations: [],
+      contextActions: buildContextActions(schema, operations),
+      bulkOperations: buildBulkOperations(schema, operations),
+      exportConfig: schema.exportConfig
+    };
+  }
+  normalizeField(schema) {
+    return {
+      name: schema.name,
+      label: schema.label,
+      type: schema.type,
+      required: schema.required ?? false,
+      readonly: schema.readonly ?? false,
+      hidden: schema.hidden ?? false,
+      sensitive: schema.sensitive ?? false,
+      searchable: schema.searchable ?? false,
+      sortable: schema.sortable ?? false,
+      filterable: schema.filterable ?? false,
+      exportable: schema.exportable ?? true,
+      filterOperators: schema.filterOperators ?? filterOperatorsForType(schema.type),
+      description: schema.description,
+      enumOptions: schema.enumOptions,
+      relationEntity: schema.relationEntity,
+      mask: schema.mask,
+      list: {
+        visible: schema.list?.visible ?? !(schema.hidden ?? false),
+        width: schema.list?.width,
+        align: schema.list?.align,
+        order: schema.list?.order
+      },
+      detail: {
+        visible: schema.detail?.visible ?? !(schema.hidden ?? false),
+        group: schema.detail?.group,
+        order: schema.detail?.order
+      },
+      form: {
+        creatable: schema.form?.creatable ?? true,
+        editable: schema.form?.editable ?? !(schema.readonly ?? false),
+        cloneable: schema.form?.cloneable ?? !(schema.readonly ?? false),
+        placeholder: schema.form?.placeholder,
+        helpText: schema.form?.helpText,
+        section: schema.form?.section,
+        order: schema.form?.order
+      }
+    };
+  }
+};
+
+// src/engine/MaestroEngine.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/export/CsvExportProvider.ts
+var CsvExportProvider = class {
+  export(entity, records, options) {
+    const fields = this.resolveFields(entity, options);
+    const headers = fields.map((f) => f.label);
+    const rows = records.map(
+      (record) => fields.map((field) => this.formatValue(record[field.name], field, options))
+    );
+    const csvLines = [headers, ...rows].map(
+      (row) => row.map((cell) => this.escapeCsvCell(String(cell ?? ""))).join(",")
+    );
+    const bom = options.bom !== false ? "\uFEFF" : "";
+    const data = bom + csvLines.join("\r\n");
+    const datestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const filename = `${entity.id}_export_${datestamp}.csv`;
+    return {
+      format: "csv",
+      data,
+      filename,
+      recordCount: records.length,
+      mimeType: "text/csv;charset=utf-8"
+    };
+  }
+  resolveFields(entity, options) {
+    let fields = entity.fields.filter((f) => f.exportable && !f.hidden);
+    if (options.includeFields?.length) {
+      const include = new Set(options.includeFields);
+      fields = fields.filter((f) => include.has(f.name));
+    }
+    if (options.excludeFields?.length) {
+      const exclude = new Set(options.excludeFields);
+      fields = fields.filter((f) => !exclude.has(f.name));
+    }
+    return fields;
+  }
+  formatValue(value, field, options) {
+    if (value === null || value === void 0) return "";
+    if (field.sensitive) return "***";
+    switch (field.type) {
+      case "boolean":
+        return value ? "Sim" : "N\xE3o";
+      case "date":
+      case "datetime": {
+        if (value instanceof Date) {
+          return options.dateFormat ? this.formatDate(value, options.dateFormat) : value.toISOString();
+        }
+        return String(value);
+      }
+      case "enum": {
+        const option = field.enumOptions?.find((o) => o.value === value);
+        return option ? option.label : String(value);
+      }
+      case "json":
+        return JSON.stringify(value);
+      default:
+        return String(value);
+    }
+  }
+  formatDate(date, format) {
+    return format.replace("YYYY", String(date.getFullYear())).replace("MM", String(date.getMonth() + 1).padStart(2, "0")).replace("DD", String(date.getDate()).padStart(2, "0")).replace("HH", String(date.getHours()).padStart(2, "0")).replace("mm", String(date.getMinutes()).padStart(2, "0")).replace("ss", String(date.getSeconds()).padStart(2, "0"));
+  }
+  escapeCsvCell(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+};
+
+// src/engine/MaestroEngine.ts
+var MaestroEngine = class {
+  constructor(metadata, datasources, operations, audit) {
+    this.metadata = metadata;
+    this.datasources = datasources;
+    this.operations = operations;
+    this.audit = audit;
+    this.rbac = new RbacEngine(metadata.policies);
+  }
+  metadata;
+  datasources;
+  operations;
+  audit;
+  rbac;
+  getMetadata() {
+    return this.metadata;
+  }
+  async list(entityId, query, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "list", actor, `entity.${entityId}.list`);
+    const provider = this.datasources.get(entity.datasource);
+    const result = await provider.list({
+      table: entity.table,
+      primaryKey: entity.primaryKey,
+      filters: query.filters,
+      sort: query.sort ?? (entity.defaultSort ? [entity.defaultSort] : void 0),
+      pagination: query.pagination,
+      search: query.search
+    });
+    await this.recordAudit(`entity.${entityId}.list`, actor, { type: entityId, id: "*" }, "debug", {
+      total: result.total
+    });
+    return result;
+  }
+  async findById(entityId, id, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "detail", actor, `entity.${entityId}.detail`);
+    const provider = this.datasources.get(entity.datasource);
+    const record = await provider.findById({ table: entity.table, primaryKey: entity.primaryKey, id });
+    if (record) {
+      await this.recordAudit(`entity.${entityId}.detail`, actor, { type: entityId, id }, "debug");
+    }
+    return record;
+  }
+  async create(entityId, data, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "create", actor, `entity.${entityId}.create`);
+    const provider = this.datasources.get(entity.datasource);
+    const created = await provider.create({
+      table: entity.table,
+      primaryKey: entity.primaryKey,
+      data: { ...data, [entity.primaryKey]: data[entity.primaryKey] ?? randomUUID3() }
+    });
+    await this.recordAudit(
+      `entity.${entityId}.create`,
+      actor,
+      { type: entityId, id: String(created[entity.primaryKey]) },
+      "info",
+      void 0,
+      void 0,
+      created
+    );
+    return created;
+  }
+  async update(entityId, id, data, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "update", actor, `entity.${entityId}.update`);
+    const provider = this.datasources.get(entity.datasource);
+    const before = await provider.findById({ table: entity.table, primaryKey: entity.primaryKey, id });
+    const updated = await provider.update({ table: entity.table, primaryKey: entity.primaryKey, id, data });
+    await this.recordAudit(
+      `entity.${entityId}.update`,
+      actor,
+      { type: entityId, id },
+      "info",
+      void 0,
+      before ?? void 0,
+      updated
+    );
+    return updated;
+  }
+  async clone(entityId, id, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "clone", actor, `entity.${entityId}.clone`);
+    const provider = this.datasources.get(entity.datasource);
+    const source = await provider.findById({ table: entity.table, primaryKey: entity.primaryKey, id });
+    if (!source) {
+      throw new MaestroError("NOT_FOUND" /* NOT_FOUND */, `Record '${id}' not found in entity '${entityId}'.`);
+    }
+    const cloneableFields = entity.fields.filter((f) => f.form.cloneable && f.name !== entity.primaryKey);
+    const cloneData = {};
+    for (const field of cloneableFields) {
+      if (source[field.name] !== void 0) cloneData[field.name] = source[field.name];
+    }
+    const created = await provider.create({
+      table: entity.table,
+      primaryKey: entity.primaryKey,
+      data: { ...cloneData, [entity.primaryKey]: randomUUID3() }
+    });
+    await this.recordAudit(
+      `entity.${entityId}.clone`,
+      actor,
+      { type: entityId, id: String(created[entity.primaryKey]) },
+      "info",
+      { sourceId: id }
+    );
+    return created;
+  }
+  async softDelete(entityId, id, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "softDelete", actor, `entity.${entityId}.softDelete`);
+    if (!entity.softDelete) {
+      throw new MaestroError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        `Entity '${entityId}' does not have softDelete configured.`
+      );
+    }
+    const provider = this.datasources.get(entity.datasource);
+    await provider.update({
+      table: entity.table,
+      primaryKey: entity.primaryKey,
+      id,
+      data: { [entity.softDelete.field]: entity.softDelete.inactiveValue }
+    });
+    await this.recordAudit(`entity.${entityId}.softDelete`, actor, { type: entityId, id }, "warn");
+  }
+  async restore(entityId, id, actor) {
+    const entity = this.requireEntity(entityId);
+    if (!entity.softDelete) {
+      throw new MaestroError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        `Entity '${entityId}' does not have softDelete configured.`
+      );
+    }
+    const permission = `entity.${entityId}.restore`;
+    if (!this.rbac.can(actor, permission)) {
+      throw new MaestroError("PERMISSION_DENIED" /* PERMISSION_DENIED */, `Permission denied: ${permission}`);
+    }
+    const provider = this.datasources.get(entity.datasource);
+    await provider.update({
+      table: entity.table,
+      primaryKey: entity.primaryKey,
+      id,
+      data: { [entity.softDelete.field]: entity.softDelete.activeValue }
+    });
+    await this.recordAudit(`entity.${entityId}.restore`, actor, { type: entityId, id }, "warn");
+  }
+  async hardDelete(entityId, id, actor) {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "delete", actor, `entity.${entityId}.delete`);
+    const provider = this.datasources.get(entity.datasource);
+    const before = await provider.findById({ table: entity.table, primaryKey: entity.primaryKey, id });
+    await provider.delete({ table: entity.table, primaryKey: entity.primaryKey, id });
+    await this.recordAudit(
+      `entity.${entityId}.delete`,
+      actor,
+      { type: entityId, id },
+      "warn",
+      void 0,
+      before ?? void 0
+    );
+  }
+  async export(entityId, query, actor, format = "csv") {
+    const entity = this.requireEntity(entityId);
+    this.requireCapability(entity, "export", actor, `entity.${entityId}.export`);
+    const provider = this.datasources.get(entity.datasource);
+    const result = await provider.list({
+      table: entity.table,
+      primaryKey: entity.primaryKey,
+      filters: query.filters,
+      sort: query.sort,
+      search: query.search
+    });
+    const exportProvider = new CsvExportProvider();
+    const exportResult = exportProvider.export(entity, result.records, { format });
+    await this.recordAudit(
+      `entity.${entityId}.export`,
+      actor,
+      { type: entityId, id: "*" },
+      "info",
+      { recordCount: exportResult.recordCount, format }
+    );
+    return exportResult;
+  }
+  async executeOperation(operationId, context, actor) {
+    const operation = this.operations.find(operationId);
+    if (!operation) {
+      throw new MaestroError("NOT_FOUND" /* NOT_FOUND */, `Operation '${operationId}' not found.`);
+    }
+    if (operation.requiredPermission && !this.rbac.can(actor, operation.requiredPermission)) {
+      throw new MaestroError(
+        "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+        `Permission denied: ${operation.requiredPermission}`
+      );
+    }
+    const correlationId = context.correlationId ?? randomUUID3();
+    const result = await operation.execute({ ...context, actor, correlationId });
+    const entityMeta = context.entityId ? this.metadata.entities.find((e) => e.id === context.entityId) : void 0;
+    const recordId = context.record && entityMeta ? String(context.record[entityMeta.primaryKey] ?? "unknown") : "*";
+    await this.recordAudit(
+      `operation.${operationId}`,
+      actor,
+      context.entityId ? { type: context.entityId, id: recordId } : void 0,
+      result.success ? "info" : "error",
+      { success: result.success },
+      void 0,
+      void 0,
+      correlationId
+    );
+    return result;
+  }
+  requireEntity(entityId) {
+    const entity = this.metadata.entities.find((e) => e.id === entityId);
+    if (!entity) {
+      throw new MaestroError("NOT_FOUND" /* NOT_FOUND */, `Entity '${entityId}' not found.`);
+    }
+    return entity;
+  }
+  requireCapability(entity, capability, actor, permission) {
+    if (!entity.capabilities[capability]) {
+      throw new MaestroError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        `Capability '${String(capability)}' is not enabled for entity '${entity.id}'.`
+      );
+    }
+    if (!this.rbac.can(actor, permission)) {
+      throw new MaestroError("PERMISSION_DENIED" /* PERMISSION_DENIED */, `Permission denied: ${permission}`);
+    }
+  }
+  async recordAudit(action, actor, resource, level = "info", metadata, before, after, correlationId) {
+    await this.audit?.record({
+      action,
+      actor,
+      resource,
+      level,
+      metadata,
+      before,
+      after,
+      correlationId
+    });
+  }
+};
+
+// src/engine/createMaestro.ts
+function createMaestro(config) {
+  const validation = validateMaestroConfig(config);
+  if (!validation.valid) {
+    const messages = validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+    throw new MaestroError("CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */, `Invalid Maestro configuration: ${messages}`);
+  }
+  const metadataEngine = new MetadataEngine();
+  const metadata = metadataEngine.normalize(config);
+  const datasources = new DatasourceRegistry();
+  for (const [id, provider] of Object.entries(config.datasources)) {
+    datasources.register(id, provider);
+  }
+  const operations = new OperationRegistry();
+  for (const operation of config.operations ?? []) {
+    operations.register(operation);
+  }
+  const audit = config.audit ? new AuditRecorder(config.audit) : void 0;
+  return new MaestroEngine(metadata, datasources, operations, audit);
+}
+
+// src/introspection/utils.ts
+var DISPLAY_FIELD_PRIORITY = [
+  "name",
+  "title",
+  "username",
+  "email",
+  "code",
+  "slug",
+  "label",
+  "first_name",
+  "firstname",
+  "full_name",
+  "fullname",
+  "subject"
+];
+var TIMESTAMP_PATTERN = /^(created_at|createdat|created_date|createddate|updated_at|updatedat|updated_date|updateddate|deleted_at|deletedat|modified_at|modifiedat)$/i;
+var SEARCH_CANDIDATE_PATTERN = /^(name|title|description|email|username|first_name|firstname|last_name|lastname|full_name|fullname|label|code|slug|reference|subject)$/i;
+function inferFieldType(nativeType, fieldName) {
+  const nt = nativeType.toLowerCase().replace(/\(.*\)/, "").trim();
+  const fn = fieldName.toLowerCase();
+  if (["uuid", "uniqueidentifier"].includes(nt)) return "uuid";
+  if (["boolean", "bool", "bit"].includes(nt)) return "boolean";
+  if (nt === "date") return "date";
+  if ([
+    "timestamp",
+    "timestamptz",
+    "timestamp with time zone",
+    "timestamp without time zone",
+    "datetime",
+    "datetime2"
+  ].includes(nt))
+    return "datetime";
+  if (["time", "timetz", "time with time zone", "time without time zone"].includes(nt))
+    return "time";
+  if (["json", "jsonb"].includes(nt)) return "json";
+  if (nt.includes("[]") || nt === "array") return "array";
+  if ([
+    "int",
+    "int2",
+    "int4",
+    "int8",
+    "int16",
+    "integer",
+    "bigint",
+    "smallint",
+    "tinyint",
+    "mediumint",
+    "serial",
+    "bigserial",
+    "smallserial"
+  ].includes(nt))
+    return "integer";
+  if (["float", "float4", "float8", "double", "double precision", "real"].includes(nt))
+    return "number";
+  if (["decimal", "numeric", "money", "smallmoney"].includes(nt)) {
+    if (/^(price|amount|value|total|cost|fee|salary|balance|revenue|profit|tax)$|_(price|amount|value|total|cost|fee)$/.test(
+      fn
+    ))
+      return "currency";
+    return "decimal";
+  }
+  if (["text", "mediumtext", "longtext", "clob"].includes(nt)) return "text";
+  if (fn === "email" || fn.endsWith("_email")) return "email";
+  if (fn === "phone" || fn === "telephone" || fn.endsWith("_phone") || fn.endsWith("_tel"))
+    return "phone";
+  if (fn === "url" || fn === "website" || fn.endsWith("_url") || fn.endsWith("_website"))
+    return "url";
+  if (/^(doc|document|cpf|cnpj|ssn|nif|rg)$|_(doc|document|cpf|cnpj|ssn|rg)$/.test(fn))
+    return "document";
+  return "string";
+}
+function isTimestampField(fieldName, fieldType) {
+  return TIMESTAMP_PATTERN.test(fieldName) && (fieldType === "datetime" || fieldType === "date");
+}
+function isSoftDeleteCandidate(fieldName, fieldType, nullable) {
+  const fn = fieldName.toLowerCase();
+  if ((fn === "deleted_at" || fn === "deletedat") && fieldType === "datetime" && nullable)
+    return true;
+  if ((fn === "is_deleted" || fn === "isdeleted" || fn === "deleted") && fieldType === "boolean")
+    return true;
+  if ((fn === "is_active" || fn === "isactive" || fn === "active") && fieldType === "boolean")
+    return true;
+  return false;
+}
+function isSearchCandidate(fieldName, fieldType, isPrimaryKey) {
+  if (isPrimaryKey) return false;
+  if (!["string", "text", "email", "phone", "url"].includes(fieldType)) return false;
+  return SEARCH_CANDIDATE_PATTERN.test(fieldName);
+}
+function tableNameToEntityId(table) {
+  return table.replace(/([A-Z])/g, (match, c, offset) => offset > 0 ? `-${c}` : c).replace(/_/g, "-").replace(/--+/g, "-").toLowerCase();
+}
+function humanizeWord(word) {
+  if (!word) return "";
+  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+function tableNameToLabel(table) {
+  const words = table.replace(/([A-Z])/g, " $1").replace(/_/g, " ").trim().split(/\s+/).filter(Boolean).map(humanizeWord);
+  const plural = words.join(" ");
+  const lastWord = words[words.length - 1];
+  let singularLast;
+  if (lastWord.toLowerCase().endsWith("ies")) {
+    singularLast = lastWord.slice(0, -3) + "y";
+  } else if (lastWord.toLowerCase().endsWith("ses") || lastWord.toLowerCase().endsWith("xes") || lastWord.toLowerCase().endsWith("ches") || lastWord.toLowerCase().endsWith("shes")) {
+    singularLast = lastWord.slice(0, -2);
+  } else if (lastWord.toLowerCase().endsWith("s") && !lastWord.toLowerCase().endsWith("ss")) {
+    singularLast = lastWord.slice(0, -1);
+  } else {
+    singularLast = lastWord;
+  }
+  const singular = [...words.slice(0, -1), singularLast].join(" ");
+  return { singular, plural };
+}
+function humanizeFieldName(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/_/g, " ").trim().replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function detectDisplayField(fields) {
+  for (const priority of DISPLAY_FIELD_PRIORITY) {
+    const match = fields.find((f) => f.name.toLowerCase() === priority && !f.isPrimaryKey);
+    if (match) return match.name;
+  }
+  const fallback = fields.find(
+    (f) => !f.isPrimaryKey && ["string", "text", "email"].includes(f.type)
+  );
+  return fallback?.name;
+}
+
+// src/hybrid-loader/HybridLoader.ts
+function fieldFromIntrospection(field) {
+  return {
+    name: field.name,
+    label: humanizeFieldName(field.name),
+    type: field.type,
+    required: !field.nullable && !field.isPrimaryKey,
+    readonly: field.isPrimaryKey,
+    hidden: field.isPrimaryKey,
+    searchable: field.candidateForSearch ?? false,
+    sortable: !field.isPrimaryKey && !field.isTimestamp,
+    filterable: field.isIndexed ?? false,
+    exportable: !field.isPrimaryKey
+  };
+}
+function mergeFields(introspectedFields, overrideFields, strategy) {
+  const overrideMap = new Map(overrideFields.map((f) => [f.name, f]));
+  const introspectedMap = new Map(introspectedFields.map((f) => [f.name, f]));
+  const result = [];
+  for (const override of overrideFields) {
+    const introspected = introspectedMap.get(override.name);
+    if (introspected) {
+      result.push(override);
+    } else {
+      result.push(override);
+    }
+  }
+  if (strategy === "extend") {
+    for (const introspected of introspectedFields) {
+      if (!overrideMap.has(introspected.name)) {
+        result.push(fieldFromIntrospection(introspected));
+      }
+    }
+  }
+  return result;
+}
+function detectSoftDelete(fields) {
+  const PRIORITY = ["deleted_at", "deletedat", "is_deleted", "isdeleted", "deleted", "is_active", "isactive", "active"];
+  for (const candidate of PRIORITY) {
+    const field = fields.find((f) => f.name.toLowerCase() === candidate && f.candidateForSoftDelete);
+    if (field) {
+      const fn = field.name.toLowerCase();
+      if (fn === "deleted_at" || fn === "deletedat") {
+        return { field: field.name, activeValue: null, inactiveValue: "timestamp" };
+      }
+      if (fn === "is_deleted" || fn === "isdeleted" || fn === "deleted") {
+        return { field: field.name, activeValue: false, inactiveValue: true };
+      }
+      return { field: field.name, activeValue: true, inactiveValue: false };
+    }
+  }
+  return void 0;
+}
+function detectSearchConfig(fields) {
+  const searchFields = fields.filter((f) => f.candidateForSearch).map((f) => f.name);
+  return searchFields.length > 0 ? { fields: searchFields } : void 0;
+}
+function entityFromIntrospection(entity, datasource) {
+  const pk = entity.fields.find((f) => f.isPrimaryKey)?.name ?? "id";
+  const displayField = detectDisplayField(entity.fields);
+  const softDelete = detectSoftDelete(entity.fields);
+  const search = detectSearchConfig(entity.fields);
+  return {
+    id: tableNameToEntityId(entity.table),
+    label: tableNameToLabel(entity.table),
+    source: {
+      datasource,
+      table: entity.table,
+      primaryKey: pk
+    },
+    displayField,
+    fields: entity.fields.map(fieldFromIntrospection),
+    ...softDelete && { softDelete },
+    ...search && { search }
+  };
+}
+function mergeEntity(introspected, override, strategy) {
+  return {
+    ...override,
+    fields: mergeFields(introspected.fields, override.fields, strategy)
+  };
+}
+function introspectedRelationToSchema(rel, entityIdByTable) {
+  const fromEntity = entityIdByTable.get(rel.from.table);
+  const toEntity = entityIdByTable.get(rel.to.table);
+  if (!fromEntity || !toEntity) return null;
+  return {
+    id: rel.id,
+    type: rel.type,
+    from: { entity: fromEntity, field: rel.from.field },
+    to: { entity: toEntity, field: rel.to.field },
+    label: `${tableNameToLabel(rel.to.table).plural}`
+  };
+}
+function mergeIntrospectionWithOverrides(options) {
+  const { introspection, overrides, datasources, defaultDatasource, strategy = "extend" } = options;
+  const overrideByTable = /* @__PURE__ */ new Map();
+  const overrideById = /* @__PURE__ */ new Map();
+  for (const entity of overrides.entities) {
+    overrideByTable.set(entity.source.table, entity);
+    overrideById.set(entity.id, entity);
+  }
+  const entityIdByTable = /* @__PURE__ */ new Map();
+  const mergedEntities = [];
+  const handledOverrideIds = /* @__PURE__ */ new Set();
+  for (const introspectedEntity of introspection.entities) {
+    const override = overrideByTable.get(introspectedEntity.table) ?? overrideById.get(tableNameToEntityId(introspectedEntity.table));
+    if (override) {
+      handledOverrideIds.add(override.id);
+      mergedEntities.push(mergeEntity(introspectedEntity, override, strategy));
+      entityIdByTable.set(introspectedEntity.table, override.id);
+    } else {
+      const generated = entityFromIntrospection(introspectedEntity, defaultDatasource);
+      mergedEntities.push(generated);
+      entityIdByTable.set(introspectedEntity.table, generated.id);
+    }
+  }
+  for (const override of overrides.entities) {
+    if (!handledOverrideIds.has(override.id)) {
+      mergedEntities.push(override);
+    }
+  }
+  const overrideRelationIds = new Set(overrides.relations.map((r) => r.id));
+  const mergedRelations = [...overrides.relations];
+  for (const rel of introspection.relations) {
+    if (!overrideRelationIds.has(rel.id)) {
+      const schema = introspectedRelationToSchema(rel, entityIdByTable);
+      if (schema) mergedRelations.push(schema);
+    }
+  }
+  return {
+    datasources,
+    entities: mergedEntities,
+    relations: mergedRelations,
+    policies: overrides.policies,
+    operations: options.operations,
+    audit: options.audit,
+    logger: options.logger
+  };
+}
+
+// src/engine/createMaestroFromIntrospection.ts
+async function createMaestroFromIntrospection(options) {
+  const introspection = await options.provider.introspect();
+  const overrides = options.overrides ?? { entities: [], relations: [] };
+  const datasources = options.datasources ?? {};
+  const defaultDatasource = options.defaultDatasource ?? "";
+  const config = mergeIntrospectionWithOverrides({
+    introspection,
+    overrides,
+    datasources,
+    defaultDatasource,
+    strategy: options.mergeStrategy ?? "extend",
+    operations: options.operations,
+    audit: options.audit,
+    logger: options.logger
+  });
+  if (options.policies) {
+    config.policies = options.policies;
+  }
+  return createMaestro(config);
+}
+
+// src/http/QueryStringParser.ts
+var VALID_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "notEquals",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "in",
+  "notIn",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "between",
+  "isNull",
+  "isNotNull",
+  "isTrue",
+  "isFalse"
+]);
+function parseStr(val) {
+  return Array.isArray(val) ? val[0] : val;
+}
+function parseNum(val) {
+  const s = parseStr(val);
+  if (!s) return void 0;
+  const n = Number(s);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function parseFilterValue(operator, value) {
+  if (value === void 0) return void 0;
+  if (operator === "in" || operator === "notIn") return value.split(",");
+  if (operator === "between") {
+    const [from, to] = value.split(",");
+    return [from, to];
+  }
+  return value;
+}
+function parseQueryInput(query) {
+  const result = {};
+  const filterParam = query["filter"] ?? query["filters"];
+  if (filterParam) {
+    const rawFilters = Array.isArray(filterParam) ? filterParam : [filterParam];
+    const filters = [];
+    for (const raw of rawFilters) {
+      const colonIdx = raw.indexOf(":");
+      if (colonIdx === -1) continue;
+      const field = raw.slice(0, colonIdx);
+      const rest = raw.slice(colonIdx + 1);
+      const colonIdx2 = rest.indexOf(":");
+      const op = colonIdx2 === -1 ? rest : rest.slice(0, colonIdx2);
+      const valueRaw = colonIdx2 === -1 ? void 0 : rest.slice(colonIdx2 + 1);
+      if (!field || !VALID_OPERATORS.has(op)) continue;
+      const operator = op;
+      filters.push({ field, operator, value: parseFilterValue(operator, valueRaw) });
+    }
+    if (filters.length > 0) result.filters = filters;
+  }
+  const sortParam = query["sort"];
+  if (sortParam) {
+    const rawSorts = Array.isArray(sortParam) ? sortParam : [sortParam];
+    const sort = [];
+    for (const raw of rawSorts) {
+      const colonIdx = raw.indexOf(":");
+      const field = colonIdx === -1 ? raw : raw.slice(0, colonIdx);
+      const direction = colonIdx === -1 ? "asc" : raw.slice(colonIdx + 1);
+      if (!field) continue;
+      sort.push({ field, direction: direction === "desc" ? "desc" : "asc" });
+    }
+    if (sort.length > 0) result.sort = sort;
+  }
+  const page = parseNum(query["page"]);
+  const pageSize = parseNum(query["pageSize"]);
+  const offset = parseNum(query["offset"]);
+  const limit = parseNum(query["limit"]);
+  const cursor = parseStr(query["cursor"]);
+  if (page !== void 0) {
+    const pagination = { strategy: "page", page, pageSize: pageSize ?? 20 };
+    result.pagination = pagination;
+  } else if (offset !== void 0) {
+    const pagination = { strategy: "offset", offset, limit: limit ?? 20 };
+    result.pagination = pagination;
+  } else if (cursor !== void 0) {
+    const pagination = { strategy: "cursor", cursor, limit: limit ?? 20 };
+    result.pagination = pagination;
+  }
+  const searchTerm = parseStr(query["search"]);
+  if (searchTerm) {
+    const searchFields = parseStr(query["searchFields"]);
+    result.search = {
+      term: searchTerm,
+      fields: searchFields ? searchFields.split(",") : []
+    };
+  }
+  return result;
+}
+
+// src/http/createMaestroHttpHandlers.ts
+var HTTP_STATUS = {
+  ["PERMISSION_DENIED" /* PERMISSION_DENIED */]: 403,
+  ["NOT_FOUND" /* NOT_FOUND */]: 404,
+  ["CONFLICT" /* CONFLICT */]: 409,
+  ["VALIDATION_ERROR" /* VALIDATION_ERROR */]: 400,
+  ["CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */]: 400,
+  ["INTERNAL_ERROR" /* INTERNAL_ERROR */]: 500
+};
+function errorResponse(err) {
+  if (err instanceof MaestroError) {
+    return {
+      status: HTTP_STATUS[err.code] ?? 500,
+      body: { error: err.code, message: err.message }
+    };
+  }
+  const message = err instanceof Error ? err.message : "Internal server error";
+  return { status: 500, body: { error: "INTERNAL_ERROR", message } };
+}
+function createMaestroHttpHandlers(engine, options) {
+  const resolve = options.actorResolver;
+  const list = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      const result = await engine.list(req.params["entity"], parseQueryInput(req.query), actor);
+      return { status: 200, body: result };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const findById = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      const record = await engine.findById(req.params["entity"], req.params["id"], actor);
+      if (!record) {
+        return { status: 404, body: { error: "NOT_FOUND", message: `Record '${req.params["id"]}' not found.` } };
+      }
+      return { status: 200, body: record };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const create = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      const created = await engine.create(req.params["entity"], req.body, actor);
+      return { status: 201, body: created };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const update = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      const updated = await engine.update(
+        req.params["entity"],
+        req.params["id"],
+        req.body,
+        actor
+      );
+      return { status: 200, body: updated };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const clone = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      const cloned = await engine.clone(req.params["entity"], req.params["id"], actor);
+      return { status: 201, body: cloned };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const softDelete = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      await engine.softDelete(req.params["entity"], req.params["id"], actor);
+      return { status: 204, body: null };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const restore = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      await engine.restore(req.params["entity"], req.params["id"], actor);
+      return { status: 200, body: { success: true } };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const hardDelete = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      await engine.hardDelete(req.params["entity"], req.params["id"], actor);
+      return { status: 204, body: null };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const exportHandler = async (req) => {
+    try {
+      const { actor } = await resolve(req);
+      const rawFormat = Array.isArray(req.query["format"]) ? req.query["format"][0] : req.query["format"];
+      const format = rawFormat === "json" ? "json" : "csv";
+      const exportResult = await engine.export(req.params["entity"], parseQueryInput(req.query), actor, format);
+      return {
+        status: 200,
+        body: exportResult.data,
+        headers: {
+          "Content-Type": exportResult.mimeType,
+          "Content-Disposition": `attachment; filename="${exportResult.filename}"`
+        }
+      };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const executeOperation = async (req) => {
+    try {
+      const { actor, correlationId } = await resolve(req);
+      const body = req.body ?? {};
+      const result = await engine.executeOperation(
+        req.params["operationId"],
+        {
+          actor,
+          correlationId,
+          entityId: body["entityId"],
+          record: body["record"],
+          input: body["input"]
+        },
+        actor
+      );
+      return { status: result.success ? 200 : 422, body: result };
+    } catch (err) {
+      return errorResponse(err);
+    }
+  };
+  const getMetadata = async () => {
+    return { status: 200, body: engine.getMetadata() };
+  };
+  const getEntityMetadata = async (req) => {
+    const entityId = req.params["entity"];
+    const meta = engine.getMetadata();
+    const entity = meta.entities.find((e) => e.id === entityId);
+    if (!entity) {
+      return { status: 404, body: { error: "NOT_FOUND", message: `Entity '${entityId}' not found.` } };
+    }
+    return { status: 200, body: entity };
+  };
+  const health = async () => {
+    return { status: 200, body: { status: "ok" } };
+  };
+  return {
+    list,
+    findById,
+    create,
+    update,
+    clone,
+    softDelete,
+    restore,
+    hardDelete,
+    export: exportHandler,
+    executeOperation,
+    getMetadata,
+    getEntityMetadata,
+    health
+  };
+}
+
+// src/config-loader/MaestroFileLoader.ts
+import { readFile, readdir, access } from "fs/promises";
+import { join, extname } from "path";
+var defaultFileReader = {
+  readFile: (p) => readFile(p, "utf-8"),
+  readDir: async (p) => {
+    const entries = await readdir(p, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  },
+  exists: async (p) => {
+    try {
+      await access(p);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function parseContent(content, ext, yamlParser) {
+  if (ext === ".yml" || ext === ".yaml") {
+    if (!yamlParser) {
+      throw new Error(
+        "YAML files require a yamlParser option. Install js-yaml and pass { parse: jsYaml.load } as yamlParser."
+      );
+    }
+    return yamlParser.parse(content);
+  }
+  return JSON.parse(content);
+}
+async function readAllInDir(dir, suffix, reader, yamlParser) {
+  const exists = await reader.exists(dir);
+  if (!exists) return [];
+  const files = await reader.readDir(dir);
+  const matched = files.filter(
+    (f) => f.endsWith(`${suffix}.json`) || f.endsWith(`${suffix}.yml`) || f.endsWith(`${suffix}.yaml`)
+  );
+  const results = [];
+  for (const f of matched) {
+    const content = await reader.readFile(join(dir, f));
+    results.push(parseContent(content, extname(f), yamlParser));
+  }
+  return results;
+}
+async function loadMaestroConfig(options) {
+  const reader = options.fileReader ?? defaultFileReader;
+  const { rootDir, yamlParser } = options;
+  const [entitiesRaw, relationsRaw] = await Promise.all([
+    readAllInDir(join(rootDir, "entities"), ".entity", reader, yamlParser),
+    readAllInDir(join(rootDir, "relations"), ".relation", reader, yamlParser)
+  ]);
+  let policies;
+  const policyCandidates = [
+    "policies/rbac.policy.json",
+    "policies/rbac.policy.yml",
+    "policies/rbac.policy.yaml"
+  ];
+  for (const candidate of policyCandidates) {
+    const fullPath = join(rootDir, candidate);
+    if (await reader.exists(fullPath)) {
+      const content = await reader.readFile(fullPath);
+      policies = parseContent(content, extname(candidate), yamlParser);
+      break;
+    }
+  }
+  return {
+    entities: entitiesRaw,
+    relations: relationsRaw,
+    policies
+  };
+}
+
+// src/config-generator/ConfigGenerator.ts
+function detectSoftDelete2(fields) {
+  const PRIORITY = [
+    "deleted_at",
+    "deletedat",
+    "is_deleted",
+    "isdeleted",
+    "deleted",
+    "is_active",
+    "isactive",
+    "active"
+  ];
+  for (const candidate of PRIORITY) {
+    const field = fields.find(
+      (f) => f.name.toLowerCase() === candidate && f.candidateForSoftDelete
+    );
+    if (!field) continue;
+    const fn = field.name.toLowerCase();
+    if (fn === "deleted_at" || fn === "deletedat") {
+      return { field: field.name, activeValue: null, inactiveValue: "timestamp" };
+    }
+    if (fn === "is_deleted" || fn === "isdeleted" || fn === "deleted") {
+      return { field: field.name, activeValue: false, inactiveValue: true };
+    }
+    return { field: field.name, activeValue: true, inactiveValue: false };
+  }
+  return void 0;
+}
+function fieldToSchema(field) {
+  return {
+    name: field.name,
+    label: humanizeFieldName(field.name),
+    type: field.type,
+    required: !field.nullable && !field.isPrimaryKey,
+    readonly: field.isPrimaryKey,
+    hidden: field.isPrimaryKey,
+    searchable: field.candidateForSearch ?? false,
+    sortable: !field.isPrimaryKey && !field.isTimestamp,
+    filterable: field.isIndexed ?? false,
+    exportable: !field.isPrimaryKey
+  };
+}
+function generateEntityConfig(entity, datasource) {
+  const pk = entity.fields.find((f) => f.isPrimaryKey)?.name ?? "id";
+  const displayField = detectDisplayField(entity.fields);
+  const softDelete = detectSoftDelete2(entity.fields);
+  const searchFields = entity.fields.filter((f) => f.candidateForSearch).map((f) => f.name);
+  return {
+    id: tableNameToEntityId(entity.table),
+    label: tableNameToLabel(entity.table),
+    source: {
+      datasource,
+      table: entity.table,
+      primaryKey: pk
+    },
+    ...displayField && { displayField },
+    fields: entity.fields.map(fieldToSchema),
+    ...softDelete && { softDelete },
+    ...searchFields.length > 0 && { search: { fields: searchFields } }
+  };
+}
+function generateRelationConfig(relation, entityIdByTable) {
+  const fromEntity = entityIdByTable.get(relation.from.table);
+  const toEntity = entityIdByTable.get(relation.to.table);
+  if (!fromEntity || !toEntity) return null;
+  return {
+    id: relation.id,
+    type: relation.type,
+    from: { entity: fromEntity, field: relation.from.field },
+    to: { entity: toEntity, field: relation.to.field },
+    label: tableNameToLabel(relation.to.table).plural
+  };
+}
+function generateAllConfigs(result, datasource) {
+  const entities = {};
+  const entityIdByTable = /* @__PURE__ */ new Map();
+  for (const entity of result.entities) {
+    const schema = generateEntityConfig(entity, datasource);
+    entities[schema.id] = schema;
+    entityIdByTable.set(entity.table, schema.id);
+  }
+  const relations = {};
+  for (const relation of result.relations) {
+    const schema = generateRelationConfig(relation, entityIdByTable);
+    if (schema) relations[schema.id] = schema;
+  }
+  return { entities, relations };
+}
+
+// src/diff/DiffEngine.ts
+var DiffEngine = class {
+  compare(previous, current, options = {}) {
+    const changes = [];
+    const prevEntityMap = new Map(previous.entities.map((e) => [e.table, e]));
+    const currEntityMap = new Map(current.entities.map((e) => [e.table, e]));
+    for (const [table, entity] of currEntityMap) {
+      if (!prevEntityMap.has(table)) {
+        changes.push({
+          category: "entity",
+          kind: "entity_added",
+          impact: "SAFE",
+          entityTable: table,
+          current: entity
+        });
+      }
+    }
+    for (const [table, entity] of prevEntityMap) {
+      if (!currEntityMap.has(table)) {
+        changes.push({
+          category: "entity",
+          kind: "entity_removed",
+          impact: "BREAKING",
+          entityTable: table,
+          previous: entity
+        });
+      }
+    }
+    for (const [table, prevEntity] of prevEntityMap) {
+      const currEntity = currEntityMap.get(table);
+      if (!currEntity) continue;
+      const prevLabel = options.previousEntityLabels?.get(table) ?? tableNameToLabel(prevEntity.table).singular;
+      const currLabel = options.currentEntityLabels?.get(table) ?? tableNameToLabel(currEntity.table).singular;
+      if (prevLabel !== currLabel) {
+        changes.push({
+          category: "entity",
+          kind: "entity_label_changed",
+          impact: "WARNING",
+          entityTable: table,
+          previous: prevLabel,
+          current: currLabel
+        });
+      }
+      const prevPk = prevEntity.fields.find((f) => f.isPrimaryKey)?.name;
+      const currPk = currEntity.fields.find((f) => f.isPrimaryKey)?.name;
+      if (prevPk !== currPk) {
+        changes.push({
+          category: "entity",
+          kind: "entity_primary_key_changed",
+          impact: "BREAKING",
+          entityTable: table,
+          previous: prevPk,
+          current: currPk
+        });
+      }
+      changes.push(...this.compareFields(table, prevEntity.fields, currEntity.fields));
+    }
+    const prevRelMap = new Map(previous.relations.map((r) => [r.id, r]));
+    const currRelMap = new Map(current.relations.map((r) => [r.id, r]));
+    for (const [id, rel] of currRelMap) {
+      if (!prevRelMap.has(id)) {
+        changes.push({
+          category: "relation",
+          kind: "relation_added",
+          impact: "SAFE",
+          relationId: id,
+          current: rel
+        });
+      }
+    }
+    for (const [id, rel] of prevRelMap) {
+      if (!currRelMap.has(id)) {
+        changes.push({
+          category: "relation",
+          kind: "relation_removed",
+          impact: "BREAKING",
+          relationId: id,
+          previous: rel
+        });
+      }
+    }
+    for (const [id, prevRel] of prevRelMap) {
+      const currRel = currRelMap.get(id);
+      if (!currRel) continue;
+      if (prevRel.type !== currRel.type) {
+        changes.push({
+          category: "relation",
+          kind: "relation_cardinality_changed",
+          impact: "BREAKING",
+          relationId: id,
+          previous: prevRel.type,
+          current: currRel.type
+        });
+      }
+      if (prevRel.from.field !== currRel.from.field || prevRel.to.field !== currRel.to.field) {
+        changes.push({
+          category: "relation",
+          kind: "relation_fields_changed",
+          impact: "BREAKING",
+          relationId: id,
+          previous: { from: prevRel.from.field, to: prevRel.to.field },
+          current: { from: currRel.from.field, to: currRel.to.field }
+        });
+      }
+    }
+    const summary = {
+      total: changes.length,
+      safe: changes.filter((c) => c.impact === "SAFE").length,
+      warnings: changes.filter((c) => c.impact === "WARNING").length,
+      breaking: changes.filter((c) => c.impact === "BREAKING").length
+    };
+    return {
+      changes,
+      summary,
+      hasBreaking: summary.breaking > 0,
+      hasWarnings: summary.warnings > 0
+    };
+  }
+  compareFields(entityTable, prevFields, currFields) {
+    const changes = [];
+    const prevMap = new Map(prevFields.map((f) => [f.name, f]));
+    const currMap = new Map(currFields.map((f) => [f.name, f]));
+    for (const [name, field] of currMap) {
+      if (!prevMap.has(name)) {
+        changes.push({
+          category: "field",
+          kind: "field_added",
+          impact: "SAFE",
+          entityTable,
+          fieldName: name,
+          current: field
+        });
+      }
+    }
+    for (const [name, field] of prevMap) {
+      if (!currMap.has(name)) {
+        changes.push({
+          category: "field",
+          kind: "field_removed",
+          impact: "BREAKING",
+          entityTable,
+          fieldName: name,
+          previous: field
+        });
+      }
+    }
+    for (const [name, prevField] of prevMap) {
+      const currField = currMap.get(name);
+      if (!currField) continue;
+      if (prevField.type !== currField.type) {
+        changes.push({
+          category: "field",
+          kind: "field_type_changed",
+          impact: "BREAKING",
+          entityTable,
+          fieldName: name,
+          previous: prevField.type,
+          current: currField.type
+        });
+      }
+      if (prevField.nullable !== currField.nullable) {
+        const impact = !prevField.nullable && currField.nullable ? "SAFE" : "BREAKING";
+        changes.push({
+          category: "field",
+          kind: "field_nullable_changed",
+          impact,
+          entityTable,
+          fieldName: name,
+          previous: prevField.nullable,
+          current: currField.nullable
+        });
+      }
+      const wasIndexed = prevField.isIndexed ?? false;
+      const isIndexed = currField.isIndexed ?? false;
+      if (wasIndexed !== isIndexed) {
+        if (isIndexed) {
+          changes.push({
+            category: "field",
+            kind: "field_index_added",
+            impact: "SAFE",
+            entityTable,
+            fieldName: name,
+            previous: false,
+            current: true
+          });
+        } else {
+          changes.push({
+            category: "field",
+            kind: "field_index_removed",
+            impact: "WARNING",
+            entityTable,
+            fieldName: name,
+            previous: true,
+            current: false
+          });
+        }
+      }
+      const prevMeta = {
+        candidateForSearch: prevField.candidateForSearch ?? false,
+        candidateForSoftDelete: prevField.candidateForSoftDelete ?? false
+      };
+      const currMeta = {
+        candidateForSearch: currField.candidateForSearch ?? false,
+        candidateForSoftDelete: currField.candidateForSoftDelete ?? false
+      };
+      if (prevMeta.candidateForSearch !== currMeta.candidateForSearch || prevMeta.candidateForSoftDelete !== currMeta.candidateForSoftDelete) {
+        changes.push({
+          category: "field",
+          kind: "field_metadata_changed",
+          impact: "WARNING",
+          entityTable,
+          fieldName: name,
+          previous: prevMeta,
+          current: currMeta
+        });
+      }
+    }
+    return changes;
+  }
+};
+
+// src/introspection-report/ReportGenerator.ts
+var ReportGenerator = class {
+  generate(result, diff) {
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const hasDiff = diff !== void 0;
+    const stats = {
+      entitiesDiscovered: result.entities.length,
+      relationsDiscovered: result.relations.length,
+      totalChanges: diff?.summary.total ?? 0,
+      safeChanges: diff?.summary.safe ?? 0,
+      warnings: diff?.summary.warnings ?? 0,
+      breakingChanges: diff?.summary.breaking ?? 0
+    };
+    const changes = hasDiff ? diff.changes.map((c) => this.describeChange(c)) : [];
+    const text = this.generateText(stats, changes, hasDiff);
+    return { completedAt, stats, changes, hasDiff, text };
+  }
+  describeChange(change) {
+    switch (change.category) {
+      case "entity": {
+        switch (change.kind) {
+          case "entity_added":
+            return {
+              impact: "SAFE",
+              description: `Entity "${change.entityTable}" added`
+            };
+          case "entity_removed":
+            return {
+              impact: "BREAKING",
+              description: `Entity "${change.entityTable}" removed`,
+              recommendation: `Ensure all consumers of "${change.entityTable}" are updated before deploying.`
+            };
+          case "entity_label_changed":
+            return {
+              impact: "WARNING",
+              description: `Entity "${change.entityTable}" label changed: "${change.previous}" \u2192 "${change.current}"`,
+              recommendation: "Update UI labels and documentation to reflect the new entity name."
+            };
+          case "entity_primary_key_changed":
+            return {
+              impact: "BREAKING",
+              description: `Entity "${change.entityTable}" primary key changed: "${change.previous}" \u2192 "${change.current}"`,
+              recommendation: "This is a destructive change. Review all queries and foreign key references before deploying."
+            };
+        }
+        break;
+      }
+      case "field": {
+        switch (change.kind) {
+          case "field_added":
+            return {
+              impact: "SAFE",
+              description: `Field "${change.entityTable}.${change.fieldName}" added`
+            };
+          case "field_removed":
+            return {
+              impact: "BREAKING",
+              description: `Field "${change.entityTable}.${change.fieldName}" removed`,
+              recommendation: `Remove all references to "${change.fieldName}" in "${change.entityTable}" before deploying.`
+            };
+          case "field_type_changed":
+            return {
+              impact: "BREAKING",
+              description: `Field "${change.entityTable}.${change.fieldName}" changed type: ${change.previous} \u2192 ${change.current}`,
+              recommendation: "Verify that existing data can be migrated to the new type and that all consumers handle the new type."
+            };
+          case "field_nullable_changed":
+            if (!change.previous && change.current) {
+              return {
+                impact: "SAFE",
+                description: `Field "${change.entityTable}.${change.fieldName}" is now optional (was required)`
+              };
+            }
+            return {
+              impact: "BREAKING",
+              description: `Field "${change.entityTable}.${change.fieldName}" is now required (was optional)`,
+              recommendation: "Ensure existing rows have values for this field before deploying the migration."
+            };
+          case "field_index_added":
+            return {
+              impact: "SAFE",
+              description: `Index added to field "${change.entityTable}.${change.fieldName}"`
+            };
+          case "field_index_removed":
+            return {
+              impact: "WARNING",
+              description: `Index removed from field "${change.entityTable}.${change.fieldName}"`,
+              recommendation: "Removing indexes may degrade query performance. Review affected queries."
+            };
+          case "field_metadata_changed":
+            return {
+              impact: "WARNING",
+              description: `Derived metadata changed for field "${change.entityTable}.${change.fieldName}"`
+            };
+        }
+        break;
+      }
+      case "relation": {
+        switch (change.kind) {
+          case "relation_added":
+            return {
+              impact: "SAFE",
+              description: `Relation "${change.relationId}" added`
+            };
+          case "relation_removed":
+            return {
+              impact: "BREAKING",
+              description: `Relation "${change.relationId}" removed`,
+              recommendation: `Update all code that references relation "${change.relationId}".`
+            };
+          case "relation_cardinality_changed":
+            return {
+              impact: "BREAKING",
+              description: `Relation "${change.relationId}" cardinality changed: ${change.previous} \u2192 ${change.current}`,
+              recommendation: "Verify data integrity and update all query logic that depends on this relation."
+            };
+          case "relation_fields_changed": {
+            const prev = change.previous;
+            const curr = change.current;
+            return {
+              impact: "BREAKING",
+              description: `Relation "${change.relationId}" participating fields changed (from: ${prev?.from} \u2192 ${curr?.from}, to: ${prev?.to} \u2192 ${curr?.to})`,
+              recommendation: "Review all JOIN logic and foreign key constraints for this relation."
+            };
+          }
+        }
+        break;
+      }
+    }
+    return { impact: "WARNING", description: "Unknown change detected" };
+  }
+  generateText(stats, changes, hasDiff) {
+    const lines = [];
+    lines.push("Introspection completed");
+    lines.push("");
+    lines.push(`Entities discovered: ${stats.entitiesDiscovered}`);
+    lines.push(`Relations discovered: ${stats.relationsDiscovered}`);
+    if (!hasDiff) {
+      lines.push("");
+      lines.push("No previous snapshot available for comparison.");
+      return lines.join("\n");
+    }
+    if (stats.totalChanges === 0) {
+      lines.push("");
+      lines.push("No changes detected since last snapshot.");
+      return lines.join("\n");
+    }
+    lines.push("");
+    lines.push(`Changes detected: ${stats.totalChanges}`);
+    const safeChanges = changes.filter((c) => c.impact === "SAFE");
+    const warnings = changes.filter((c) => c.impact === "WARNING");
+    const breaking = changes.filter((c) => c.impact === "BREAKING");
+    if (safeChanges.length > 0) {
+      lines.push("");
+      lines.push("SAFE:");
+      for (const c of safeChanges) {
+        lines.push(`- ${c.description}`);
+      }
+    }
+    if (warnings.length > 0) {
+      lines.push("");
+      lines.push("WARNINGS:");
+      for (const c of warnings) {
+        lines.push(`- ${c.description}`);
+        if (c.recommendation) lines.push(`  \u2192 ${c.recommendation}`);
+      }
+    }
+    if (breaking.length > 0) {
+      lines.push("");
+      lines.push("BREAKING:");
+      for (const c of breaking) {
+        lines.push(`- ${c.description}`);
+        if (c.recommendation) lines.push(`  \u2192 ${c.recommendation}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/snapshot/InMemorySnapshotRepository.ts
+var InMemorySnapshotRepository = class {
+  store = /* @__PURE__ */ new Map();
+  async save(snapshot) {
+    this.store.set(snapshot.id, snapshot);
+  }
+  async load(id) {
+    return this.store.get(id) ?? null;
+  }
+};
+
+// src/introspection-runtime/IntrospectionRuntime.ts
+var _snapshotCounter = 0;
+function generateSnapshotId() {
+  return `snapshot-${Date.now()}-${++_snapshotCounter}`;
+}
+var IntrospectionRuntime = class {
+  constructor(snapshotRepository) {
+    this.snapshotRepository = snapshotRepository;
+  }
+  snapshotRepository;
+  lastProvider;
+  async run(options) {
+    this.lastProvider = options.provider;
+    const introspectionResult = await options.provider.introspect();
+    const snapshot = {
+      id: generateSnapshotId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      result: introspectionResult
+    };
+    let diff;
+    if (options.snapshotId && this.snapshotRepository) {
+      const previous = await this.snapshotRepository.load(options.snapshotId);
+      if (previous) {
+        const engine = new DiffEngine();
+        diff = engine.compare(previous.result, introspectionResult);
+      }
+    }
+    const reportGenerator = new ReportGenerator();
+    const report = reportGenerator.generate(introspectionResult, diff);
+    const shouldSave = options.saveSnapshot !== false && this.snapshotRepository !== void 0;
+    if (shouldSave) {
+      await this.snapshotRepository.save(snapshot);
+    }
+    const overrides = options.overrides ?? { entities: [], relations: [] };
+    const datasources = options.datasources ?? {};
+    const defaultDatasource = options.defaultDatasource ?? "";
+    const config = mergeIntrospectionWithOverrides({
+      introspection: introspectionResult,
+      overrides,
+      datasources,
+      defaultDatasource,
+      strategy: options.mergeStrategy ?? "extend",
+      operations: options.operations,
+      audit: options.audit,
+      logger: options.logger
+    });
+    if (options.policies) {
+      config.policies = options.policies;
+    }
+    const metadataEngine = new MetadataEngine();
+    const metadata = metadataEngine.normalize(config);
+    return { metadata, diff, report, snapshot };
+  }
+  async saveSnapshot(snapshot) {
+    if (!this.snapshotRepository) {
+      throw new Error(
+        "IntrospectionRuntime: no snapshotRepository configured. Pass one in the constructor."
+      );
+    }
+    await this.snapshotRepository.save(snapshot);
+  }
+  async loadSnapshot(id) {
+    if (!this.snapshotRepository) return null;
+    return this.snapshotRepository.load(id);
+  }
+  async compareWithSnapshot(snapshotId, provider) {
+    if (!this.snapshotRepository) return null;
+    const resolvedProvider = provider ?? this.lastProvider;
+    if (!resolvedProvider) {
+      throw new Error(
+        "IntrospectionRuntime.compareWithSnapshot: a provider must be supplied or run() must have been called first."
+      );
+    }
+    const previous = await this.snapshotRepository.load(snapshotId);
+    if (!previous) return null;
+    const current = await resolvedProvider.introspect();
+    const engine = new DiffEngine();
+    return engine.compare(previous.result, current);
+  }
+};
+
+// src/correlation/CorrelationId.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function generateCorrelationId() {
+  return randomUUID4();
+}
+
+// src/risk/MetadataRiskClassifier.ts
+var MetadataRiskClassifier = class {
+  constructor(operationRiskMap = {}, defaultRisk = "LOW") {
+    this.operationRiskMap = operationRiskMap;
+    this.defaultRisk = defaultRisk;
+  }
+  operationRiskMap;
+  defaultRisk;
+  classify(input) {
+    const fromMetadata = input.metadata?.["riskLevel"];
+    if (isOperationalRisk(fromMetadata)) return fromMetadata;
+    return this.operationRiskMap[input.operation] ?? this.defaultRisk;
+  }
+};
+var RISK_LEVELS = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
+function isOperationalRisk(value) {
+  return typeof value === "string" && RISK_LEVELS.includes(value);
+}
+
+// src/authorization/ContextualAuthorizationEngine.ts
+var ContextualAuthorizationEngine = class {
+  constructor(policy, criticalOperations = /* @__PURE__ */ new Set()) {
+    this.criticalOperations = criticalOperations;
+    this.rbac = new RbacEngine(policy);
+  }
+  criticalOperations;
+  rbac;
+  async evaluate(context) {
+    if (!this.rbac.can(context.actor, context.operation)) {
+      return { decision: "DENY", reason: `Actor lacks permission for operation: ${context.operation}` };
+    }
+    const risk = context.riskLevel ?? "LOW";
+    if (risk === "CRITICAL" || this.criticalOperations.has(context.operation)) {
+      return { decision: "REQUIRES_CONFIRMATION", reason: `Operation requires confirmation due to risk level: ${risk}` };
+    }
+    return { decision: "ALLOW" };
+  }
+};
+
+// src/policy/PolicyEngine.ts
+var DECISION_PRIORITY = {
+  ALLOW: 0,
+  REQUIRES_CONFIRMATION: 1,
+  DENY: 2
+};
+var PolicyEngine = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  provider;
+  evaluate(context) {
+    const violations = [];
+    let decision = "ALLOW";
+    let reason;
+    for (const rule of this.provider.rules()) {
+      const result = rule.evaluate(context);
+      if (result === null) continue;
+      if (DECISION_PRIORITY[result.decision] > DECISION_PRIORITY[decision]) {
+        decision = result.decision;
+        reason = result.reason;
+      }
+      if (result.decision === "DENY" || result.decision === "REQUIRES_CONFIRMATION") {
+        violations.push({
+          ruleId: rule.id,
+          reason: result.reason,
+          context,
+          occurredAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return { decision, violations, reason };
+  }
+};
+
+// src/policy/InMemoryPolicyProvider.ts
+var InMemoryPolicyProvider = class {
+  _rules;
+  constructor(rules = []) {
+    this._rules = rules;
+  }
+  rules() {
+    return this._rules;
+  }
+};
+
+// src/confirmation/ConfirmationEngine.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var ConfirmationEngine = class {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  repository;
+  async request(input) {
+    const requiredApprovals = input.requiredApprovals ?? 1;
+    const request = {
+      id: randomUUID5(),
+      operation: input.operation,
+      actor: input.actor,
+      resource: input.resource,
+      status: requiredApprovals > 1 ? "AWAITING_CONFIRMATION" : "REQUESTED",
+      requiredApprovals,
+      approvals: [],
+      rejections: [],
+      requestedAt: /* @__PURE__ */ new Date(),
+      expiresAt: input.expiresAt,
+      metadata: input.metadata,
+      correlationId: input.correlationId
+    };
+    await this.repository.save(request);
+    return request;
+  }
+  async approve(requestId, approver, comment) {
+    const request = await this.findOrThrow(requestId);
+    this.assertActive(request);
+    const updated = {
+      ...request,
+      approvals: [...request.approvals, { approver, approvedAt: /* @__PURE__ */ new Date(), comment }]
+    };
+    const fullyApproved = updated.approvals.length >= updated.requiredApprovals;
+    updated.status = fullyApproved ? "APPROVED" : "AWAITING_CONFIRMATION";
+    await this.repository.save(updated);
+    return updated;
+  }
+  async reject(requestId, approver, comment) {
+    const request = await this.findOrThrow(requestId);
+    this.assertActive(request);
+    const updated = {
+      ...request,
+      status: "REJECTED",
+      rejections: [...request.rejections, { approver, approvedAt: /* @__PURE__ */ new Date(), comment }]
+    };
+    await this.repository.save(updated);
+    return updated;
+  }
+  async execute(requestId) {
+    const request = await this.findOrThrow(requestId);
+    if (request.status !== "APPROVED") {
+      throw new MaestroError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Cannot execute confirmation request in status: ${request.status}`
+      );
+    }
+    const updated = {
+      ...request,
+      status: "EXECUTED",
+      executedAt: /* @__PURE__ */ new Date()
+    };
+    await this.repository.save(updated);
+    return updated;
+  }
+  async getPending() {
+    return this.repository.listPending();
+  }
+  async findOrThrow(requestId) {
+    const request = await this.repository.findById(requestId);
+    if (!request) {
+      throw new MaestroError(
+        "NOT_FOUND" /* NOT_FOUND */,
+        `Confirmation request not found: ${requestId}`
+      );
+    }
+    return request;
+  }
+  assertActive(request) {
+    const terminal = ["APPROVED", "REJECTED", "EXECUTED", "EXPIRED"];
+    if (terminal.includes(request.status)) {
+      throw new MaestroError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Confirmation request is already in terminal status: ${request.status}`
+      );
+    }
+  }
+};
+
+// src/confirmation/InMemoryConfirmationRepository.ts
+var InMemoryConfirmationRepository = class {
+  store = /* @__PURE__ */ new Map();
+  async save(request) {
+    this.store.set(request.id, request);
+  }
+  async findById(id) {
+    return this.store.get(id);
+  }
+  async listPending() {
+    return Array.from(this.store.values()).filter(
+      (r) => r.status === "REQUESTED" || r.status === "AWAITING_CONFIRMATION"
+    );
+  }
+};
+
+// src/governance/GovernanceEventType.ts
+var GOVERNANCE_EVENT_TYPES = {
+  OPERATION_EXECUTED: "governance.operation.executed",
+  AUTHORIZATION_DENIED: "governance.authorization.denied",
+  POLICY_TRIGGERED: "governance.policy.triggered",
+  CONFIRMATION_REQUESTED: "governance.confirmation.requested",
+  CONFIRMATION_APPROVED: "governance.confirmation.approved",
+  CONFIRMATION_REJECTED: "governance.confirmation.rejected",
+  AUDIT_RECORDED: "governance.audit.recorded"
+};
+
+// src/governance/InMemoryGovernanceEventBus.ts
+import { randomUUID as randomUUID6 } from "crypto";
+var InMemoryGovernanceEventBus = class extends InMemoryEventBus {
+  async publishGovernance(type, payload, correlationId) {
+    const event = {
+      id: randomUUID6(),
+      type,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload,
+      correlationId
+    };
+    await this.publish(event);
+    return event;
+  }
+};
+
+// src/governance/DefaultGovernanceApi.ts
+var DefaultGovernanceApi = class {
+  constructor(auditRepository, confirmationRepository, violationLog = []) {
+    this.auditRepository = auditRepository;
+    this.confirmationRepository = confirmationRepository;
+    this.violationLog = violationLog;
+  }
+  auditRepository;
+  confirmationRepository;
+  violationLog;
+  async getAuditTimeline(filter) {
+    return this.auditRepository.list(filter);
+  }
+  async getCorrelationTrace(correlationId) {
+    return this.auditRepository.list({ correlationId });
+  }
+  async getPendingConfirmations() {
+    return this.confirmationRepository.listPending();
+  }
+  async getPolicyViolations(filter) {
+    let violations = [...this.violationLog];
+    if (filter?.ruleId !== void 0) {
+      violations = violations.filter((v) => v.ruleId === filter.ruleId);
+    }
+    if (filter?.correlationId !== void 0) {
+      violations = violations.filter((v) => v.context.correlationId === filter.correlationId);
+    }
+    if (filter?.from !== void 0) {
+      const from = filter.from;
+      violations = violations.filter((v) => v.occurredAt >= from);
+    }
+    if (filter?.to !== void 0) {
+      const to = filter.to;
+      violations = violations.filter((v) => v.occurredAt <= to);
+    }
+    return violations;
+  }
+};
 export {
   AuditRecorder,
+  ConfirmationEngine,
   ConsoleLogger,
+  ConsoleStructuredLogger,
+  ContextualAuthorizationEngine,
+  CsvExportProvider,
+  DEFAULT_CAPABILITIES,
+  DatasourceRegistry,
+  DefaultGovernanceApi,
+  DiffEngine,
   ErrorCode,
+  GOVERNANCE_EVENT_TYPES,
   InMemoryAuditRepository,
   InMemoryConfigProvider,
+  InMemoryConfirmationRepository,
+  InMemoryDatasourceProvider,
   InMemoryEventBus,
   InMemoryFeatureFlagProvider,
+  InMemoryGovernanceEventBus,
+  InMemoryPolicyProvider,
+  InMemorySnapshotRepository,
+  IntrospectionRuntime,
+  MaestroEngine,
   MaestroError,
-  RbacEngine
+  MetadataEngine,
+  MetadataRiskClassifier,
+  OperationRegistry,
+  PolicyEngine,
+  RbacEngine,
+  ReportGenerator,
+  createMaestro,
+  createMaestroFromIntrospection,
+  createMaestroHttpHandlers,
+  detectDisplayField,
+  generateAllConfigs,
+  generateCorrelationId,
+  generateEntityConfig,
+  generateRelationConfig,
+  humanizeFieldName,
+  inferFieldType,
+  isSearchCandidate,
+  isSoftDeleteCandidate,
+  isTimestampField,
+  loadMaestroConfig,
+  mergeIntrospectionWithOverrides,
+  parseQueryInput,
+  tableNameToEntityId,
+  tableNameToLabel,
+  validateMaestroConfig
 };
 //# sourceMappingURL=index.js.map