@elevasis/ui 2.40.1 → 2.41.1

package/dist/{chunk-RXH4D6TY.js → chunk-5M4HSHQ5.js}

@@ -1,6 +1,6 @@
-import { formatOntologyId, getSystem, compileOrganizationOntology, parseOntologyId, getLeadGenStageCatalog } from './chunk-RH5VWWSC.js';
 import { formatDistanceToNow } from 'date-fns';
 import { IconUser, IconExternalLink, IconPlug, IconBolt, IconGitBranch, IconBrain } from '@tabler/icons-react';
+import { z } from 'zod';
 
 // src/utils/dateFormatters.ts
 function formatDateTime(dateString) {
@@ -168,6 +168,627 @@ function debounce(fn, wait) {
   return debounced;
 }
 
+// ../core/src/organization-model/helpers.ts
+function defineDomainRecord(schema, entries) {
+  return Object.fromEntries(
+    entries.map((entry) => {
+      const parsed = schema.parse(entry);
+      return [parsed.id, parsed];
+    })
+  );
+}
+function childSystemsOf(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
+function defaultPathFor(id) {
+  return `/${id.replaceAll(".", "/")}`;
+}
+function parentIdOf(id) {
+  const index = id.lastIndexOf(".");
+  return index === -1 ? void 0 : id.slice(0, index);
+}
+function findById(systems, id) {
+  return systems[id];
+}
+function findByPath(systems, path) {
+  return Object.values(systems).find((system) => (system.path ?? system.ui?.path ?? defaultPathFor(system.id)) === path);
+}
+function childrenOf(systems, id) {
+  const prefix = `${id}.`;
+  return Object.values(systems).filter(
+    (system) => system.id.startsWith(prefix) && !system.id.slice(prefix.length).includes(".")
+  );
+}
+function topLevel(systems) {
+  return Object.values(systems).filter((system) => !system.id.includes("."));
+}
+function ancestorsOf(systems, id) {
+  const segments = id.split(".");
+  const ids = segments.map((_, index) => segments.slice(0, index + 1).join("."));
+  return ids.map((ancestorId) => findById(systems, ancestorId)).filter((system) => Boolean(system));
+}
+function parentOf(systems, id) {
+  const parentId = parentIdOf(id);
+  return parentId ? findById(systems, parentId) : void 0;
+}
+function inheritedValue(systems, id, getValue) {
+  return ancestorsOf(systems, id).slice().reverse().map(getValue).find((value) => value !== void 0);
+}
+function requiresAdminFor(systems, id) {
+  return inheritedValue(systems, id, (system) => system.requiresAdmin) ?? false;
+}
+function devOnlyFor(systems, id) {
+  return inheritedValue(systems, id, (system) => system.devOnly || system.lifecycle === "beta" || void 0) ?? false;
+}
+function getSystem(model, path) {
+  const flatMatch = model.systems[path];
+  if (flatMatch !== void 0) return flatMatch;
+  const segments = path.split(".");
+  let current = model.systems;
+  let node;
+  for (const seg of segments) {
+    node = current[seg];
+    if (node === void 0) return void 0;
+    current = childSystemsOf(node);
+  }
+  return node;
+}
+function getSystemAncestors(model, path) {
+  const flatMatch = model.systems[path];
+  if (flatMatch !== void 0) {
+    const ancestorIds = path.split(".").map((_, index, segments2) => segments2.slice(0, index + 1).join(".")).slice(0, -1);
+    return [
+      ...ancestorIds.map((ancestorId) => model.systems[ancestorId]).filter((system) => system !== void 0),
+      flatMatch
+    ];
+  }
+  const segments = path.split(".");
+  const result = [];
+  let current = model.systems;
+  for (const seg of segments) {
+    const node = current[seg];
+    if (node === void 0) return [];
+    result.push(node);
+    current = childSystemsOf(node);
+  }
+  return result;
+}
+function listAllSystems(model) {
+  const results = [];
+  function walk(map, prefix) {
+    for (const [localId2, system] of Object.entries(map)) {
+      const fullPath = prefix ? `${prefix}.${localId2}` : localId2;
+      results.push({ path: fullPath, system });
+      const childSystems = childSystemsOf(system);
+      if (Object.keys(childSystems).length > 0) {
+        walk(childSystems, fullPath);
+      }
+    }
+  }
+  walk(model.systems, "");
+  return results;
+}
+function isPlainJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeJsonConfig(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const existing = result[key];
+    result[key] = isPlainJsonObject(existing) && isPlainJsonObject(value) ? mergeJsonConfig(existing, value) : value;
+  }
+  return result;
+}
+function resolveSystemConfig(model, path) {
+  const system = getSystem(model, path);
+  if (system === void 0) return {};
+  return mergeJsonConfig({}, system.config ?? {});
+}
+function getResourcesForSystem(model, systemPath, options = {}) {
+  const { includeDescendants = false } = options;
+  const prefix = systemPath + ".";
+  return Object.values(model.resources ?? {}).filter(
+    (r) => r.systemPath === systemPath || includeDescendants && r.systemPath.startsWith(prefix)
+  );
+}
+var OntologyKindSchema = z.enum([
+  "object",
+  "link",
+  "action",
+  "catalog",
+  "event",
+  "interface",
+  "value-type",
+  "property",
+  "group",
+  "surface"
+]);
+var SYSTEM_PATH_PATTERN = "[a-z0-9][a-z0-9-]*(?:\\.[a-z0-9][a-z0-9-]*)*";
+var LOCAL_ID_PATTERN = "[a-z0-9][a-z0-9._-]*";
+var ONTOLOGY_ID_PATTERN = `^(global|${SYSTEM_PATH_PATTERN}):(${OntologyKindSchema.options.join("|")})\\/(${LOCAL_ID_PATTERN})$`;
+var ONTOLOGY_ID_REGEX = new RegExp(ONTOLOGY_ID_PATTERN);
+var OntologyIdSchema = z.string().trim().min(1).max(300).regex(
+  ONTOLOGY_ID_REGEX,
+  "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
+);
+function parseOntologyId(id) {
+  const normalized = OntologyIdSchema.parse(id);
+  const match = ONTOLOGY_ID_REGEX.exec(normalized);
+  if (match === null) {
+    throw new Error(`Invalid ontology ID "${id}"`);
+  }
+  return {
+    id: normalized,
+    scope: match[1],
+    kind: match[2],
+    localId: match[3],
+    isGlobal: match[1] === "global"
+  };
+}
+function formatOntologyId(input) {
+  return OntologyIdSchema.parse(`${input.scope}:${input.kind}/${input.localId}`);
+}
+var OntologyReferenceListSchema = z.array(OntologyIdSchema).default([]).optional();
+var OntologyRecordBaseSchema = z.object({
+  id: OntologyIdSchema,
+  label: z.string().trim().min(1).max(160).optional(),
+  description: z.string().trim().min(1).max(2e3).optional(),
+  ownerSystemId: z.string().trim().min(1).max(200).optional(),
+  aliases: z.array(OntologyIdSchema).optional()
+}).passthrough();
+var OntologyObjectTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  storage: z.record(z.string(), z.unknown()).optional()
+});
+var OntologyLinkTypeSchema = OntologyRecordBaseSchema.extend({
+  from: OntologyIdSchema,
+  to: OntologyIdSchema,
+  cardinality: z.string().trim().min(1).max(80).optional(),
+  via: z.string().trim().min(1).max(255).optional()
+});
+var OntologyActionTypeSchema = OntologyRecordBaseSchema.extend({
+  actsOn: OntologyReferenceListSchema,
+  input: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  effects: z.array(z.record(z.string(), z.unknown())).optional()
+});
+var OntologyCatalogTypeSchema = OntologyRecordBaseSchema.extend({
+  kind: z.string().trim().min(1).max(120).optional(),
+  appliesTo: OntologyIdSchema.optional(),
+  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
+  payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
+});
+var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
+  primitive: z.string().trim().min(1).max(120).optional()
+});
+var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
+  valueType: OntologyIdSchema.optional(),
+  searchable: z.boolean().optional(),
+  pii: z.boolean().optional()
+});
+var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
+  members: OntologyReferenceListSchema
+});
+var OntologySurfaceTypeSchema = OntologyRecordBaseSchema.extend({
+  route: z.string().trim().min(1).max(500).optional()
+});
+var OntologyScopeSchema = z.object({
+  objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
+  linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
+  actionTypes: z.record(OntologyIdSchema, OntologyActionTypeSchema).default({}).optional(),
+  catalogTypes: z.record(OntologyIdSchema, OntologyCatalogTypeSchema).default({}).optional(),
+  eventTypes: z.record(OntologyIdSchema, OntologyEventTypeSchema).default({}).optional(),
+  interfaceTypes: z.record(OntologyIdSchema, OntologyInterfaceTypeSchema).default({}).optional(),
+  valueTypes: z.record(OntologyIdSchema, OntologyValueTypeSchema).default({}).optional(),
+  sharedProperties: z.record(OntologyIdSchema, OntologySharedPropertySchema).default({}).optional(),
+  groups: z.record(OntologyIdSchema, OntologyGroupSchema).default({}).optional(),
+  surfaces: z.record(OntologyIdSchema, OntologySurfaceTypeSchema).default({}).optional()
+}).default({});
+var DEFAULT_ONTOLOGY_SCOPE = {
+  valueTypes: {
+    "global:value-type/uuid": {
+      id: "global:value-type/uuid",
+      label: "UUID",
+      primitive: "string"
+    },
+    "global:value-type/text": {
+      id: "global:value-type/text",
+      label: "Text",
+      primitive: "string"
+    },
+    "global:value-type/url": {
+      id: "global:value-type/url",
+      label: "URL",
+      primitive: "string"
+    },
+    "global:value-type/email": {
+      id: "global:value-type/email",
+      label: "Email",
+      primitive: "string"
+    }
+  }
+};
+var SCOPE_KIND = {
+  objectTypes: "object",
+  linkTypes: "link",
+  actionTypes: "action",
+  catalogTypes: "catalog",
+  eventTypes: "event",
+  interfaceTypes: "interface",
+  valueTypes: "value-type",
+  sharedProperties: "property",
+  groups: "group",
+  surfaces: "surface"
+};
+var SCOPE_KEYS = Object.keys(SCOPE_KIND);
+function ontologyGraphNodeId(id) {
+  return `ontology:${OntologyIdSchema.parse(id)}`;
+}
+function listResolvedOntologyRecords(index) {
+  return SCOPE_KEYS.flatMap((scopeKey) => {
+    const kind = SCOPE_KIND[scopeKey];
+    return Object.entries(index[scopeKey]).sort(([leftId], [rightId]) => leftId.localeCompare(rightId)).map(([id, record]) => ({
+      id,
+      kind,
+      record
+    }));
+  });
+}
+function originFromContext(context) {
+  return {
+    kind: context.kind,
+    source: context.source,
+    path: context.path,
+    ...context.systemPath !== void 0 ? { systemPath: context.systemPath } : {},
+    ...context.legacyId !== void 0 ? { legacyId: context.legacyId } : {}
+  };
+}
+function createEmptyIndex() {
+  return {
+    objectTypes: {},
+    linkTypes: {},
+    actionTypes: {},
+    catalogTypes: {},
+    eventTypes: {},
+    interfaceTypes: {},
+    valueTypes: {},
+    sharedProperties: {},
+    groups: {},
+    surfaces: {}
+  };
+}
+function sortResolvedOntologyIndex(index) {
+  const sorted = createEmptyIndex();
+  for (const scopeKey of SCOPE_KEYS) {
+    const target = sorted[scopeKey];
+    for (const [id, record] of Object.entries(index[scopeKey]).sort(
+      ([leftId], [rightId]) => leftId.localeCompare(rightId)
+    )) {
+      target[id] = record;
+    }
+  }
+  return sorted;
+}
+function childSystemsOf2(system) {
+  return system.systems ?? system.subsystems ?? {};
+}
+function addRecord(index, diagnostics, sourcesById, scopeKey, record, context) {
+  let parsed;
+  try {
+    parsed = parseOntologyId(record.id);
+  } catch {
+    diagnostics.push({
+      code: "invalid_ontology_id",
+      message: `Invalid ontology ID "${record.id}" from ${context.source} at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const expectedKind = SCOPE_KIND[scopeKey];
+  if (parsed.kind !== expectedKind) {
+    diagnostics.push({
+      code: "ontology_kind_mismatch",
+      message: `Ontology ID "${record.id}" has kind "${parsed.kind}" but was authored in ${scopeKey} (${expectedKind}) at ${context.path.join(".")}`,
+      id: record.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context)
+    });
+    return;
+  }
+  const existing = sourcesById.get(parsed.id);
+  if (existing !== void 0) {
+    diagnostics.push({
+      code: "duplicate_ontology_id",
+      message: `Duplicate ontology ID "${parsed.id}" from ${context.source} at ${context.path.join(".")} conflicts with ${existing.source} at ${existing.path.join(".")}`,
+      id: parsed.id,
+      path: context.path,
+      source: context.source,
+      origin: originFromContext(context),
+      existingSource: existing.source,
+      existingOrigin: originFromContext(existing)
+    });
+    return;
+  }
+  sourcesById.set(parsed.id, context);
+  index[scopeKey][parsed.id] = {
+    ...record,
+    origin: originFromContext(context)
+  };
+}
+function addScope(index, diagnostics, sourcesById, scope, source, path) {
+  if (scope === void 0) return;
+  for (const scopeKey of SCOPE_KEYS) {
+    const records = scope[scopeKey] ?? {};
+    for (const [key, record] of Object.entries(records)) {
+      addRecord(index, diagnostics, sourcesById, scopeKey, record, {
+        source,
+        path: [...path, scopeKey, key],
+        kind: "authored",
+        systemPath: source.startsWith("system:") ? source.slice("system:".length, -".ontology".length) : void 0
+      });
+    }
+  }
+}
+function legacyObjectId(entity) {
+  return formatOntologyId({ scope: entity.ownedBySystemId, kind: "object", localId: entity.id });
+}
+function legacyActionOwner(action, entities) {
+  const firstAffectedEntityId = action.affects?.find((entityId) => entities[entityId] !== void 0);
+  if (firstAffectedEntityId !== void 0) {
+    return entities[firstAffectedEntityId].ownedBySystemId;
+  }
+  if (typeof action.scope === "object") {
+    return action.scope.domain;
+  }
+  return "global";
+}
+function addLegacyEntityProjections(index, diagnostics, sourcesById, entities) {
+  for (const entity of Object.values(entities)) {
+    const objectType = {
+      id: legacyObjectId(entity),
+      label: entity.label,
+      description: entity.description,
+      ownerSystemId: entity.ownedBySystemId,
+      ...entity.table !== void 0 ? {
+        storage: {
+          kind: "table",
+          table: entity.table
+        }
+      } : {},
+      ...entity.rowSchema !== void 0 ? { rowSchema: entity.rowSchema } : {},
+      ...entity.stateCatalogId !== void 0 ? { stateCatalogId: entity.stateCatalogId } : {}
+    };
+    addRecord(index, diagnostics, sourcesById, "objectTypes", objectType, {
+      source: "legacy.entities",
+      path: ["entities", entity.id],
+      kind: "projected",
+      systemPath: entity.ownedBySystemId,
+      legacyId: entity.id
+    });
+    entity.links?.forEach((link, linkIndex) => {
+      const targetEntity = entities[link.toEntity];
+      if (targetEntity === void 0) return;
+      const linkType = {
+        id: formatOntologyId({
+          scope: entity.ownedBySystemId,
+          kind: "link",
+          localId: `${entity.id}-${link.toEntity}-${linkIndex}`
+        }),
+        label: link.label ?? link.kind,
+        ownerSystemId: entity.ownedBySystemId,
+        from: legacyObjectId(entity),
+        to: legacyObjectId(targetEntity),
+        cardinality: link.kind,
+        ...link.via !== void 0 ? { via: link.via } : {}
+      };
+      addRecord(index, diagnostics, sourcesById, "linkTypes", linkType, {
+        source: "legacy.entities.links",
+        path: ["entities", entity.id, "links", linkIndex],
+        kind: "projected",
+        systemPath: entity.ownedBySystemId,
+        legacyId: `${entity.id}.links.${linkIndex}`
+      });
+    });
+  }
+}
+function addLegacyActionProjections(index, diagnostics, sourcesById, actions, entities) {
+  for (const action of Object.values(actions)) {
+    const ownerSystemId = legacyActionOwner(action, entities);
+    const actionType = {
+      id: formatOntologyId({ scope: ownerSystemId, kind: "action", localId: action.id }),
+      label: action.label,
+      description: action.description,
+      ownerSystemId,
+      actsOn: action.affects?.map((entityId) => entities[entityId] ? legacyObjectId(entities[entityId]) : void 0).filter((id) => id !== void 0),
+      ...action.resourceId !== void 0 ? { resourceId: action.resourceId } : {},
+      ...action.invocations !== void 0 ? { invocations: action.invocations } : {},
+      ...action.lifecycle !== void 0 ? { lifecycle: action.lifecycle } : {},
+      legacyActionId: action.id
+    };
+    addRecord(index, diagnostics, sourcesById, "actionTypes", actionType, {
+      source: "legacy.actions",
+      path: ["actions", action.id],
+      kind: "projected",
+      systemPath: ownerSystemId,
+      legacyId: action.id
+    });
+  }
+}
+function addSystemScopes(index, diagnostics, sourcesById, systems, prefix, schemaPath) {
+  for (const [key, system] of Object.entries(systems)) {
+    const systemPath = prefix ? `${prefix}.${key}` : key;
+    const currentPath = [...schemaPath, key];
+    addScope(index, diagnostics, sourcesById, system.ontology, `system:${systemPath}.ontology`, [
+      ...currentPath,
+      "ontology"
+    ]);
+    addSystemScopes(index, diagnostics, sourcesById, childSystemsOf2(system), systemPath, [
+      ...currentPath,
+      system.systems !== void 0 ? "systems" : "subsystems"
+    ]);
+  }
+}
+function compileOrganizationOntology(model) {
+  const ontology = createEmptyIndex();
+  const diagnostics = [];
+  const sourcesById = /* @__PURE__ */ new Map();
+  addScope(ontology, diagnostics, sourcesById, model.ontology, "organization.ontology", ["ontology"]);
+  addSystemScopes(ontology, diagnostics, sourcesById, model.systems ?? {}, "", ["systems"]);
+  addLegacyEntityProjections(ontology, diagnostics, sourcesById, model.entities ?? {});
+  addLegacyActionProjections(ontology, diagnostics, sourcesById, model.actions ?? {}, model.entities ?? {});
+  return { ontology: sortResolvedOntologyIndex(ontology), diagnostics };
+}
+
+// ../core/src/organization-model/migration-helpers.ts
+function catalogRecords(model) {
+  return Object.values(compileOrganizationOntology(model).ontology.catalogTypes);
+}
+function localId(id) {
+  return parseOntologyId(id).localId;
+}
+function systemScope(id, fallback) {
+  return parseOntologyId(id).scope || fallback || "";
+}
+function entriesOf(catalog) {
+  return Object.entries(catalog.entries ?? {}).map(([id, value]) => [
+    id,
+    value && typeof value === "object" && !Array.isArray(value) ? value : {}
+  ]);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function numberValue(value, fallback = 0) {
+  return typeof value === "number" ? value : fallback;
+}
+function stageFromEntry(entryId, entry) {
+  return {
+    id: entryId,
+    label: stringValue(entry.label) ?? entryId,
+    order: numberValue(entry.order),
+    semanticClass: stringValue(entry.semanticClass) ?? "open",
+    surfaceIds: stringArray(entry.surfaceIds),
+    resourceIds: stringArray(entry.resourceIds),
+    color: stringValue(entry.color)
+  };
+}
+function appliesToLocalId(catalog) {
+  const appliesTo = catalog.appliesTo;
+  if (appliesTo === void 0) return void 0;
+  return parseOntologyId(appliesTo).localId;
+}
+function appliesToEntityKind(catalog) {
+  const id = appliesToLocalId(catalog);
+  if (id === "company" || id === "contact" || id === "project" || id === "milestone" || id === "task") return id;
+  if (id === "deal") return void 0;
+  return void 0;
+}
+function getAllPipelines(model) {
+  return catalogRecords(model).filter((catalog) => catalog.kind === "pipeline").map((catalog) => {
+    const pipeline = {
+      id: localId(catalog.id),
+      label: catalog.label ?? localId(catalog.id),
+      ...catalog.description ? { description: catalog.description } : {},
+      entityId: appliesToLocalId(catalog) ?? "",
+      stages: entriesOf(catalog).map(([entryId, entry]) => stageFromEntry(entryId, entry)).sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+    };
+    return { systemPath: catalog.ownerSystemId ?? systemScope(catalog.id), pipeline };
+  }).sort((a, b) => a.systemPath.localeCompare(b.systemPath) || a.pipeline.id.localeCompare(b.pipeline.id));
+}
+function getAllBuildTemplates(model) {
+  const catalogs = catalogRecords(model);
+  const stepCatalogs = new Map(
+    catalogs.filter((catalog) => catalog.kind === "template-step").map((catalog) => [catalog.id, catalog])
+  );
+  return catalogs.filter((catalog) => catalog.kind === "template").flatMap(
+    (catalog) => entriesOf(catalog).map(([templateId, templateEntry]) => {
+      const stepCatalogId = stringValue(templateEntry.stepCatalog);
+      const stepCatalog = stepCatalogId !== void 0 ? stepCatalogs.get(stepCatalogId) : void 0;
+      const steps = stepCatalog === void 0 ? [] : entriesOf(stepCatalog).sort(
+        ([leftId, left], [rightId, right]) => numberValue(left.order, Number.MAX_SAFE_INTEGER) - numberValue(right.order, Number.MAX_SAFE_INTEGER) || leftId.localeCompare(rightId)
+      );
+      return {
+        order: numberValue(templateEntry.order, Number.MAX_SAFE_INTEGER),
+        template: {
+          id: templateId,
+          label: stringValue(templateEntry.label) ?? templateId,
+          ...stringValue(templateEntry.description) ? { description: stringValue(templateEntry.description) } : {},
+          ...stringValue(templateEntry.color) ? { color: stringValue(templateEntry.color) } : {},
+          steps: steps.map(([stepId, step]) => ({
+            id: stepId,
+            label: stringValue(step.label) ?? stepId,
+            ...stringValue(step.description) ? { description: stringValue(step.description) } : {},
+            ...step
+          }))
+        }
+      };
+    })
+  ).sort((a, b) => a.order - b.order || a.template.id.localeCompare(b.template.id)).map(({ template }) => template);
+}
+function getAllProspectingStages(model, kind) {
+  return catalogRecords(model).filter((catalog) => catalog.kind === "stage" && appliesToEntityKind(catalog) === kind).flatMap(
+    (catalog) => entriesOf(catalog).map(([entryId, entry]) => ({
+      id: entryId,
+      label: stringValue(entry.label) ?? entryId,
+      order: numberValue(entry.order),
+      ...stringValue(entry.color) ? { color: stringValue(entry.color) } : {},
+      ...stringValue(entry.description) ? { description: stringValue(entry.description) } : {}
+    }))
+  ).sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+}
+function getLeadGenStageCatalog(model) {
+  const results = {};
+  for (const catalog of catalogRecords(model).filter(
+    (record) => record.kind === "stage" && (record.ownerSystemId ?? systemScope(record.id)) === "sales.lead-gen"
+  )) {
+    const catalogEntity = appliesToEntityKind(catalog);
+    if (catalogEntity !== "company" && catalogEntity !== "contact") continue;
+    for (const [entryId, entry] of entriesOf(catalog)) {
+      const entity = entry.entity === "contact" ? "contact" : entry.entity === "company" ? "company" : catalogEntity;
+      const additionalEntities = stringArray(entry.additionalEntities).filter(
+        (item) => item === "company" || item === "contact"
+      );
+      const recordEntity = entry.recordEntity === "company" || entry.recordEntity === "contact" ? entry.recordEntity : void 0;
+      const recordStageKey = stringValue(entry.recordStageKey);
+      results[entryId] = {
+        key: entryId,
+        label: stringValue(entry.label) ?? entryId,
+        description: stringValue(entry.description) ?? "",
+        order: numberValue(entry.order),
+        entity,
+        ...additionalEntities.length > 0 ? { additionalEntities } : {},
+        ...recordEntity ? { recordEntity } : {},
+        ...recordStageKey ? { recordStageKey } : {}
+      };
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(results).sort(([, a], [, b]) => a.order - b.order || a.key.localeCompare(b.key))
+  );
+}
+function getAllProjectStatuses(model, appliesTo) {
+  return catalogRecords(model).filter((catalog) => catalog.kind === "status-flow" && appliesToEntityKind(catalog) === appliesTo).flatMap(
+    (catalog) => entriesOf(catalog).map(([entryId, entry]) => ({
+      id: entryId,
+      label: stringValue(entry.label) ?? entryId,
+      order: numberValue(entry.order),
+      ...stringValue(entry.color) ? { color: stringValue(entry.color) } : {},
+      ...stringValue(entry.description) ? { description: stringValue(entry.description) } : {}
+    }))
+  ).sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+}
+
 // ../core/src/business/acquisition/ontology-validation.ts
 var LEAD_GEN_API_INTERFACE = {
   systemPath: "sales.lead-gen",
@@ -710,6 +1331,14 @@ function getResourceIcon(type) {
 // src/utils/constants/api.ts
 var API_URL = import.meta.env.PROD ? "https://api.elevasis.io" : "http://localhost:5170";
 
+// src/utils/constants/cache.ts
+var STALE_TIME_MONITORING = 3e4;
+var STALE_TIME_ADMIN = 6e4;
+var STALE_TIME_DEFAULT = 3e5;
+var GC_TIME_SHORT = 3e5;
+var GC_TIME_MEDIUM = 6e5;
+var GC_TIME_LONG = 18e5;
+
 // src/utils/constants/polling.ts
 var REFETCH_INTERVAL_DASHBOARD = 6e4;
 var REFETCH_INTERVAL_REALTIME = 3e4;
@@ -798,4 +1427,4 @@ function setupBrowserMocks() {
   setupResizeObserver();
 }
 
-export { APIClientError, API_URL, DEBOUNCE_FILTER, DEBOUNCE_SLIDER, LEAD_GEN_API_INTERFACE, LIMIT_ACTIVITY_FEED, OAUTH_FLOW_TIMEOUT, PAGE_SIZE_DEFAULT, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_REALTIME, REFETCH_INTERVAL_RUNNING, REFETCH_INTERVAL_RUNNING_FAST, SSE_CLOSE_GRACE_PERIOD, SSE_TOKEN_REFRESH_DELAY, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, computeInterfaceReadiness, debounce, formatBucketTime, formatChartAxisDate, formatDate, formatDateTime, formatErrorMessage, formatRelativeTime, formatTimeAgo, getErrorInfo, getErrorTitle, getResourceColor, getResourceIcon, getTimeRangeDates, getTimeRangeLabel, isAPIClientError, restoreConsole, setupBrowserMocks, suppressKnownWarnings, validateEmail };
+export { APIClientError, API_URL, DEBOUNCE_FILTER, DEBOUNCE_SLIDER, DEFAULT_ONTOLOGY_SCOPE, GC_TIME_LONG, GC_TIME_MEDIUM, GC_TIME_SHORT, LEAD_GEN_API_INTERFACE, LIMIT_ACTIVITY_FEED, OAUTH_FLOW_TIMEOUT, OntologyIdSchema, OntologyScopeSchema, PAGE_SIZE_DEFAULT, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_REALTIME, REFETCH_INTERVAL_RUNNING, REFETCH_INTERVAL_RUNNING_FAST, SSE_CLOSE_GRACE_PERIOD, SSE_TOKEN_REFRESH_DELAY, STALE_TIME_ADMIN, STALE_TIME_DEFAULT, STALE_TIME_MONITORING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, ancestorsOf, childrenOf, compileOrganizationOntology, computeInterfaceReadiness, debounce, defaultPathFor, defineDomainRecord, devOnlyFor, findById, findByPath, formatBucketTime, formatChartAxisDate, formatDate, formatDateTime, formatErrorMessage, formatRelativeTime, formatTimeAgo, getAllBuildTemplates, getAllPipelines, getAllProjectStatuses, getAllProspectingStages, getErrorInfo, getErrorTitle, getLeadGenStageCatalog, getResourceColor, getResourceIcon, getResourcesForSystem, getSystem, getSystemAncestors, getTimeRangeDates, getTimeRangeLabel, isAPIClientError, listAllSystems, listResolvedOntologyRecords, ontologyGraphNodeId, parentOf, parseOntologyId, requiresAdminFor, resolveSystemConfig, restoreConsole, setupBrowserMocks, suppressKnownWarnings, topLevel, validateEmail };

package/dist/{chunk-TE4P6OSJ.js → chunk-7FJI76OH.js}

@@ -1,5 +1,5 @@
-import { APIClientError } from './chunk-RXH4D6TY.js';
 import { OrganizationContext } from './chunk-DD3CCMCZ.js';
+import { APIClientError } from './chunk-5M4HSHQ5.js';
 import { createContext, useContext, useMemo, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';