@elevasis/ui 2.72.0 → 2.74.0

package/dist/chunk-N6K2Q5BM.js

@@ -0,0 +1,393 @@
+import { REFETCH_INTERVAL_DASHBOARD } from './chunk-Y6I3IC45.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema, UuidSchema } from './chunk-TVTSASST.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { z } from 'zod';
+
+var RelativeScheduleItemSchema = z.object({
+  offset: z.string().regex(/^[+-]\d+[dhm]$/, "Invalid offset format. Use +3d, -2h, +30m, etc."),
+  payload: z.record(z.string(), z.unknown()),
+  label: z.string().optional()
+});
+var AbsoluteScheduleItemSchema = z.object({
+  runAt: z.string().datetime({ message: "Invalid datetime format" }),
+  payload: z.record(z.string(), z.unknown()),
+  label: z.string().optional()
+});
+var RecurringScheduleConfigSchema = z.object({
+  type: z.literal("recurring"),
+  cron: z.string().optional(),
+  interval: z.enum(["daily", "weekly", "monthly"]).optional(),
+  time: z.string().regex(/^\d{2}:\d{2}$/, "Time must be in HH:MM format").optional(),
+  timezone: z.string().min(1, "Timezone is required"),
+  payload: z.record(z.string(), z.unknown()),
+  endAt: z.string().datetime().nullable().optional(),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+}).refine((data) => data.cron || data.interval, { message: "Either cron or interval must be provided" });
+var RelativeScheduleConfigSchema = z.object({
+  type: z.literal("relative"),
+  anchorAt: z.string().datetime({ message: "Invalid anchor datetime" }),
+  anchorLabel: z.string().optional(),
+  items: z.array(RelativeScheduleItemSchema).min(1, "At least one item required"),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+});
+var AbsoluteScheduleConfigSchema = z.object({
+  type: z.literal("absolute"),
+  items: z.array(AbsoluteScheduleItemSchema).min(1, "At least one item required"),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+});
+var TaskScheduleConfigSchema = z.discriminatedUnion("type", [
+  RecurringScheduleConfigSchema,
+  RelativeScheduleConfigSchema,
+  AbsoluteScheduleConfigSchema
+]);
+var ScheduleTargetSchema = z.object({
+  resourceType: ResourceTypeSchema,
+  resourceId: NonEmptyStringSchema.max(255)
+});
+var OptionalOriginTrackingSchema = z.object({
+  originExecutionId: UuidSchema.optional(),
+  originResourceType: OriginResourceTypeSchema.optional(),
+  originResourceId: z.string().max(100).optional()
+});
+z.object({
+  organizationId: UuidSchema,
+  name: NonEmptyStringSchema.max(255),
+  description: z.string().max(1e3).optional(),
+  target: ScheduleTargetSchema,
+  scheduleConfig: TaskScheduleConfigSchema,
+  maxRetries: z.number().int().min(0).max(10).optional().default(3),
+  idempotencyKey: z.string().max(255).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).merge(OptionalOriginTrackingSchema);
+var CreateScheduleRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(255),
+  description: z.string().max(1e3).optional(),
+  target: z.object({
+    resourceType: ResourceTypeSchema,
+    resourceId: z.string().min(1, "Resource ID is required").max(255)
+  }),
+  scheduleConfig: TaskScheduleConfigSchema,
+  maxRetries: z.number().int().min(0).max(10).optional(),
+  idempotencyKey: z.string().max(255).optional(),
+  // Origin tracking (optional)
+  originExecutionId: z.string().uuid().optional(),
+  originResourceType: OriginResourceTypeSchema.optional(),
+  originResourceId: z.string().max(255).optional()
+});
+z.object({
+  status: z.enum(["active", "paused", "completed", "cancelled"]).optional(),
+  targetResourceType: ResourceTypeSchema.optional(),
+  targetResourceId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var GetScheduleParamsSchema = z.object({
+  id: z.string().uuid("Invalid schedule ID")
+});
+var UpdateAnchorRequestSchema = z.object({
+  anchorAt: z.string().datetime({ message: "Invalid anchor datetime format" })
+});
+var UpdateScheduleRequestSchema = z.object({
+  name: z.string().min(1, "Name cannot be empty").max(255).optional(),
+  description: z.string().max(1e3).nullable().optional(),
+  scheduleConfig: TaskScheduleConfigSchema.optional(),
+  maxRetries: z.number().int().min(0).max(10).optional()
+}).strict().refine(
+  (data) => data.name !== void 0 || data.description !== void 0 || data.scheduleConfig !== void 0 || data.maxRetries !== void 0,
+  { message: "At least one field (name, description, scheduleConfig, maxRetries) must be provided" }
+);
+z.object({
+  schedules: z.array(
+    z.object({
+      // Required identifiers
+      id: z.string().uuid(),
+      organization_id: z.string().uuid(),
+      name: z.string(),
+      // Target
+      target_resource_type: z.string(),
+      target_resource_id: z.string(),
+      // Schedule definition
+      schedule_config: z.record(z.string(), z.unknown()),
+      // JSONB from database
+      current_step: z.number().int(),
+      status: z.string(),
+      // Scheduling state
+      next_run_at: z.string().nullable(),
+      last_run_at: z.string().nullable(),
+      last_execution_id: z.string().uuid().nullable(),
+      // Config
+      max_retries: z.number().int(),
+      retry_count: z.number().int(),
+      idempotency_key: z.string().nullable(),
+      description: z.string().nullable(),
+      // Origin tracking
+      origin_execution_id: z.string().uuid().nullable(),
+      origin_resource_type: z.string().nullable(),
+      origin_resource_id: z.string().nullable(),
+      // Timestamps (PostgreSQL format with microseconds)
+      created_at: z.string(),
+      updated_at: z.string()
+    })
+  ).min(1).max(100)
+});
+z.object({
+  id: z.string().uuid("Invalid schedule ID")
+});
+z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var ScheduleResponseSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  target: z.object({
+    resourceType: ResourceTypeSchema,
+    resourceId: z.string()
+  }),
+  scheduleConfig: TaskScheduleConfigSchema,
+  nextRunAt: z.string().datetime().nullable(),
+  currentStep: z.number().int(),
+  status: z.enum(["active", "paused", "completed", "cancelled"]),
+  lastRunAt: z.string().datetime().nullable(),
+  lastExecutionId: z.string().uuid().nullable(),
+  maxRetries: z.number().int(),
+  idempotencyKey: z.string().nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+z.object({
+  schedules: z.array(ScheduleResponseSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+var ExecutionHistoryItemSchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.string().datetime(),
+  status: z.enum(["running", "completed", "failed", "cancelled"]),
+  step: z.number().int().nullable(),
+  itemLabel: z.string().nullable(),
+  duration: z.number().nullable(),
+  // milliseconds
+  error: z.string().nullable()
+});
+z.object({
+  executions: z.array(ExecutionHistoryItemSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+z.object({
+  processed: z.number().int(),
+  succeeded: z.number().int(),
+  failed: z.number().int(),
+  errors: z.array(
+    z.object({
+      scheduleId: z.string().uuid(),
+      error: z.string()
+    })
+  ).optional()
+});
+
+// src/hooks/scheduling/useScheduledTasks.ts
+function useScheduledTasks(options = {}) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["schedules", "dashboard", workOSOrganizationId, options.status, options.targetResourceType],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (options.status) params.append("status", options.status);
+      if (options.targetResourceType) params.append("targetResourceType", options.targetResourceType);
+      const queryString = params.toString();
+      const response = await apiRequest(
+        `/task-scheduler/schedules${queryString ? `?${queryString}` : ""}`
+      );
+      return response.schedules;
+    },
+    enabled: isReady,
+    refetchInterval: REFETCH_INTERVAL_DASHBOARD
+  });
+}
+
+// src/hooks/scheduling/queryKeys.ts
+var scheduleKeys = {
+  all: (orgId) => ["schedules", orgId],
+  lists: (orgId) => [...scheduleKeys.all(orgId), "list"],
+  list: (orgId, filters) => [...scheduleKeys.lists(orgId), filters],
+  details: (orgId) => [...scheduleKeys.all(orgId), "detail"],
+  detail: (orgId, id) => [...scheduleKeys.details(orgId), id],
+  executions: (orgId, id) => [...scheduleKeys.detail(orgId, id), "executions"]
+};
+function useListSchedules(filters) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: scheduleKeys.list(workOSOrganizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters?.status) params.set("status", filters.status);
+      if (filters?.targetResourceType) params.set("targetResourceType", filters.targetResourceType);
+      if (filters?.targetResourceId) params.set("targetResourceId", filters.targetResourceId);
+      if (filters?.limit) params.set("limit", String(filters.limit));
+      if (filters?.offset) params.set("offset", String(filters.offset));
+      const queryString = params.toString();
+      const endpoint = `/task-scheduler/schedules${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady
+  });
+}
+function useGetSchedule(id) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: scheduleKeys.detail(workOSOrganizationId, id),
+    queryFn: async () => {
+      const data = await apiRequest(`/task-scheduler/schedules/${id}`);
+      return data.schedule;
+    },
+    enabled: isReady && !!id
+  });
+}
+function useGetExecutionHistory(scheduleId, options) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: [...scheduleKeys.executions(workOSOrganizationId, scheduleId), options?.limit, options?.offset],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", String(options.limit));
+      if (options?.offset) params.set("offset", String(options.offset));
+      const queryString = params.toString();
+      const endpoint = `/task-scheduler/schedules/${scheduleId}/executions${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady && !!scheduleId
+  });
+}
+function useCreateSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (input) => {
+      const validated = CreateScheduleRequestSchema.parse(input);
+      const data = await apiRequest("/task-scheduler/schedules", {
+        method: "POST",
+        body: JSON.stringify(validated)
+      });
+      return data.schedule;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useUpdateSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async ({ id, ...fields }) => {
+      GetScheduleParamsSchema.parse({ id });
+      const validated = UpdateScheduleRequestSchema.parse(fields);
+      const data = await apiRequest(`/task-scheduler/schedules/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(validated)
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.detail(workOSOrganizationId, variables.id)
+      });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useUpdateAnchor() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async ({ id, anchorAt }) => {
+      GetScheduleParamsSchema.parse({ id });
+      UpdateAnchorRequestSchema.parse({ anchorAt });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/anchor`, {
+        method: "PATCH",
+        body: JSON.stringify({ anchorAt })
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.detail(workOSOrganizationId, variables.id)
+      });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function usePauseSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/pause`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useResumeSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/resume`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useCancelSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/cancel`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+function useDeleteSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      await apiRequest(`/task-scheduler/schedules/${id}`, { method: "DELETE" });
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(workOSOrganizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(workOSOrganizationId) });
+    }
+  });
+}
+
+export { scheduleKeys, useCancelSchedule, useCreateSchedule, useDeleteSchedule, useGetExecutionHistory, useGetSchedule, useListSchedules, usePauseSchedule, useResumeSchedule, useScheduledTasks, useUpdateAnchor, useUpdateSchedule };

package/dist/{chunk-Z2W5VNN3.js → chunk-O32UQ26A.js}

@@ -1,5 +1,5 @@
 import { OrganizationContext } from './chunk-DD3CCMCZ.js';
-import { APIClientError } from './chunk-Q3O3WY7Q.js';
+import { APIClientError } from './chunk-R5UGIFYU.js';
 import { createContext, useContext, useMemo, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -124,7 +124,8 @@ function useApiClient(apiUrl) {
         response.status,
         errorData.requestId,
         errorData.fields,
-        errorData.retryAfter
+        errorData.retryAfter,
+        errorData.details
       );
     },
     [onError]

package/dist/{chunk-M7WWRZ5Z.js → chunk-QFGNRKIE.js}

@@ -1,6 +1,3 @@
-import { UuidSchema } from './chunk-TVTSASST.js';
-import { z } from 'zod';
-
 // src/hooks/sessions/mergeSessionMessages.ts
 function canonicalize(value) {
   if (Array.isArray(value)) {
@@ -45,80 +42,6 @@ function mergeSessionMessages(historyMessages, liveMessages) {
     return (a.messageIndex ?? 0) - (b.messageIndex ?? 0);
   });
 }
-var SessionIdParamSchema = z.object({
-  sessionId: UuidSchema
-}).strict();
-var ExecutionIdParamsSchema = z.object({
-  sessionId: UuidSchema,
-  executionId: UuidSchema
-}).strict();
-var CreateSessionSchema = z.object({
-  resourceId: z.string().min(1).max(100),
-  userId: UuidSchema.optional(),
-  metadata: z.any().optional()
-}).strict();
-z.object({
-  input: z.unknown().refine(
-    (val) => {
-      let text;
-      if (typeof val === "string") {
-        text = val;
-      } else if (val && typeof val === "object" && "message" in val) {
-        text = String(val.message);
-      } else {
-        text = JSON.stringify(val);
-      }
-      return text.length > 0 && text.length <= 1e5;
-    },
-    { message: "Input must be between 1 and 100,000 characters" }
-  ),
-  metadata: z.any().optional()
-}).strict();
-z.object({
-  userId: UuidSchema.optional(),
-  resourceId: z.string().optional(),
-  limit: z.coerce.number().int().min(1).max(100).default(20)
-}).strict();
-z.object({
-  limit: z.coerce.number().int().min(1).max(100).default(100),
-  cursor: z.coerce.number().int().min(0).optional()
-}).strict();
-var WebSocketSessionTurnSchema = z.object({
-  type: z.literal("session:turn"),
-  input: z.unknown().refine(
-    (val) => {
-      let text;
-      if (typeof val === "string") {
-        text = val;
-      } else if (val && typeof val === "object" && "message" in val) {
-        text = String(val.message);
-      } else {
-        text = JSON.stringify(val) || "";
-      }
-      return text && text.length > 0 && text.length <= 1e5;
-    },
-    { message: "Input must be between 1 and 100,000 characters" }
-  )
-}).strict();
-var NotificationCategorySchema = z.enum(["info", "queue", "alert", "error", "system"]);
-var GetNotificationsQuerySchema = z.object({
-  limit: z.coerce.number().int().min(1).max(100).default(50),
-  offset: z.coerce.number().int().min(0).default(0)
-});
-var MarkAsReadParamsSchema = z.object({
-  id: UuidSchema
-});
-z.object({
-  userId: UuidSchema,
-  organizationId: UuidSchema,
-  category: NotificationCategorySchema,
-  title: z.string().trim().min(1).max(200),
-  message: z.string().trim().min(1).max(1e3),
-  actionUrl: z.string().url().optional()
-}).strict();
-z.object({
-  ids: z.array(UuidSchema).min(1).max(500)
-}).strict();
 
 // src/hooks/sessions/sessionWebSocketUtils.ts
 var liveTempMessageCounter = 0;
@@ -156,4 +79,4 @@ function getWebSocketBaseUrl(apiUrl) {
   return `${protocol}//${url.host}`;
 }
 
-export { CreateSessionSchema, ExecutionIdParamsSchema, GetNotificationsQuerySchema, MarkAsReadParamsSchema, SessionIdParamSchema, WebSocketSessionTurnSchema, createLiveTempMessageIdentity, formatMessageEvent, getWebSocketBaseUrl, mergeSessionMessages };
+export { createLiveTempMessageIdentity, formatMessageEvent, getWebSocketBaseUrl, mergeSessionMessages };

package/dist/{chunk-Q3O3WY7Q.js → chunk-R5UGIFYU.js}

@@ -64,7 +64,16 @@ var APIClientError = class extends Error {
   requestId;
   fields;
   retryAfter;
-  constructor(message, code, statusCode, requestId, fields, retryAfter) {
+  /**
+   * Structured detail payload carried on `APIErrorResponse.details`
+   * (`packages/core/src/platform/api/types.ts`). Deliberately typed as a
+   * general bag rather than narrowed to any one error family — CONFLICT
+   * linked-row counts, SERVICE_UNAVAILABLE readiness payloads, and future
+   * error shapes all flow through the same field. Use a shape-specific
+   * accessor (e.g. `getSystemReadinessServerErrorDetails`) to narrow it.
+   */
+  details;
+  constructor(message, code, statusCode, requestId, fields, retryAfter, details) {
     super(message);
     this.name = "APIClientError";
     this.code = code;
@@ -72,11 +81,21 @@ var APIClientError = class extends Error {
     this.requestId = requestId;
     this.fields = fields;
     this.retryAfter = retryAfter;
+    this.details = details;
   }
 };
 function isAPIClientError(error) {
   return error instanceof APIClientError;
 }
+function isSystemReadinessErrorDetails(details) {
+  if (!details || typeof details !== "object") return false;
+  const candidate = details;
+  return typeof candidate.systemPath === "string" && typeof candidate.interfaceKey === "string" && typeof candidate.readinessCode === "string" && Array.isArray(candidate.issues);
+}
+function getSystemReadinessServerErrorDetails(error) {
+  if (!isAPIClientError(error)) return void 0;
+  return isSystemReadinessErrorDetails(error.details) ? error.details : void 0;
+}
 function getErrorInfo(error) {
   if (isAPIClientError(error)) {
     return {
@@ -512,44 +531,64 @@ var OntologyRecordBaseSchema = z.object({
 }).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()
-});
+  storage: z.record(z.string(), z.unknown()).optional(),
+  // Carried by the legacy entity projection (`addLegacyEntityProjections`); not
+  // authored directly, but a real key an authored record must not collide with.
+  rowSchema: z.string().trim().min(1).optional(),
+  stateCatalogId: z.string().trim().min(1).optional()
+}).strict();
 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()
-});
+}).strict();
 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()
