@elevasis/core 0.27.0 → 0.28.0

package/src/organization-model/domains/knowledge.ts

@@ -3,22 +3,23 @@ import { IconNameSchema, ModelIdSchema } from './shared'
 import { NodeIdStringSchema } from './systems'
 import { RoleIdSchema } from './roles'
 import { OntologyIdSchema } from '../ontology'
-
-// ---------------------------------------------------------------------------
-// KnowledgeLink — a typed graph link pointing to another OM node.
-// Uses NodeIdStringSchema (kind:dotted-path) to resolve to a graph node.
-// Phase 1 only emits 'governs' edges from knowledge nodes.
-// ---------------------------------------------------------------------------
-
-export const KnowledgeTargetKindSchema = z
-  .enum([
-    'system',
-    'resource',
-    'knowledge',
-    'stage',
-    'action',
-    'role',
-    'goal',
+import { defineDomainRecord } from '../helpers'
+
+// ---------------------------------------------------------------------------
+// KnowledgeLink — a typed graph link pointing to another OM node.
+// Uses NodeIdStringSchema (kind:dotted-path) to resolve to a graph node.
+// Phase 1 only emits 'governs' edges from knowledge nodes.
+// ---------------------------------------------------------------------------
+
+export const KnowledgeTargetKindSchema = z
+  .enum([
+    'system',
+    'resource',
+    'knowledge',
+    'stage',
+    'action',
+    'role',
+    'goal',
     'customer-segment',
     'offering',
     'ontology'
@@ -59,48 +60,48 @@ const LegacyKnowledgeLinkSchema = z
       })
     }
   })
