@fayz-ai/core 0.9.0 → 0.10.0

package/dist/chunk-732GZEUI.js

@@ -0,0 +1,1592 @@
+import { getAllEntities } from './chunk-CU64QI4A.js';
+import * as React from 'react';
+
+// src/entity/events.ts
+function fieldsFor(entity) {
+  return [
+    { name: "record_name", label: entity.label, type: "string", example: `${entity.label} Exemplo` },
+    { name: "record_id", label: "ID", type: "string", example: "8f14e45f-\u2026" },
+    { name: "entity_label", label: "Cadastro", type: "string", example: entity.label },
+    { name: "actor_name", label: "Quem fez", type: "string", example: "Jo\xE3o Pereira" },
+    { name: "business_name", label: "Seu neg\xF3cio", type: "string", example: "Seu Neg\xF3cio" }
+  ];
+}
+function entityEventKey(entityKey, action) {
+  return `registry.${entityKey}.${action}`;
+}
+var ACTION_LABEL = {
+  created: (l) => `${l} cadastrado`,
+  updated: (l) => `${l} atualizado`,
+  deleted: (l) => `${l} exclu\xEDdo`,
+  imported: (_l, plural) => `${plural} importados`
+};
+var ACTION_TRIGGER = {
+  created: (l) => `Quando um registro de ${l.toLowerCase()} \xE9 criado`,
+  updated: (l) => `Quando um registro de ${l.toLowerCase()} \xE9 alterado`,
+  deleted: (l) => `Quando um registro de ${l.toLowerCase()} \xE9 exclu\xEDdo`,
+  imported: (_l, plural) => `Quando uma planilha de ${plural.toLowerCase()} \xE9 importada`
+};
+var ACTION_ICON = {
+  created: "Plus",
+  updated: "Pencil",
+  deleted: "Trash2",
+  imported: "Upload"
+};
+function buildEntityDomainEvents(entities) {
+  const out = [];
+  for (const entity of entities) {
+    const fields = fieldsFor(entity);
+    const actions = ["created", "updated", "deleted", "imported"];
+    for (const action of actions) {
+      const plural = entity.labelPlural || entity.label;
+      out.push({
+        name: entityEventKey(entity.entityKey, action),
+        title: ACTION_LABEL[action](entity.label, plural),
+        description: `${plural} \xB7 ${ACTION_LABEL[action](entity.label, plural).toLowerCase()}`,
+        trigger: ACTION_TRIGGER[action](entity.label, plural),
+        icon: entity.icon ?? ACTION_ICON[action],
+        fields: action === "imported" ? [
+          { name: "record_count", label: "Quantidade", type: "string", example: "128" },
+          ...fields.filter((f) => f.name !== "record_name" && f.name !== "record_id")
+        ] : fields,
+        audit: true,
+        // Cadastro não pertence a plugin nenhum: o dono é o app. Agrupar sob
+        // "Cadastros" mantém a lista legível quando são trinta entidades.
+        pluginId: entity.pluginId ?? "registry",
+        pluginName: entity.pluginName ?? "Cadastros",
+        pluginIcon: entity.pluginIcon ?? entity.icon
+      });
+    }
+  }
+  return out;
+}
+
+// src/registry/block-schema.ts
+var BLOCK_SETTING_TYPES = [
+  "text",
+  "richtext",
+  "number",
+  "boolean",
+  "color",
+  "image",
+  "url",
+  "select",
+  "product",
+  "category",
+  "collection",
+  "entity",
+  "list"
+];
+var STRING_TYPES = {
+  text: true,
+  richtext: true,
+  color: true,
+  image: true,
+  url: true,
+  select: true,
+  product: true,
+  category: true,
+  collection: true,
+  entity: true
+};
+var FORMAT_BY_TYPE = {
+  url: "uri",
+  image: "uri",
+  color: "color"
+};
+function settingToJsonSchema(setting) {
+  const node = {
+    title: setting.label,
+    // The control survives the compile: a `product` setting is a string in JSON
+    // Schema terms, but an editor rendering it as a text input is a bug.
+    "x-fayz-control": setting.type
+  };
+  if (setting.help) node.description = setting.help;
+  if (setting.default !== void 0) node.default = setting.default;
+  const format = FORMAT_BY_TYPE[setting.type];
+  if (format) node.format = format;
+  if (setting.type === "number") {
+    node.type = "number";
+    if (setting.min !== void 0) node.minimum = setting.min;
+    if (setting.max !== void 0) node.maximum = setting.max;
+    return node;
+  }
+  if (setting.type === "boolean") {
+    node.type = "boolean";
+    return node;
+  }
+  if (setting.type === "list") {
+    node.type = "array";
+    node.items = setting.of?.length ? settingsToJsonSchema(setting.of) : (
+      // A list with no declared item shape accepts anything rather than
+      // nothing — an under-specified block should still render.
+      {}
+    );
+    return node;
+  }
+  if (STRING_TYPES[setting.type]) {
+    node.type = "string";
+    if (setting.type === "select" && setting.options?.length) {
+      node.enum = setting.options.map((option) => option.value);
+      node["x-fayz-enum-labels"] = setting.options.map((option) => option.label);
+    }
+    return node;
+  }
+  return node;
+}
+function settingsToJsonSchema(settings = []) {
+  const properties = {};
+  const required = [];
+  for (const setting of settings) {
+    properties[setting.id] = settingToJsonSchema(setting);
+    if (setting.required) required.push(setting.id);
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+function defaultPropsFromSettings(settings = []) {
+  const props = {};
+  for (const setting of settings) {
+    if (setting.default !== void 0) props[setting.id] = setting.default;
+  }
+  return props;
+}
+
+// src/registry/registry-class.ts
+var Registry = class {
+  constructor(kind) {
+    this.kind = kind;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  register(id, value, meta = {}) {
+    const title = meta.title ?? meta.label;
+    this.entries.set(id, { id, value, meta: title === void 0 ? meta : { ...meta, title, label: title } });
+  }
+  get(id) {
+    return this.entries.get(id)?.value;
+  }
+  getEntry(id) {
+    return this.entries.get(id);
+  }
+  has(id) {
+    return this.entries.has(id);
+  }
+  list() {
+    return Array.from(this.entries.values());
+  }
+  ids() {
+    return Array.from(this.entries.keys());
+  }
+  /**
+   * Every entry reduced to the uniform meta envelope, sorted by id.
+   *
+   * Sorted for the same reason as `describeBlocks`: this feeds prompts,
+   * documents and generated catalogs, and registration order is an
+   * implementation detail that would make every diff noisy.
+   */
+  describe() {
+    return this.list().map(({ id, meta }) => ({
+      id,
+      kind: this.kind,
+      title: meta.title ?? meta.label,
+      description: meta.description,
+      schema: meta.propsSchema,
+      stability: meta.stability ?? "stable",
+      since: meta.since,
+      source: meta.source,
+      pluginId: meta.pluginId
+    })).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+function isCustomId(id) {
+  return id.startsWith("custom:");
+}
+
+// src/registry/handles.ts
+var HANDLE_NAME_RE = /^[a-z0-9][a-z0-9-]*(\.[A-Za-z0-9_][A-Za-z0-9_-]*)+$/;
+var handleRegistry = new Registry("handle");
+function formatValidSet() {
+  const ids = handleRegistry.ids().sort();
+  return ids.length ? `Registered handles: ${ids.join(", ")}` : "No handles are registered \u2014 call registerHandle(name, value) before referencing one.";
+}
+function registerHandle(name, value, meta = {}, options = {}) {
+  if (!HANDLE_NAME_RE.test(name)) {
+    throw new Error(
+      `Invalid handle name "${name}". Handles are namespaced: '<app-or-plugin-id>.<name>' (e.g. 'artorious.customCard'), matching ${String(HANDLE_NAME_RE)}.`
+    );
+  }
+  if (value === void 0) {
+    throw new Error(`registerHandle("${name}"): the value is undefined \u2014 a handle must name something.`);
+  }
+  const existing = handleRegistry.getEntry(name);
+  if (existing) {
+    if (Object.is(existing.value, value)) return;
+    if (!options.replace) {
+      throw new Error(
+        `Handle "${name}" is already registered with a different value. Pass { replace: true } if the replacement is deliberate, or pick another name. ${formatValidSet()}`
+      );
+    }
+  }
+  handleRegistry.register(name, value, meta);
+}
+function getHandle(name) {
+  return handleRegistry.get(name);
+}
+function hasHandle(name) {
+  return handleRegistry.has(name);
+}
+function resolveHandle(name) {
+  if (!handleRegistry.has(name)) {
+    throw new Error(`Unknown handle "${name}". ${formatValidSet()}`);
+  }
+  return handleRegistry.get(name);
+}
+function listHandles() {
+  return handleRegistry.ids().sort();
+}
+function handleNameFor(value) {
+  for (const entry of handleRegistry.list()) {
+    if (Object.is(entry.value, value)) return entry.id;
+  }
+  return void 0;
+}
+function clearHandles() {
+  handleRegistry.clear();
+}
+
+// src/registry/loaders.ts
+var loaderRegistry = new Registry("loader");
+function defineLoader(id, impl, meta = {}) {
+  const propsSchema = meta.settings ? settingsToJsonSchema(meta.settings) : void 0;
+  loaderRegistry.register(
+    id,
+    impl,
+    propsSchema ? { ...meta, propsSchema } : { ...meta }
+  );
+}
+function formatValidSet2() {
+  const ids = loaderRegistry.ids().sort();
+  return ids.length ? `Registered loaders: ${ids.join(", ")}` : "No loaders are registered \u2014 call defineLoader(id, impl, meta) before referencing one.";
+}
+function resolveLoader(id) {
+  const impl = loaderRegistry.get(id);
+  if (!impl) throw new Error(`Unknown loader "${id}". ${formatValidSet2()}`);
+  return impl;
+}
+function hasLoader(id) {
+  return loaderRegistry.has(id);
+}
+function listLoaders() {
+  return loaderRegistry.ids().sort();
+}
+function clearLoaders() {
+  loaderRegistry.clear();
+}
+function describeLoaders() {
+  return loaderRegistry.describe().map((base) => {
+    const meta = loaderRegistry.getEntry(base.id)?.meta;
+    return {
+      ...base,
+      paramsSchema: base.schema,
+      params: meta?.settings ?? [],
+      output: meta?.output
+    };
+  });
+}
+function isLoaderParamRef(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.$param === "string" && Object.keys(value).length === 1;
+}
+function isLoaderPropRef(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.$prop === "string" && Object.keys(value).length === 1;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const record = value;
+  const parts = Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`);
+  return `{${parts.join(",")}}`;
+}
+function dataNeedKey(loader, params = {}) {
+  return `${loader} ${canonicalJson(params)}`;
+}
+
+// src/registry/entities.ts
+var ENTITY_FIELD_TYPES = [
+  "text",
+  "richtext",
+  "number",
+  "boolean",
+  "json",
+  "image",
+  "url",
+  "ref",
+  "point",
+  "datetime"
+];
+var GENERIC_ENTITY_TABLE = "plg_entity_records";
+var ENTITY_KEY_RE = /^[a-z][a-z0-9_]*$/;
+var FIELD_NAME_RE = /^[a-z][a-z0-9_]*$/;
+var RESERVED_ENTITY_FIELDS = ["id", "slug", "entity", "tenant_id", "created_at", "updated_at"];
+var entityDeclarationRegistry = new Registry("entity");
+function fail(message, valid) {
+  throw new Error(valid?.length ? `${message} Valid: ${valid.join(", ")}.` : message);
+}
+function normalizeDeclaration(key, input) {
+  if (!ENTITY_KEY_RE.test(key)) {
+    fail(`defineEntity: "${key}" is not a valid entity key \u2014 keys are snake_case (${ENTITY_KEY_RE}).`);
+  }
+  const fieldNames = Object.keys(input.fields ?? {});
+  if (fieldNames.length === 0) {
+    fail(`defineEntity("${key}"): an entity declares at least one field.`);
+  }
+  for (const [name, field] of Object.entries(input.fields)) {
+    if (!FIELD_NAME_RE.test(name)) {
+      fail(`defineEntity("${key}"): "${name}" is not a valid field name \u2014 fields are snake_case (${FIELD_NAME_RE}).`);
+    }
+    if (RESERVED_ENTITY_FIELDS.includes(name)) {
+      fail(`defineEntity("${key}"): "${name}" is a structural record column and cannot be a declared field.`, RESERVED_ENTITY_FIELDS);
+    }
+    if (!ENTITY_FIELD_TYPES.includes(field?.type)) {
+      fail(`defineEntity("${key}"): field "${name}" has unknown type "${String(field?.type)}".`, ENTITY_FIELD_TYPES);
+    }
+    if (field.type === "ref" && !field.entity) {
+      fail(`defineEntity("${key}"): ref field "${name}" must name the entity it points to ({ type: 'ref', entity: '<key>' }).`);
+    }
+  }
+  const knows = (name, where) => {
+    if (!fieldNames.includes(name)) {
+      fail(`defineEntity("${key}"): ${where} references undeclared field "${name}".`, fieldNames);
+    }
+  };
+  for (const index of input.indexes ?? []) {
+    for (const name of index) knows(name, "an index");
+  }
+  if (input.titleField) knows(input.titleField, "titleField");
+  for (const name of input.displayFields ?? []) knows(name, "displayFields");
+  const titleField = input.titleField ?? fieldNames.find((name) => input.fields[name].type === "text");
+  const displayFields = input.displayFields ?? fieldNames.filter((name) => input.fields[name].type !== "json");
+  return {
+    key,
+    title: input.title ?? key,
+    description: input.description,
+    fields: input.fields,
+    scope: input.scope ?? "tenant",
+    access: { read: input.access?.read ?? "staff", write: "staff" },
+    indexes: input.indexes ?? [],
+    titleField,
+    displayFields,
+    storage: { mode: "generic", table: GENERIC_ENTITY_TABLE }
+  };
+}
+function defineEntity(key, input, meta = {}) {
+  const declaration = normalizeDeclaration(key, input);
+  entityDeclarationRegistry.register(key, declaration, {
+    title: declaration.title,
+    description: declaration.description,
+    propsSchema: entityRecordSchema(declaration),
+    source: meta.source ?? "app",
+    pluginId: meta.pluginId,
+    since: meta.since
+  });
+  return declaration;
+}
+function formatValidEntities() {
+  const ids = entityDeclarationRegistry.ids().sort();
+  return ids.length ? `Declared entities: ${ids.join(", ")}` : "No entities are declared \u2014 call defineEntity(key, declaration) first.";
+}
+function resolveEntityDeclaration(key) {
+  const declaration = entityDeclarationRegistry.get(key);
+  if (!declaration) throw new Error(`Unknown entity "${key}". ${formatValidEntities()}`);
+  return declaration;
+}
+function hasEntityDeclaration(key) {
+  return entityDeclarationRegistry.has(key);
+}
+function listEntityDeclarations() {
+  return entityDeclarationRegistry.ids().sort();
+}
+function clearEntityDeclarations() {
+  entityDeclarationRegistry.clear();
+}
+var FIELD_FORMAT = {
+  image: "uri",
+  url: "uri",
+  datetime: "date-time"
+};
+function fieldToJsonSchema(name, field) {
+  const node = {
+    title: field.label ?? name,
+    // The control survives the compile, exactly as in block settings: a `ref`
+    // is a string in JSON Schema terms, but an editor rendering it as a text
+    // input (instead of a record picker) is a bug.
+    "x-fayz-control": field.type
+  };
+  if (field.help) node.description = field.help;
+  if (field.default !== void 0) node.default = field.default;
+  const format = FIELD_FORMAT[field.type];
+  if (format) node.format = format;
+  switch (field.type) {
+    case "number":
+      node.type = "number";
+      return node;
+    case "boolean":
+      node.type = "boolean";
+      return node;
+    case "json":
+      return node;
+    case "point":
+      node.type = "object";
+      node.properties = { lat: { type: "number" }, lng: { type: "number" } };
+      node.required = ["lat", "lng"];
+      node.additionalProperties = false;
+      return node;
+    case "ref":
+      node.type = "string";
+      node["x-fayz-ref-entity"] = field.entity;
+      return node;
+    default:
+      node.type = "string";
+      return node;
+  }
+}
+function entityRecordSchema(declaration) {
+  const properties = {};
+  const required = [];
+  for (const [name, field] of Object.entries(declaration.fields)) {
+    properties[name] = fieldToJsonSchema(name, field);
+    if (field.required) required.push(name);
+  }
+  const schema = {
+    type: "object",
+    title: declaration.title,
+    properties,
+    additionalProperties: false
+  };
+  if (declaration.description) schema.description = declaration.description;
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+function typeOf(value) {
+  return Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+}
+function validateEntityRecordData(declaration, data) {
+  const issues = [];
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return [{ path: "", code: "invalid-value", message: `record data is an object, got ${typeOf(data)}` }];
+  }
+  const record = data;
+  const fieldNames = Object.keys(declaration.fields);
+  for (const [name, value] of Object.entries(record)) {
+    const field = declaration.fields[name];
+    if (!field) {
+      issues.push({
+        path: name,
+        code: "unknown-field",
+        message: `field "${name}" is not declared by this entity`,
+        valid: fieldNames
+      });
+      continue;
+    }
+    if (value === null || value === void 0) continue;
+    switch (field.type) {
+      case "number":
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          issues.push({ path: name, code: "invalid-value", message: `"${name}" expects a number, got ${typeOf(value)}` });
+        }
+        break;
+      case "boolean":
+        if (typeof value !== "boolean") {
+          issues.push({ path: name, code: "invalid-value", message: `"${name}" expects a boolean, got ${typeOf(value)}` });
+        }
+        break;
+      case "json":
+        break;
+      // any JSON value
+      case "point": {
+        const point = value;
+        if (typeOf(value) !== "object" || typeof point.lat !== "number" || typeof point.lng !== "number" || Object.keys(point).length !== 2) {
+          issues.push({ path: name, code: "invalid-value", message: `"${name}" expects {lat: number, lng: number}` });
+        }
+        break;
+      }
+      default:
+        if (typeof value !== "string") {
+          issues.push({ path: name, code: "invalid-value", message: `"${name}" expects a string, got ${typeOf(value)}` });
+        }
+    }
+  }
+  for (const [name, field] of Object.entries(declaration.fields)) {
+    if (field.required && (record[name] === void 0 || record[name] === null || record[name] === "")) {
+      issues.push({ path: name, code: "missing-field", message: `required field "${name}" is missing` });
+    }
+  }
+  return issues;
+}
+function describeEntities() {
+  return entityDeclarationRegistry.describe().map((base) => {
+    const declaration = entityDeclarationRegistry.get(base.id);
+    return {
+      ...base,
+      recordSchema: base.schema,
+      access: declaration.access,
+      scope: declaration.scope,
+      storage: declaration.storage,
+      indexes: declaration.indexes,
+      titleField: declaration.titleField,
+      displayFields: declaration.displayFields
+    };
+  });
+}
+var FIELD_TYPE_TO_INPUT = {
+  text: "text",
+  richtext: "markdown",
+  number: "number",
+  boolean: "boolean",
+  // JSON and point have no dedicated control yet; they degrade to text inputs
+  // with a hint, which is honest — the descriptor still names the real type in
+  // the record schema, so a richer control can adopt them without a migration.
+  json: "textarea",
+  point: "text",
+  image: "image",
+  url: "url",
+  ref: "relation",
+  datetime: "datetime"
+};
+function entityAdminForm(declaration) {
+  const fields = Object.entries(declaration.fields).map(([name, field]) => {
+    const def = {
+      key: name,
+      label: field.label ?? name,
+      type: FIELD_TYPE_TO_INPUT[field.type],
+      showInForm: true,
+      showInTable: declaration.displayFields.includes(name)
+    };
+    if (field.required) def.required = true;
+    if (field.help) def.hint = field.help;
+    if (field.default !== void 0) def.defaultValue = field.default;
+    if (field.type === "json") def.hint = field.help ?? "JSON value";
+    if (field.type === "point") def.hint = field.help ?? "lat,lng";
+    if (field.type === "ref" && field.entity) {
+      def.relation = {
+        table: declaration.storage.table,
+        valueField: "id",
+        labelField: "slug",
+        filter: { entity: field.entity }
+      };
+    }
+    return def;
+  });
+  return { entity: declaration.key, title: declaration.title, fields };
+}
+var SIDECAR_REFERENCES = ["product", "category"];
+var sidecarDeclarationRegistry = new Registry("sidecar");
+function defineSidecarFields(reference, fields, meta = {}) {
+  if (!SIDECAR_REFERENCES.includes(reference)) {
+    fail(`defineSidecarFields: "${reference}" is not a sidecar reference.`, SIDECAR_REFERENCES);
+  }
+  for (const [name, field] of Object.entries(fields)) {
+    if (!FIELD_NAME_RE.test(name)) {
+      fail(`defineSidecarFields("${reference}"): "${name}" is not a valid field name (${FIELD_NAME_RE}).`);
+    }
+    if (!ENTITY_FIELD_TYPES.includes(field?.type)) {
+      fail(`defineSidecarFields("${reference}"): field "${name}" has unknown type "${String(field?.type)}".`, ENTITY_FIELD_TYPES);
+    }
+  }
+  const declaration = { reference, fields };
+  sidecarDeclarationRegistry.register(reference, declaration, {
+    title: `Custom fields: ${reference}`,
+    propsSchema: entityRecordSchema({ title: `${reference} custom fields`, fields }),
+    source: meta.source ?? "app",
+    pluginId: meta.pluginId
+  });
+  return declaration;
+}
+function resolveSidecarDeclaration(reference) {
+  const declaration = sidecarDeclarationRegistry.get(reference);
+  if (!declaration) {
+    const declared = sidecarDeclarationRegistry.ids().sort();
+    throw new Error(
+      `No sidecar fields are declared for "${reference}". ${declared.length ? `Declared references: ${declared.join(", ")}` : "Call defineSidecarFields(reference, fields) first."}`
+    );
+  }
+  return declaration;
+}
+function hasSidecarDeclaration(reference) {
+  return sidecarDeclarationRegistry.has(reference);
+}
+function clearSidecarDeclarations() {
+  sidecarDeclarationRegistry.clear();
+}
+
+// src/registry/block-constraints.ts
+function metaFor(type) {
+  return blockRegistry.getEntry(type)?.meta;
+}
+function placement(parentType) {
+  return parentType ? `under "${parentType}"` : "at the tree root";
+}
+function* walk(nodes, basePath, ancestors) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const path = `${basePath}[${i}]`;
+    yield { node, path, ancestors };
+    if (node.children?.length) {
+      yield* walk(node.children, `${path}.children`, [...ancestors, node.type]);
+    }
+  }
+}
+function checkNodePlacement(type, ancestors) {
+  const meta = metaFor(type);
+  if (!meta) return [];
+  const found = [];
+  const parentType = ancestors[ancestors.length - 1];
+  if (meta.parent?.length && (parentType === void 0 || !meta.parent.includes(parentType))) {
+    found.push({
+      path: "",
+      type,
+      rule: "constraint-parent",
+      detail: `block "${type}" may only be a direct child of one of [${meta.parent.join(", ")}]; it is placed ${placement(parentType)}`,
+      valid: [...meta.parent]
+    });
+  }
+  if (meta.ancestor?.length && !ancestors.some((a) => meta.ancestor.includes(a))) {
+    found.push({
+      path: "",
+      type,
+      rule: "constraint-ancestor",
+      detail: `block "${type}" must appear inside one of [${meta.ancestor.join(", ")}] (at any depth); it is placed ${placement(parentType)}`,
+      valid: [...meta.ancestor]
+    });
+  }
+  return found;
+}
+function checkBlockConstraints(nodes) {
+  const found = [];
+  const firstInstanceOf = /* @__PURE__ */ new Map();
+  for (const { node, path, ancestors } of walk(nodes, "", [])) {
+    for (const violation of checkNodePlacement(node.type, ancestors)) {
+      found.push({ ...violation, path });
+    }
+    const meta = metaFor(node.type);
+    if (meta?.allowMultiple === false) {
+      const first = firstInstanceOf.get(node.type);
+      if (first === void 0) {
+        firstInstanceOf.set(node.type, path);
+      } else {
+        found.push({
+          path,
+          type: node.type,
+          rule: "constraint-multiple",
+          detail: `block "${node.type}" declares allowMultiple: false and already appears at ${first || "(root)"} \u2014 remove one of the instances`,
+          valid: [first]
+        });
+      }
+    }
+  }
+  return found;
+}
+function checkBlockContext(nodes, provided = []) {
+  const findings = [];
+  for (const { node, path, ancestors } of walk(nodes, "", [])) {
+    const meta = metaFor(node.type);
+    if (!meta?.usesContext?.length) continue;
+    const available = new Set(provided);
+    for (const ancestorType of ancestors) {
+      for (const key of metaFor(ancestorType)?.providesContext ?? []) available.add(key);
+    }
+    const missing = meta.usesContext.filter((key) => !available.has(key));
+    if (missing.length > 0) findings.push({ path, type: node.type, missing });
+  }
+  return findings;
+}
+function buildRequiredChild(spec) {
+  const defaults = defaultPropsFromSettings(metaFor(spec.type)?.settings);
+  return {
+    type: spec.type,
+    id: spec.id ?? spec.type,
+    props: { ...defaults, ...spec.props }
+  };
+}
+function repairChildren(parentPath, parentMeta, children, repairs) {
+  let out = [...children];
+  if (parentMeta?.requiredChildren?.length) {
+    let cursor = 0;
+    for (const spec of parentMeta.requiredChildren) {
+      const at = out.findIndex((child) => child.type === spec.type);
+      if (at >= 0) {
+        cursor = at + 1;
+        continue;
+      }
+      const index = Math.min(cursor, out.length);
+      out.splice(index, 0, buildRequiredChild(spec));
+      repairs.push({ path: parentPath, inserted: spec.type, index });
+      cursor = index + 1;
+    }
+  }
+  out = out.map((child, i) => {
+    if (!child.children?.length && !metaFor(child.type)?.requiredChildren?.length) return child;
+    const childPath = parentPath ? `${parentPath}[${i}]` : `[${i}]`;
+    const repaired = repairChildren(`${childPath}.children`, metaFor(child.type), child.children ?? [], repairs);
+    return repaired === child.children ? child : { ...child, children: repaired };
+  });
+  return out;
+}
+function repairBlockTree(nodes) {
+  const repairs = [];
+  const repaired = nodes.map((node, i) => {
+    const meta = metaFor(node.type);
+    if (!node.children?.length && !meta?.requiredChildren?.length) return node;
+    const children = repairChildren(`[${i}].children`, meta, node.children ?? [], repairs);
+    if (children.length === (node.children?.length ?? 0) && children.every((c, j) => c === node.children?.[j])) {
+      return node;
+    }
+    return { ...node, children };
+  });
+  if (repairs.length === 0) return { nodes, repairs };
+  return { nodes: repaired, repairs };
+}
+
+// src/registry/schema-check.ts
+function typeOf2(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+  return typeof value;
+}
+function typeMatches(declared, actual) {
+  if (declared === actual) return true;
+  return declared === "number" && actual === "integer";
+}
+function joinPath(base, key) {
+  return base === "" ? String(key) : `${base}.${key}`;
+}
+function checkAgainstSchema(schema, value, path = "") {
+  const issues = [];
+  const declaredType = schema.type;
+  if (declaredType !== void 0) {
+    const actual = typeOf2(value);
+    const accepted = Array.isArray(declaredType) ? declaredType.map(String) : [String(declaredType)];
+    if (!accepted.some((t) => typeMatches(t, actual))) {
+      issues.push({ path, message: `expected ${accepted.join(" | ")}, got ${actual}` });
+      return issues;
+    }
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((allowed) => JSON.stringify(allowed) === JSON.stringify(value))) {
+    issues.push({
+      path,
+      message: `value ${JSON.stringify(value)} is not one of ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}`
+    });
+  }
+  if (schema.const !== void 0 && JSON.stringify(schema.const) !== JSON.stringify(value)) {
+    issues.push({ path, message: `expected constant ${JSON.stringify(schema.const)}` });
+  }
+  if (typeof value === "string") {
+    if (typeof schema.minLength === "number" && value.length < schema.minLength) {
+      issues.push({ path, message: `string shorter than minLength ${schema.minLength}` });
+    }
+    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
+      issues.push({ path, message: `string longer than maxLength ${schema.maxLength}` });
+    }
+  }
+  if (typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+      issues.push({ path, message: `${value} is below minimum ${schema.minimum}` });
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+      issues.push({ path, message: `${value} is above maximum ${schema.maximum}` });
+    }
+  }
+  if (Array.isArray(value)) {
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+      issues.push({ path, message: `array shorter than minItems ${schema.minItems}` });
+    }
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+      issues.push({ path, message: `array longer than maxItems ${schema.maxItems}` });
+    }
+    if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+      value.forEach((item, index) => {
+        issues.push(...checkAgainstSchema(schema.items, item, joinPath(path, index)));
+      });
+    }
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const record = value;
+    const properties = schema.properties && typeof schema.properties === "object" ? schema.properties : void 0;
+    if (Array.isArray(schema.required)) {
+      for (const key of schema.required) {
+        if (typeof key === "string" && record[key] === void 0) {
+          issues.push({ path: joinPath(path, key), message: `required property "${key}" is missing` });
+        }
+      }
+    }
+    if (properties) {
+      for (const [key, propSchema] of Object.entries(properties)) {
+        if (record[key] !== void 0) {
+          issues.push(...checkAgainstSchema(propSchema, record[key], joinPath(path, key)));
+        }
+      }
+      if (schema.additionalProperties === false) {
+        const known = new Set(Object.keys(properties));
+        for (const key of Object.keys(record)) {
+          if (!known.has(key)) {
+            issues.push({
+              path: joinPath(path, key),
+              message: `unknown property "${key}" \u2014 declared properties: ${[...known].sort().join(", ")}`
+            });
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
+function formatSchemaIssues(issues) {
+  return issues.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message).join("; ");
+}
+
+// src/registry/extension-points.ts
+var handlersByPoint = /* @__PURE__ */ new Map();
+var extensionPointRegistry = new Registry("extension-point");
+var POINT_ID_PATTERN = /^[a-z][a-zA-Z0-9-]*\.[a-z][a-zA-Z0-9-]*$/;
+function isProductionBuild() {
+  try {
+    return process.env.NODE_ENV === "production";
+  } catch {
+    return true;
+  }
+}
+function formatValidPoints() {
+  const ids = extensionPointRegistry.ids().sort();
+  return ids.length ? `Declared extension points: ${ids.join(", ")}` : "No extension points are declared \u2014 call defineExtensionPoint first.";
+}
+function defineExtensionPoint(declaration) {
+  if (!POINT_ID_PATTERN.test(declaration.id)) {
+    throw new Error(
+      `Extension point id "${declaration.id}" is not namespaced. Use "namespace.point" (e.g. "cart.lineAnnotation").`
+    );
+  }
+  const meta = {
+    description: declaration.description,
+    source: declaration.source,
+    since: declaration.since
+  };
+  extensionPointRegistry.register(declaration.id, declaration, meta);
+  if (!handlersByPoint.has(declaration.id)) handlersByPoint.set(declaration.id, []);
+}
+function resolvePoint(pointId) {
+  const spec = extensionPointRegistry.get(pointId);
+  if (!spec) throw new Error(`Unknown extension point "${pointId}". ${formatValidPoints()}`);
+  return spec;
+}
+function registerExtensionHandler(pointId, handlerId, handler, options = {}) {
+  const spec = resolvePoint(pointId);
+  const handlers = handlersByPoint.get(pointId);
+  const existingIndex = handlers.findIndex((h) => h.id === handlerId);
+  if ((spec.mode ?? "many") === "escape" && existingIndex < 0 && handlers.length > 0) {
+    throw new Error(
+      `Extension point "${pointId}" is an escape valve and is already held by handler "${handlers[0].id}"${handlers[0].pluginId ? ` (plugin "${handlers[0].pluginId}")` : ""}. An escape valve accepts exactly ONE registrant (I4) \u2014 unregister the holder first, or extend through a many-handler point instead.`
+    );
+  }
+  const entry = {
+    id: handlerId,
+    handler,
+    after: options.after ?? [],
+    description: options.description,
+    source: options.source,
+    pluginId: options.pluginId
+  };
+  if (existingIndex >= 0) handlers[existingIndex] = entry;
+  else handlers.push(entry);
+}
+function unregisterExtensionHandler(pointId, handlerId) {
+  const handlers = handlersByPoint.get(pointId);
+  if (!handlers) return;
+  const index = handlers.findIndex((h) => h.id === handlerId);
+  if (index >= 0) handlers.splice(index, 1);
+}
+function orderHandlers(pointId, handlers) {
+  const byId = new Map(handlers.map((h) => [h.id, h]));
+  for (const handler of handlers) {
+    for (const dep of handler.after) {
+      if (!byId.has(dep)) {
+        throw new Error(
+          `Extension handler "${handler.id}" at "${pointId}" declares after: ["${dep}"], but no handler "${dep}" is registered there. Registered handlers: ${handlers.map((h) => h.id).join(", ")}`
+        );
+      }
+    }
+  }
+  const ordered = [];
+  const state = /* @__PURE__ */ new Map();
+  function visit(handler, chain) {
+    const mark = state.get(handler.id);
+    if (mark === "done") return;
+    if (mark === "visiting") {
+      throw new Error(
+        `Extension handlers at "${pointId}" declare a dependency cycle: ${[...chain, handler.id].join(" \u2192 ")}`
+      );
+    }
+    state.set(handler.id, "visiting");
+    for (const dep of handler.after) visit(byId.get(dep), [...chain, handler.id]);
+    state.set(handler.id, "done");
+    ordered.push(handler);
+  }
+  for (const handler of handlers) visit(handler, []);
+  return ordered;
+}
+function schemaViolation(kind, pointId, handlerId, detail) {
+  const who = handlerId ? ` handler "${handlerId}"` : "";
+  return new Error(`Extension point "${pointId}"${who}: invalid ${kind} \u2014 ${detail}`);
+}
+async function runExtensionPoint(pointId, input) {
+  const spec = resolvePoint(pointId);
+  if ((spec.mode ?? "many") === "escape") {
+    throw new Error(
+      `Extension point "${pointId}" is an escape valve \u2014 call runEscapeValve, whose Output | null contract is the point (I4).`
+    );
+  }
+  const inputIssues = checkAgainstSchema(spec.input, input);
+  if (inputIssues.length > 0) {
+    const error = schemaViolation("input", pointId, null, formatSchemaIssues(inputIssues));
+    if (!isProductionBuild()) throw error;
+    console.error(`[extension-points] ${error.message}`);
+    return [];
+  }
+  const handlers = orderHandlers(pointId, handlersByPoint.get(pointId) ?? []);
+  const contributions = [];
+  for (const handler of handlers) {
+    let value;
+    try {
+      value = await handler.handler(input);
+    } catch (cause) {
+      const error = new Error(
+        `Extension point "${pointId}" handler "${handler.id}" threw: ${cause instanceof Error ? cause.message : String(cause)}`
+      );
+      if (!isProductionBuild()) throw error;
+      console.error(`[extension-points] ${error.message}`);
+      continue;
+    }
+    if (value === void 0 || value === null) continue;
+    const outputIssues = checkAgainstSchema(spec.output, value);
+    if (outputIssues.length > 0) {
+      const error = schemaViolation("output", pointId, handler.id, formatSchemaIssues(outputIssues));
+      if (!isProductionBuild()) throw error;
+      console.error(`[extension-points] ${error.message}`);
+      continue;
+    }
+    contributions.push({ handlerId: handler.id, value });
+  }
+  return contributions;
+}
+async function runEscapeValve(pointId, input) {
+  const spec = resolvePoint(pointId);
+  if ((spec.mode ?? "many") !== "escape") {
+    throw new Error(`Extension point "${pointId}" is not an escape valve \u2014 call runExtensionPoint.`);
+  }
+  const inputIssues = checkAgainstSchema(spec.input, input);
+  if (inputIssues.length > 0) {
+    const error = schemaViolation("input", pointId, null, formatSchemaIssues(inputIssues));
+    if (!isProductionBuild()) throw error;
+    console.error(`[extension-points] ${error.message}`);
+    return null;
+  }
+  const holder = (handlersByPoint.get(pointId) ?? [])[0];
+  if (!holder) return null;
+  let value;
+  try {
+    value = await holder.handler(input);
+  } catch (cause) {
+    const error = new Error(
+      `Escape valve "${pointId}" handler "${holder.id}" threw: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+    if (!isProductionBuild()) throw error;
+    console.error(`[extension-points] ${error.message}`);
+    return null;
+  }
+  if (value === void 0 || value === null) return null;
+  const outputIssues = checkAgainstSchema(spec.output, value);
+  if (outputIssues.length > 0) {
+    const error = schemaViolation("output", pointId, holder.id, formatSchemaIssues(outputIssues));
+    if (!isProductionBuild()) throw error;
+    console.error(`[extension-points] ${error.message}`);
+    return null;
+  }
+  return value;
+}
+function describeExtensionPoints() {
+  return extensionPointRegistry.describe().map((base) => {
+    const spec = extensionPointRegistry.get(base.id);
+    return {
+      ...base,
+      mode: spec.mode ?? "many",
+      inputSchema: spec.input,
+      outputSchema: spec.output,
+      handlers: (handlersByPoint.get(base.id) ?? []).map((h) => ({
+        id: h.id,
+        after: h.after,
+        description: h.description,
+        source: h.source,
+        pluginId: h.pluginId
+      }))
+    };
+  });
+}
+function hasExtensionPoint(pointId) {
+  return extensionPointRegistry.has(pointId);
+}
+function listExtensionPoints() {
+  return extensionPointRegistry.ids().sort();
+}
+function listExtensionHandlers(pointId) {
+  resolvePoint(pointId);
+  return (handlersByPoint.get(pointId) ?? []).map((h) => h.id);
+}
+function clearExtensionPoints() {
+  extensionPointRegistry.clear();
+  handlersByPoint.clear();
+}
+function extensionAfterHooks(pointId, methods) {
+  resolvePoint(pointId);
+  const map = {};
+  for (const method of methods) {
+    map[method] = async (args, result) => {
+      await runExtensionPoint(pointId, { method, args, result });
+    };
+  }
+  return map;
+}
+
+// src/registry/index.ts
+var componentRegistry = new Registry("component");
+var blockRegistry = new Registry("block");
+var pageRegistry = new Registry("page");
+var scaffoldRegistry = new Registry("scaffold");
+var metricRegistry = new Registry("metric");
+var pluginRegistry = new Registry("plugin");
+var registerComponent = (id, c, meta) => componentRegistry.register(id, c, meta);
+var getComponent = (id) => componentRegistry.get(id);
+var registerBlock = (id, c, meta) => blockRegistry.register(id, c, meta);
+var getBlock = (id) => blockRegistry.get(id);
+var listBlocks = () => blockRegistry.list();
+var getBlockMeta = (id) => blockRegistry.getEntry(id)?.meta;
+var defineBlock = (id, component, meta = {}) => {
+  const propsSchema = meta.settings ? settingsToJsonSchema(meta.settings) : void 0;
+  blockRegistry.register(id, component, propsSchema ? { ...meta, propsSchema } : { ...meta });
+};
+var registerPage = (id, c, meta) => pageRegistry.register(id, c, meta);
+var getPage = (id) => pageRegistry.get(id);
+var registerScaffold = (id, c, meta) => scaffoldRegistry.register(id, c, meta);
+var getScaffold = (id) => scaffoldRegistry.get(id);
+var registerMetric = (def, meta) => metricRegistry.register(def.id, def, meta);
+var getMetric = (id) => metricRegistry.get(id);
+var listMetrics = () => metricRegistry.list();
+var registerPlugin = (id, manifest, meta) => pluginRegistry.register(id, manifest, meta);
+var getPlugin = (id) => pluginRegistry.get(id);
+var listPlugins = () => pluginRegistry.list();
+var pluginFactoryRegistry = new Registry("plugin-factory");
+var registerPluginFactory = (id, factory, meta) => pluginFactoryRegistry.register(id, factory, meta);
+var getPluginFactory = (id) => pluginFactoryRegistry.get(id);
+var listPluginFactories = () => pluginFactoryRegistry.list();
+
+// src/registry/block-catalog.ts
+function describeEntry(entry) {
+  const meta = entry.meta ?? {};
+  const settings = meta.settings ?? [];
+  return {
+    id: entry.id,
+    label: meta.label,
+    description: meta.description,
+    source: meta.source,
+    pluginId: meta.pluginId,
+    settings,
+    presets: meta.presets ?? [],
+    enabledOn: meta.enabledOn ?? [],
+    stability: meta.stability ?? "stable",
+    propsSchema: meta.propsSchema,
+    defaults: defaultPropsFromSettings(settings),
+    parent: meta.parent ?? [],
+    ancestor: meta.ancestor ?? [],
+    usesContext: meta.usesContext ?? [],
+    providesContext: meta.providesContext ?? [],
+    allowMultiple: meta.allowMultiple ?? true,
+    requiredChildren: meta.requiredChildren ?? []
+  };
+}
+function describeBlock(id) {
+  const entry = blockRegistry.getEntry(id);
+  return entry ? describeEntry(entry) : void 0;
+}
+function describeBlocks(options = {}) {
+  const { enabledOn, source, includeExperimental = false } = options;
+  return blockRegistry.list().map(describeEntry).filter((block) => {
+    if (!includeExperimental && block.stability === "experimental") return false;
+    if (source && !source.includes(block.source ?? "app")) return false;
+    if (enabledOn && block.enabledOn.length > 0 && !block.enabledOn.includes(enabledOn)) {
+      return false;
+    }
+    return true;
+  }).sort((a, b) => a.id.localeCompare(b.id));
+}
+function isBlockEnabledOn(block, surface) {
+  return block.enabledOn.length === 0 || block.enabledOn.includes(surface);
+}
+function walkSettings(settings, prefix = "") {
+  const out = [];
+  for (const setting of settings) {
+    const path = prefix ? `${prefix}[].${setting.id}` : setting.id;
+    out.push({ path, setting });
+    if (setting.of?.length) out.push(...walkSettings(setting.of, path));
+  }
+  return out;
+}
+function auditSettings(blockId, settings) {
+  const found = [];
+  const err = (rule, detail) => found.push({ level: "error", rule, blockId, detail });
+  const warn = (rule, detail) => found.push({ level: "warning", rule, blockId, detail });
+  for (const { path, setting } of walkSettings(settings)) {
+    if (!setting.id) {
+      err("setting-missing-id", `a setting at "${path}" has no id \u2014 it cannot write to a prop`);
+    }
+    if (!setting.label) {
+      warn("setting-missing-label", `setting "${path}" has no label \u2014 the editor renders a blank field`);
+    }
+    if (setting.type === "select" && !setting.options?.length) {
+      err("select-without-options", `setting "${path}" is a select with no options`);
+    }
+    if (setting.type === "list" && !setting.of?.length) {
+      warn(
+        "list-without-item-shape",
+        `setting "${path}" is a list with no \`of\` \u2014 an agent cannot generate items for it`
+      );
+    }
+    if (setting.type !== "number" && (setting.min !== void 0 || setting.max !== void 0)) {
+      warn("bounds-on-non-number", `setting "${path}" declares min/max but is not a number`);
+    }
+    if (setting.required && setting.default !== void 0) {
+      warn(
+        "required-with-default",
+        `setting "${path}" is required but also has a default \u2014 the default always satisfies it`
+      );
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const setting of settings) {
+    if (setting.id && seen.has(setting.id)) {
+      err("setting-duplicate-id", `setting "${setting.id}" is declared more than once`);
+    }
+    seen.add(setting.id);
+  }
+  return found;
+}
+function auditPresets(blockId, settings, presets) {
+  const found = [];
+  const declared = new Set(settings.map((s) => s.id));
+  const required = settings.filter((s) => s.required).map((s) => s.id);
+  const names = /* @__PURE__ */ new Set();
+  for (const preset of presets) {
+    const label = preset.name || "(unnamed)";
+    if (!preset.name) {
+      found.push({
+        level: "error",
+        rule: "preset-missing-name",
+        blockId,
+        detail: "a preset has no name \u2014 the editor has nothing to show in the picker"
+      });
+    } else if (names.has(preset.name)) {
+      found.push({
+        level: "error",
+        rule: "preset-duplicate-name",
+        blockId,
+        detail: `two presets are both named "${preset.name}"`
+      });
+    }
+    names.add(preset.name);
+    for (const key of Object.keys(preset.props ?? {})) {
+      if (!declared.has(key)) {
+        found.push({
+          level: "error",
+          rule: "preset-undeclared-prop",
+          blockId,
+          detail: `preset "${label}" sets "${key}", which is not a declared setting`
+        });
+      }
+    }
+    for (const key of required) {
+      if (preset.props?.[key] === void 0) {
+        found.push({
+          level: "error",
+          rule: "preset-missing-required",
+          blockId,
+          detail: `preset "${label}" omits required setting "${key}" \u2014 it inserts a broken block`
+        });
+      }
+    }
+  }
+  return found;
+}
+function auditBlocks(options = {}) {
+  const { source, requirePresets = false, requireEnabledOn = false } = options;
+  const findings = [];
+  for (const entry of blockRegistry.list()) {
+    const meta = entry.meta ?? {};
+    if (source && !source.includes(meta.source ?? "app")) continue;
+    const blockId = entry.id;
+    const settings = meta.settings;
+    const presets = meta.presets ?? [];
+    for (const [field, refs] of [
+      ["parent", meta.parent],
+      ["ancestor", meta.ancestor],
+      ["requiredChildren", meta.requiredChildren?.map((child) => child.type)]
+    ]) {
+      for (const ref of refs ?? []) {
+        if (!blockRegistry.has(ref)) {
+          findings.push({
+            level: "error",
+            rule: "constraint-unknown-block",
+            blockId,
+            detail: `${field} references "${ref}", which is not a registered block`
+          });
+        }
+      }
+    }
+    if (!settings) {
+      if (meta.propsSchema) {
+        findings.push({
+          level: "warning",
+          rule: "block-handwritten-schema",
+          blockId,
+          detail: "has a hand-written propsSchema \u2014 declare `settings` and let defineBlock compile it"
+        });
+      } else {
+        findings.push({
+          level: "warning",
+          rule: "block-undescribed",
+          blockId,
+          detail: "declares no settings \u2014 an editor and an agent can only guess its props"
+        });
+      }
+      continue;
+    }
+    findings.push(...auditSettings(blockId, settings));
+    findings.push(...auditPresets(blockId, settings, presets));
+    if (meta.enabledOn?.length === 0) {
+      findings.push({
+        level: "error",
+        rule: "enabled-on-empty",
+        blockId,
+        detail: 'enabledOn is an empty array, so the block is placeable nowhere \u2014 omit it for "anywhere"'
+      });
+    }
+    if (requirePresets && presets.length === 0 && settings.length > 0) {
+      findings.push({
+        level: "warning",
+        rule: "block-no-preset",
+        blockId,
+        detail: "has settings but no preset \u2014 inserting it lands an empty skeleton"
+      });
+    }
+    if (requireEnabledOn && meta.enabledOn === void 0) {
+      findings.push({
+        level: "warning",
+        rule: "block-no-enabled-on",
+        blockId,
+        detail: "does not declare enabledOn, so it is offered on every surface"
+      });
+    }
+  }
+  return findings;
+}
+function summarizeBlockAudit(findings) {
+  const errors = findings.filter((f) => f.level === "error").length;
+  return { ok: errors === 0, errors, warnings: findings.length - errors };
+}
+var PLUGIN_API_VERSION = 1;
+function resolvePluginComponent(def) {
+  if (def.component) return def.component;
+  if (def.componentId) return getComponent(def.componentId);
+  return void 0;
+}
+var EMPTY_CONTEXT = {
+  tenant: null,
+  user: null,
+  currentPath: "/",
+  matchedPath: "/",
+  layout: "sidebar"
+};
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function matchesRoutePattern(pattern, currentPath) {
+  if (pattern === currentPath) return true;
+  if (pattern.endsWith("/*")) {
+    const base = pattern.slice(0, -2);
+    return currentPath === base || currentPath.startsWith(`${base}/`);
+  }
+  if (pattern.endsWith("*")) return currentPath.startsWith(pattern.slice(0, -1));
+  return false;
+}
+function isWidgetVisible(widget, context) {
+  if (widget.permission && context.hasPermission && !context.hasPermission(widget.permission)) return false;
+  const visibility = widget.visibility;
+  if (!visibility) return true;
+  if (visibility.layouts && !visibility.layouts.includes(context.layout)) return false;
+  if (visibility.roles && context.user?.role && !visibility.roles.includes(context.user.role)) return false;
+  if (visibility.roles && !context.user?.role) return false;
+  if (visibility.plans && context.tenant?.plan && !visibility.plans.includes(context.tenant.plan)) return false;
+  if (visibility.plans && !context.tenant?.plan) return false;
+  if (visibility.routes && !visibility.routes.some((p) => matchesRoutePattern(p, context.currentPath))) return false;
+  if (visibility.excludeRoutes?.some((p) => matchesRoutePattern(p, context.currentPath))) return false;
+  if (visibility.permissions?.length) {
+    if (!context.hasPermission) return false;
+    if (!visibility.permissions.every((req) => context.hasPermission?.(req))) return false;
+  }
+  if (visibility.when && !visibility.when(context)) return false;
+  return true;
+}
+function normalizeSettingsTabs(plugin) {
+  return (plugin.settings ?? []).map((entry, index) => ({
+    ...entry,
+    pluginId: entry.pluginId ?? plugin.id,
+    order: entry.order ?? index,
+    id: entry.id ?? `${plugin.id}-${slugify(entry.label)}`
+  }));
+}
+function createEmptyRuntime(context = EMPTY_CONTEXT) {
+  return {
+    context,
+    plugins: [],
+    activePlugins: [],
+    routes: [],
+    navigation: [],
+    settingsTabs: [],
+    widgets: [],
+    dashboardWidgets: [],
+    analyticsCards: [],
+    events: [],
+    capabilities: [],
+    aiTools: [],
+    registries: /* @__PURE__ */ new Map(),
+    connectorsByHost: /* @__PURE__ */ new Map(),
+    pluginFeatures: [],
+    pluginLimits: [],
+    issues: []
+  };
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+function resolvePluginRuntime({
+  plugins = [],
+  tenantPlugins = [],
+  hasTenantBindings,
+  context
+}) {
+  if (plugins.length === 0) return createEmptyRuntime(context);
+  const issues = [];
+  const normalizedPlugins = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    if (normalizedPlugins.has(plugin.id)) {
+      issues.push({ type: "duplicate_plugin", pluginId: plugin.id, message: `Plugin "${plugin.id}" registered more than once.` });
+      continue;
+    }
+    if (plugin.apiVersion != null && plugin.apiVersion > PLUGIN_API_VERSION) {
+      issues.push({
+        type: "incompatible_api_version",
+        pluginId: plugin.id,
+        message: `Plugin "${plugin.id}" requires plugin API v${plugin.apiVersion}, but this runtime supports v${PLUGIN_API_VERSION}. Upgrade @fayz-ai/core.`
+      });
+      continue;
+    }
+    normalizedPlugins.set(plugin.id, plugin);
+  }
+  const bindings = /* @__PURE__ */ new Map();
+  for (const b of tenantPlugins) bindings.set(b.pluginId, b);
+  const bindingsAreManaged = hasTenantBindings ?? tenantPlugins.length > 0;
+  const requested = /* @__PURE__ */ new Set();
+  const activationReason = /* @__PURE__ */ new Map();
+  for (const plugin of normalizedPlugins.values()) {
+    const binding = bindings.get(plugin.id);
+    if (binding?.status === "active") {
+      requested.add(plugin.id);
+      activationReason.set(plugin.id, "tenant");
+      continue;
+    }
+    if (plugin.defaultEnabled === true || !bindingsAreManaged && plugin.defaultEnabled !== false) {
+      requested.add(plugin.id);
+      activationReason.set(plugin.id, "default");
+    }
+  }
+  const orderedIds = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function visit(pluginId, ancestry = []) {
+    if (visited.has(pluginId)) return;
+    const plugin = normalizedPlugins.get(pluginId);
+    if (!plugin) return;
+    if (visiting.has(pluginId)) {
+      issues.push({ type: "circular_dependency", pluginId, message: `Circular dependency: ${[...ancestry, pluginId].join(" -> ")}.` });
+      return;
+    }
+    visiting.add(pluginId);
+    for (const depId of plugin.dependencies ?? []) {
+      if (!normalizedPlugins.has(depId)) {
+        issues.push({ type: "missing_dependency", pluginId, dependencyId: depId, message: `Plugin "${plugin.id}" depends on missing plugin "${depId}".` });
+        continue;
+      }
+      if (requested.has(pluginId) && !requested.has(depId)) {
+        requested.add(depId);
+        activationReason.set(depId, "dependency");
+      }
+      visit(depId, [...ancestry, pluginId]);
+    }
+    visiting.delete(pluginId);
+    visited.add(pluginId);
+    orderedIds.push(pluginId);
+  }
+  for (const id of normalizedPlugins.keys()) visit(id);
+  const resolvedById = /* @__PURE__ */ new Map();
+  for (const pluginId of orderedIds) {
+    const plugin = normalizedPlugins.get(pluginId);
+    if (!plugin) continue;
+    const binding = bindings.get(plugin.id);
+    const missing = (plugin.dependencies ?? []).filter((id) => !normalizedPlugins.has(id));
+    const compatible = !plugin.verticalId || plugin.verticalId === context.tenant?.verticalId;
+    if (!compatible) {
+      issues.push({ type: "vertical_mismatch", pluginId: plugin.id, message: `Plugin "${plugin.id}" requires vertical "${plugin.verticalId}".` });
+    }
+    const reason = activationReason.get(plugin.id) ?? "inactive";
+    const depsReady = (plugin.dependencies ?? []).every((id) => resolvedById.get(id)?.isActive);
+    const explicitlyDisabled = binding?.status === "disabled" || binding?.status === "removed";
+    const shouldActivate = reason === "dependency" ? true : requested.has(plugin.id) && !explicitlyDisabled;
+    const isActive = shouldActivate && compatible && missing.length === 0 && depsReady;
+    resolvedById.set(plugin.id, {
+      ...plugin,
+      status: isActive ? "active" : binding?.status ?? "disabled",
+      isActive,
+      activationReason: isActive ? reason : "inactive",
+      config: binding?.config ?? {},
+      missingDependencies: missing,
+      settingsTabs: normalizeSettingsTabs(plugin),
+      widgets: plugin.widgets ?? [],
+      resolvedRegistries: plugin.registries ?? [],
+      resolvedAITools: plugin.aiTools ?? []
+    });
+  }
+  const resolvedPlugins = orderedIds.map((id) => resolvedById.get(id)).filter((p) => Boolean(p));
+  const activePlugins = resolvedPlugins.filter((p) => p.isActive);
+  const routes = [];
+  const navigation = [];
+  const settingsTabs = [];
+  const widgets = [];
+  const dashboardWidgets = [];
+  const analyticsCards = [];
+  const events = [];
+  const capabilities = [];
+  const aiTools = [];
+  const registries = /* @__PURE__ */ new Map();
+  const connectorsByHost = /* @__PURE__ */ new Map();
+  const pluginFeatures = [];
+  const pluginLimits = [];
+  for (const plugin of activePlugins) {
+    routes.push(...plugin.routes.map((r) => ({ ...r, plugin })));
+    navigation.push(...plugin.navigation.map((entry, i) => ({
+      ...entry,
+      id: entry.id ?? `${plugin.id}:${entry.route}:${i}`,
+      icon: entry.icon ?? plugin.icon
+    })));
+    settingsTabs.push(...plugin.settingsTabs);
+    capabilities.push(...plugin.capabilities ?? []);
+    events.push(...(plugin.events ?? []).map((e) => ({
+      ...e,
+      pluginId: plugin.id,
+      pluginName: plugin.name,
+      pluginIcon: plugin.icon
+    })));
+    aiTools.push(...plugin.resolvedAITools);
+    if (plugin.resolvedRegistries.length > 0) registries.set(plugin.id, plugin.resolvedRegistries);
+    for (const connector of plugin.connectors ?? []) {
+      const list = connectorsByHost.get(connector.hostPluginId) ?? [];
+      list.push(connector);
+      connectorsByHost.set(connector.hostPluginId, list);
+    }
+    if (plugin.declaredFeatures) pluginFeatures.push(...plugin.declaredFeatures);
+    if (plugin.declaredLimits) pluginLimits.push(...plugin.declaredLimits);
+    widgets.push(...plugin.widgets.map((w, i) => ({
+      ...w,
+      order: w.order ?? i,
+      config: { ...plugin.config, ...w.props ?? {} },
+      plugin
+    })));
+    dashboardWidgets.push(...(plugin.dashboardWidgets ?? []).map((w, i) => ({
+      ...w,
+      domain: w.domain ?? plugin.id,
+      order: w.defaultOrder ?? i,
+      plugin
+    })));
+    analyticsCards.push(...(plugin.analyticsCards ?? []).map((c, i) => ({
+      ...c,
+      domain: c.domain ?? plugin.id,
+      order: c.dashboard?.order ?? i,
+      plugin
+    })));
+  }
+  events.push(...buildEntityDomainEvents(getAllEntities()));
+  navigation.sort((a, b) => {
+    const order = { main: 0, secondary: 1, settings: 2 };
+    return (order[a.section] ?? 99) - (order[b.section] ?? 99) || a.position - b.position;
+  });
+  settingsTabs.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  widgets.sort((a, b) => a.zone !== b.zone ? a.zone.localeCompare(b.zone) : a.order - b.order);
+  dashboardWidgets.sort((a, b) => a.order - b.order);
+  analyticsCards.sort((a, b) => a.order - b.order);
+  return { context, plugins: resolvedPlugins, activePlugins, routes, navigation, settingsTabs, widgets, dashboardWidgets, analyticsCards, capabilities, events, aiTools, issues, registries, connectorsByHost, pluginFeatures, pluginLimits };
+}
+function getWidgetsForZone(runtime, zone, contextOverrides) {
+  const ctx = { ...runtime.context, ...contextOverrides };
+  return runtime.widgets.filter((w) => w.zone === zone && isWidgetVisible(w, ctx));
+}
+function getAnalyticsCards(runtime, options = {}) {
+  const ctx = { ...runtime.context, ...options.contextOverrides };
+  const placedOnly = options.placedOnly || Boolean(options.surface);
+  return runtime.analyticsCards.filter((c) => {
+    if (placedOnly && !c.dashboard) return false;
+    if (options.surface) {
+      const surfaces = c.dashboard?.surfaces ?? ["analytics"];
+      if (!surfaces.includes(options.surface)) return false;
+    }
+    if (options.domain && c.domain !== options.domain) return false;
+    if (options.category && c.category !== options.category) return false;
+    if (c.verticalId && ctx.tenant?.verticalId && c.verticalId !== ctx.tenant.verticalId) return false;
+    if (c.permission && ctx.hasPermission && !ctx.hasPermission(c.permission)) return false;
+    return true;
+  });
+}
+function getDashboardWidgets(runtime, options) {
+  const ctx = { ...runtime.context, ...options.contextOverrides };
+  return runtime.dashboardWidgets.filter((w) => {
+    const surfaces = w.surfaces ?? ["home", "plugin-home"];
+    if (!surfaces.includes(options.surface)) return false;
+    if (options.domain && w.domain !== options.domain) return false;
+    if (w.verticalId && ctx.tenant?.verticalId && w.verticalId !== ctx.tenant.verticalId) return false;
+    if (w.permission && ctx.hasPermission && !ctx.hasPermission(w.permission)) return false;
+    return true;
+  });
+}
+var PluginRuntimeContext = React.createContext(null);
+var PluginRuntimeProvider = PluginRuntimeContext.Provider;
+function usePluginRuntime() {
+  return React.useContext(PluginRuntimeContext) ?? createEmptyRuntime();
+}
+function usePluginRuntimeOptional() {
+  return React.useContext(PluginRuntimeContext);
+}
+function useConnectorsForPlugin(hostPluginId) {
+  return usePluginRuntime().connectorsByHost.get(hostPluginId) ?? [];
+}
+
+export { BLOCK_SETTING_TYPES, ENTITY_FIELD_TYPES, GENERIC_ENTITY_TABLE, PLUGIN_API_VERSION, PluginRuntimeProvider, RESERVED_ENTITY_FIELDS, Registry, SIDECAR_REFERENCES, auditBlocks, blockRegistry, buildEntityDomainEvents, checkAgainstSchema, checkBlockConstraints, checkBlockContext, checkNodePlacement, clearEntityDeclarations, clearExtensionPoints, clearHandles, clearLoaders, clearSidecarDeclarations, componentRegistry, dataNeedKey, defaultPropsFromSettings, defineBlock, defineEntity, defineExtensionPoint, defineLoader, definePlugin, defineSidecarFields, describeBlock, describeBlocks, describeEntities, describeExtensionPoints, describeLoaders, entityAdminForm, entityDeclarationRegistry, entityEventKey, entityRecordSchema, extensionAfterHooks, extensionPointRegistry, formatSchemaIssues, getAnalyticsCards, getBlock, getBlockMeta, getComponent, getDashboardWidgets, getHandle, getMetric, getPage, getPlugin, getPluginFactory, getScaffold, getWidgetsForZone, handleNameFor, handleRegistry, hasEntityDeclaration, hasExtensionPoint, hasHandle, hasLoader, hasSidecarDeclaration, isBlockEnabledOn, isCustomId, isLoaderParamRef, isLoaderPropRef, listBlocks, listEntityDeclarations, listExtensionHandlers, listExtensionPoints, listHandles, listLoaders, listMetrics, listPluginFactories, listPlugins, loaderRegistry, metricRegistry, pageRegistry, pluginFactoryRegistry, pluginRegistry, registerBlock, registerComponent, registerExtensionHandler, registerHandle, registerMetric, registerPage, registerPlugin, registerPluginFactory, registerScaffold, repairBlockTree, resolveEntityDeclaration, resolveHandle, resolveLoader, resolvePluginComponent, resolvePluginRuntime, resolveSidecarDeclaration, runEscapeValve, runExtensionPoint, scaffoldRegistry, settingsToJsonSchema, sidecarDeclarationRegistry, summarizeBlockAudit, unregisterExtensionHandler, useConnectorsForPlugin, usePluginRuntime, usePluginRuntimeOptional, validateEntityRecordData };
+//# sourceMappingURL=chunk-732GZEUI.js.map
+//# sourceMappingURL=chunk-732GZEUI.js.map