-});
+  effects: z.array(z.record(z.string(), z.unknown())).optional(),
+  resourceId: z.string().trim().min(1).optional(),
+  invocations: z.array(z.unknown()).optional(),
+  lifecycle: z.string().trim().min(1).optional(),
+  // Carried by the legacy action projection (`addLegacyActionProjections`); not
+  // authored directly, but a real key an authored record must not collide with.
+  legacyActionId: z.string().trim().min(1).optional()
+}).strict();
 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()
-});
+  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  // Carried by lead-gen's legacy stage-catalog projection
+  // (`createLeadGenStageCatalog`); not authored directly, but a real key an
+  // authored record must not collide with.
+  legacyCatalogKey: z.string().trim().min(1).optional(),
+  // Carried in live tenant configs (Elevasis, `nirvana-marketing`, and the
+  // `_template` scaffold all author these on `sales.crm:catalog/crm.pipeline`)
+  // as a cross-reference to the pre-ontology CRM pipeline key/entity id. No
+  // code currently reads them back — do not silently normalize them away.
+  legacyPipelineKey: z.string().trim().min(1).optional(),
+  legacyEntityKey: z.string().trim().min(1).optional()
+}).strict();
 var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
   payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
+}).strict();
 var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
   properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
+}).strict();
 var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
   primitive: z.string().trim().min(1).max(120).optional()
