@cullet/erp-core 1.1.0 → 1.3.0

package/dist/policy-service.d.cts

@@ -0,0 +1,559 @@
+import { a as Result } from "./outcome.cjs";
+import { _ as PolicyReporter, b as SchoolId, t as GateOutcome, u as GatePayload, v as PolicyDecisionId, x as TenantId, y as PolicyDefinitionId } from "./gate-types.cjs";
+import { a as ComputeOutcome, l as ComputePayload, n as ComputeRegistry, t as GateEngineRegistry } from "./gate-engine-registry.cjs";
+
+//#region src/core/policies/catalog/catalog-types.d.ts
+type PolicyKind = "GATE" | "COMPUTE";
+type PolicyOwner = "PLATFORM_OWNER" | "TENANT_ADMIN" | "SCHOOL_ADMIN";
+type PolicyScopeLevel = "GLOBAL" | "TENANT" | "SCHOOL";
+/**
+ * Defines where the "as of" date comes from for a given policy.
+ */
+type AsOfSource = "NOW" | "CALLER_PROVIDED";
+//#endregion
+//#region src/core/policies/catalog/policy-key.d.ts
+declare class PolicyKey {
+  readonly module: string;
+  readonly area: string;
+  readonly name: string;
+  private constructor();
+  static parse(raw: string): Result<PolicyKey, string>;
+  toString(): string;
+  equals(other: PolicyKey): boolean;
+}
+//#endregion
+//#region src/core/policies/catalog/policy-catalog-entry.d.ts
+/**
+ * Properties for creating a PolicyCatalogEntry.
+ */
+interface PolicyCatalogEntryProps {
+  readonly key: PolicyKey;
+  readonly kind: PolicyKind;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly payloadSchemaVersion?: number;
+  readonly owner: PolicyOwner;
+  readonly allowedScopes: readonly PolicyScopeLevel[];
+  readonly asOfSource: AsOfSource;
+  /** Paths the context must contain for this policy to be evaluable. */
+  readonly contextRequirements: readonly string[];
+  readonly tags?: readonly string[];
+  readonly description: string;
+}
+/**
+ * Represents a single entry in the Policy Catalog.
+ * Encapsulates metadata and validation logic for a policy.
+ */
+declare class PolicyCatalogEntry {
+  readonly key: PolicyKey;
+  readonly kind: PolicyKind;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly payloadSchemaVersion?: number;
+  readonly owner: PolicyOwner;
+  readonly allowedScopes: readonly PolicyScopeLevel[];
+  readonly asOfSource: AsOfSource;
+  readonly contextRequirements: readonly string[];
+  readonly tags: readonly string[];
+  readonly description: string;
+  constructor(props: PolicyCatalogEntryProps);
+  static assertFamilyConsistency(entries: readonly PolicyCatalogEntry[]): void;
+  static from(entry: PolicyCatalogEntry | PolicyCatalogEntryProps): PolicyCatalogEntry;
+  isGate(): boolean;
+  isCompute(): boolean;
+  allowsScope(scope: PolicyScopeLevel): boolean;
+  hasExplicitVersionSelector(): boolean;
+  matchesVersion(params: {
+    readonly kind: PolicyKind;
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+    readonly payloadSchemaVersion?: number;
+  }): boolean;
+  toVariantKey(): string;
+  usesNowAsOf(): boolean;
+  usesCallerProvidedAsOf(): boolean;
+  requiresContext(path: string): boolean;
+  requiresAllContexts(paths: readonly string[]): boolean;
+  hasTag(tag: string): boolean;
+  equals(other: PolicyCatalogEntry): boolean;
+  toJSON(): PolicyCatalogEntryProps;
+}
+//#endregion
+//#region src/core/policies/catalog/policy-catalog.d.ts
+/**
+ * In-code catalog of all known policies.
+ * The catalog defines the universe of policies; the database cannot invent new ones.
+ */
+declare class PolicyCatalog {
+  private readonly versionedEntries;
+  private readonly entriesByKey;
+  /**
+   * Indexes the given entries up front into two lookups — one per exact
+   * variant, one per policy key (the "family") — and validates them eagerly:
+   * a duplicate variant or an internally inconsistent family throws here, at
+   * wiring time, so a malformed catalog fails fast at startup rather than on
+   * the first evaluation.
+   *
+   * @throws {UnexpectedError} When two entries resolve to the same variant key.
+   */
+  constructor(entries: readonly PolicyCatalogEntry[]);
+  /**
+   * Returns the single entry for a key. Deliberately strict: if the key has
+   * more than one variant it errs rather than guessing, steering the caller to
+   * {@link getVersioned} or {@link getFamily}. Use this only when a key is
+   * known to be unambiguous.
+   *
+   * @returns `ok` with the entry, or `err` when the key is unknown or ambiguous.
+   */
+  get(key: string): Result<PolicyCatalogEntry, string>;
+  /**
+   * Returns every variant registered under a key — the whole "family". This is
+   * the lookup the evaluation pipeline uses, since a single key may host
+   * several engine/schema variants that the resolver then chooses between.
+   *
+   * @returns `ok` with the family (always non-empty), or `err` when the key is unknown.
+   */
+  getFamily(key: string): Result<readonly PolicyCatalogEntry[], string>;
+  /**
+   * Resolves the one entry matching an exact variant — kind plus engine and
+   * payload-schema versions. Falls back to the sole family member when a key
+   * has exactly one entry and that entry declares no explicit version
+   * selector, so unversioned single-variant policies "just work" without the
+   * caller spelling out versions.
+   *
+   * @param params - The key and the variant coordinates to match on.
+   * @returns `ok` with the matching entry, or `err` when no variant matches.
+   */
+  getVersioned(params: {
+    readonly key: string;
+    readonly kind: "GATE" | "COMPUTE";
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+    readonly payloadSchemaVersion?: number;
+  }): Result<PolicyCatalogEntry, string>;
+  /** Lists every registered variant across all keys — useful for introspection and diagnostics. */
+  list(): readonly PolicyCatalogEntry[];
+  /** Returns whether any variant is registered under the given key. */
+  has(key: string): boolean;
+}
+//#endregion
+//#region src/core/policies/defs/policy-payload.contracts.d.ts
+type AnyPolicyPayload = GatePayload | ComputePayload;
+/**
+ * Payload type associated with a policy key.
+ *
+ * Intentionally NOT backed by global module augmentation: two modules registering
+ * different shapes for the same literal key would silently override each other and
+ * the last `declare module` wins. Per-key payload typing must be expressed
+ * explicitly at the definition site (see {@link PolicyDefinition} type params).
+ */
+//#endregion
+//#region src/core/policies/defs/policy-scope.d.ts
+/**
+ * Scope attached to a PolicyDefinition — defines where it applies.
+ */
+interface PolicyScope {
+  readonly level: PolicyScopeLevel;
+  readonly tenantId: TenantId | null;
+  readonly schoolId: SchoolId | null;
+}
+/**
+ * Ordered list of scopes from most-specific to least-specific.
+ * Used by the resolver to match definitions.
+ *
+ * Example:
+ * ```
+ * [
+ *   { level: 'SCHOOL',  tenantId: 't1', schoolId: 's1' },
+ *   { level: 'TENANT',  tenantId: 't1', schoolId: null },
+ *   { level: 'GLOBAL',  tenantId: null, schoolId: null },
+ * ]
+ * ```
+ */
+type ScopeChain = readonly PolicyScope[];
+declare class PolicyScopeMatcher {
+  static weight(level: PolicyScopeLevel): number;
+  static matchesChain(defScope: PolicyScope, chain: ScopeChain): boolean;
+  static equals(a: PolicyScope, b: PolicyScope): boolean;
+}
+//#endregion
+//#region src/core/policies/defs/policy-definition.d.ts
+type PolicyDefinitionStatus = "DRAFT" | "PUBLISHED" | "RETIRED";
+interface BasePolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> {
+  readonly id: PolicyDefinitionId;
+  readonly policyKey: K;
+  readonly policyVersion: string;
+  readonly payloadSchemaVersion: number;
+  readonly contextVersionMin: number;
+  readonly contextVersionMax: number;
+  readonly enabled: boolean;
+  readonly status: PolicyDefinitionStatus;
+  readonly scope: PolicyScope;
+  readonly effectiveFrom: Date;
+  readonly effectiveTo: Date | null;
+  readonly priority: number;
+  readonly payloadJson: P;
+  readonly payloadHash: string;
+  readonly createdAt: Date;
+  readonly publishedAt: Date | null;
+}
+interface GatePolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> extends BasePolicyDefinitionProps<K, P> {
+  readonly kind: "GATE";
+  readonly gateEngineVersion: number;
+}
+interface ComputePolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> extends BasePolicyDefinitionProps<K, P> {
+  readonly kind: "COMPUTE";
+  readonly computeEngineVersion: number;
+}
+type GatePolicyDefinitionInput<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> = Omit<GatePolicyDefinitionProps<K, P>, "kind" | "enabled"> & {
+  readonly enabled?: boolean;
+};
+type ComputePolicyDefinitionInput<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> = Omit<ComputePolicyDefinitionProps<K, P>, "kind" | "enabled"> & {
+  readonly enabled?: boolean;
+};
+type PolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> = GatePolicyDefinitionProps<K, P> | ComputePolicyDefinitionProps<K, P>;
+declare class PolicyDefinition<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> {
+  private static assertPolicyVersionIsSemver;
+  private static assertCoherentBounds;
+  readonly id: PolicyDefinitionId;
+  readonly policyKey: K;
+  readonly policyVersion: string;
+  readonly payloadSchemaVersion: number;
+  readonly contextVersionMin: number;
+  readonly contextVersionMax: number;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly enabled: boolean;
+  readonly status: PolicyDefinitionStatus;
+  readonly scope: PolicyScope;
+  readonly effectiveFrom: Date;
+  readonly effectiveTo: Date | null;
+  readonly priority: number;
+  readonly payloadJson: P;
+  readonly payloadHash: string;
+  readonly createdAt: Date;
+  readonly publishedAt: Date | null;
+  readonly kind: PolicyKind;
+  private constructor();
+  static gate<K extends string, P extends AnyPolicyPayload = AnyPolicyPayload>(props: GatePolicyDefinitionInput<K, P>): PolicyDefinition<K, P>;
+  static compute<K extends string, P extends AnyPolicyPayload = AnyPolicyPayload>(props: ComputePolicyDefinitionInput<K, P>): PolicyDefinition<K, P>;
+  isGate(): this is PolicyDefinition<K, P> & {
+    readonly kind: "GATE";
+    readonly gateEngineVersion: number;
+  };
+  isCompute(): this is PolicyDefinition<K, P> & {
+    readonly kind: "COMPUTE";
+    readonly computeEngineVersion: number;
+  };
+}
+interface FindCandidatesParams {
+  readonly policyKey: string;
+  readonly kind: PolicyKind;
+  readonly payloadSchemaVersion?: number;
+  readonly asOf: Date;
+  readonly contextVersion: number;
+  readonly scopeChain: readonly PolicyScope[];
+}
+//#endregion
+//#region src/core/policies/defs/policy-definition-repository.d.ts
+interface PolicyDefinitionRepository {
+  findCandidates(params: FindCandidatesParams): PolicyDefinition[];
+}
+//#endregion
+//#region src/core/policies/context/context-seed.d.ts
+/**
+ * Seed data provided by the use case / caller.
+ * Contains raw IDs and inputs that the context system will resolve into paths.
+ * Each resolver is responsible for validating and extracting what it needs from fields.
+ */
+interface ContextSeed {
+  readonly tenantId: TenantId;
+  readonly schoolId: SchoolId;
+  readonly fields: Record<string, unknown>;
+}
+declare class ContextSeedValidator {
+  private static isBlankSeedId;
+  static validate(seed: ContextSeed): Result<ContextSeed, string>;
+}
+//#endregion
+//#region src/core/policies/context/context-resolver.d.ts
+interface ContextResolverRetryOptions {
+  readonly maxAttempts?: number;
+  readonly initialDelayMs?: number;
+  readonly maxDelayMs?: number;
+  readonly backoffMultiplier?: number;
+}
+interface ContextResolverCircuitBreakerOptions {
+  readonly failureThreshold?: number;
+  readonly cooldownMs?: number;
+}
+interface ContextResolverResilienceOptions {
+  readonly timeoutMs?: number;
+  readonly retry?: ContextResolverRetryOptions | false;
+  readonly circuitBreaker?: ContextResolverCircuitBreakerOptions | false;
+}
+/**
+ * A resolver that knows how to produce a value for a specific context path.
+ * Designed as async to allow future DB/API lookups without breaking the interface.
+ */
+interface ContextValueResolver {
+  readonly path: string;
+  readonly resilience?: ContextResolverResilienceOptions;
+  resolve(seed: ContextSeed): Promise<Result<unknown, string>>;
+}
+//#endregion
+//#region src/core/policies/context/context-registry.d.ts
+interface ContextResolverRegistrationOptions {
+  readonly namespace?: string;
+}
+/**
+ * Registry of context value resolvers, keyed by path.
+ */
+declare class ContextResolverRegistry {
+  private readonly resolvers;
+  register(resolver: ContextValueResolver, options?: ContextResolverRegistrationOptions): Result<void, string>;
+  registerAll(resolvers: readonly ContextValueResolver[], options?: ContextResolverRegistrationOptions): Result<void, string>;
+  get(path: string): ContextValueResolver | undefined;
+  has(path: string): boolean;
+  getNamespace(path: string): string | undefined;
+}
+declare function registerNamespacedContextResolversIn(registry: ContextResolverRegistry, namespace: string, resolvers: readonly ContextValueResolver[]): Result<ContextResolverRegistry, string>;
+//#endregion
+//#region src/core/policies/context/context-builder.d.ts
+interface PolicyContextBuilderOptions {
+  readonly defaultResolverResilience?: ContextResolverResilienceOptions;
+  readonly now?: () => number;
+  readonly sleep?: (delayMs: number) => Promise<void>;
+}
+/**
+ * Builds a context object by resolving required paths from a seed.
+ */
+declare class PolicyContextBuilder {
+  private readonly registry;
+  private readonly circuitStates;
+  private readonly defaultResolverResilience?;
+  private readonly now;
+  private readonly sleep;
+  constructor(registry: ContextResolverRegistry, options?: PolicyContextBuilderOptions);
+  private static clampPositiveInteger;
+  private static clampNonNegativeInteger;
+  private static normalizeTimeoutMs;
+  private static mergeRetryOptions;
+  private static mergeCircuitBreakerOptions;
+  private resolveResilienceOptions;
+  private getRetryDelayMs;
+  private resetCircuit;
+  private isCircuitOpen;
+  private recordResolverFailure;
+  private static describeThrownResolverError;
+  private resolveOnce;
+  private resolveWithResilience;
+  /**
+   * Resolves all required context paths and returns a flat context object.
+   * If any required path cannot be resolved, returns an error.
+   */
+  build(requirements: readonly string[], seed: ContextSeed): Promise<Result<Record<string, unknown>, string>>;
+}
+//#endregion
+//#region src/core/policies/asof/asof.d.ts
+interface DeriveAsOfOptions {
+  readonly maxFutureYears?: number;
+}
+declare class PolicyAsOfResolver {
+  private static resolveMaxFutureYears;
+  static derive(source: AsOfSource, seed: ContextSeed, now: Date, options?: DeriveAsOfOptions): Result<Date, string>;
+}
+//#endregion
+//#region src/core/policies/resolver/policy-resolver.d.ts
+/**
+ * Selects the best policy definition from a list of already-filtered candidates.
+ *
+ * Ordering criteria (highest priority first):
+ *   1. Scope specificity: SCHOOL (3) > TENANT (2) > GLOBAL (1)
+ *   2. Priority: higher number wins
+ *   3. publishedAt descending (fallback to createdAt)
+ *   4. Engine version descending (prefer-latest-engine-version — deterministic tiebreaker)
+ *   5. policyVersion descending (semver — final deterministic tiebreaker)
+ */
+declare class PolicyResolver {
+  /**
+   * Picks the single winning definition from an already-filtered candidate
+   * list by applying the class's ordering criteria in priority order. The sort
+   * runs over a copy, so the caller's array is left untouched, and the final
+   * semver tiebreaker guarantees the winner is fully deterministic — it never
+   * depends on the order the repository returned the candidates in.
+   *
+   * @param candidates - Definitions already filtered to match key, scope, and as-of.
+   * @returns `ok` with the highest-ranked definition, or `err` when the list is empty.
+   */
+  resolveBest(candidates: readonly PolicyDefinition[]): Result<PolicyDefinition, string>;
+}
+//#endregion
+//#region src/core/policies/service/policy-evaluation-error.d.ts
+type PolicyEvaluationError = {
+  readonly kind: "INVALID_CONTEXT";
+  readonly stage: "SEED_VALIDATION" | "AS_OF_DERIVATION" | "CONTEXT_BUILD";
+  readonly policyKey: string;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "INVALID_POLICY_KEY";
+  readonly rawPolicyKey: string;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "POLICY_NOT_FOUND";
+  readonly policyKey: string;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "POLICY_DEFINITION_NOT_FOUND";
+  readonly policyKey: string;
+  readonly contextVersion: number;
+  readonly asOf: Date;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "POLICY_VARIANT_NOT_FOUND";
+  readonly policyKey: string;
+  readonly policyKind: PolicyKind;
+  readonly payloadSchemaVersion: number;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "ENGINE_FAILURE";
+  readonly policyKey: string;
+  readonly engine: PolicyKind;
+  readonly engineVersion: number;
+  readonly message: string;
+  readonly cause: string;
+};
+declare class PolicyEvaluationErrors {
+  static invalidContext(stage: Extract<PolicyEvaluationError, {
+    kind: "INVALID_CONTEXT";
+  }>["stage"], policyKey: string, cause: string): PolicyEvaluationError;
+  static invalidPolicyKey(rawPolicyKey: string, cause: string): PolicyEvaluationError;
+  static policyNotFound(policyKey: string, cause: string): PolicyEvaluationError;
+  static policyDefinitionNotFound(policyKey: string, asOf: Date, contextVersion: number, cause: string): PolicyEvaluationError;
+  static policyVariantNotFound(params: {
+    readonly policyKey: string;
+    readonly policyKind: PolicyKind;
+    readonly payloadSchemaVersion: number;
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+    readonly cause: string;
+  }): PolicyEvaluationError;
+  static engineFailure(policyKey: string, engine: PolicyKind, engineVersion: number, cause: string): PolicyEvaluationError;
+}
+//#endregion
+//#region src/core/policies/service/policy-service.d.ts
+/**
+ * Everything a single policy evaluation needs. `policyKey` names the policy,
+ * `scopeChain` narrows the search from most-specific to least-specific scope,
+ * `contextVersion` pins which context schema applies, and `seed` carries the
+ * raw facts the context builder expands. `decisionId` is the caller's
+ * idempotency/audit handle, echoed back on the result.
+ */
+interface EvaluateInput {
+  readonly decisionId: PolicyDecisionId;
+  readonly policyKey: string;
+  readonly scopeChain: readonly PolicyScope[];
+  readonly contextVersion: number;
+  readonly seed: ContextSeed;
+}
+/**
+ * Cross-cutting knobs for a {@link PolicyService}: how the as-of instant is
+ * derived ({@link asOf}) and where evaluation telemetry is sent
+ * ({@link reporter}). Both are optional; the service defaults to a silent
+ * reporter so telemetry is opt-in.
+ */
+interface PolicyServiceOptions {
+  readonly asOf?: DeriveAsOfOptions;
+  readonly reporter?: PolicyReporter;
+}
+/**
+ * The collaborators a {@link PolicyService} is wired with. Each is an injected
+ * port so the service stays storage- and engine-agnostic: the catalog defines
+ * the universe of policies, `defRepo` supplies their versioned definitions, the
+ * `resolver` picks the winning definition, and the engine registries execute it.
+ */
+interface PolicyServiceParams {
+  readonly catalog: PolicyCatalog;
+  readonly contextBuilder: PolicyContextBuilder;
+  readonly defRepo: PolicyDefinitionRepository;
+  readonly resolver: PolicyResolver;
+  readonly gateEngines: GateEngineRegistry;
+  readonly computeRegistry: ComputeRegistry;
+  readonly options?: PolicyServiceOptions;
+}
+/** Union of all possible policy decision Outcomes. */
+type PolicyDecision = GateOutcome | ComputeOutcome;
+/**
+ * The full record of one successful evaluation. Beyond the business
+ * {@link decision}, it pins the exact definition that produced it — id, key,
+ * version, payload hash, and engine version — together with the `asOf` instant
+ * the policy was selected for and the wall-clock `evaluatedAt`. That provenance
+ * is what makes a decision reproducible and auditable after the fact.
+ */
+interface PolicyEvaluationResult {
+  readonly decisionId: PolicyDecisionId;
+  readonly ref: {
+    readonly definitionId: PolicyDefinitionId;
+    readonly policyKey: string;
+    readonly policyVersion: string;
+    readonly payloadHash: string;
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+  };
+  readonly kind: "GATE" | "COMPUTE";
+  readonly asOf: Date;
+  readonly evaluatedAt: Date;
+  readonly contextVersion: number;
+  /** Business decision expressed as an Outcome — not a technical Result. */
+  readonly decision: PolicyDecision;
+}
+/**
+ * Orchestrates the end-to-end evaluation of a policy: it parses and validates
+ * the context seed, derives the as-of instant, resolves the best matching
+ * definition for the requested key/scope/version, builds the context the policy
+ * needs, and runs it through the right engine (gate or compute).
+ *
+ * The service never throws for an expected failure: every step returns a
+ * {@link Result}, and the failures are folded into a typed
+ * {@link PolicyEvaluationError} so callers branch on `isErr()` rather than
+ * catching. Telemetry is best-effort — a throwing reporter can never abort an
+ * evaluation — which keeps observability strictly side-band.
+ */
+declare class PolicyService {
+  #private;
+  private readonly catalog;
+  private readonly contextBuilder;
+  private readonly defRepo;
+  private readonly resolver;
+  private readonly gateEngines;
+  private readonly computeRegistry;
+  private readonly options;
+  constructor(params: PolicyServiceParams);
+  private resolveEvaluationNow;
+  /**
+   * Evaluates a policy and returns its decision.
+   *
+   * This is the single public entry point. It delegates the actual work to the
+   * private pipeline and wraps it with telemetry: a completed or failed event
+   * is reported either way, but reporting is guarded so it can never change the
+   * outcome. The returned {@link Result} is `ok` with a
+   * {@link PolicyEvaluationResult} on success, or `err` with a typed
+   * {@link PolicyEvaluationError} describing which stage rejected the input —
+   * the method itself does not throw for expected failures.
+   *
+   * @param input - The policy key, scope chain, context version, and seed to
+   *   evaluate, plus the caller's `decisionId`.
+   * @returns A `Result` carrying the decision or the evaluation error.
+   */
+  evaluate(input: EvaluateInput): Promise<Result<PolicyEvaluationResult, PolicyEvaluationError>>;
+}
+//#endregion
+export { PolicyScope as A, BasePolicyDefinitionProps as C, PolicyDefinition as D, GatePolicyDefinitionProps as E, PolicyKey as F, AsOfSource as I, PolicyKind as L, ScopeChain as M, PolicyCatalog as N, PolicyDefinitionProps as O, PolicyCatalogEntryProps as P, PolicyOwner as R, PolicyDefinitionRepository as S, FindCandidatesParams as T, ContextResolverResilienceOptions as _, PolicyServiceOptions as a, ContextSeed as b, PolicyEvaluationErrors as c, PolicyAsOfResolver as d, PolicyContextBuilder as f, ContextResolverCircuitBreakerOptions as g, registerNamespacedContextResolversIn as h, PolicyService as i, PolicyScopeMatcher as j, PolicyDefinitionStatus as k, PolicyResolver as l, ContextResolverRegistry as m, PolicyDecision as n, PolicyServiceParams as o, PolicyContextBuilderOptions as p, PolicyEvaluationResult as r, PolicyEvaluationError as s, EvaluateInput as t, DeriveAsOfOptions as u, ContextResolverRetryOptions as v, ComputePolicyDefinitionProps as w, ContextSeedValidator as x, ContextValueResolver as y, PolicyScopeLevel as z };
+//# sourceMappingURL=policy-service.d.cts.map

