@orkestrel/program 0.0.11 → 0.0.12

package/dist/src/core/index.d.ts

@@ -19,33 +19,17 @@ import { RatingResult } from '@orkestrel/rater';
 import { ReasonInterface } from '@orkestrel/reason';
 import { Subject } from '@orkestrel/reason';
 
-/** The reserved working-subject key a batch's aggregate projection is written under. */
+/** Names the reserved working-subject key a batch's aggregate projection is written under. */
 export declare const AGGREGATE_KEY = "aggregate";
 
-/** Batch aggregate fields, an optional partition key, and optional gates. */
+/** Describes batch aggregate fields, an optional partition field, and optional gates. */
 export declare interface AggregateDefinition {
     readonly fields: readonly FieldPath[];
-    readonly by?: FieldPath;
+    readonly partition?: FieldPath;
     readonly gates?: LogicalDefinition;
 }
 
-/**
- * Build an {@link AggregateDefinition}.
- *
- * @param fields - The aggregate fields to sum across a batch
- * @param input - Optional partition field and aggregate gates
- * @returns A fresh aggregate definition
- *
- * @example
- * ```ts
- * import { aggregateDefinition } from '@orkestrel/program'
- *
- * aggregateDefinition(['amount'], { by: 'location' })
- * ```
- */
-export declare function aggregateDefinition(fields: readonly FieldPath[], input?: AggregateInput): AggregateDefinition;
-
-/** One batch aggregate partition. */
+/** Describes one batch aggregate partition. */
 export declare interface AggregateGroup {
     readonly key: string;
     readonly count: number;
@@ -53,7 +37,7 @@ export declare interface AggregateGroup {
 }
 
 /**
- * Partition a batch of subjects by a field, summing aggregate fields per key.
+ * Partitions a batch of subjects by a field, summing aggregate fields per key.
  *
  * @remarks
  * The partition key is derived by {@link formatGroupKey}. Group order follows
@@ -61,8 +45,8 @@ export declare interface AggregateGroup {
  *
  * @param subjects - The batch of subjects
  * @param fields - The fields to sum within each partition
- * @param by - The partition key field; no partition is built when absent
- * @returns A fresh list of aggregate groups, or an empty list when `by` is absent
+ * @param partition - The field the batch partitions on; no partition is built when absent
+ * @returns A fresh list of aggregate groups, or an empty list when `partition` is absent
  *
  * @example
  * ```ts
@@ -71,29 +55,29 @@ export declare interface AggregateGroup {
  * aggregateGroups([{ location: 'east', amount: 5 }], ['amount'], 'location')
  * ```
  */
-export declare function aggregateGroups(subjects: readonly Subject[], fields: readonly FieldPath[], by?: FieldPath): readonly AggregateGroup[];
+export declare function aggregateGroups(subjects: readonly Subject[], fields: readonly FieldPath[], partition?: FieldPath): readonly AggregateGroup[];
 
 /**
- * Optional fields accepted by `aggregateDefinition`.
+ * Describes the optional fields accepted by `buildAggregateDefinition`.
  *
  * @remarks
- * `by` — the partition key field; omitted skips partitioning. `gates` — a
- * logical definition evaluated once over the whole batch to derive `limit`
- * determinations.
+ * `partition` — the field a batch partitions on; omitted skips partitioning.
+ * `gates` — a logical definition evaluated once over the whole batch to derive
+ * `limit` determinations.
  */
 export declare interface AggregateInput {
-    readonly by?: FieldPath;
+    readonly partition?: FieldPath;
     readonly gates?: LogicalDefinition;
 }
 
-/** One subject's private aggregate working projection. */
+/** Describes one subject's private aggregate working projection. */
 export declare interface AggregateProjection {
     readonly count: number;
     readonly sums: Readonly<Record<string, number>>;
     readonly group?: AggregateGroup;
 }
 
-/** A batch program outcome across every subject. */
+/** Describes a batch program outcome across every subject. */
 export declare interface AggregateResult {
     readonly id: string;
     readonly name: string;
@@ -109,7 +93,7 @@ export declare interface AggregateResult {
 }
 
 /**
- * Sum aggregate fields across a batch of subjects.
+ * Sums aggregate fields across a batch of subjects.
  *
  * @remarks
  * A {@link FieldPath} may be nested — a nested path sums a nested subject field
@@ -131,7 +115,7 @@ export declare interface AggregateResult {
 export declare function aggregateSums(subjects: readonly Subject[], fields: readonly FieldPath[]): Readonly<Record<string, number>>;
 
 /**
- * Assert a program definition's always-on construction invariants — missing
+ * Asserts a program definition's always-on construction invariants — missing
  * scope references and duplicate rating-line or notice ids.
  *
  * @remarks
@@ -140,10 +124,10 @@ export declare function aggregateSums(subjects: readonly Subject[], fields: read
  * an authoring mistake this severe cannot silently compile.
  *
  * @param definition - The program definition to assert
- * @throws {@link ProgramError} `'MISSING'` when a ruling or notice scope names
-     * no rating line
-     * @throws {@link ProgramError} `'DUPLICATE'` when two rating lines or two
-         * notices share an id
+ * @throws {@link ProgramError} Thrown when a ruling or notice scope names no
+     * rating line (`'MISSING'`).
+     * @throws {@link ProgramError} Thrown when two rating lines or two notices share
+         * an id (`'DUPLICATE'`).
          *
          * @example
          * ```ts
@@ -155,1152 +139,1788 @@ export declare function aggregateSums(subjects: readonly Subject[], fields: read
      export declare function assertProgramDefinition(definition: ProgramDefinition): void;
 
      /**
-      * Assert a value is a valid program {@link Subject}, narrowing it in place.
+      * Asserts a value is a valid program {@link Subject}, narrowing it in place.
       *
       * @param subject - The candidate subject to validate
-      * @throws {@link ProgramError} `'MISMATCH'` when the value is not a record, or
-          * `'RESERVED'` when it already carries the `aggregate` or `outcome` key
-          *
-          * @example
-          * ```ts
-          * import { assertProgramSubject } from '@orkestrel/program'
-          *
-          * assertProgramSubject({ id: 'r1' }) // does not throw
-          * ```
-          */
-      export declare function assertProgramSubject(subject: unknown): asserts subject is Subject;
-
-      /**
-       * Build one subject's overall and optional group aggregate projection.
-       *
-       * @remarks
-       * The projection carries the whole-batch `count` and `sums` plus the subject's
-       * OWN partition, located by the same {@link formatGroupKey} key
-       * {@link aggregateGroups} partitions under.
-       *
-       * @param subject - The subject to project for
-       * @param count - The whole-batch subject count
-       * @param sums - The whole-batch summed aggregate fields
-       * @param groups - The batch partitions
-       * @param by - The partition key field; no group is attached when absent
-       * @returns A fresh aggregate projection
-       *
-       * @example
-       * ```ts
-       * import { buildAggregateProjection } from '@orkestrel/program'
-       *
-       * buildAggregateProjection(subject, 2, { amount: 8 }, groups, 'location')
-       * ```
-       */
-      export declare function buildAggregateProjection(subject: Subject, count: number, sums: Readonly<Record<string, number>>, groups: readonly AggregateGroup[], by?: FieldPath): AggregateProjection;
-
-      /**
-       * Build the reserved-key record a batch aggregate-gate definition runs against.
-       *
-       * @remarks
-       * Unlike a per-subject {@link buildAggregateProjection}, the batch record carries
-       * every `group` (a `groups` array) under {@link AGGREGATE_KEY} so a gate rule can
-       * read `aggregate.sums.<field>` (overall) or a partition inside `aggregate.groups`.
-       *
-       * @param count - The whole-batch subject count
-       * @param sums - The whole-batch summed aggregate fields
-       * @param groups - The batch partitions
-       * @returns A fresh record carrying the batch aggregate under {@link AGGREGATE_KEY}
-       *
-       * @example
-       * ```ts
-       * import { buildAggregateRecord } from '@orkestrel/program'
-       *
-       * buildAggregateRecord(2, { amount: 8 }, [])
-       * ```
-       */
-      export declare function buildAggregateRecord(count: number, sums: Readonly<Record<string, number>>, groups: readonly AggregateGroup[]): Readonly<Record<string, unknown>>;
-
-      /**
-       * Assemble one batch {@link AggregateResult} from its per-subject and aggregate
-       * parts.
-       *
-       * @remarks
-       * `count` is the subject count, `trace` / `errors` accumulate every subject's
-       * plus the batch aggregate-gate evaluation's (`options.gates`), and `success`
-       * requires every subject execution to succeed AND the gate evaluation to have
-       * produced no errors. A fired aggregate gate contributes a `limit`
-       * determination, never a technical failure (a non-logical gate result is a
-       * caller-facing `MISMATCH` thrown by `Program` before this assembles).
-       *
-       * @param definition - The authored program definition
-       * @param subjects - The per-subject program results, in input order
-       * @param determinations - The batch aggregate-gate `limit` determinations
-       * @param groups - The batch partitions
-       * @param tallies - The completed status tallies
-       * @param sums - The whole-batch summed aggregate fields
-       * @param options - Optional resolved aggregate-gate result
-       * @returns A fresh aggregate result
-       *
-       * @example
-       * ```ts
-       * import { buildAggregateResult } from '@orkestrel/program'
-       *
-       * buildAggregateResult(definition, subjects, [], [], tallies, { amount: 8 })
-       * ```
-       */
-      export declare function buildAggregateResult(definition: ProgramDefinition, subjects: readonly ProgramResult[], determinations: readonly Determination[], groups: readonly AggregateGroup[], tallies: Readonly<Record<Status, Tally>>, sums: Readonly<Record<string, number>>, options?: {
-          readonly gates?: LogicalResult;
-      }): AggregateResult;
-
-      /**
-       * Convert a logical result's applied rules into `limit` {@link Determination}s.
-       *
-       * @remarks
-       * Fires for both the per-subject authority and the batch aggregate gates — both
-       * are plain {@link LogicalDefinition}s with no program-authored ruling map, so a
-       * fired rule's own `description` (from `@orkestrel/reason`) is the message
-       * template, interpolated against the working record the definition ran against.
-       * Rich premises reuse the qualifier's {@link logicalPremises}. A rule that never
-       * fires produces no determination — program has no authored ruling map to keep
-       * evidence for.
-       *
-       * @param definition - The authority or aggregate-gate logical definition
-       * @param result - The evaluated logical result
-       * @param working - The working record the definition ran against
-       * @param evaluator - The shared reason check evaluator
-       * @param labels - Optional field-to-label overrides, keyed by dot-joined field
-       * @returns A fresh list of `limit` determinations
-       *
-       * @example
-       * ```ts
-       * import { buildLimits } from '@orkestrel/program'
-       *
-       * buildLimits(authority, resolved, outcome, evaluator)
-       * ```
-       */
-      export declare function buildLimits(definition: LogicalDefinition, result: LogicalResult, working: Readonly<Record<string, unknown>>, evaluator: EvaluatorInterface, labels?: Readonly<Record<string, string>>): readonly Determination[];
-
-      /**
-       * Resolve authored {@link Notice}s into unconditionally-applied `notice`
-       * {@link Determination}s.
-       *
-       * @remarks
-       * Notices are program output only — they never affect eligibility, status, line
-       * selection, or the decision. Each message interpolates against the original
-       * subject.
-       *
-       * @param notices - The authored notices
-       * @param subject - The original subject notices interpolate against
-       * @returns A fresh list of notice determinations
-       *
-       * @example
-       * ```ts
-       * import { buildNotices } from '@orkestrel/program'
-       *
-       * buildNotices([{ id: 'min', message: 'Minimum applies' }], { id: 'r1' })
-       * ```
-       */
-      export declare function buildNotices(notices: readonly Notice[], subject: Readonly<Record<string, unknown>>): readonly Determination[];
-
-      /**
-       * Build the private authority outcome projection from an assembled program result.
-       *
-       * @remarks
-       * The authority reads this record under {@link OUTCOME_KEY}; it never receives
-       * the mutable internal state of either sibling engine. `total` is carried from
-       * the nested rating result when rating occurred.
-       *
-       * @param result - The preliminary program result computed before authority runs
-       * @returns A record shaped for the authority's `outcome` projection
-       *
-       * @example
-       * ```ts
-       * import { buildOutcomeProjection } from '@orkestrel/program'
-       *
-       * buildOutcomeProjection(result) // { id, eligibility, status, rated, scopes }
-       * ```
-       */
-      export declare function buildOutcomeProjection(result: ProgramResult): Readonly<Record<string, unknown>>;
-
-      /**
-       * Assemble a {@link ProgramResult} from its qualification, rating, and
-       * determination parts — before or after authority.
-       *
-       * @remarks
-       * `eligibility` mirrors the qualification. `success` is execution integrity: the
-       * qualification succeeded, rating (when it ran) succeeded, and authority (when it
-       * ran) produced no errors — a valid ineligible or referral outcome still
-       * succeeds. `trace` and `errors` accumulate the qualification's, every rated
-       * line's worksheet trail, and the authority's. A `decision` is present ONLY when
-       * an authority ran (`options.authority`), the execution SUCCEEDED (`success`),
-       * no `limit` determination applied, and status is not `unrated`.
-       *
-       * @param definition - The authored program definition
-       * @param qualification - The subject's qualification result
-       * @param rating - The subject's rating result, when rating occurred
-       * @param determinations - The program-scoped determinations (notices, then limits)
-       * @param status - The already-derived status
-       * @param options - Optional authority result driving the decision projection
-       * @returns A fresh program result
-       *
-       * @example
-       * ```ts
-       * import { buildProgramResult } from '@orkestrel/program'
-       *
-       * buildProgramResult(definition, qualification, rating, [], 'eligible')
-       * ```
-       */
-      export declare function buildProgramResult(definition: ProgramDefinition, qualification: QualificationResult, rating: RatingResult | undefined, determinations: readonly Determination[], status: Status, options?: {
-          readonly authority?: LogicalResult;
-      }): ProgramResult;
-
-      /**
-       * Add optional aggregate context to a private subject copy for qualification.
-       *
-       * @remarks
-       * The original subject is returned unchanged when no aggregate context exists.
-       * When context exists the helper creates a private copy under {@link AGGREGATE_KEY}
-       * and defensively copies every nested record — the rater still receives the
-       * original subject, never this copy.
-       *
-       * @param subject - The original caller subject
-       * @param aggregate - The subject's aggregate projection, when a batch supplies one
-       * @returns The subject, or a private copy carrying the aggregate projection
-       *
-       * @example
-       * ```ts
-       * import { buildQualificationSubject } from '@orkestrel/program'
-       *
-       * buildQualificationSubject({ id: 'r1' }) // { id: 'r1' }
-       * ```
-       */
-      export declare function buildQualificationSubject(subject: Subject, aggregate?: AggregateProjection): Subject;
-
-      /**
-       * Complete a partial status tally record with zero entries for every missing
-       * {@link Status}.
-       *
-       * @param entries - The partial tally entries to complete
-       * @returns A record with all five statuses present
-       *
-       * @example
-       * ```ts
-       * import { completeTallies } from '@orkestrel/program'
-       *
-       * completeTallies({ eligible: { count: 1, sums: {} } })
-       * ```
-       */
-      export declare function completeTallies(entries: Partial<Record<Status, Tally>>): Readonly<Record<Status, Tally>>;
-
-      /**
-       * Return a fresh JSON value tree that does not alias the input.
-       *
-       * @remarks
-       * The input must be an acyclic JSON tree of bounded depth — a pathologically
-       * deep tree throws the engine's `RangeError` (stack exhaustion) rather than
-       * hanging. Each copied record uses `Object.defineProperty` for own-property
-       * definition, which defends against prototype-pollution keys (`__proto__`).
-       *
-       * @param value - The JSON value to copy
-       * @returns A fresh JSON value
-       *
-       * @example
-       * ```ts
-       * import { copyJSONValue } from '@orkestrel/program'
-       *
-       * copyJSONValue({ a: [1, 2] }) // { a: [1, 2] }, a fresh copy
-       * ```
-       */
-      export declare function copyJSONValue(value: JSONValue): JSONValue;
-
-      /**
-       * Create one compiled program over a qualifier and rater.
-       *
-       * @remarks
-       * Validates the definition at construction when `options.validate` is left at
-       * its {@link DEFAULT_PROGRAM_VALIDATE} default. A standalone program creates and
-       * OWNS one shared quantitative-plus-logical reason engine and injects it into the
-       * qualifier and rater it creates; injected dependencies remain caller-owned.
-       *
-       * @param definition - The authored program definition
-       * @param options - Optional injected qualifier, rater, engine, validation, labels, and emitter hooks
-       * @returns A {@link ProgramInterface}
-       *
-       * @example
-       * ```ts
-       * import { createProgram, programDefinition } from '@orkestrel/program'
-       *
-       * const program = createProgram(programDefinition('standard', 'Standard', qualification, rating))
-       * program.execute({ id: 'risk-1' })
-       * program.destroy()
-       * ```
-       */
-      export declare function createProgram(definition: ProgramDefinition, options?: ProgramOptions): ProgramInterface;
-
-      /**
-       * Create one ordered manager over compiled programs.
-       *
-       * @remarks
-       * Creates or borrows one shared reason engine, qualifier, and rater and injects
-       * them into every compiled program, so a batch of definitions shares one engine.
-       * Seed definitions are compiled in order.
-       *
-       * @param options - Optional injected qualifier, rater, engine, seed programs, validation, labels, and emitter hooks
-       * @returns A {@link ProgramManagerInterface}
-       *
-       * @example
-       * ```ts
-       * import { createProgramManager } from '@orkestrel/program'
-       *
-       * const manager = createProgramManager({ programs: [definition] })
-       * manager.program('standard')?.execute(subject)
-       * manager.destroy()
-       * ```
-       */
-      export declare function createProgramManager(options?: ProgramManagerOptions): ProgramManagerInterface;
-
-      /**
-       * Map a global {@link Eligibility} to its deterministic authority {@link Decision}.
-       *
-       * @param eligibility - The global eligibility
-       * @returns The matching decision
-       *
-       * @example
-       * ```ts
-       * import { decideEligibility } from '@orkestrel/program'
-       *
-       * decideEligibility('eligible') // 'approved'
-       * decideEligibility('referral') // 'submitted'
-       * ```
-       */
-      export declare function decideEligibility(eligibility: Eligibility): Decision;
-
-      /** A final authority outcome, derived from global eligibility. */
-      export declare type Decision = 'approved' | 'denied' | 'submitted';
-
-      /** Default definition validation policy for `createProgram` / `ProgramManager.add`. */
-      export declare const DEFAULT_PROGRAM_VALIDATE = true;
-
-      /**
-       * Derive the final program {@link Status} from a definition's rating policy and
-       * qualification/rating evidence.
-       *
-       * @remarks
-       * Explicit policy, not an opaque precedence reduce (AGENTS §10): global
-       * ineligibility or referral is terminal; a scoped referral yields `referral`;
-       * an applied `condition` or an applied scoped `restriction` (a line was
-       * removed but others rated) is `conditional`. When the definition OMITS
-       * `rating` the program is eligibility-only — status resolves to `conditional`
-       * or `eligible` and is NEVER `unrated`. Otherwise a subject with no successful
-       * rating is `unrated`.
-       *
-       * @param definition - The authored program definition
-       * @param qualification - The subject's qualification result
-       * @param rating - The subject's rating result, when rating occurred
-       * @returns The derived status
-       *
-       * @example
-       * ```ts
-       * import { deriveStatus } from '@orkestrel/program'
-       *
-       * deriveStatus(definition, qualification, rating) // 'eligible'
-       * ```
-       */
-      export declare function deriveStatus(definition: ProgramDefinition, qualification: QualificationResult, rating?: RatingResult): Status;
-
-      /** One resolved notice or authority-limit outcome. */
-      export declare interface Determination {
-          readonly id: string;
-          readonly effect: ProgramEffect;
-          readonly applied: boolean;
-          readonly scope?: string;
-          readonly message?: string;
-          readonly premises: readonly Premise[];
-      }
-
-      /** The deterministic authority decision for each global eligibility. */
-      export declare const ELIGIBILITY_DECISIONS: Readonly<Record<Eligibility, Decision>>;
-
-      /**
-       * Build a zero-sum record for a set of aggregate fields.
-       *
-       * @param fields - The fields to zero
-       * @returns A fresh record of dot-joined field to `0`
-       *
-       * @example
-       * ```ts
-       * import { emptySums } from '@orkestrel/program'
-       *
-       * emptySums(['amount']) // { amount: 0 }
-       * ```
-       */
-      export declare function emptySums(fields: readonly FieldPath[]): Readonly<Record<string, number>>;
-
-      /**
-       * Build complete zero status tallies in {@link STATUS_PRECEDENCE} order.
-       *
-       * @param fields - The fields each tally's sums are zeroed for
-       * @returns A fresh, complete tally record
-       *
-       * @example
-       * ```ts
-       * import { emptyTallies } from '@orkestrel/program'
-       *
-       * emptyTallies(['amount'])
-       * ```
-       */
-      export declare function emptyTallies(fields: readonly FieldPath[]): Readonly<Record<Status, Tally>>;
-
-      /**
-       * Return authored scopes (qualification ruling scopes or notice scopes) that
-       * name no rating line on the program.
-       *
-       * @remarks
-       * A scope is an opaque string to the qualifier — program alone matches it to a
-       * rating-line id. A scope naming no line is a hard authoring error surfaced as
-       * {@link ProgramError} `'MISSING'` at construction, regardless of the validate
-       * option.
-       *
-       * @param definition - The program definition to check
-       * @returns A fresh, deduped list of missing scope references
-       *
-       * @example
-       * ```ts
-       * import { findMissingScopes } from '@orkestrel/program'
-       *
-       * findMissingScopes(definition) // []
-       * ```
-       */
-      export declare function findMissingScopes(definition: ProgramDefinition): readonly string[];
-
-      /**
-       * Coerce a subject's partition-key field to its group-key string.
-       *
-       * @remarks
-       * The key is the resolved field coerced with `String` — `undefined` collapses
-       * to the empty string, so a subject missing the field and a subject whose
-       * field is literally `''` land in the SAME partition, and a numeric `1`
-       * collides with the string `'1'`.
-       *
-       * @param subject - The subject to key
-       * @param by - The partition key field
-       * @returns The subject's group key
-       *
-       * @example
-       * ```ts
-       * import { formatGroupKey } from '@orkestrel/program'
-       *
-       * formatGroupKey({ location: 'east' }, 'location') // 'east'
-       * ```
-       */
-      export declare function formatGroupKey(subject: Subject, by: FieldPath): string;
-
-      /**
-       * Determine whether a caller subject already carries a reserved program key.
-       *
-       * @remarks
-       * `aggregate` and `outcome` are program-private working-subject namespaces — the
-       * batch aggregate projection and the authority outcome projection are written
-       * under them. A caller subject that already owns either key would silently
-       * collide with a projection, so it is rejected before qualification.
-       *
-       * @param subject - The caller subject to check
-       * @returns `true` when the subject owns `aggregate` or `outcome`
-       *
-       * @example
-       * ```ts
-       * import { hasReservedKey } from '@orkestrel/program'
-       *
-       * hasReservedKey({ id: 'r1' }) // false
-       * hasReservedKey({ id: 'r1', aggregate: {} }) // true
-       * ```
-       */
-      export declare function hasReservedKey(subject: Readonly<Record<string, unknown>>): boolean;
-
-      /**
-       * Determine whether a value is an exact {@link AggregateDefinition} record.
-       *
-       * @param value - The candidate value
-       * @returns `true` when `value` is an {@link AggregateDefinition}
-       *
-       * @example
-       * ```ts
-       * import { isAggregateDefinition } from '@orkestrel/program'
-       *
-       * isAggregateDefinition({ fields: ['amount'] }) // true
-       * ```
-       */
-      export declare function isAggregateDefinition(value: unknown): value is AggregateDefinition;
-
-      /**
-       * Determine whether a value is an open result-side {@link AggregateGroup}.
-       *
-       * @remarks
-       * Unknown members and class instances are admitted. Arrays are refused.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every published aggregate-group member conforms
-       *
-       * @example
-       * ```ts
-       * import { isAggregateGroup } from '@orkestrel/program'
-       *
-       * isAggregateGroup({ key: 'east', count: 1, sums: { premium: 100 } }) // true
-       * ```
-       */
-      export declare const isAggregateGroup: Guard<AggregateGroup>;
-
-      /**
-       * Determine whether a value is an open {@link AggregateResult}.
-       *
-       * @remarks
-       * This guard is result-postured for values returned through a borrowed
-       * {@link ProgramInterface}. It admits unknown members and class instances while
-       * checking every nested program result, determination, group, total tally
-       * record, and sums record. Arrays are refused.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every published aggregate-result member conforms
-       *
-       * @example
-       * ```ts
-       * import { isAggregateResult } from '@orkestrel/program'
-       *
-       * isAggregateResult(program.execute(subjects)) // true
-       * ```
-       */
-      export declare const isAggregateResult: Guard<AggregateResult>;
-
-      /**
-       * Determine whether a value is a {@link Decision} literal.
-       *
-       * @param value - The candidate value
-       * @returns `true` when `value` is a {@link Decision}
-       *
-       * @example
-       * ```ts
-       * import { isDecision } from '@orkestrel/program'
-       *
-       * isDecision('approved') // true
-       * ```
-       */
-      export declare const isDecision: Guard<Decision>;
-
-      /**
-       * Determine whether a value is an open result-side {@link Determination}.
-       *
-       * @remarks
-       * Unknown members and class instances are admitted. Arrays are refused.
-       * Optional `scope` and `message` members may be absent or `undefined`.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every published determination member conforms
-       *
-       * @example
-       * ```ts
-       * import { isDetermination } from '@orkestrel/program'
-       *
-       * isDetermination({ id: 'audit', effect: 'notice', applied: true, premises: [] }) // true
-       * ```
-       */
-      export declare const isDetermination: Guard<Determination>;
-
-      /**
-       * Determine whether a value is an exact {@link Notice} record.
-       *
-       * @param value - The candidate value
-       * @returns `true` when `value` is a {@link Notice}
-       *
-       * @example
-       * ```ts
-       * import { isNotice } from '@orkestrel/program'
-       *
-       * isNotice({ id: 'minimum', message: 'Minimum applies' }) // true
-       * ```
-       */
-      export declare function isNotice(value: unknown): value is Notice;
-
-      /**
-       * Determine whether a value is an exact {@link ProgramDefinition} record.
-       *
-       * @remarks
-       * `rating` is optional — an omitted `rating` authors an eligibility-only
-       * program (see {@link ProgramDefinition}).
-       *
-       * @param value - The candidate value
-       * @returns `true` when `value` is a {@link ProgramDefinition}
-       *
-       * @example
-       * ```ts
-       * import { isProgramDefinition } from '@orkestrel/program'
-       *
-       * isProgramDefinition({ id: 'p', name: 'P', qualification }) // true
-       * ```
-       */
-      export declare function isProgramDefinition(value: unknown): value is ProgramDefinition;
-
-      /**
-       * Determine whether a value is a {@link ProgramEffect} literal.
-       *
-       * @param value - The candidate value
-       * @returns `true` when `value` is a {@link ProgramEffect}
-       *
-       * @example
-       * ```ts
-       * import { isProgramEffect } from '@orkestrel/program'
-       *
-       * isProgramEffect('notice') // true
-       * ```
-       */
-      export declare const isProgramEffect: Guard<ProgramEffect>;
-
-      /** Narrow a caught value to a {@link ProgramError}. */
-      export declare function isProgramError(value: unknown): value is ProgramError;
-
-      /**
-       * Determine whether a value is an open {@link ProgramResult}.
-       *
-       * @remarks
-       * This guard is result-postured for values returned through a borrowed
-       * {@link ProgramInterface}. It admits unknown members and class instances while
-       * composing qualifier's `isQualificationResult` and rater's `isRatingResult`
-       * over their complete nested result closures. Arrays are refused.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every published program-result member conforms
-       *
-       * @example
-       * ```ts
-       * import { isProgramResult } from '@orkestrel/program'
-       *
-       * isProgramResult(program.execute(subject)) // true
-       * ```
-       */
-      export declare const isProgramResult: Guard<ProgramResult>;
-
-      /**
-       * Determine whether a value is an open program sums record.
-       *
-       * @remarks
-       * Every own string-named property is checked, including non-enumerable
-       * properties. Inherited and symbol-named members are outside the record this
-       * guard certifies. Values remain plain JavaScript numbers, including `NaN` and
-       * infinities, because the published contract does not refine them.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every own string-named value is a number
-       *
-       * @example
-       * ```ts
-       * import { isProgramSums } from '@orkestrel/program'
-       *
-       * isProgramSums({ premium: 100 }) // true
-       * ```
-       */
-      export declare function isProgramSums(value: unknown): value is Readonly<Record<string, number>>;
-
-      /**
-       * Determine whether a value is an open {@link ProgramValidationResult}.
-       *
-       * @remarks
-       * `ProgramValidationResult` is this package's own declared interface, not an
-       * alias of reason's validation result. This guard therefore checks the three
-       * program-owned members directly so the contracts may evolve independently.
-       * Unknown members and class instances are admitted. Arrays are refused.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every published program-validation member conforms
-       *
-       * @example
-       * ```ts
-       * import { isProgramValidationResult } from '@orkestrel/program'
-       *
-       * isProgramValidationResult({ valid: true, errors: [], warnings: [] }) // true
-       * ```
-       */
-      export declare const isProgramValidationResult: Guard<ProgramValidationResult>;
-
-      /**
-       * Determine whether a value is a {@link Status} literal.
-       *
-       * @param value - The candidate value
-       * @returns `true` when `value` is a {@link Status}
-       *
-       * @example
-       * ```ts
-       * import { isStatus } from '@orkestrel/program'
-       *
-       * isStatus('eligible') // true
-       * ```
-       */
-      export declare const isStatus: Guard<Status>;
-
-      /**
-       * Determine whether a value is a total open status-tally record.
-       *
-       * @remarks
-       * Every {@link Status} in {@link STATUS_PRECEDENCE} is required and checked.
-       * Unknown members and class instances are admitted. Arrays are refused.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every required status member is a {@link Tally}
-       *
-       * @example
-       * ```ts
-       * import { emptyTallies, isTallies } from '@orkestrel/program'
-       *
-       * isTallies(emptyTallies([])) // true
-       * ```
-       */
-      export declare function isTallies(value: unknown): value is Readonly<Record<Status, Tally>>;
-
-      /**
-       * Determine whether a value is an open result-side {@link Tally}.
-       *
-       * @remarks
-       * Unknown members and class instances are admitted. Arrays are refused.
-       *
-       * @param value - The candidate value
-       * @returns `true` when every published tally member conforms
-       *
-       * @example
-       * ```ts
-       * import { isTally } from '@orkestrel/program'
-       *
-       * isTally({ count: 1, sums: { premium: 100 } }) // true
-       * ```
-       */
-      export declare const isTally: Guard<Tally>;
-
-      /** An authored, unconditional program notice. */
-      export declare interface Notice {
-          readonly id: string;
-          readonly message: string;
-          readonly scope?: string;
-      }
-
-      /**
-       * Build a {@link Notice}.
-       *
-       * @param id - The notice id
-       * @param message - The message template, carrying optional `{{token}}`s
-       * @param input - Optional presentation scope
-       * @returns A fresh notice
-       *
-       * @example
-       * ```ts
-       * import { noticeDefinition } from '@orkestrel/program'
-       *
-       * noticeDefinition('minimum', 'Minimum earned premium applies')
-       * ```
-       */
-      export declare function noticeDefinition(id: string, message: string, input?: NoticeInput): Notice;
-
-      /**
-       * Optional fields accepted by `noticeDefinition`.
-       *
-       * @remarks
-       * `scope` — the rating-line id the notice presents against; omitted for an
-       * unscoped, program-wide notice.
-       */
-      export declare interface NoticeInput {
-          readonly scope?: string;
-      }
-
-      /** The reserved working-subject key the authority's outcome projection is written under. */
-      export declare const OUTCOME_KEY = "outcome";
-
-      /**
-       * One compiled program — composes one qualifier and one rater over a shared
-       * reason engine and executes single subjects or aggregate-aware batches.
-       *
-       * @remarks
-       * Qualification decides whether rating happens: a globally ineligible, referred,
-       * or failed subject never reaches the rater, and a scoped ineligibility removes
-       * only its line before the first rating call. The rater always receives the
-       * ORIGINAL subject; the qualifier's aggregate projection stays private. When no
-       * qualifier, rater, or engine is injected the program creates ONE shared
-       * quantitative-plus-logical engine, injects it into the qualifier and rater it
-       * creates, and destroys only what it owns. A definition failure during
-       * construction (an invalid definition under `options.validate`) tears down
-       * whatever the constructor had already allocated before throwing. Construction
-       * snapshots the caller's definition once, runs the always-on assertions against
-       * that snapshot, and seals its plain-object graph before exposure. A `Map`, `Set`,
-       * or `Date` reached through a reason `Check.value` is cloned but remains mutable
-       * because its contents live in internal slots. Uncloneable values and non-empty
-       * typed arrays are refused with `ProgramError('DEFINITION')` and the host error
-       * as its cause. `destroy()` is idempotent and REENTRANCY-SAFE — the destroyed
-       * flag is set BEFORE any teardown or the `destroy` event fires, so a listener
-       * that re-enters `destroy()` is a no-op — and tears the emitter down last.
-       */
-      export declare class Program implements ProgramInterface {
-          #private;
-          readonly id: string;
-          readonly name: string;
-          readonly definition: ProgramDefinition;
-          constructor(definition: ProgramDefinition, options?: ProgramOptions);
-          get emitter(): EmitterInterface<ProgramEventMap>;
-          execute(subjects: readonly Subject[]): AggregateResult;
-          execute(subject: Subject): ProgramResult;
-          validate(): ProgramValidationResult;
-          destroy(): void;
-      }
-
-      /**
-       * A pure authored program definition.
-       *
-       * @remarks
-       * `qualification` runs first through `@orkestrel/qualifier`; `rating` runs only
-       * over the lines scoped eligibility left standing, through `@orkestrel/rater`.
-       * `authority` (a logical definition) runs last, over the assembled result
-       * extended with an outcome projection, to derive limit determinations and the
-       * final decision. An omitted `rating` authors an ELIGIBILITY-ONLY program — the
-       * rater is never invoked, an eligible subject resolves to `'eligible'` (or
-       * `'conditional'` under an applied condition or scoped restriction), status is
-       * never `'unrated'`, and decisions remain reachable through `authority`. Program
-       * construction clones the definition and seals its plain-object graph. A `Map`,
-       * `Set`, or `Date` reached through a reason `Check.value` is cloned, but its
-       * contents remain mutable because the seal cannot reach its internal slots. A
-       * value that structured cloning cannot copy, or a non-empty typed array that
-       * cannot be frozen, is refused with `ProgramError('DEFINITION')` and the host
-       * error attached as its cause.
-       */
-      export declare interface ProgramDefinition {
-          readonly id: string;
-          readonly name: string;
-          readonly description?: string;
-          readonly qualification: QualificationDefinition;
-          readonly rating?: RatingDefinition;
-          readonly notices?: readonly Notice[];
-          readonly authority?: LogicalDefinition;
-          readonly aggregate?: AggregateDefinition;
-          readonly metadata?: JSONValue;
-      }
-
-      /**
-       * Build a {@link ProgramDefinition}.
-       *
-       * @remarks
-       * Copies every collection and omits absent optional keys, so the returned
-       * definition is a fresh, JSON-serializable value that never aliases its inputs.
-       *
-       * @param id - The program id
-       * @param name - The display name
-       * @param qualification - The nested qualification definition
-       * @param rating - The nested rating definition; omit for an eligibility-only program
-       * @param input - Optional description, notices, authority, aggregate, and metadata
-       * @returns A fresh program definition
-       *
-       * @example
-       * ```ts
-       * import { programDefinition } from '@orkestrel/program'
-       *
-       * programDefinition('standard', 'Standard', qualification, rating, { notices: [notice] })
-       * ```
-       */
-      export declare function programDefinition(id: string, name: string, qualification: QualificationDefinition, rating?: RatingDefinition, input?: ProgramInput): ProgramDefinition;
-
-      /** A post-qualification program determination effect. */
-      export declare type ProgramEffect = 'notice' | 'limit';
-
-      /**
-       * A coded programmer error thrown by the program layer.
-       *
-       * @remarks
-       * `DUPLICATE` — a program id collision on `ProgramManager.add`, or a duplicate
-       * authored rating-line or notice id. `MISSING` — an
-       * authored notice or qualification ruling scope names no rating line.
-       * `DEFINITION` — a program, qualification, rating, authority, or aggregate
-       * policy failed validation. `MISMATCH` — an injected entity or a returned
-       * reason result has the wrong contract. `RESERVED` — a subject already
-       * carries `aggregate` or `outcome`. `DESTROYED` — use of a destroyed entity.
-       */
-      export declare class ProgramError extends Error {
-          readonly code: ProgramErrorCode;
-          readonly context?: unknown;
-          constructor(code: ProgramErrorCode, message: string, context?: unknown);
-      }
-
-      /** A coded {@link ProgramError} programmer-error code. */
-      export declare type ProgramErrorCode = 'DUPLICATE' | 'MISSING' | 'DEFINITION' | 'MISMATCH' | 'RESERVED' | 'DESTROYED';
-
-      /**
-       * The push observation surface of a {@link ProgramInterface} (AGENTS §13).
-       *
-       * @remarks
-       * `rate` fires only when at least one line was selected. `determine` fires once
-       * per notice, then once per applied limit. `decide` fires only when a decision
-       * was reached.
-       */
-      export declare type ProgramEventMap = {
-          readonly qualify: readonly [result: QualificationResult];
-          readonly rate: readonly [result: RatingResult];
-          readonly determine: readonly [result: Determination];
-          readonly decide: readonly [decision: Decision, result: ProgramResult];
-          readonly execute: readonly [result: ProgramResult];
-          readonly aggregate: readonly [result: AggregateResult];
-          readonly destroy: readonly [];
-      };
-
-      /**
-       * Optional fields accepted by `programDefinition`.
-       *
-       * @remarks
-       * `description` — a free-text summary. `notices` — authored unconditional
-       * notices. `authority` — a logical definition evaluated per subject to derive
-       * limit determinations and the decision. `aggregate` — batch aggregate fields,
-       * partition key, and gates. `metadata` — opaque caller data, copied fresh.
-       */
-      export declare interface ProgramInput {
-          readonly description?: string;
-          readonly notices?: readonly Notice[];
-          readonly authority?: LogicalDefinition;
-          readonly aggregate?: AggregateDefinition;
-          readonly metadata?: JSONValue;
-      }
-
-      /**
-       * One compiled program — composes one qualifier and one rater over a shared
-       * reason engine.
-       *
-       * @remarks
-       * The array-of-subjects `execute` overload is declared FIRST (AGENTS §9.2) so a
-       * subject list resolves to one aggregate-aware batch execution.
-       */
-      export declare interface ProgramInterface {
-          readonly id: string;
-          readonly name: string;
-          readonly definition: ProgramDefinition;
-          readonly emitter: EmitterInterface<ProgramEventMap>;
-          execute(subjects: readonly Subject[]): AggregateResult;
-          execute(subject: Subject): ProgramResult;
-          validate(): ProgramValidationResult;
-          destroy(): void;
-      }
-
-      /**
-       * An ordered manager over compiled {@link ProgramInterface}s (AGENTS §9), sharing
-       * one qualifier, rater, and reason engine across every program it compiles.
-       *
-       * @remarks
-       * OWNS its ordered `#programs` collection and its own {@link Emitter} over
-       * {@link ProgramManagerEventMap}. Creates or borrows one shared engine, qualifier,
-       * and rater and injects the same instances into every compiled program. `remove`
-       * destroys the programs it removes; `destroy()` removes all programs, then
-       * destroys only the owned shared dependencies, and tears the emitter down LAST.
-       * A seed-program failure during construction tears the manager down (destroying
-       * whatever had already been compiled) before rethrowing the original error.
-       * `destroy()` is REENTRANCY-SAFE — the destroyed flag is set BEFORE any teardown
-       * or the `remove` / `destroy` events fire, so a `remove` listener that re-enters
-       * `destroy()` is a no-op. Every call after `destroy()` throws {@link ProgramError}
-       * `'DESTROYED'`.
-       */
-      export declare class ProgramManager implements ProgramManagerInterface {
-          #private;
-          constructor(options?: ProgramManagerOptions);
-          get emitter(): EmitterInterface<ProgramManagerEventMap>;
-          get size(): number;
-          has(id: string): boolean;
-          program(id: string): ProgramInterface | undefined;
-          programs(): readonly ProgramInterface[];
-          add(definition: ProgramDefinition): ProgramInterface;
-          remove(ids: readonly string[]): boolean;
-          remove(id: string): boolean;
-          remove(): void;
-          destroy(): void;
-      }
-
-      /** The push observation surface of a {@link ProgramManagerInterface} (AGENTS §13). */
-      export declare type ProgramManagerEventMap = {
-          readonly add: readonly [id: string];
-          readonly remove: readonly [id: string];
-          readonly destroy: readonly [];
-      };
-
-      /** An ordered manager over compiled programs (AGENTS §9), sharing one qualifier and rater. */
-      export declare interface ProgramManagerInterface {
-          readonly emitter: EmitterInterface<ProgramManagerEventMap>;
-          readonly size: number;
-          has(id: string): boolean;
-          program(id: string): ProgramInterface | undefined;
-          programs(): readonly ProgramInterface[];
-          add(definition: ProgramDefinition): ProgramInterface;
-          remove(ids: readonly string[]): boolean;
-          remove(id: string): boolean;
-          remove(): void;
-          destroy(): void;
-      }
-
-      /**
-       * Options for `createProgramManager` / the `ProgramManager` constructor.
-       *
-       * @remarks
-       * `qualifier` — an injected, caller-owned qualifier; created and owned when
-       * omitted. `rater` — an injected, caller-owned rater; created and owned when
-       * omitted. `engine` — an injected, caller-owned reason engine; created and
-       * owned when omitted. `programs` — seed definitions compiled in order.
-       * `validate` — validate each seeded/added definition at construction (default
-       * {@link DEFAULT_PROGRAM_VALIDATE}). `labels` — field-to-label overrides for
-       * determination premises, keyed by dot-joined field. `on` — initial emitter
-       * hooks. `error` — the emitter's listener-error handler.
-       */
-      export declare interface ProgramManagerOptions {
-          readonly qualifier?: QualifierInterface;
-          readonly rater?: RaterInterface;
-          readonly engine?: ReasonInterface;
-          readonly programs?: readonly ProgramDefinition[];
-          readonly validate?: boolean;
-          readonly labels?: Readonly<Record<string, string>>;
-          readonly on?: EmitterHooks<ProgramManagerEventMap>;
-          readonly error?: EmitterErrorHandler;
-      }
-
-      /**
-       * Options for `createProgram` / the `Program` constructor.
-       *
-       * @remarks
-       * `qualifier` — an injected, caller-owned qualifier; created and owned by the
-       * program when omitted. `rater` — an injected, caller-owned rater; created and
-       * owned when omitted. `engine` — an injected, caller-owned reason engine;
-       * created and owned when omitted. `validate` — validate the definition at
-       * construction (default {@link DEFAULT_PROGRAM_VALIDATE}). `labels` —
-       * field-to-label overrides for determination premises, keyed by dot-joined
-       * field. `on` — initial emitter hooks. `error` — the emitter's listener-error
-       * handler.
-       */
-      export declare interface ProgramOptions {
-          readonly qualifier?: QualifierInterface;
-          readonly rater?: RaterInterface;
-          readonly engine?: ReasonInterface;
-          readonly validate?: boolean;
-          readonly labels?: Readonly<Record<string, string>>;
-          readonly on?: EmitterHooks<ProgramEventMap>;
-          readonly error?: EmitterErrorHandler;
-      }
-
-      /** One subject's complete program outcome. */
-      export declare interface ProgramResult {
-          readonly id: string;
-          readonly name: string;
-          readonly eligibility: Eligibility;
-          readonly status: Status;
+      * @throws {@link ProgramError} Thrown when the value is not a record (`'MISMATCH'`).
+          * @throws {@link ProgramError} Thrown when the value already carries the `aggregate`
+              * or `outcome` key (`'RESERVED'`).
+              *
+              * @example
+              * ```ts
+              * import { assertProgramSubject } from '@orkestrel/program'
+              *
+              * assertProgramSubject({ id: 'r1' }) // does not throw
+              * ```
+              */
+          export declare function assertProgramSubject(subject: unknown): asserts subject is Subject;
+
+          /**
+           * Builds a fresh {@link AggregateDefinition}.
+           *
+           * @param fields - The aggregate fields to sum across a batch
+           * @param input - Optional partition field and aggregate gates
+           * @returns A fresh aggregate definition
+           *
+           * @example
+           * ```ts
+           * import { buildAggregateDefinition } from '@orkestrel/program'
+           *
+           * buildAggregateDefinition(['amount'], { partition: 'location' })
+           * ```
+           */
+          export declare function buildAggregateDefinition(fields: readonly FieldPath[], input?: AggregateInput): AggregateDefinition;
+
+          /**
+           * Builds one subject's overall and optional group aggregate projection.
+           *
+           * @remarks
+           * The projection carries the whole-batch `count` and `sums` plus the subject's
+           * OWN partition, located by the same {@link formatGroupKey} key
+           * {@link aggregateGroups} partitions under.
+           *
+           * @param subject - The subject to project for
+           * @param count - The whole-batch subject count
+           * @param sums - The whole-batch summed aggregate fields
+           * @param groups - The batch partitions
+           * @param partition - The field the batch partitions on; no group is attached when absent
+           * @returns A fresh aggregate projection
+           *
+           * @example
+           * ```ts
+           * import { buildAggregateProjection } from '@orkestrel/program'
+           *
+           * buildAggregateProjection(subject, 2, { amount: 8 }, groups, 'location')
+           * ```
+           */
+          export declare function buildAggregateProjection(subject: Subject, count: number, sums: Readonly<Record<string, number>>, groups: readonly AggregateGroup[], partition?: FieldPath): AggregateProjection;
+
+          /**
+           * Builds the reserved-key record a batch aggregate-gate definition runs against.
+           *
+           * @remarks
+           * Unlike a per-subject {@link buildAggregateProjection}, the batch record carries
+           * every `group` (a `groups` array) under {@link AGGREGATE_KEY} so a gate rule can
+           * read `aggregate.sums.<field>` (overall) or a partition inside `aggregate.groups`.
+           *
+           * @param count - The whole-batch subject count
+           * @param sums - The whole-batch summed aggregate fields
+           * @param groups - The batch partitions
+           * @returns A fresh record carrying the batch aggregate under {@link AGGREGATE_KEY}
+           *
+           * @example
+           * ```ts
+           * import { buildAggregateRecord } from '@orkestrel/program'
+           *
+           * buildAggregateRecord(2, { amount: 8 }, [])
+           * ```
+           */
+          export declare function buildAggregateRecord(count: number, sums: Readonly<Record<string, number>>, groups: readonly AggregateGroup[]): Readonly<Record<string, unknown>>;
+
+          /**
+           * Assembles one batch {@link AggregateResult} from its per-subject and aggregate
+           * parts.
+           *
+           * @remarks
+           * `count` is the subject count, `trace` / `errors` accumulate every subject's
+           * plus the batch aggregate-gate evaluation's (`options.gates`), and `success`
+           * requires every subject execution to succeed AND the gate evaluation to have
+           * produced no errors. A fired aggregate gate contributes a `limit`
+           * determination, never a technical failure (a non-logical gate result is a
+           * caller-facing `MISMATCH` thrown by `Program` before this assembles).
+           *
+           * @param definition - The authored program definition
+           * @param subjects - The per-subject program results, in input order
+           * @param determinations - The batch aggregate-gate `limit` determinations
+           * @param groups - The batch partitions
+           * @param tallies - The completed status tallies
+           * @param sums - The whole-batch summed aggregate fields
+           * @param options - Optional resolved aggregate-gate result
+           * @returns A fresh aggregate result
+           *
+           * @example
+           * ```ts
+           * import { buildAggregateResult } from '@orkestrel/program'
+           *
+           * buildAggregateResult(definition, subjects, [], [], tallies, { amount: 8 })
+           * ```
+           */
+          export declare function buildAggregateResult(definition: ProgramDefinition, subjects: readonly ProgramResult[], determinations: readonly Determination[], groups: readonly AggregateGroup[], tallies: Readonly<Record<Status, Tally>>, sums: Readonly<Record<string, number>>, options?: {
+              readonly gates?: LogicalResult;
+          }): AggregateResult;
+
+          /**
+           * Builds a zero-sum record for a set of aggregate fields.
+           *
+           * @param fields - The fields to zero
+           * @returns A fresh record of dot-joined field to `0`
+           *
+           * @example
+           * ```ts
+           * import { buildEmptySums } from '@orkestrel/program'
+           *
+           * buildEmptySums(['amount']) // { amount: 0 }
+           * ```
+           */
+          export declare function buildEmptySums(fields: readonly FieldPath[]): Readonly<Record<string, number>>;
+
+          /**
+           * Builds complete zero status tallies in {@link STATUSES} order.
+           *
+           * @param fields - The fields each tally's sums are zeroed for
+           * @returns A fresh, complete tally record
+           *
+           * @example
+           * ```ts
+           * import { buildEmptyTallies } from '@orkestrel/program'
+           *
+           * buildEmptyTallies(['amount'])
+           * ```
+           */
+          export declare function buildEmptyTallies(fields: readonly FieldPath[]): Readonly<Record<Status, Tally>>;
+
+          /**
+           * Converts a logical result's applied rules into `limit` {@link Determination} values.
+           *
+           * @remarks
+           * Fires for both the per-subject authority and the batch aggregate gates — both
+           * are plain {@link LogicalDefinition} definitions with no program-authored ruling map, so a
+           * fired rule's own `description` (from `@orkestrel/reason`) is the message
+           * template, interpolated against the working record the definition ran against.
+           * Rich premises reuse the qualifier's {@link ruleToPremises}. A rule that never
+           * fires produces no determination — program has no authored ruling map to keep
+           * evidence for.
+           *
+           * @param definition - The authority or aggregate-gate logical definition
+           * @param result - The evaluated logical result
+           * @param working - The working record the definition ran against
+           * @param evaluator - The shared reason check evaluator
+           * @param labels - Optional field-to-label overrides, keyed by dot-joined field
+           * @returns A fresh list of `limit` determinations
+           *
+           * @example
+           * ```ts
+           * import { buildLimitDeterminations } from '@orkestrel/program'
+           *
+           * buildLimitDeterminations(authority, resolved, outcome, evaluator)
+           * ```
+           */
+          export declare function buildLimitDeterminations(definition: LogicalDefinition, result: LogicalResult, working: Readonly<Record<string, unknown>>, evaluator: EvaluatorInterface, labels?: Readonly<Record<string, string>>): readonly Determination[];
+
+          /**
+           * Builds a fresh {@link Notice}.
+           *
+           * @param id - The notice id
+           * @param message - The message template, carrying optional `{{token}}` placeholders
+           * @param input - Optional presentation scope
+           * @returns A fresh notice
+           *
+           * @example
+           * ```ts
+           * import { buildNotice } from '@orkestrel/program'
+           *
+           * buildNotice('minimum', 'Minimum earned premium applies')
+           * ```
+           */
+          export declare function buildNotice(id: string, message: string, input?: NoticeInput): Notice;
+
           /**
+           * Resolves authored {@link Notice} values into unconditionally-applied `notice`
+           * {@link Determination} values.
+           *
            * @remarks
-           * Present ONLY when the program HAS an `authority`, the execution SUCCEEDED
-           * (qualification, rating when it ran, and authority all produced no errors),
+           * Notices are program output only — they never affect eligibility, status, line
+           * selection, or the decision. Each message interpolates against the original
+           * subject.
+           *
+           * @param notices - The authored notices
+           * @param subject - The original subject notices interpolate against
+           * @returns A fresh list of notice determinations
+           *
+           * @example
+           * ```ts
+           * import { buildNoticeDeterminations } from '@orkestrel/program'
+           *
+           * buildNoticeDeterminations([{ id: 'min', message: 'Minimum applies' }], { id: 'r1' })
+           * ```
+           */
+          export declare function buildNoticeDeterminations(notices: readonly Notice[], subject: Readonly<Record<string, unknown>>): readonly Determination[];
+
+          /**
+           * Builds the private authority outcome projection from an assembled program result.
+           *
+           * @remarks
+           * The authority reads this record under {@link OUTCOME_KEY}; it never receives
+           * the mutable internal state of either sibling engine. `total` is carried from
+           * the nested rating result when rating occurred.
+           *
+           * @param result - The preliminary program result computed before authority runs
+           * @returns A record shaped for the authority's `outcome` projection
+           *
+           * @example
+           * ```ts
+           * import { buildOutcomeProjection } from '@orkestrel/program'
+           *
+           * buildOutcomeProjection(result) // { id, eligibility, status, rated, scopes }
+           * ```
+           */
+          export declare function buildOutcomeProjection(result: ProgramResult): Readonly<Record<string, unknown>>;
+
+          /**
+           * Builds a fresh {@link ProgramDefinition}.
+           *
+           * @remarks
+           * Omits absent optional keys. `metadata` is deep-copied with `structuredClone`.
+           * `notices` is copied as a fresh array whose elements are shared with the
+           * input. `qualification`, `rating`, `authority`, and `aggregate` are stored
+           * by reference. The {@link Program} constructor later snapshots and seals
+           * the whole graph.
+           *
+           * @param id - The program id
+           * @param name - The display name
+           * @param qualification - The nested qualification definition
+           * @param rating - The nested rating definition; omit for an eligibility-only program
+           * @param input - Optional description, notices, authority, aggregate, and metadata
+           * @returns A fresh program definition
+           *
+           * @example
+           * ```ts
+           * import { buildProgramDefinition } from '@orkestrel/program'
+           *
+           * buildProgramDefinition('standard', 'Standard', qualification, rating, { notices: [notice] })
+           * ```
+           */
+          export declare function buildProgramDefinition(id: string, name: string, qualification: QualificationDefinition, rating?: RatingDefinition, input?: ProgramInput): ProgramDefinition;
+
+          /**
+           * Assembles a {@link ProgramResult} from its qualification, rating, and
+           * determination parts — before or after authority.
+           *
+           * @remarks
+           * `eligibility` mirrors the qualification. `success` is execution integrity: the
+           * qualification succeeded, rating (when it ran) succeeded, and authority (when it
+           * ran) produced no errors — a valid ineligible or referral outcome still
+           * succeeds. `trace` and `errors` accumulate the qualification's, every rated
+           * line's worksheet trail, and the authority's. A `decision` is present ONLY when
+           * an authority ran (`options.authority`), the execution SUCCEEDED (`success`),
            * no `limit` determination applied, and status is not `unrated`.
+           *
+           * @param definition - The authored program definition
+           * @param qualification - The subject's qualification result
+           * @param rating - The subject's rating result, when rating occurred
+           * @param determinations - The program-scoped determinations (notices, then limits)
+           * @param status - The already-derived status
+           * @param options - Optional authority result driving the decision projection
+           * @returns A fresh program result
+           *
+           * @example
+           * ```ts
+           * import { buildProgramResult } from '@orkestrel/program'
+           *
+           * buildProgramResult(definition, qualification, rating, [], 'eligible')
+           * ```
+           */
+          export declare function buildProgramResult(definition: ProgramDefinition, qualification: QualificationResult, rating: RatingResult | undefined, determinations: readonly Determination[], status: Status, options?: {
+              readonly authority?: LogicalResult;
+          }): ProgramResult;
+
+          /**
+           * Adds optional aggregate context to a private subject copy for qualification.
+           *
+           * @remarks
+           * The original subject is returned unchanged when no aggregate context exists.
+           * When context exists the helper creates a private copy under {@link AGGREGATE_KEY}
+           * and defensively copies every nested record — the rater still receives the
+           * original subject, never this copy.
+           *
+           * @param subject - The original caller subject
+           * @param aggregate - The subject's aggregate projection, when a batch supplies one
+           * @returns The subject, or a private copy carrying the aggregate projection
+           *
+           * @example
+           * ```ts
+           * import { buildQualificationSubject } from '@orkestrel/program'
+           *
+           * buildQualificationSubject({ id: 'r1' }) // { id: 'r1' }
+           * ```
+           */
+          export declare function buildQualificationSubject(subject: Subject, aggregate?: AggregateProjection): Subject;
+
+          /**
+           * Completes a partial status tally record with zero entries for every missing
+           * {@link Status}.
+           *
+           * @param entries - The partial tally entries to complete
+           * @returns A record carrying every {@link Status}
+           *
+           * @example
+           * ```ts
+           * import { completeTallies } from '@orkestrel/program'
+           *
+           * completeTallies({ eligible: { count: 1, sums: {} } })
+           * ```
+           */
+          export declare function completeTallies(entries: Partial<Record<Status, Tally>>): Readonly<Record<Status, Tally>>;
+
+          /**
+           * Creates one compiled program over a qualifier and rater.
+           *
+           * @remarks
+           * If `options.validate` is `true`, the program validates the definition at
+           * construction; if `false`, it compiles the definition unvalidated. Default:
+           * {@link DEFAULT_PROGRAM_VALIDATE}. A standalone program creates and
+           * OWNS one shared quantitative-plus-logical reason engine and injects it into the
+           * qualifier and rater it creates; injected dependencies remain caller-owned.
+           *
+           * @param definition - The authored program definition
+           * @param options - Optional injected qualifier, rater, engine, validation, labels, and emitter hooks
+           * @returns A {@link ProgramInterface}
+           *
+           * @example
+           * ```ts
+           * import { buildProgramDefinition, createProgram } from '@orkestrel/program'
+           *
+           * const definition = buildProgramDefinition('standard', 'Standard', qualification, rating)
+           * const program = createProgram(definition)
+           * program.execute({ id: 'risk-1' })
+           * program.destroy()
+           * ```
+           */
+          export declare function createProgram(definition: ProgramDefinition, options?: ProgramOptions): ProgramInterface;
+
+          /**
+           * Creates one ordered manager over compiled programs.
+           *
+           * @remarks
+           * Creates or borrows one shared reason engine, qualifier, and rater and injects
+           * them into every compiled program, so a batch of definitions shares one engine.
+           * Seed definitions are compiled in order.
+           *
+           * @param options - Optional injected qualifier, rater, engine, seed programs, validation, labels, and emitter hooks
+           * @returns A {@link ProgramManagerInterface}
+           *
+           * @example
+           * ```ts
+           * import { createProgramManager } from '@orkestrel/program'
+           *
+           * const manager = createProgramManager({ programs: [definition] })
+           * manager.program('standard')?.execute(subject)
+           * manager.destroy()
+           * ```
+           */
+          export declare function createProgramManager(options?: ProgramManagerOptions): ProgramManagerInterface;
+
+          /**
+           * Maps a global {@link Eligibility} to its deterministic authority {@link Decision}.
+           *
+           * @param eligibility - The global eligibility
+           * @returns The matching decision
+           *
+           * @example
+           * ```ts
+           * import { decideEligibility } from '@orkestrel/program'
+           *
+           * decideEligibility('eligible') // 'approved'
+           * decideEligibility('referral') // 'submitted'
+           * ```
+           */
+          export declare function decideEligibility(eligibility: Eligibility): Decision;
+
+          /** Identifies a final authority outcome, derived from global eligibility. */
+          export declare type Decision = 'approved' | 'denied' | 'submitted';
+
+          /** Names the default definition validation policy for `createProgram` / `ProgramManager.add`. */
+          export declare const DEFAULT_PROGRAM_VALIDATE = true;
+
+          /**
+           * Derives the final program {@link Status} from a definition's rating policy and
+           * qualification/rating evidence.
+           *
+           * @remarks
+           * Explicit policy, not an opaque precedence reduce: global
+           * ineligibility or referral is terminal; a scoped referral yields `referral`;
+           * an applied `condition` or an applied scoped `restriction` (a line was
+           * removed but others rated) is `conditional`. When the definition OMITS
+           * `rating` the program is eligibility-only — status resolves to `conditional`
+           * or `eligible` and is NEVER `unrated`. Otherwise a subject with no successful
+           * rating is `unrated`.
+           *
+           * @param definition - The authored program definition
+           * @param qualification - The subject's qualification result
+           * @param rating - The subject's rating result, when rating occurred
+           * @returns The derived status
+           *
+           * @example
+           * ```ts
+           * import { deriveStatus } from '@orkestrel/program'
+           *
+           * deriveStatus(definition, qualification, rating) // 'eligible'
+           * ```
+           */
+          export declare function deriveStatus(definition: ProgramDefinition, qualification: QualificationResult, rating?: RatingResult): Status;
+
+          /** Describes one resolved notice or authority-limit outcome. */
+          export declare interface Determination {
+              readonly id: string;
+              readonly effect: ProgramEffect;
+              readonly applied: boolean;
+              readonly scope?: string;
+              readonly message?: string;
+              readonly premises: readonly Premise[];
+          }
+
+          /** Maps each global eligibility to its deterministic authority decision. */
+          export declare const ELIGIBILITY_DECISIONS: Readonly<Record<Eligibility, Decision>>;
+
+          /**
+           * Returns authored scopes (qualification ruling scopes or notice scopes) that
+           * name no rating line on the program.
+           *
+           * @remarks
+           * A scope is an opaque string to the qualifier — program alone matches it to a
+           * rating-line id. A scope naming no line is a hard authoring error surfaced as
+           * {@link ProgramError} `'MISSING'` at construction, regardless of the validate
+           * option.
+           *
+           * @param definition - The program definition to check
+           * @returns A fresh, deduped list of missing scope references
+           *
+           * @example
+           * ```ts
+           * import { findMissingScopes } from '@orkestrel/program'
+           *
+           * findMissingScopes(definition) // []
+           * ```
+           */
+          export declare function findMissingScopes(definition: ProgramDefinition): readonly string[];
+
+          /**
+           * Coerces a subject's partition-key field to its group-key string.
+           *
+           * @remarks
+           * The key is the resolved field coerced with `String` — `undefined` collapses
+           * to the empty string, so a subject missing the field and a subject whose
+           * field is literally `''` land in the SAME partition, and a numeric `1`
+           * collides with the string `'1'`.
+           *
+           * @param subject - The subject to key
+           * @param partition - The field the batch partitions on
+           * @returns The subject's group key
+           *
+           * @example
+           * ```ts
+           * import { formatGroupKey } from '@orkestrel/program'
+           *
+           * formatGroupKey({ location: 'east' }, 'location') // 'east'
+           * ```
+           */
+          export declare function formatGroupKey(subject: Subject, partition: FieldPath): string;
+
+          /**
+           * Determines whether a caller subject already carries a reserved program key.
+           *
+           * @remarks
+           * `aggregate` and `outcome` are program-private working-subject namespaces — the
+           * batch aggregate projection and the authority outcome projection are written
+           * under them. A caller subject that already owns either key would silently
+           * collide with a projection, so it is rejected before qualification.
+           *
+           * @param subject - The caller subject to check
+           * @returns True if the subject owns `aggregate` or `outcome`; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { hasReservedKey } from '@orkestrel/program'
+           *
+           * hasReservedKey({ id: 'r1' }) // false
+           * hasReservedKey({ id: 'r1', aggregate: {} }) // true
+           * ```
+           */
+          export declare function hasReservedKey(subject: Readonly<Record<string, unknown>>): boolean;
+
+          /**
+           * Determines whether a value is an exact {@link AggregateDefinition} record.
+           *
+           * @param value - The candidate value
+           * @returns True if `value` is an {@link AggregateDefinition}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isAggregateDefinition } from '@orkestrel/program'
+           *
+           * isAggregateDefinition({ fields: ['amount'] }) // true
+           * ```
+           */
+          export declare function isAggregateDefinition(value: unknown): value is AggregateDefinition;
+
+          /**
+           * Determines whether a value is an open result-side {@link AggregateGroup}.
+           *
+           * @remarks
+           * Unknown members and class instances are admitted. Arrays are refused.
+           *
+           * @param value - The candidate value
+           * @returns True if every published aggregate-group member conforms; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isAggregateGroup } from '@orkestrel/program'
+           *
+           * isAggregateGroup({ key: 'east', count: 1, sums: { premium: 100 } }) // true
+           * ```
+           */
+          export declare const isAggregateGroup: Guard<AggregateGroup>;
+
+          /**
+           * Determines whether a value is an open {@link AggregateResult}.
+           *
+           * @remarks
+           * This guard is result-postured for values returned through a borrowed
+           * {@link ProgramInterface}. It admits unknown members and class instances while
+           * checking every nested program result, determination, group, total tally
+           * record, and sums record. Arrays are refused.
+           *
+           * @param value - The candidate value
+           * @returns True if every published aggregate-result member conforms; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isAggregateResult } from '@orkestrel/program'
+           *
+           * isAggregateResult(program.execute(subjects)) // true
+           * ```
+           */
+          export declare const isAggregateResult: Guard<AggregateResult>;
+
+          /**
+           * Determines whether a value is a {@link Decision} literal.
+           *
+           * @param value - The candidate value
+           * @returns True if `value` is a {@link Decision}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isDecision } from '@orkestrel/program'
+           *
+           * isDecision('approved') // true
+           * ```
+           */
+          export declare const isDecision: Guard<Decision>;
+
+          /**
+           * Determines whether a value is an open result-side {@link Determination}.
+           *
+           * @remarks
+           * Unknown members and class instances are admitted. Arrays are refused.
+           * Optional `scope` and `message` members may be absent or `undefined`.
+           *
+           * @param value - The candidate value
+           * @returns True if every published determination member conforms; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isDetermination } from '@orkestrel/program'
+           *
+           * isDetermination({ id: 'audit', effect: 'notice', applied: true, premises: [] }) // true
+           * ```
+           */
+          export declare const isDetermination: Guard<Determination>;
+
+          /**
+           * Determines whether a value is an exact {@link Notice} record.
+           *
+           * @param value - The candidate value
+           * @returns True if `value` is a {@link Notice}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isNotice } from '@orkestrel/program'
+           *
+           * isNotice({ id: 'minimum', message: 'Minimum applies' }) // true
+           * ```
+           */
+          export declare function isNotice(value: unknown): value is Notice;
+
+          /**
+           * Determines whether a value is an exact {@link ProgramDefinition} record.
+           *
+           * @remarks
+           * `rating` is optional — an omitted `rating` authors an eligibility-only
+           * program (see {@link ProgramDefinition}).
+           *
+           * @param value - The candidate value
+           * @returns True if `value` is a {@link ProgramDefinition}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isProgramDefinition } from '@orkestrel/program'
+           *
+           * isProgramDefinition({ id: 'p', name: 'P', qualification }) // true
+           * ```
+           */
+          export declare function isProgramDefinition(value: unknown): value is ProgramDefinition;
+
+          /**
+           * Determines whether a value is a {@link ProgramEffect} literal.
+           *
+           * @param value - The candidate value
+           * @returns True if `value` is a {@link ProgramEffect}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isProgramEffect } from '@orkestrel/program'
+           *
+           * isProgramEffect('notice') // true
+           * ```
+           */
+          export declare const isProgramEffect: Guard<ProgramEffect>;
+
+          /**
+           * Determines whether a caught value is a {@link ProgramError}.
+           *
+           * @param value - The candidate value
+           * @returns True if the value is a {@link ProgramError}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isProgramError, ProgramError } from '@orkestrel/program'
+           *
+           * isProgramError(new ProgramError('RESERVED', 'Subject carries a reserved key')) // true
+           * isProgramError(new Error('Subject carries a reserved key')) // false
+           * ```
+           */
+          export declare function isProgramError(value: unknown): value is ProgramError;
+
+          /**
+           * Determines whether a value is an open {@link ProgramResult}.
+           *
+           * @remarks
+           * This guard is result-postured for values returned through a borrowed
+           * {@link ProgramInterface}. It admits unknown members and class instances while
+           * composing qualifier's `isQualificationResult` and rater's `isRatingResult`
+           * over their complete nested result closures. Arrays are refused.
+           *
+           * @param value - The candidate value
+           * @returns True if every published program-result member conforms; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isProgramResult } from '@orkestrel/program'
+           *
+           * isProgramResult(program.execute(subject)) // true
+           * ```
+           */
+          export declare const isProgramResult: Guard<ProgramResult>;
+
+          /**
+           * Determines whether a value is an open program sums record.
+           *
+           * @remarks
+           * Every own string-named property is checked, including non-enumerable
+           * properties. Inherited and symbol-named members are outside the record this
+           * guard certifies. Values remain plain JavaScript numbers, including `NaN` and
+           * infinities, because the published contract does not refine them.
+           *
+           * @param value - The candidate value
+           * @returns True if every own string-named value is a number; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isProgramSums } from '@orkestrel/program'
+           *
+           * isProgramSums({ premium: 100 }) // true
+           * ```
+           */
+          export declare function isProgramSums(value: unknown): value is Readonly<Record<string, number>>;
+
+          /**
+           * Determines whether a value is an open {@link ProgramValidationResult}.
+           *
+           * @remarks
+           * `ProgramValidationResult` is this package's own declared interface, not an
+           * alias of reason's validation result. This guard therefore checks the
+           * program-owned members directly so the contracts may evolve independently.
+           * Unknown members and class instances are admitted. Arrays are refused.
+           *
+           * @param value - The candidate value
+           * @returns True if every published program-validation member conforms; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isProgramValidationResult } from '@orkestrel/program'
+           *
+           * isProgramValidationResult({ valid: true, errors: [], warnings: [] }) // true
+           * ```
+           */
+          export declare const isProgramValidationResult: Guard<ProgramValidationResult>;
+
+          /**
+           * Determines whether a value is a {@link Status} literal.
+           *
+           * @param value - The candidate value
+           * @returns True if `value` is a {@link Status}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isStatus } from '@orkestrel/program'
+           *
+           * isStatus('eligible') // true
+           * ```
+           */
+          export declare const isStatus: Guard<Status>;
+
+          /**
+           * Determines whether a value is a total open status-tally record.
+           *
+           * @remarks
+           * Every {@link Status} in {@link STATUSES} is required and checked.
+           * Unknown members and class instances are admitted. Arrays are refused.
+           *
+           * @param value - The candidate value
+           * @returns True if every required status member is a {@link Tally}; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { buildEmptyTallies, isTallies } from '@orkestrel/program'
+           *
+           * isTallies(buildEmptyTallies([])) // true
+           * ```
+           */
+          export declare function isTallies(value: unknown): value is Readonly<Record<Status, Tally>>;
+
+          /**
+           * Determines whether a value is an open result-side {@link Tally}.
+           *
+           * @remarks
+           * Unknown members and class instances are admitted. Arrays are refused.
+           *
+           * @param value - The candidate value
+           * @returns True if every published tally member conforms; false otherwise
+           *
+           * @example
+           * ```ts
+           * import { isTally } from '@orkestrel/program'
+           *
+           * isTally({ count: 1, sums: { premium: 100 } }) // true
+           * ```
+           */
+          export declare const isTally: Guard<Tally>;
+
+          /** Describes an authored, unconditional program notice. */
+          export declare interface Notice {
+              readonly id: string;
+              readonly message: string;
+              readonly scope?: string;
+          }
+
+          /**
+           * Describes the optional fields accepted by `buildNotice`.
+           *
+           * @remarks
+           * `scope` — the rating-line id the notice presents against; omitted for an
+           * unscoped, program-wide notice.
+           */
+          export declare interface NoticeInput {
+              readonly scope?: string;
+          }
+
+          /** Names the reserved working-subject key the authority's outcome projection is written under. */
+          export declare const OUTCOME_KEY = "outcome";
+
+          /**
+           * Composes one qualifier and one rater over a shared reason engine and executes
+           * single subjects or aggregate-aware batches.
+           *
+           * @remarks
+           * Qualification decides whether rating happens: a globally ineligible, referred,
+           * or failed subject never reaches the rater, and a scoped ineligibility removes
+           * only its line before the first rating call. The rater always receives the
+           * ORIGINAL subject; the qualifier's aggregate projection stays private. When no
+           * qualifier, rater, or engine is injected the program creates ONE shared
+           * quantitative-plus-logical engine, injects it into the qualifier and rater it
+           * creates, and destroys only what it owns. A definition failure during
+           * construction (an invalid definition under `options.validate`) tears down
+           * whatever the constructor had already allocated before throwing. Construction
+           * snapshots the caller's definition once, runs the always-on assertions against
+           * that snapshot, and seals its plain-object graph before exposure. A `Map`, `Set`,
+           * or `Date` reached through a reason `Check.value` is cloned but remains mutable
+           * because its contents live in internal slots. Uncloneable values and non-empty
+           * typed arrays are refused with `ProgramError('DEFINITION')` and the host error
+           * as its cause. `destroy()` is idempotent and REENTRANCY-SAFE — the destroyed
+           * flag is set BEFORE any teardown or the `destroy` event fires, so a listener
+           * that re-enters `destroy()` is a no-op — and tears the emitter down last.
            */
-          readonly decision?: Decision;
-          readonly qualification: QualificationResult;
-          readonly rating?: RatingResult;
-          readonly determinations: readonly Determination[];
-          readonly success: boolean;
-          readonly trace: readonly string[];
-          readonly errors: readonly string[];
-      }
-
-      /** Semantic definition validation. */
-      export declare interface ProgramValidationResult {
-          readonly valid: boolean;
-          readonly errors: readonly string[];
-          readonly warnings: readonly string[];
-      }
-
-      /**
-       * Select the rating lines a subject may be rated on from scoped eligibility.
-       *
-       * @remarks
-       * A scope names a rating-line id. A line survives when its scope is absent
-       * (eligible by default), `eligible`, or a `condition` (which is not an
-       * eligibility value and never appears here). A scoped `ineligible` or `referral`
-       * removes the line BEFORE the rater is invoked — the excluded line is never
-       * evaluated merely to discard its amount.
-       *
-       * @param lines - The program's authored rating lines
-       * @param scopes - The qualification's per-scope eligibility
-       * @returns The surviving line definitions, in authored order
-       *
-       * @example
-       * ```ts
-       * import { selectProgramLines } from '@orkestrel/program'
-       *
-       * selectProgramLines(lines, { wind: 'ineligible' }) // every line except 'wind'
-       * ```
-       */
-      export declare function selectProgramLines(lines: readonly LineDefinition[], scopes: Readonly<Record<string, Eligibility>>): readonly LineDefinition[];
-
-      /** The presentation and tally status derived from eligibility, conditions, and rating success. */
-      export declare type Status = 'ineligible' | 'referral' | 'conditional' | 'unrated' | 'eligible';
-
-      /** Status tally precedence order — least to most resolved. */
-      export declare const STATUS_PRECEDENCE: readonly Status[];
-
-      /**
-       * Fold one subject's finite aggregate field values into a sums record.
-       *
-       * @remarks
-       * Returns a FRESH record — `sums` is never mutated. Only finite numbers
-       * contribute; a non-numeric or absent value contributes zero (never a
-       * coercion). A {@link FieldPath} may be nested — `formatField` renders the
-       * dot-joined key the returned record is keyed by.
-       *
-       * @param sums - The sums record to fold into
-       * @param subject - The subject to fold in
-       * @param fields - The fields to sum
-       * @returns A fresh sums record with `subject`'s contribution added
-       *
-       * @example
-       * ```ts
-       * import { sumFields } from '@orkestrel/program'
-       *
-       * sumFields({ amount: 0 }, { amount: 5 }, ['amount']) // { amount: 5 }
-       * ```
-       */
-      export declare function sumFields(sums: Readonly<Record<string, number>>, subject: Subject, fields: readonly FieldPath[]): Readonly<Record<string, number>>;
-
-      /** A status tally — a count plus summed aggregate fields. */
-      export declare interface Tally {
-          readonly count: number;
-          readonly sums: Readonly<Record<string, number>>;
-      }
-
-      /**
-       * Add one subject's aggregate contribution to a status tally record.
-       *
-       * @param tallies - The tallies to update
-       * @param result - The subject's program result (its `status` selects the tally)
-       * @param subject - The subject to fold in
-       * @param fields - The fields to sum
-       * @returns A fresh, complete tally record with the subject folded in
-       *
-       * @example
-       * ```ts
-       * import { tallyProgram } from '@orkestrel/program'
-       *
-       * tallyProgram(tallies, result, { id: 'r1', amount: 5 }, ['amount'])
-       * ```
-       */
-      export declare function tallyProgram(tallies: Readonly<Record<Status, Tally>>, result: ProgramResult, subject: Subject, fields: readonly FieldPath[]): Readonly<Record<Status, Tally>>;
-
-      /**
-       * Validate a program definition's shape, references, and nested definitions.
-       *
-       * @remarks
-       * The single semantic-validation implementation used by `Program.validate`. It
-       * establishes exact shape through {@link isProgramDefinition}, validates the
-       * rating structurally through the rater's {@link isRatingDefinition} guard (the
-       * rater exposes no `validate`), delegates qualification validation to the
-       * injected qualifier and authority / aggregate-gate validation to the shared
-       * reason engine, and checks scope, notice, and aggregate-field references here.
-       *
-       * @param definition - The program definition to validate
-       * @param qualifier - The qualifier that validates the nested qualification
-       * @param engine - The reason engine that validates authority and aggregate gates
-       * @returns A structured validation result
-       *
-       * @example
-       * ```ts
-       * import { validateProgramDefinition } from '@orkestrel/program'
-       *
-       * validateProgramDefinition(definition, qualifier, engine) // { valid: true, ... }
-       * ```
-       */
-      export declare function validateProgramDefinition(definition: ProgramDefinition, qualifier: QualifierInterface, engine: ReasonInterface): ProgramValidationResult;
-
-      export { }
+          export declare class Program implements ProgramInterface {
+              #private;
+              /** Holds the authored id of the definition this program compiled. */
+              readonly id: string;
+              /** Holds the authored display name of the definition this program compiled. */
+              readonly name: string;
+              /** Holds the sealed snapshot of the authored definition this program compiled. */
+              readonly definition: ProgramDefinition;
+              /**
+               * Compiles one program from an authored definition.
+               *
+               * @param definition - The authored program definition
+               * @param options - Optional injected qualifier, rater, engine, validation, labels, and emitter hooks
+               * @throws {@link ProgramError} Thrown when the definition cannot be cloned or
+                   * sealed, or when validation is enabled and the definition fails
+                   * (`'DEFINITION'`).
+                   * @throws {@link ProgramError} Thrown when a ruling or notice scope names no
+                       * rating line (`'MISSING'`).
+                       * @throws {@link ProgramError} Thrown when the definition repeats a rating-line
+                           * or notice id (`'DUPLICATE'`).
+                           */
+                       constructor(definition: ProgramDefinition, options?: ProgramOptions);
+                       /**
+                        * Holds the typed observation surface carrying `qualify`, `rate`, `determine`,
+                        * `decide`, `execute`, `aggregate`, and `destroy`.
+                        *
+                        * @returns The emitter this program owns
+                        *
+                        * @example
+                        * ```ts
+                        * import { createProgram } from '@orkestrel/program'
+                        *
+                        * const program = createProgram(definition)
+                        * program.emitter.on('execute', (result) => result.status)
+                        * program.destroy()
+                        * ```
+                        */
+                       get emitter(): EmitterInterface<ProgramEventMap>;
+                       /**
+                        * Executes a subject list as one aggregate-aware batch.
+                        *
+                        * @remarks
+                        * Every subject is asserted before any work runs, so a reserved key in the last
+                        * subject rejects the batch before the first one qualifies. The batch sums,
+                        * partitions, and per-subject aggregate projections are computed next, each
+                        * subject executes in input order, every result tallies by status, and optional
+                        * aggregate gates run last against the batch aggregate record.
+                        *
+                        * @param subjects - The subjects to execute, in input order
+                        * @returns A fresh aggregate result carrying every subject result, the batch
+                        * determinations, partitions, tallies, and sums
+                        * @throws {@link ProgramError} Thrown when the program has been destroyed
+                            * (`'DESTROYED'`).
+                            * @throws {@link ProgramError} Thrown when a subject is not a record, or when a
+                                * borrowed qualifier, rater, or reason engine returns an off-contract result
+                                * (`'MISMATCH'`).
+                                * @throws {@link ProgramError} Thrown when a subject already carries the
+                                    * `aggregate` or `outcome` key (`'RESERVED'`).
+                                    *
+                                    * @example
+                                    * ```ts
+                                    * import { createProgram } from '@orkestrel/program'
+                                    *
+                                    * const program = createProgram(definition)
+                                    * program.execute([{ id: 'risk-1', licensed: true }]).count // 1
+                                    * program.destroy()
+                                    * ```
+                                    */
+                                execute(subjects: readonly Subject[]): AggregateResult;
+                                /**
+                                 * Executes one subject through the composed qualify-rate-determine workflow.
+                                 *
+                                 * @remarks
+                                 * Qualification decides whether rating happens: a globally ineligible, referred,
+                                 * or failed subject never reaches the rater, and a scoped ineligibility removes
+                                 * only its line before the first rating call. The rater always receives the
+                                 * ORIGINAL subject. Notices, status, optional authority, and the optional
+                                 * decision follow, in that order.
+                                 *
+                                 * @param subject - The subject to execute
+                                 * @returns A fresh program result carrying the nested qualification and rating
+                                 * evidence, determinations, status, and optional decision
+                                 * @throws {@link ProgramError} Thrown when the program has been destroyed
+                                     * (`'DESTROYED'`).
+                                     * @throws {@link ProgramError} Thrown when the subject is not a record, or when a
+                                         * borrowed qualifier, rater, or reason engine returns an off-contract result
+                                         * (`'MISMATCH'`).
+                                         * @throws {@link ProgramError} Thrown when the subject already carries the
+                                             * `aggregate` or `outcome` key (`'RESERVED'`).
+                                             *
+                                             * @example
+                                             * ```ts
+                                             * import { createProgram } from '@orkestrel/program'
+                                             *
+                                             * const program = createProgram(definition)
+                                             * program.execute({ id: 'risk-1', licensed: true }).status // 'eligible'
+                                             * program.destroy()
+                                             * ```
+                                             */
+                                         execute(subject: Subject): ProgramResult;
+                                         /**
+                                          * Validates this program's definition and every nested definition.
+                                          *
+                                          * @remarks
+                                          * Exact shape is `isProgramDefinition`'s job. This checks the meaning: non-empty id
+                                          * and name, every ruling and notice scope naming a rating line, unique non-empty
+                                          * aggregate fields, and a non-empty partition field when present. Nested
+                                          * qualification validation is delegated to the injected qualifier, and authority
+                                          * and aggregate-gate validation to the shared reason engine.
+                                          *
+                                          * @returns A fresh validation result carrying `valid`, `errors`, and `warnings`
+                                          * @throws {@link ProgramError} Thrown when the program has been destroyed
+                                              * (`'DESTROYED'`).
+                                              *
+                                              * @example
+                                              * ```ts
+                                              * import { createProgram } from '@orkestrel/program'
+                                              *
+                                              * const program = createProgram(definition, { validate: false })
+                                              * program.validate().valid // true
+                                              * program.destroy()
+                                              * ```
+                                              */
+                                          validate(): ProgramValidationResult;
+                                          /**
+                                           * Destroys this program, idempotently.
+                                           *
+                                           * @remarks
+                                           * The destroyed flag is set BEFORE any teardown or the `destroy` event, so a
+                                           * listener re-entering `destroy` is a no-op. An owned qualifier, rater, and reason
+                                           * engine are destroyed; an injected one stays caller-owned. The emitter is torn
+                                           * down last, and stays reachable afterwards.
+                                           *
+                                           * @example
+                                           * ```ts
+                                           * import { createProgram } from '@orkestrel/program'
+                                           *
+                                           * const program = createProgram(definition)
+                                           * program.destroy()
+                                           * program.destroy() // a second call is a no-op
+                                           * ```
+                                           */
+                                          destroy(): void;
+                                         }
+
+                                         /**
+                                          * Describes a pure authored program definition.
+                                          *
+                                          * @remarks
+                                          * `qualification` runs first through `@orkestrel/qualifier`; `rating` runs only
+                                          * over the lines scoped eligibility left standing, through `@orkestrel/rater`.
+                                          * `authority` (a logical definition) runs last, over the assembled result
+                                          * extended with an outcome projection, to derive limit determinations and the
+                                          * final decision. An omitted `rating` authors an ELIGIBILITY-ONLY program — the
+                                          * rater is never invoked, an eligible subject resolves to `'eligible'` (or
+                                          * `'conditional'` under an applied condition or scoped restriction), status is
+                                          * never `'unrated'`, and decisions remain reachable through `authority`. Program
+                                          * construction clones the definition and seals its plain-object graph. A `Map`,
+                                          * `Set`, or `Date` reached through a reason `Check.value` is cloned, but its
+                                          * contents remain mutable because the seal cannot reach its internal slots. A
+                                          * value that structured cloning cannot copy, or a non-empty typed array that
+                                          * cannot be frozen, is refused with `ProgramError('DEFINITION')` and the host
+                                          * error attached as its cause.
+                                          */
+                                         export declare interface ProgramDefinition {
+                                             readonly id: string;
+                                             readonly name: string;
+                                             readonly description?: string;
+                                             readonly qualification: QualificationDefinition;
+                                             readonly rating?: RatingDefinition;
+                                             readonly notices?: readonly Notice[];
+                                             readonly authority?: LogicalDefinition;
+                                             readonly aggregate?: AggregateDefinition;
+                                             readonly metadata?: JSONValue;
+                                         }
+
+                                         /** Identifies a post-qualification program determination effect. */
+                                         export declare type ProgramEffect = 'notice' | 'limit';
+
+                                         /**
+                                          * Reports a coded programmer error thrown by the program layer.
+                                          *
+                                          * @remarks
+                                          * `DUPLICATE` — a program id collision on `ProgramManager.add`, or a duplicate
+                                          * authored rating-line or notice id. `MISSING` — an
+                                          * authored notice or qualification ruling scope names no rating line.
+                                          * `DEFINITION` — a program, qualification, rating, authority, or aggregate
+                                          * policy failed validation. `MISMATCH` — an injected entity or a returned
+                                          * reason result has the wrong contract. `RESERVED` — a subject already
+                                          * carries `aggregate` or `outcome`. `DESTROYED` — use of a destroyed entity.
+                                          *
+                                          * @example
+                                          * ```ts
+                                          * import { ProgramError } from '@orkestrel/program'
+                                          *
+                                          * const error = new ProgramError('RESERVED', 'Subject carries a reserved key', 'aggregate')
+                                          * error.code // 'RESERVED'
+                                          * ```
+                                          */
+                                         export declare class ProgramError extends Error {
+                                             readonly code: ProgramErrorCode;
+                                             readonly context?: unknown;
+                                             /**
+                                              * Creates a coded program error.
+                                              *
+                                              * @param code - The machine-readable failure category
+                                              * @param message - The human-readable failure description
+                                              * @param context - Optional structured context for the failure
+                                              * @param cause - Optional underlying value the failure wraps
+                                              */
+                                             constructor(code: ProgramErrorCode, message: string, context?: unknown, cause?: unknown);
+                                         }
+
+                                         /** Identifies a coded {@link ProgramError} programmer-error code. */
+                                         export declare type ProgramErrorCode = 'DUPLICATE' | 'MISSING' | 'DEFINITION' | 'MISMATCH' | 'RESERVED' | 'DESTROYED';
+
+                                         /**
+                                          * Describes the push observation surface of a {@link ProgramInterface}.
+                                          *
+                                          * @remarks
+                                          * `rate` fires only when at least one line was selected. `determine` fires once
+                                          * per notice, then once per applied limit. `decide` fires only when a decision
+                                          * was reached.
+                                          */
+                                         export declare type ProgramEventMap = {
+                                             readonly qualify: readonly [result: QualificationResult];
+                                             readonly rate: readonly [result: RatingResult];
+                                             readonly determine: readonly [result: Determination];
+                                             readonly decide: readonly [decision: Decision, result: ProgramResult];
+                                             readonly execute: readonly [result: ProgramResult];
+                                             readonly aggregate: readonly [result: AggregateResult];
+                                             readonly destroy: readonly [];
+                                         };
+
+                                         /**
+                                          * Describes the optional fields accepted by `buildProgramDefinition`.
+                                          *
+                                          * @remarks
+                                          * `description` — a free-text summary. `notices` — authored unconditional
+                                          * notices. `authority` — a logical definition evaluated per subject to derive
+                                          * limit determinations and the decision. `aggregate` — batch aggregate fields,
+                                          * partition field, and gates. `metadata` — opaque caller data, copied fresh.
+                                          */
+                                         export declare interface ProgramInput {
+                                             readonly description?: string;
+                                             readonly notices?: readonly Notice[];
+                                             readonly authority?: LogicalDefinition;
+                                             readonly aggregate?: AggregateDefinition;
+                                             readonly metadata?: JSONValue;
+                                         }
+
+                                         /**
+                                          * Defines one compiled program that composes one qualifier and one rater over a
+                                          * shared reason engine.
+                                          */
+                                         export declare interface ProgramInterface {
+                                             /** Holds the authored id of the definition this program compiled. */
+                                             readonly id: string;
+                                             /** Holds the authored display name of the definition this program compiled. */
+                                             readonly name: string;
+                                             /** Holds the sealed snapshot of the authored definition this program compiled. */
+                                             readonly definition: ProgramDefinition;
+                                             /**
+                                              * Holds the typed observation surface carrying `qualify`, `rate`, `determine`,
+                                              * `decide`, `execute`, `aggregate`, and `destroy`.
+                                              */
+                                             readonly emitter: EmitterInterface<ProgramEventMap>;
+                                             /**
+                                              * Executes a subject list as one aggregate-aware batch.
+                                              *
+                                              * @remarks
+                                              * Every subject is asserted before any work runs, so a reserved key in the last
+                                              * subject rejects the batch before the first one qualifies. The batch sums,
+                                              * partitions, and per-subject aggregate projections are computed next, each
+                                              * subject executes in input order, every result tallies by status, and optional
+                                              * aggregate gates run last against the batch aggregate record.
+                                              *
+                                              * @param subjects - The subjects to execute, in input order
+                                              * @returns A fresh aggregate result carrying every subject result, the batch
+                                              * determinations, partitions, tallies, and sums
+                                              * @throws {@link ProgramError} Thrown when the program has been destroyed
+                                                  * (`'DESTROYED'`).
+                                                  * @throws {@link ProgramError} Thrown when a subject is not a record, or when a
+                                                      * borrowed qualifier, rater, or reason engine returns an off-contract result
+                                                      * (`'MISMATCH'`).
+                                                      * @throws {@link ProgramError} Thrown when a subject already carries the
+                                                          * `aggregate` or `outcome` key (`'RESERVED'`).
+                                                          *
+                                                          * @example
+                                                          * ```ts
+                                                          * import { createProgram } from '@orkestrel/program'
+                                                          *
+                                                          * const program = createProgram(definition)
+                                                          * program.execute([{ id: 'risk-1', licensed: true }]).count // 1
+                                                          * program.destroy()
+                                                          * ```
+                                                          */
+                                                      execute(subjects: readonly Subject[]): AggregateResult;
+                                                      /**
+                                                       * Executes one subject through the composed qualify-rate-determine workflow.
+                                                       *
+                                                       * @remarks
+                                                       * Qualification decides whether rating happens: a globally ineligible, referred,
+                                                       * or failed subject never reaches the rater, and a scoped ineligibility removes
+                                                       * only its line before the first rating call. The rater always receives the
+                                                       * ORIGINAL subject. Notices, status, optional authority, and the optional
+                                                       * decision follow, in that order.
+                                                       *
+                                                       * @param subject - The subject to execute
+                                                       * @returns A fresh program result carrying the nested qualification and rating
+                                                       * evidence, determinations, status, and optional decision
+                                                       * @throws {@link ProgramError} Thrown when the program has been destroyed
+                                                           * (`'DESTROYED'`).
+                                                           * @throws {@link ProgramError} Thrown when the subject is not a record, or when a
+                                                               * borrowed qualifier, rater, or reason engine returns an off-contract result
+                                                               * (`'MISMATCH'`).
+                                                               * @throws {@link ProgramError} Thrown when the subject already carries the
+                                                                   * `aggregate` or `outcome` key (`'RESERVED'`).
+                                                                   *
+                                                                   * @example
+                                                                   * ```ts
+                                                                   * import { createProgram } from '@orkestrel/program'
+                                                                   *
+                                                                   * const program = createProgram(definition)
+                                                                   * program.execute({ id: 'risk-1', licensed: true }).status // 'eligible'
+                                                                   * program.destroy()
+                                                                   * ```
+                                                                   */
+                                                               execute(subject: Subject): ProgramResult;
+                                                               /**
+                                                                * Validates this program's definition and every nested definition.
+                                                                *
+                                                                * @remarks
+                                                                * Exact shape is `isProgramDefinition`'s job. This checks the meaning: non-empty id
+                                                                * and name, every ruling and notice scope naming a rating line, unique non-empty
+                                                                * aggregate fields, and a non-empty partition field when present. Nested
+                                                                * qualification validation is delegated to the injected qualifier, and authority
+                                                                * and aggregate-gate validation to the shared reason engine.
+                                                                *
+                                                                * @returns A fresh validation result carrying `valid`, `errors`, and `warnings`
+                                                                * @throws {@link ProgramError} Thrown when the program has been destroyed
+                                                                    * (`'DESTROYED'`).
+                                                                    *
+                                                                    * @example
+                                                                    * ```ts
+                                                                    * import { createProgram } from '@orkestrel/program'
+                                                                    *
+                                                                    * const program = createProgram(definition, { validate: false })
+                                                                    * program.validate().valid // true
+                                                                    * program.destroy()
+                                                                    * ```
+                                                                    */
+                                                                validate(): ProgramValidationResult;
+                                                                /**
+                                                                 * Destroys this program, idempotently.
+                                                                 *
+                                                                 * @remarks
+                                                                 * The destroyed flag is set BEFORE any teardown or the `destroy` event, so a
+                                                                 * listener re-entering `destroy` is a no-op. An owned qualifier, rater, and reason
+                                                                 * engine are destroyed; an injected one stays caller-owned. The emitter is torn
+                                                                 * down last, and stays reachable afterwards.
+                                                                 *
+                                                                 * @example
+                                                                 * ```ts
+                                                                 * import { createProgram } from '@orkestrel/program'
+                                                                 *
+                                                                 * const program = createProgram(definition)
+                                                                 * program.destroy()
+                                                                 * program.destroy() // a second call is a no-op
+                                                                 * ```
+                                                                 */
+                                                                destroy(): void;
+                                                               }
+
+                                                               /**
+                                                                * Manages compiled {@link ProgramInterface} programs in order, sharing one
+                                                                * qualifier, rater, and reason engine across every program it compiles.
+                                                                *
+                                                                * @remarks
+                                                                * OWNS its ordered `#programs` collection and its own {@link Emitter} over
+                                                                * {@link ProgramManagerEventMap}. Creates or borrows one shared engine, qualifier,
+                                                                * and rater and injects the same instances into every compiled program. `remove`
+                                                                * destroys the programs it removes; `destroy()` removes all programs, then
+                                                                * destroys only the owned shared dependencies, and tears the emitter down LAST.
+                                                                * A seed-program failure during construction tears the manager down (destroying
+                                                                * whatever had already been compiled) before rethrowing the original error.
+                                                                * `destroy()` is REENTRANCY-SAFE — the destroyed flag is set BEFORE any teardown
+                                                                * or the `remove` / `destroy` events fire, so a `remove` listener that re-enters
+                                                                * `destroy()` is a no-op. Every call after `destroy()` throws {@link ProgramError}
+                                                                * `'DESTROYED'`.
+                                                                */
+                                                               export declare class ProgramManager implements ProgramManagerInterface {
+                                                                   #private;
+                                                                   /**
+                                                                    * Creates one manager and compiles every seed definition in order.
+                                                                    *
+                                                                    * @param options - Optional injected qualifier, rater, engine, seed programs, validation, labels, and emitter hooks
+                                                                    * @throws {@link ProgramError} Thrown when a seed definition fails to compile,
+                                                                        * after the manager destroys whatever it had already compiled.
+                                                                        */
+                                                                    constructor(options?: ProgramManagerOptions);
+                                                                    /**
+                                                                     * Holds the typed observation surface carrying `add`, `remove`, and `destroy`.
+                                                                     *
+                                                                     * @returns The emitter this manager owns
+                                                                     *
+                                                                     * @example
+                                                                     * ```ts
+                                                                     * import { createProgramManager } from '@orkestrel/program'
+                                                                     *
+                                                                     * const manager = createProgramManager()
+                                                                     * manager.emitter.on('add', (id) => id)
+                                                                     * manager.destroy()
+                                                                     * ```
+                                                                     */
+                                                                    get emitter(): EmitterInterface<ProgramManagerEventMap>;
+                                                                    /**
+                                                                     * Holds how many programs the manager has compiled.
+                                                                     *
+                                                                     * @returns The number of compiled programs
+                                                                     * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                         * (`'DESTROYED'`).
+                                                                         *
+                                                                         * @example
+                                                                         * ```ts
+                                                                         * import { createProgramManager } from '@orkestrel/program'
+                                                                         *
+                                                                         * const manager = createProgramManager({ programs: [definition] })
+                                                                         * manager.count // 1
+                                                                         * manager.destroy()
+                                                                         * ```
+                                                                         */
+                                                                     get count(): number;
+                                                                     /**
+                                                                      * Reports whether an id names a compiled program.
+                                                                      *
+                                                                      * @param id - The program id to look for
+                                                                      * @returns True if a compiled program carries the id; false otherwise
+                                                                      * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                          * (`'DESTROYED'`).
+                                                                          *
+                                                                          * @example
+                                                                          * ```ts
+                                                                          * import { createProgramManager } from '@orkestrel/program'
+                                                                          *
+                                                                          * const manager = createProgramManager({ programs: [definition] })
+                                                                          * manager.has('standard') // true
+                                                                          * manager.destroy()
+                                                                          * ```
+                                                                          */
+                                                                      has(id: string): boolean;
+                                                                      /**
+                                                                       * Looks one compiled program up by id.
+                                                                       *
+                                                                       * @param id - The program id to look up
+                                                                       * @returns The compiled program, or `undefined` when no program carries the id
+                                                                       * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                           * (`'DESTROYED'`).
+                                                                           *
+                                                                           * @example
+                                                                           * ```ts
+                                                                           * import { createProgramManager } from '@orkestrel/program'
+                                                                           *
+                                                                           * const manager = createProgramManager({ programs: [definition] })
+                                                                           * manager.program('standard')?.execute({ id: 'risk-1', licensed: true })
+                                                                           * manager.destroy()
+                                                                           * ```
+                                                                           */
+                                                                       program(id: string): ProgramInterface | undefined;
+                                                                       /**
+                                                                        * Returns every compiled program, in insertion order.
+                                                                        *
+                                                                        * @remarks
+                                                                        * The returned array is a fresh copy, so mutating it never reaches the manager's
+                                                                        * own collection.
+                                                                        *
+                                                                        * @returns A fresh array of compiled programs, in insertion order
+                                                                        * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                            * (`'DESTROYED'`).
+                                                                            *
+                                                                            * @example
+                                                                            * ```ts
+                                                                            * import { createProgramManager } from '@orkestrel/program'
+                                                                            *
+                                                                            * const manager = createProgramManager({ programs: [definition] })
+                                                                            * manager.programs().map((program) => program.id) // ['standard']
+                                                                            * manager.destroy()
+                                                                            * ```
+                                                                            */
+                                                                        programs(): readonly ProgramInterface[];
+                                                                        /**
+                                                                         * Compiles one definition and appends it to the collection.
+                                                                         *
+                                                                         * @remarks
+                                                                         * The compiled program borrows the manager's shared qualifier, rater, and reason
+                                                                         * engine, and inherits the manager's `validate` and `labels` options. After
+                                                                         * appending the program, the `add` event fires with its id.
+                                                                         *
+                                                                         * @param definition - The authored program definition to compile
+                                                                         * @returns The compiled program
+                                                                         * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                             * (`'DESTROYED'`).
+                                                                             * @throws {@link ProgramError} Thrown when the manager already carries the
+                                                                                 * definition's id, or the definition repeats a rating-line or notice id
+                                                                                 * (`'DUPLICATE'`).
+                                                                                 * @throws {@link ProgramError} Thrown when a ruling or notice scope names no
+                                                                                     * rating line (`'MISSING'`).
+                                                                                     * @throws {@link ProgramError} Thrown when validation is enabled and the
+                                                                                         * definition fails (`'DEFINITION'`).
+                                                                                         *
+                                                                                         * @example
+                                                                                         * ```ts
+                                                                                         * import { createProgramManager } from '@orkestrel/program'
+                                                                                         *
+                                                                                         * const manager = createProgramManager()
+                                                                                         * manager.add(definition).id // 'standard'
+                                                                                         * manager.destroy()
+                                                                                         * ```
+                                                                                         */
+                                                                                     add(definition: ProgramDefinition): ProgramInterface;
+                                                                                     /**
+                                                                                      * Removes every listed id, destroying each removed program.
+                                                                                      *
+                                                                                      * @remarks
+                                                                                      * Every id is attempted, so one absent id does not stop the rest. Each removal
+                                                                                      * destroys its program and fires `remove` with that id. An empty list succeeds
+                                                                                      * vacuously.
+                                                                                      *
+                                                                                      * @param ids - The program ids to remove
+                                                                                      * @returns True if every listed id named a compiled program; false otherwise
+                                                                                      * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                          * (`'DESTROYED'`).
+                                                                                          *
+                                                                                          * @example
+                                                                                          * ```ts
+                                                                                          * import { createProgramManager } from '@orkestrel/program'
+                                                                                          *
+                                                                                          * const manager = createProgramManager({ programs: [definition] })
+                                                                                          * manager.remove(['standard', 'absent']) // false
+                                                                                          * manager.destroy()
+                                                                                          * ```
+                                                                                          */
+                                                                                      remove(ids: readonly string[]): boolean;
+                                                                                      /**
+                                                                                       * Removes one id, destroying the program it named.
+                                                                                       *
+                                                                                       * @param id - The program id to remove
+                                                                                       * @returns True if the id named a compiled program; false otherwise
+                                                                                       * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                           * (`'DESTROYED'`).
+                                                                                           *
+                                                                                           * @example
+                                                                                           * ```ts
+                                                                                           * import { createProgramManager } from '@orkestrel/program'
+                                                                                           *
+                                                                                           * const manager = createProgramManager({ programs: [definition] })
+                                                                                           * manager.remove('standard') // true
+                                                                                           * manager.destroy()
+                                                                                           * ```
+                                                                                           */
+                                                                                       remove(id: string): boolean;
+                                                                                       /**
+                                                                                        * Removes every compiled program, destroying each one.
+                                                                                        *
+                                                                                        * @remarks
+                                                                                        * Each removal fires `remove` with that program's id. The manager itself stays
+                                                                                        * usable, so a later `add` compiles into the drained collection.
+                                                                                        *
+                                                                                        * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                            * (`'DESTROYED'`).
+                                                                                            *
+                                                                                            * @example
+                                                                                            * ```ts
+                                                                                            * import { createProgramManager } from '@orkestrel/program'
+                                                                                            *
+                                                                                            * const manager = createProgramManager({ programs: [definition] })
+                                                                                            * manager.remove()
+                                                                                            * manager.destroy()
+                                                                                            * ```
+                                                                                            */
+                                                                                        remove(): void;
+                                                                                        /**
+                                                                                         * Destroys this manager, idempotently.
+                                                                                         *
+                                                                                         * @remarks
+                                                                                         * The destroyed flag is set BEFORE any teardown or the `remove` and `destroy`
+                                                                                         * events, so a `remove` listener re-entering `destroy` is a no-op. Compiled
+                                                                                         * programs are destroyed first, then an owned qualifier, rater, and reason engine;
+                                                                                         * an injected one stays caller-owned. The emitter is torn down last, and stays
+                                                                                         * reachable afterwards.
+                                                                                         *
+                                                                                         * @example
+                                                                                         * ```ts
+                                                                                         * import { createProgramManager } from '@orkestrel/program'
+                                                                                         *
+                                                                                         * const manager = createProgramManager({ programs: [definition] })
+                                                                                         * manager.destroy()
+                                                                                         * manager.destroy() // a second call is a no-op
+                                                                                         * ```
+                                                                                         */
+                                                                                        destroy(): void;
+                                                                                       }
+
+                                                                                       /** Describes the push observation surface of a {@link ProgramManagerInterface}. */
+                                                                                       export declare type ProgramManagerEventMap = {
+                                                                                           readonly add: readonly [id: string];
+                                                                                           readonly remove: readonly [id: string];
+                                                                                           readonly destroy: readonly [];
+                                                                                       };
+
+                                                                                       /** Defines an ordered manager over compiled programs, sharing one qualifier and rater. */
+                                                                                       export declare interface ProgramManagerInterface {
+                                                                                           /**
+                                                                                            * Holds the typed observation surface carrying `add`, `remove`, and `destroy`.
+                                                                                            */
+                                                                                           readonly emitter: EmitterInterface<ProgramManagerEventMap>;
+                                                                                           /**
+                                                                                            * Holds how many programs the manager has compiled.
+                                                                                            *
+                                                                                            * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                * (`'DESTROYED'`).
+                                                                                                */
+                                                                                            readonly count: number;
+                                                                                            /**
+                                                                                             * Reports whether an id names a compiled program.
+                                                                                             *
+                                                                                             * @param id - The program id to look for
+                                                                                             * @returns True if a compiled program carries the id; false otherwise
+                                                                                             * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                 * (`'DESTROYED'`).
+                                                                                                 *
+                                                                                                 * @example
+                                                                                                 * ```ts
+                                                                                                 * import { createProgramManager } from '@orkestrel/program'
+                                                                                                 *
+                                                                                                 * const manager = createProgramManager({ programs: [definition] })
+                                                                                                 * manager.has('standard') // true
+                                                                                                 * manager.destroy()
+                                                                                                 * ```
+                                                                                                 */
+                                                                                             has(id: string): boolean;
+                                                                                             /**
+                                                                                              * Looks one compiled program up by id.
+                                                                                              *
+                                                                                              * @param id - The program id to look up
+                                                                                              * @returns The compiled program, or `undefined` when no program carries the id
+                                                                                              * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                  * (`'DESTROYED'`).
+                                                                                                  *
+                                                                                                  * @example
+                                                                                                  * ```ts
+                                                                                                  * import { createProgramManager } from '@orkestrel/program'
+                                                                                                  *
+                                                                                                  * const manager = createProgramManager({ programs: [definition] })
+                                                                                                  * manager.program('standard')?.execute({ id: 'risk-1', licensed: true })
+                                                                                                  * manager.destroy()
+                                                                                                  * ```
+                                                                                                  */
+                                                                                              program(id: string): ProgramInterface | undefined;
+                                                                                              /**
+                                                                                               * Returns every compiled program, in insertion order.
+                                                                                               *
+                                                                                               * @remarks
+                                                                                               * The returned array is a fresh copy, so mutating it never reaches the manager's
+                                                                                               * own collection.
+                                                                                               *
+                                                                                               * @returns A fresh array of compiled programs, in insertion order
+                                                                                               * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                   * (`'DESTROYED'`).
+                                                                                                   *
+                                                                                                   * @example
+                                                                                                   * ```ts
+                                                                                                   * import { createProgramManager } from '@orkestrel/program'
+                                                                                                   *
+                                                                                                   * const manager = createProgramManager({ programs: [definition] })
+                                                                                                   * manager.programs().map((program) => program.id) // ['standard']
+                                                                                                   * manager.destroy()
+                                                                                                   * ```
+                                                                                                   */
+                                                                                               programs(): readonly ProgramInterface[];
+                                                                                               /**
+                                                                                                * Compiles one definition and appends it to the collection.
+                                                                                                *
+                                                                                                * @remarks
+                                                                                                * The compiled program borrows the manager's shared qualifier, rater, and reason
+                                                                                                * engine, and inherits the manager's `validate` and `labels` options. After
+                                                                                                * appending the program, the `add` event fires with its id.
+                                                                                                *
+                                                                                                * @param definition - The authored program definition to compile
+                                                                                                * @returns The compiled program
+                                                                                                * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                    * (`'DESTROYED'`).
+                                                                                                    * @throws {@link ProgramError} Thrown when the manager already carries the
+                                                                                                        * definition's id, or the definition repeats a rating-line or notice id
+                                                                                                        * (`'DUPLICATE'`).
+                                                                                                        * @throws {@link ProgramError} Thrown when a ruling or notice scope names no
+                                                                                                            * rating line (`'MISSING'`).
+                                                                                                            * @throws {@link ProgramError} Thrown when validation is enabled and the
+                                                                                                                * definition fails (`'DEFINITION'`).
+                                                                                                                *
+                                                                                                                * @example
+                                                                                                                * ```ts
+                                                                                                                * import { createProgramManager } from '@orkestrel/program'
+                                                                                                                *
+                                                                                                                * const manager = createProgramManager()
+                                                                                                                * manager.add(definition).id // 'standard'
+                                                                                                                * manager.destroy()
+                                                                                                                * ```
+                                                                                                                */
+                                                                                                            add(definition: ProgramDefinition): ProgramInterface;
+                                                                                                            /**
+                                                                                                             * Removes every listed id, destroying each removed program.
+                                                                                                             *
+                                                                                                             * @remarks
+                                                                                                             * Every id is attempted, so one absent id does not stop the rest. Each removal
+                                                                                                             * destroys its program and fires `remove` with that id. An empty list succeeds
+                                                                                                             * vacuously.
+                                                                                                             *
+                                                                                                             * @param ids - The program ids to remove
+                                                                                                             * @returns True if every listed id named a compiled program; false otherwise
+                                                                                                             * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                                 * (`'DESTROYED'`).
+                                                                                                                 *
+                                                                                                                 * @example
+                                                                                                                 * ```ts
+                                                                                                                 * import { createProgramManager } from '@orkestrel/program'
+                                                                                                                 *
+                                                                                                                 * const manager = createProgramManager({ programs: [definition] })
+                                                                                                                 * manager.remove(['standard', 'absent']) // false
+                                                                                                                 * manager.destroy()
+                                                                                                                 * ```
+                                                                                                                 */
+                                                                                                             remove(ids: readonly string[]): boolean;
+                                                                                                             /**
+                                                                                                              * Removes one id, destroying the program it named.
+                                                                                                              *
+                                                                                                              * @param id - The program id to remove
+                                                                                                              * @returns True if the id named a compiled program; false otherwise
+                                                                                                              * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                                  * (`'DESTROYED'`).
+                                                                                                                  *
+                                                                                                                  * @example
+                                                                                                                  * ```ts
+                                                                                                                  * import { createProgramManager } from '@orkestrel/program'
+                                                                                                                  *
+                                                                                                                  * const manager = createProgramManager({ programs: [definition] })
+                                                                                                                  * manager.remove('standard') // true
+                                                                                                                  * manager.destroy()
+                                                                                                                  * ```
+                                                                                                                  */
+                                                                                                              remove(id: string): boolean;
+                                                                                                              /**
+                                                                                                               * Removes every compiled program, destroying each one.
+                                                                                                               *
+                                                                                                               * @remarks
+                                                                                                               * Each removal fires `remove` with that program's id. The manager itself stays
+                                                                                                               * usable, so a later `add` compiles into the drained collection.
+                                                                                                               *
+                                                                                                               * @throws {@link ProgramError} Thrown when the manager has been destroyed
+                                                                                                                   * (`'DESTROYED'`).
+                                                                                                                   *
+                                                                                                                   * @example
+                                                                                                                   * ```ts
+                                                                                                                   * import { createProgramManager } from '@orkestrel/program'
+                                                                                                                   *
+                                                                                                                   * const manager = createProgramManager({ programs: [definition] })
+                                                                                                                   * manager.remove()
+                                                                                                                   * manager.destroy()
+                                                                                                                   * ```
+                                                                                                                   */
+                                                                                                               remove(): void;
+                                                                                                               /**
+                                                                                                                * Destroys this manager, idempotently.
+                                                                                                                *
+                                                                                                                * @remarks
+                                                                                                                * The destroyed flag is set BEFORE any teardown or the `remove` and `destroy`
+                                                                                                                * events, so a `remove` listener re-entering `destroy` is a no-op. Compiled
+                                                                                                                * programs are destroyed first, then an owned qualifier, rater, and reason engine;
+                                                                                                                * an injected one stays caller-owned. The emitter is torn down last, and stays
+                                                                                                                * reachable afterwards.
+                                                                                                                *
+                                                                                                                * @example
+                                                                                                                * ```ts
+                                                                                                                * import { createProgramManager } from '@orkestrel/program'
+                                                                                                                *
+                                                                                                                * const manager = createProgramManager({ programs: [definition] })
+                                                                                                                * manager.destroy()
+                                                                                                                * manager.destroy() // a second call is a no-op
+                                                                                                                * ```
+                                                                                                                */
+                                                                                                               destroy(): void;
+                                                                                                              }
+
+                                                                                                              /**
+                                                                                                               * Describes the options for `createProgramManager` / the `ProgramManager` constructor.
+                                                                                                               *
+                                                                                                               * @remarks
+                                                                                                               * `qualifier` — an injected, caller-owned qualifier; created and owned when
+                                                                                                               * omitted. `rater` — an injected, caller-owned rater; created and owned when
+                                                                                                               * omitted. `engine` — an injected, caller-owned reason engine; created and
+                                                                                                               * owned when omitted. `programs` — seed definitions compiled in order.
+                                                                                                               * `validate` — if `true`, the manager validates each seeded and added
+                                                                                                               * definition; if `false`, it compiles each definition unvalidated.
+                                                                                                               * Default: {@link DEFAULT_PROGRAM_VALIDATE}. `labels` — field-to-label
+                                                                                                               * overrides for determination premises, keyed by dot-joined field. `on` —
+                                                                                                               * initial emitter hooks. `error` — the emitter's listener-error handler.
+                                                                                                               */
+                                                                                                              export declare interface ProgramManagerOptions {
+                                                                                                                  readonly qualifier?: QualifierInterface;
+                                                                                                                  readonly rater?: RaterInterface;
+                                                                                                                  readonly engine?: ReasonInterface;
+                                                                                                                  readonly programs?: readonly ProgramDefinition[];
+                                                                                                                  readonly validate?: boolean;
+                                                                                                                  readonly labels?: Readonly<Record<string, string>>;
+                                                                                                                  readonly on?: EmitterHooks<ProgramManagerEventMap>;
+                                                                                                                  readonly error?: EmitterErrorHandler;
+                                                                                                              }
+
+                                                                                                              /**
+                                                                                                               * Describes the options for `createProgram` / the `Program` constructor.
+                                                                                                               *
+                                                                                                               * @remarks
+                                                                                                               * `qualifier` — an injected, caller-owned qualifier; created and owned by the
+                                                                                                               * program when omitted. `rater` — an injected, caller-owned rater; created and
+                                                                                                               * owned when omitted. `engine` — an injected, caller-owned reason engine;
+                                                                                                               * created and owned when omitted. `validate` — if `true`, the program validates
+                                                                                                               * the definition at construction; if `false`, it compiles the definition
+                                                                                                               * unvalidated. Default: {@link DEFAULT_PROGRAM_VALIDATE}. `labels` —
+                                                                                                               * field-to-label overrides for determination premises, keyed by dot-joined
+                                                                                                               * field. `on` — initial emitter hooks. `error` — the emitter's listener-error
+                                                                                                               * handler.
+                                                                                                               */
+                                                                                                              export declare interface ProgramOptions {
+                                                                                                                  readonly qualifier?: QualifierInterface;
+                                                                                                                  readonly rater?: RaterInterface;
+                                                                                                                  readonly engine?: ReasonInterface;
+                                                                                                                  readonly validate?: boolean;
+                                                                                                                  readonly labels?: Readonly<Record<string, string>>;
+                                                                                                                  readonly on?: EmitterHooks<ProgramEventMap>;
+                                                                                                                  readonly error?: EmitterErrorHandler;
+                                                                                                              }
+
+                                                                                                              /** Describes one subject's complete program outcome. */
+                                                                                                              export declare interface ProgramResult {
+                                                                                                                  readonly id: string;
+                                                                                                                  readonly name: string;
+                                                                                                                  readonly eligibility: Eligibility;
+                                                                                                                  readonly status: Status;
+                                                                                                                  /**
+                                                                                                                   * Holds the final authority outcome.
+                                                                                                                   *
+                                                                                                                   * @remarks
+                                                                                                                   * Present ONLY when the program HAS an `authority`, the execution SUCCEEDED
+                                                                                                                   * (qualification, rating when it ran, and authority all produced no errors),
+                                                                                                                   * no `limit` determination applied, and status is not `unrated`.
+                                                                                                                   */
+                                                                                                                  readonly decision?: Decision;
+                                                                                                                  readonly qualification: QualificationResult;
+                                                                                                                  readonly rating?: RatingResult;
+                                                                                                                  readonly determinations: readonly Determination[];
+                                                                                                                  readonly success: boolean;
+                                                                                                                  readonly trace: readonly string[];
+                                                                                                                  readonly errors: readonly string[];
+                                                                                                              }
+
+                                                                                                              /** Describes semantic definition validation. */
+                                                                                                              export declare interface ProgramValidationResult {
+                                                                                                                  readonly valid: boolean;
+                                                                                                                  readonly errors: readonly string[];
+                                                                                                                  readonly warnings: readonly string[];
+                                                                                                              }
+
+                                                                                                              /**
+                                                                                                               * Selects the rating lines a subject may be rated on from scoped eligibility.
+                                                                                                               *
+                                                                                                               * @remarks
+                                                                                                               * A scope names a rating-line id. A line survives when its scope is absent
+                                                                                                               * (eligible by default), `eligible`, or a `condition` (which is not an
+                                                                                                               * eligibility value and never appears here). A scoped `ineligible` or `referral`
+                                                                                                               * removes the line BEFORE the rater is invoked — the excluded line is never
+                                                                                                               * evaluated merely to discard its amount.
+                                                                                                               *
+                                                                                                               * @param lines - The program's authored rating lines
+                                                                                                               * @param scopes - The qualification's per-scope eligibility
+                                                                                                               * @returns The surviving line definitions, in authored order
+                                                                                                               *
+                                                                                                               * @example
+                                                                                                               * ```ts
+                                                                                                               * import { selectProgramLines } from '@orkestrel/program'
+                                                                                                               *
+                                                                                                               * selectProgramLines(lines, { wind: 'ineligible' }) // every line except 'wind'
+                                                                                                               * ```
+                                                                                                               */
+                                                                                                              export declare function selectProgramLines(lines: readonly LineDefinition[], scopes: Readonly<Record<string, Eligibility>>): readonly LineDefinition[];
+
+                                                                                                              /** Identifies the presentation and tally status derived from eligibility, conditions, and rating success. */
+                                                                                                              export declare type Status = (typeof STATUSES)[number];
+
+                                                                                                              /** Lists every {@link Status} literal — the source the union and its guard derive from. */
+                                                                                                              export declare const STATUSES: readonly ["ineligible", "referral", "conditional", "unrated", "eligible"];
+
+                                                                                                              /**
+                                                                                                               * Folds one subject's finite aggregate field values into a sums record.
+                                                                                                               *
+                                                                                                               * @remarks
+                                                                                                               * Returns a FRESH record — `sums` is never mutated. Only finite numbers
+                                                                                                               * contribute; a non-numeric or absent value contributes zero (never a
+                                                                                                               * coercion). A {@link FieldPath} may be nested — `formatField` renders the
+                                                                                                               * dot-joined key the returned record is keyed by.
+                                                                                                               *
+                                                                                                               * @param sums - The sums record to fold into
+                                                                                                               * @param subject - The subject to fold in
+                                                                                                               * @param fields - The fields to sum
+                                                                                                               * @returns A fresh sums record with `subject`'s contribution added
+                                                                                                               *
+                                                                                                               * @example
+                                                                                                               * ```ts
+                                                                                                               * import { sumFields } from '@orkestrel/program'
+                                                                                                               *
+                                                                                                               * sumFields({ amount: 0 }, { amount: 5 }, ['amount']) // { amount: 5 }
+                                                                                                               * ```
+                                                                                                               */
+                                                                                                              export declare function sumFields(sums: Readonly<Record<string, number>>, subject: Subject, fields: readonly FieldPath[]): Readonly<Record<string, number>>;
+
+                                                                                                              /** Describes a status tally — a count plus summed aggregate fields. */
+                                                                                                              export declare interface Tally {
+                                                                                                                  readonly count: number;
+                                                                                                                  readonly sums: Readonly<Record<string, number>>;
+                                                                                                              }
+
+                                                                                                              /**
+                                                                                                               * Adds one subject's aggregate contribution to a status tally record.
+                                                                                                               *
+                                                                                                               * @param tallies - The tallies to update
+                                                                                                               * @param result - The subject's program result (its `status` selects the tally)
+                                                                                                               * @param subject - The subject to fold in
+                                                                                                               * @param fields - The fields to sum
+                                                                                                               * @returns A fresh, complete tally record with the subject folded in
+                                                                                                               *
+                                                                                                               * @example
+                                                                                                               * ```ts
+                                                                                                               * import { tallySubject } from '@orkestrel/program'
+                                                                                                               *
+                                                                                                               * tallySubject(tallies, result, { id: 'r1', amount: 5 }, ['amount'])
+                                                                                                               * ```
+                                                                                                               */
+                                                                                                              export declare function tallySubject(tallies: Readonly<Record<Status, Tally>>, result: ProgramResult, subject: Subject, fields: readonly FieldPath[]): Readonly<Record<Status, Tally>>;
+
+                                                                                                              /**
+                                                                                                               * Validates a program definition's shape, references, and nested definitions.
+                                                                                                               *
+                                                                                                               * @remarks
+                                                                                                               * The single semantic-validation implementation used by `Program.validate`. It
+                                                                                                               * establishes exact shape through {@link isProgramDefinition}, validates the
+                                                                                                               * rating structurally through the rater's {@link isRatingDefinition} guard (the
+                                                                                                               * rater exposes no `validate`), delegates qualification validation to the
+                                                                                                               * injected qualifier and authority / aggregate-gate validation to the shared
+                                                                                                               * reason engine, and checks scope, notice, and aggregate-field references here.
+                                                                                                               *
+                                                                                                               * @param definition - The program definition to validate
+                                                                                                               * @param qualifier - The qualifier that validates the nested qualification
+                                                                                                               * @param engine - The reason engine that validates authority and aggregate gates
+                                                                                                               * @returns A structured validation result
+                                                                                                               *
+                                                                                                               * @example
+                                                                                                               * ```ts
+                                                                                                               * import { validateProgramDefinition } from '@orkestrel/program'
+                                                                                                               *
+                                                                                                               * validateProgramDefinition(definition, qualifier, engine) // { valid: true, ... }
+                                                                                                               * ```
+                                                                                                               */
+                                                                                                              export declare function validateProgramDefinition(definition: ProgramDefinition, qualifier: QualifierInterface, engine: ReasonInterface): ProgramValidationResult;
+
+                                                                                                              export { }