-});
+}).strict();
 var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
   valueType: OntologyIdSchema.optional(),
   searchable: z.boolean().optional(),
   pii: z.boolean().optional()
-});
+}).strict();
 var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
   members: OntologyReferenceListSchema
-});
+}).strict();
 var OntologyEndpointTypeSchema = OntologyRecordBaseSchema.extend({
   route: z.string().trim().min(1).max(500).optional()
-});
+}).strict();
 var OntologyScopeSchema = z.object({
   objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
   linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
@@ -842,7 +881,19 @@ function resolveReadinessInterfaceMarker(model, systemPath, interfaceKey) {
 
 // ../core/src/organization-model/domains/systems.ts
 var SystemKindSchema = z.enum(["product", "operational", "platform", "diagnostic"]).meta({ label: "System kind", color: "blue" });
-var SystemLifecycleSchema = z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({ label: "Lifecycle", color: "teal" });
+var SystemLifecycleSchema = z.enum(["draft", "beta", "active", "deprecated", "archived"]).meta({
+  label: "Lifecycle",
+  color: "teal"
+});
+function systemLifecycleAllowsAccess(lifecycle, ctx) {
+  if (lifecycle === "active") return true;
+  if (lifecycle === "beta") return ctx.betaAccessEnabled === true || ctx.isDevelopment === true;
+  return false;
+}
+function isSystemLifecycleVisible(lifecycle, enabled) {
+  if (enabled === false) return false;
+  return lifecycle !== "draft" && lifecycle !== "deprecated" && lifecycle !== "archived";
+}
 var SystemIdSchema = ModelIdSchema;
 var SystemPathSchema = z.string().trim().min(1).regex(
   /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/,
@@ -968,8 +1019,13 @@ var SystemEntrySchema = z.object({
   parentSystemId: SystemIdSchema.optional(),
   /** Optional UI presence. Systems without UI omit this. */
   ui: SystemUiSchema.optional(),
-  /** Canonical lifecycle state. `beta` is what gates a System to dev-mode viewers. */
-  lifecycle: SystemLifecycleSchema.optional(),
+  /**
+   * Canonical lifecycle state. `beta` is what gates a System to dev-mode
+   * viewers. Defaults to `active` (not `.optional()`) so an omitted field
+   * never reaches a consumer as `undefined` -- see `isSystemLifecycleVisible`
+   * and `systemLifecycleAllowsAccess` above.
+   */
+  lifecycle: SystemLifecycleSchema.default("active"),
   /** Optional role responsible for this system. */
   responsibleRoleId: ModelIdSchema.meta({ ref: "role" }).optional(),
   /** Optional knowledge nodes that govern this system. */
@@ -1448,4 +1504,4 @@ function setupBrowserMocks() {
   setupResizeObserver();
 }
 
-export { APIClientError, API_URL, ActionInvocationSchema, ActionSchema, ActionsDomainSchema, DEBOUNCE_FILTER, DEBOUNCE_SLIDER, DEFAULT_ONTOLOGY_SCOPE, DEFAULT_ORGANIZATION_MODEL_ACTIONS, DEFAULT_ORGANIZATION_MODEL_SYSTEMS, DescriptionSchema, EntitiesDomainSchema, EntitySchema, GC_TIME_LONG, GC_TIME_MEDIUM, GC_TIME_SHORT, IconNameSchema, JsonValueSchema, LIMIT_ACTIVITY_FEED, LabelSchema, ModelIdSchema, NodeIdStringSchema, OAUTH_FLOW_TIMEOUT, OntologyIdSchema, OntologyScopeSchema, PAGE_SIZE_DEFAULT, PathSchema, STALE_TIME_ADMIN, STALE_TIME_DEFAULT, STALE_TIME_MONITORING, SYSTEM_INTERFACE_PROFILES, SystemEntrySchema, SystemIdSchema, SystemInterfaceRefSchema, SystemLifecycleSchema, SystemPathSchema, SystemsDomainSchema, addReadinessIssue, ancestorsOf, childrenOf, compileOrganizationOntology, computeInterfaceReadiness, defaultPathFor, devOnlyFor, findById, findByPath, formatChartAxisDate, formatDate, formatDateTime, formatErrorMessage, formatInterfaceIdentity, formatOntologyId, formatRelativeTime, formatTimeAgo, getErrorInfo, getErrorTitle, getResourceColor, getResourceIcon, getResourcesForSystem, getSystem, getSystemAncestors, isAPIClientError, listAllSystems, listResolvedOntologyRecords, ontologyGraphNodeId, parentOf, parseOntologyId, registerBuiltInReadinessProfile, registerReadinessInterfaceMarker, requireCatalogReadiness, requireContractReadiness, requireScopedBinding, resolveSystemConfig, resourceBindingIds, restoreConsole, setupBrowserMocks, suppressKnownWarnings, topLevel, validateEmail };
+export { APIClientError, API_URL, ActionInvocationSchema, ActionSchema, ActionsDomainSchema, DEBOUNCE_FILTER, DEBOUNCE_SLIDER, DEFAULT_ONTOLOGY_SCOPE, DEFAULT_ORGANIZATION_MODEL_ACTIONS, DEFAULT_ORGANIZATION_MODEL_SYSTEMS, DescriptionSchema, EntitiesDomainSchema, EntitySchema, GC_TIME_LONG, GC_TIME_MEDIUM, GC_TIME_SHORT, IconNameSchema, JsonValueSchema, LIMIT_ACTIVITY_FEED, LabelSchema, ModelIdSchema, NodeIdStringSchema, OAUTH_FLOW_TIMEOUT, OntologyIdSchema, OntologyScopeSchema, PAGE_SIZE_DEFAULT, PathSchema, STALE_TIME_ADMIN, STALE_TIME_DEFAULT, STALE_TIME_MONITORING, SYSTEM_INTERFACE_PROFILES, SystemEntrySchema, SystemIdSchema, SystemInterfaceRefSchema, SystemLifecycleSchema, SystemPathSchema, SystemsDomainSchema, addReadinessIssue, ancestorsOf, childrenOf, compileOrganizationOntology, computeInterfaceReadiness, defaultPathFor, devOnlyFor, findById, findByPath, formatChartAxisDate, formatDate, formatDateTime, formatErrorMessage, formatInterfaceIdentity, formatOntologyId, formatRelativeTime, formatTimeAgo, getErrorInfo, getErrorTitle, getResourceColor, getResourceIcon, getResourcesForSystem, getSystem, getSystemAncestors, getSystemReadinessServerErrorDetails, isAPIClientError, isSystemLifecycleVisible, listAllSystems, listResolvedOntologyRecords, ontologyGraphNodeId, parentOf, parseOntologyId, registerBuiltInReadinessProfile, registerReadinessInterfaceMarker, requireCatalogReadiness, requireContractReadiness, requireScopedBinding, resolveSystemConfig, resourceBindingIds, restoreConsole, setupBrowserMocks, suppressKnownWarnings, systemLifecycleAllowsAccess, topLevel, validateEmail };

package/dist/{chunk-753MKWFV.js → chunk-RFNJ2PTO.js}

@@ -1,4 +1,4 @@
-import { GC_TIME_LONG, STALE_TIME_DEFAULT } from './chunk-Q3O3WY7Q.js';
+import { GC_TIME_LONG, STALE_TIME_DEFAULT } from './chunk-R5UGIFYU.js';
 import { QueryClient } from '@tanstack/react-query';
 
 function createElevasisQueryClient(options = {}) {