package/dist/policy-service.d.ts

@@ -1,4 +1,5 @@
-import { C as TenantId, I as Result, S as SchoolId, b as PolicyDecisionId, t as GateOutcome, u as GatePayload, x as PolicyDefinitionId, y as PolicyReporter } from "./gate-types.js";
+import { a as Result } from "./outcome.js";
+import { _ as PolicyReporter, b as SchoolId, t as GateOutcome, u as GatePayload, v as PolicyDecisionId, x as TenantId, y as PolicyDefinitionId } from "./gate-types.js";
 import { a as ComputeOutcome, l as ComputePayload, n as ComputeRegistry, t as GateEngineRegistry } from "./gate-engine-registry.js";
 
 //#region src/core/policies/catalog/catalog-types.d.ts

package/dist/policy-service.js

@@ -1,9 +1,12 @@
-import { n as UnexpectedError, t as ValidationCode } from "./validation-code.js";
+import { t as UnexpectedError } from "./unexpected-error.js";
 import { n as sha256Hex, r as stableStringify } from "./hashing.js";
+import { t as ValidationCode } from "./validation-code.js";
 import { t as ValidationField } from "./validation-field.js";
-import { i as InvariantViolationException, r as isValidDate } from "./temporal-guards.js";
+import { t as InvariantViolationException } from "./invariant-violation-exception.js";
 import { t as InvalidValueException } from "./validation-exception.js";
-import { f as SilentPolicyReporter, l as Result, o as PolicyContextPath } from "./gate-v1-payload.schema.js";
+import { r as isValidDate } from "./temporal-guards.js";
+import { l as SilentPolicyReporter, o as PolicyContextPath } from "./gate-v1-payload.schema.js";
+import { r as Result } from "./result.js";
 //#region src/core/policies/utils/hash.ts
 /**
 * Produces a deterministic SHA-256 hex digest of a canonical JSON representation.