-
-const CanonicalKnowledgeLinkSchema = z.object({
-  target: KnowledgeTargetRefSchema
-})
-
-function nodeIdFromTarget(target: z.infer<typeof KnowledgeTargetRefSchema>): string {
-  return `${target.kind}:${target.id}`
-}
-
-function targetFromNodeId(nodeId: string): z.infer<typeof KnowledgeTargetRefSchema> {
-  const [kind, ...idParts] = nodeId.split(':')
-  return {
-    kind: KnowledgeTargetKindSchema.parse(kind),
-    id: idParts.join(':')
-  }
-}
-
-export const KnowledgeLinkSchema = z
-  .union([CanonicalKnowledgeLinkSchema, LegacyKnowledgeLinkSchema])
-  .transform((link) => {
-    const target = 'target' in link ? link.target : targetFromNodeId(link.nodeId)
-    return {
-      target,
-      nodeId: nodeIdFromTarget(target)
-    }
-  })
-
-// ---------------------------------------------------------------------------
-// OrgKnowledgeNode — single schema, `kind` discriminator drives presentation.
-// Phase 1: body is raw MDX string (lossless migration from operations/ docs).
-// Phase 2 (deferred): structured block format (Supabase-backed authoring).
-// ---------------------------------------------------------------------------
-
-export const OrgKnowledgeKindSchema = z
-  .enum(['playbook', 'strategy', 'reference'])
-  .meta({ label: 'Knowledge kind', color: 'grape' })
-
-export const OrgKnowledgeNodeSchema = z.object({
-  id: ModelIdSchema,
-  kind: OrgKnowledgeKindSchema,
-  title: z.string().trim().min(1).max(200),
-  summary: z.string().trim().min(1).max(1000),
+
+const CanonicalKnowledgeLinkSchema = z.object({
+  target: KnowledgeTargetRefSchema
+})
+
+function nodeIdFromTarget(target: z.infer<typeof KnowledgeTargetRefSchema>): string {
+  return `${target.kind}:${target.id}`
+}
+
+function targetFromNodeId(nodeId: string): z.infer<typeof KnowledgeTargetRefSchema> {
+  const [kind, ...idParts] = nodeId.split(':')
+  return {
+    kind: KnowledgeTargetKindSchema.parse(kind),
+    id: idParts.join(':')
+  }
+}
+
+export const KnowledgeLinkSchema = z
+  .union([CanonicalKnowledgeLinkSchema, LegacyKnowledgeLinkSchema])
+  .transform((link) => {
+    const target = 'target' in link ? link.target : targetFromNodeId(link.nodeId)
+    return {
+      target,
+      nodeId: nodeIdFromTarget(target)
+    }
+  })
+
+// ---------------------------------------------------------------------------
+// OrgKnowledgeNode — single schema, `kind` discriminator drives presentation.
+// Phase 1: body is raw MDX string (lossless migration from operations/ docs).
+// Phase 2 (deferred): structured block format (Supabase-backed authoring).
+// ---------------------------------------------------------------------------
+
+export const OrgKnowledgeKindSchema = z
+  .enum(['playbook', 'strategy', 'reference'])
+  .meta({ label: 'Knowledge kind', color: 'grape' })
+
+export const OrgKnowledgeNodeSchema = z.object({
+  id: ModelIdSchema,
+  kind: OrgKnowledgeKindSchema,
+  title: z.string().trim().min(1).max(200),
+  summary: z.string().trim().min(1).max(1000),
   icon: IconNameSchema.optional(),
   /** Canonical documentation URL when body content is a local summary. */
   externalUrl: z.string().trim().url().max(500).optional(),
@@ -108,38 +109,50 @@ export const OrgKnowledgeNodeSchema = z.object({
   sourceFilePath: z.string().trim().min(1).max(500).optional(),
   /** Raw MDX string. Phase 2 will introduce a structured block format. */
   body: z.string().trim().min(1),
-  /**
-   * Graph links to other OM nodes this knowledge node governs.
-   * Each link emits a `governs` edge: knowledge-node -> target node.
-   */
-  links: z.array(KnowledgeLinkSchema).default([]),
-  /** Role identifiers that own this knowledge node. */
-  ownerIds: z.array(RoleIdSchema.meta({ ref: 'role' })).default([]),
-  /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
-  updatedAt: z.string().trim().min(1).max(50)
-})
-
-// ---------------------------------------------------------------------------
-// Domain schema — flat Record<id, KnowledgeNode> (D3: flatten per Phase 4 cut)
-//
-// Wave 1 shape change: the old wrapper object { version, lastModified, nodes[] }
-// is replaced by a plain id-keyed map. version/lastModified move to
-// domainMetadata.knowledge (D7). The default is an empty map {}.
-//
-// Wave 2 (elevasis-core canonicalOrganizationModel) must produce a value of this
-// shape: Record<KnowledgeId, OrgKnowledgeNode> — i.e., an object keyed by
-// each node's id string, with OrgKnowledgeNode as the value. Example:
-//   knowledge: {
-//     'playbook.crm.discovery': { id: 'playbook.crm.discovery', kind: 'playbook', ... },
-//   }
-// ---------------------------------------------------------------------------
-
-export const KnowledgeDomainSchema = z.record(ModelIdSchema, OrgKnowledgeNodeSchema).default({})
-
-export type OrgKnowledgeNode = z.infer<typeof OrgKnowledgeNodeSchema>
-export type OrgKnowledgeNodeInput = z.input<typeof OrgKnowledgeNodeSchema>
-export type OrgKnowledgeKind = z.infer<typeof OrgKnowledgeKindSchema>
-export type KnowledgeTargetKind = z.infer<typeof KnowledgeTargetKindSchema>
-export type KnowledgeTargetRef = z.infer<typeof KnowledgeTargetRefSchema>
-export type KnowledgeLink = z.infer<typeof KnowledgeLinkSchema>
-export type KnowledgeDomain = z.infer<typeof KnowledgeDomainSchema>
+  /**
+   * Graph links to other OM nodes this knowledge node governs.
+   * Each link emits a `governs` edge: knowledge-node -> target node.
+   */
+  links: z.array(KnowledgeLinkSchema).default([]),
+  /** Role identifiers that own this knowledge node. */
+  ownerIds: z.array(RoleIdSchema.meta({ ref: 'role' })).default([]),
+  /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
+  updatedAt: z.string().trim().min(1).max(50)
+})
+
+// ---------------------------------------------------------------------------
+// Domain schema — flat Record<id, KnowledgeNode> (D3: flatten per Phase 4 cut)
+//
+// Wave 1 shape change: the old wrapper object { version, lastModified, nodes[] }
+// is replaced by a plain id-keyed map. version/lastModified move to
+// domainMetadata.knowledge (D7). The default is an empty map {}.
+//
+// Wave 2 (elevasis-core canonicalOrganizationModel) must produce a value of this
+// shape: Record<KnowledgeId, OrgKnowledgeNode> — i.e., an object keyed by
+// each node's id string, with OrgKnowledgeNode as the value. Example:
+//   knowledge: {
+//     'playbook.crm.discovery': { id: 'playbook.crm.discovery', kind: 'playbook', ... },
+//   }
+// ---------------------------------------------------------------------------
+
+export const KnowledgeDomainSchema = z.record(ModelIdSchema, OrgKnowledgeNodeSchema).default({})
+
+/** Validate and return a single knowledge node entry. */
+export function defineKnowledgeNode(entry: z.input<typeof OrgKnowledgeNodeSchema>): OrgKnowledgeNode {
+  return OrgKnowledgeNodeSchema.parse(entry)
+}
+
+/** Validate and return an id-keyed map of knowledge node entries. */
+export function defineKnowledgeNodes(
+  entries: readonly z.input<typeof OrgKnowledgeNodeSchema>[]
+): Record<string, OrgKnowledgeNode> {
+  return defineDomainRecord(OrgKnowledgeNodeSchema, entries)
+}
+
+export type OrgKnowledgeNode = z.infer<typeof OrgKnowledgeNodeSchema>
+export type OrgKnowledgeNodeInput = z.input<typeof OrgKnowledgeNodeSchema>
+export type OrgKnowledgeKind = z.infer<typeof OrgKnowledgeKindSchema>
+export type KnowledgeTargetKind = z.infer<typeof KnowledgeTargetKindSchema>
+export type KnowledgeTargetRef = z.infer<typeof KnowledgeTargetRefSchema>
+export type KnowledgeLink = z.infer<typeof KnowledgeLinkSchema>
+export type KnowledgeDomain = z.infer<typeof KnowledgeDomainSchema>

package/src/organization-model/domains/offerings.ts

@@ -1,71 +1,88 @@
-import { z } from 'zod'
-
-// ---------------------------------------------------------------------------
-// Pricing model — the four canonical pricing structures used in B2B SaaS and
-// professional services. "custom" covers bespoke / negotiated pricing.
-// ---------------------------------------------------------------------------
-
-export const PricingModelSchema = z
-  .enum(['one-time', 'subscription', 'usage-based', 'custom'])
-  .meta({ label: 'Pricing model', color: 'green' })
-
-// ---------------------------------------------------------------------------
-// Product schema — one entry per distinct offering (product or service).
-// Modeled after Business Model Canvas "Value Propositions" and company profile
-// product/service catalog language. Fields use plain English throughout.
-// ---------------------------------------------------------------------------
-
-export const ProductSchema = z.object({
-  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
-  id: z.string().trim().min(1).max(100),
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
-  name: z.string().trim().max(200).default(''),
-  /** One or two sentences describing what this product/service delivers. */
-  description: z.string().trim().max(2000).default(''),
-  /**
-   * How this product is priced:
-   * - "one-time" — single purchase (setup fee, project fee)
-   * - "subscription" — recurring (monthly/annual SaaS, retainer)
-   * - "usage-based" — metered by consumption (API calls, seats)
-   * - "custom" — negotiated or bespoke pricing
-   */
-  pricingModel: PricingModelSchema.default('custom'),
-  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
-  price: z.number().min(0).default(0),
-  /**
-   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
-   * Free-form string to accommodate any currency; defaults to "USD".
-   */
-  currency: z.string().trim().max(10).default('USD'),
-  /**
-   * IDs of customer segments this product targets.
-   * Each id must reference a declared `customers.segments[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
-  /**
-   * Optional: ID of the platform system responsible for delivering this product.
-   * When present, must reference a declared `systems.systems[].id`.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   */
-  deliveryFeatureId: z.string().trim().min(1).optional()
-})
-
-// ---------------------------------------------------------------------------
-// Offerings domain schema — id-keyed map of products and services.
-// ---------------------------------------------------------------------------
-
-export const OfferingsDomainSchema = z
-  .record(z.string(), ProductSchema)
-  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-    message: 'Each product entry id must match its map key'
-  })
-  .default({})
-
-// ---------------------------------------------------------------------------
-// Seed — empty by default; adapters populate with real product definitions.
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_ORGANIZATION_MODEL_OFFERINGS: z.infer<typeof OfferingsDomainSchema> = {}
+import { z } from 'zod'
+import { defineDomainRecord } from '../helpers'
+
+// ---------------------------------------------------------------------------
+// Pricing model — the four canonical pricing structures used in B2B SaaS and
+// professional services. "custom" covers bespoke / negotiated pricing.
+// ---------------------------------------------------------------------------
+
+export const PricingModelSchema = z
+  .enum(['one-time', 'subscription', 'usage-based', 'custom'])
+  .meta({ label: 'Pricing model', color: 'green' })
+
+// ---------------------------------------------------------------------------
+// Product schema — one entry per distinct offering (product or service).
+// Modeled after Business Model Canvas "Value Propositions" and company profile
+// product/service catalog language. Fields use plain English throughout.
+// ---------------------------------------------------------------------------
+
+export const ProductSchema = z.object({
+  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
+  id: z.string().trim().min(1).max(100),
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
+  name: z.string().trim().max(200).default(''),
+  /** One or two sentences describing what this product/service delivers. */
+  description: z.string().trim().max(2000).default(''),
+  /**
+   * How this product is priced:
+   * - "one-time" — single purchase (setup fee, project fee)
+   * - "subscription" — recurring (monthly/annual SaaS, retainer)
+   * - "usage-based" — metered by consumption (API calls, seats)
+   * - "custom" — negotiated or bespoke pricing
+   */
+  pricingModel: PricingModelSchema.default('custom'),
+  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
+  price: z.number().min(0).default(0),
+  /**
+   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
+   * Free-form string to accommodate any currency; defaults to "USD".
+   */
+  currency: z.string().trim().max(10).default('USD'),
+  /**
+   * IDs of customer segments this product targets.
+   * Each id must reference a declared `customers.segments[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
+  /**
+   * Optional: ID of the platform system responsible for delivering this product.
+   * When present, must reference a declared `systems.systems[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  deliveryFeatureId: z.string().trim().min(1).optional()
+})
+
+// ---------------------------------------------------------------------------
+// Offerings domain schema — id-keyed map of products and services.
+// ---------------------------------------------------------------------------
+
+export const OfferingsDomainSchema = z
+  .record(z.string(), ProductSchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each product entry id must match its map key'
+  })
+  .default({})
+
+// ---------------------------------------------------------------------------
+// Seed — empty by default; adapters populate with real product definitions.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_OFFERINGS: z.infer<typeof OfferingsDomainSchema> = {}
+
+/** Validate and return a single offering (product) entry. */
+export function defineOffering(entry: z.input<typeof ProductSchema>): z.infer<typeof ProductSchema> {
+  return ProductSchema.parse(entry)
+}
+
+/** Validate and return an id-keyed map of offering entries. */
+export function defineOfferings(
+  entries: readonly z.input<typeof ProductSchema>[]
+): Record<string, z.infer<typeof ProductSchema>> {
+  return defineDomainRecord(ProductSchema, entries)
+}
+
+export type Product = z.infer<typeof ProductSchema>
+export type OfferingsDomain = z.infer<typeof OfferingsDomainSchema>
+export type PricingModel = z.infer<typeof PricingModelSchema>

package/src/organization-model/domains/policies.ts

@@ -1,102 +1,115 @@
-import { z } from 'zod'
-import { DescriptionSchema, LabelSchema, ModelIdSchema } from './shared'
-import { EventIdSchema } from './resources'
-
-export const PolicyIdSchema = ModelIdSchema
-
-export const PolicyApplicabilitySchema = z.object({
-  systemIds: z.array(ModelIdSchema.meta({ ref: 'system' })).default([]),
-  actionIds: z.array(ModelIdSchema.meta({ ref: 'action' })).default([]),
-  resourceIds: z.array(ModelIdSchema.meta({ ref: 'resource' })).default([]),
-  roleIds: z.array(ModelIdSchema.meta({ ref: 'role' })).default([])
-})
-
-export const PolicyTriggerSchema = z.discriminatedUnion('kind', [
-  z.object({
-    kind: z.literal('event'),
-    eventId: EventIdSchema.meta({ ref: 'event' })
-  }),
-  z.object({
-    kind: z.literal('action-invocation'),
-    actionId: ModelIdSchema.meta({ ref: 'action' })
-  }),
-  z.object({
-    kind: z.literal('schedule'),
-    cron: z.string().trim().min(1).max(120)
-  }),
-  z.object({
-    kind: z.literal('manual')
-  })
-])
-
-export const PolicyPredicateSchema = z.discriminatedUnion('kind', [
-  z.object({
-    kind: z.literal('always')
-  }),
-  z.object({
-    kind: z.literal('expression'),
-    expression: z.string().trim().min(1).max(2000)
-  }),
-  z.object({
-    kind: z.literal('threshold'),
-    metric: ModelIdSchema,
-    operator: z.enum(['lt', 'lte', 'eq', 'gte', 'gt']).meta({ label: 'Operator' }),
-    value: z.number()
-  })
-])
-
-export const PolicyEffectSchema = z.discriminatedUnion('kind', [
-  z.object({
-    kind: z.literal('require-approval'),
-    roleId: ModelIdSchema.meta({ ref: 'role' }).optional()
-  }),
-  z.object({
-    kind: z.literal('invoke-action'),
-    actionId: ModelIdSchema.meta({ ref: 'action' })
-  }),
-  z.object({
-    kind: z.literal('notify-role'),
-    roleId: ModelIdSchema.meta({ ref: 'role' })
-  }),
-  z.object({
-    kind: z.literal('block')
-  })
-])
-
-export const PolicySchema = z.object({
-  id: PolicyIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number(),
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  trigger: PolicyTriggerSchema,
-  predicate: PolicyPredicateSchema.default({ kind: 'always' }),
-  actions: z.array(PolicyEffectSchema).min(1),
-  appliesTo: PolicyApplicabilitySchema.default({
-    systemIds: [],
-    actionIds: [],
-    resourceIds: [],
-    roleIds: []
-  }),
-  lifecycle: z
-    .enum(['draft', 'beta', 'active', 'deprecated', 'archived'])
-    .meta({ label: 'Lifecycle', color: 'teal' })
-    .default('active')
-})
-
-export const PoliciesDomainSchema = z
-  .record(z.string(), PolicySchema)
-  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-    message: 'Each policy entry id must match its map key'
-  })
-  .default({})
-
-export const DEFAULT_ORGANIZATION_MODEL_POLICIES: z.infer<typeof PoliciesDomainSchema> = {}
-
-export type PolicyId = z.infer<typeof PolicyIdSchema>
-export type PolicyApplicability = z.infer<typeof PolicyApplicabilitySchema>
-export type PolicyTrigger = z.infer<typeof PolicyTriggerSchema>
-export type PolicyPredicate = z.infer<typeof PolicyPredicateSchema>
-export type PolicyEffect = z.infer<typeof PolicyEffectSchema>
-export type Policy = z.infer<typeof PolicySchema>
-export type PoliciesDomain = z.infer<typeof PoliciesDomainSchema>
+import { z } from 'zod'
+import { DescriptionSchema, LabelSchema, ModelIdSchema } from './shared'
+import { EventIdSchema } from './resources'
+import { defineDomainRecord } from '../helpers'
+
+export const PolicyIdSchema = ModelIdSchema
+
+export const PolicyApplicabilitySchema = z.object({
+  systemIds: z.array(ModelIdSchema.meta({ ref: 'system' })).default([]),
+  actionIds: z.array(ModelIdSchema.meta({ ref: 'action' })).default([]),
+  resourceIds: z.array(ModelIdSchema.meta({ ref: 'resource' })).default([]),
+  roleIds: z.array(ModelIdSchema.meta({ ref: 'role' })).default([])
+})
+
+export const PolicyTriggerSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('event'),
+    eventId: EventIdSchema.meta({ ref: 'event' })
+  }),
+  z.object({
+    kind: z.literal('action-invocation'),
+    actionId: ModelIdSchema.meta({ ref: 'action' })
+  }),
+  z.object({
+    kind: z.literal('schedule'),
+    cron: z.string().trim().min(1).max(120)
+  }),
+  z.object({
+    kind: z.literal('manual')
+  })
+])
+
+export const PolicyPredicateSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('always')
+  }),
+  z.object({
+    kind: z.literal('expression'),
+    expression: z.string().trim().min(1).max(2000)
+  }),
+  z.object({
+    kind: z.literal('threshold'),
+    metric: ModelIdSchema,
+    operator: z.enum(['lt', 'lte', 'eq', 'gte', 'gt']).meta({ label: 'Operator' }),
+    value: z.number()
+  })
+])
+
+export const PolicyEffectSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('require-approval'),
+    roleId: ModelIdSchema.meta({ ref: 'role' }).optional()
+  }),
+  z.object({
+    kind: z.literal('invoke-action'),
+    actionId: ModelIdSchema.meta({ ref: 'action' })
+  }),
+  z.object({
+    kind: z.literal('notify-role'),
+    roleId: ModelIdSchema.meta({ ref: 'role' })
+  }),
+  z.object({
+    kind: z.literal('block')
+  })
+])
+
+export const PolicySchema = z.object({
+  id: PolicyIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  trigger: PolicyTriggerSchema,
+  predicate: PolicyPredicateSchema.default({ kind: 'always' }),
+  actions: z.array(PolicyEffectSchema).min(1),
+  appliesTo: PolicyApplicabilitySchema.default({
+    systemIds: [],
+    actionIds: [],
+    resourceIds: [],
+    roleIds: []
+  }),
+  lifecycle: z
+    .enum(['draft', 'beta', 'active', 'deprecated', 'archived'])
+    .meta({ label: 'Lifecycle', color: 'teal' })
+    .default('active')
+})
+
+export const PoliciesDomainSchema = z
+  .record(z.string(), PolicySchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each policy entry id must match its map key'
+  })
+  .default({})
+
+export const DEFAULT_ORGANIZATION_MODEL_POLICIES: z.infer<typeof PoliciesDomainSchema> = {}
+
+/** Validate and return a single policy entry. */
+export function definePolicy(entry: z.input<typeof PolicySchema>): z.infer<typeof PolicySchema> {
+  return PolicySchema.parse(entry)
+}
+
+/** Validate and return an id-keyed map of policy entries. */
+export function definePolicies(
+  entries: readonly z.input<typeof PolicySchema>[]
+): Record<string, z.infer<typeof PolicySchema>> {
+  return defineDomainRecord(PolicySchema, entries)
+}
+
+export type PolicyId = z.infer<typeof PolicyIdSchema>
+export type PolicyApplicability = z.infer<typeof PolicyApplicabilitySchema>
+export type PolicyTrigger = z.infer<typeof PolicyTriggerSchema>
+export type PolicyPredicate = z.infer<typeof PolicyPredicateSchema>
+export type PolicyEffect = z.infer<typeof PolicyEffectSchema>
+export type Policy = z.infer<typeof PolicySchema>
+export type PoliciesDomain = z.infer<typeof PoliciesDomainSchema>