@orkestrel/program 0.0.1

package/dist/src/core/index.js

@@ -0,0 +1,1390 @@
+import { arrayOf, isArray, isFiniteNumber, isJSONValue, isRecord, isString, literalOf, recordOf, resolveField } from "@orkestrel/contract";
+import { createQualifier, findRule, interpolateMessage, isQualificationDefinition, logicalPremises } from "@orkestrel/qualifier";
+import { createRater, isRatingDefinition } from "@orkestrel/rater";
+import { createEvaluator, createLogicalReasoner, createQuantitativeReasoner, createReason, findDuplicates, formatField, isFieldPath, isLogicalDefinition } from "@orkestrel/reason";
+import { Emitter } from "@orkestrel/emitter";
+//#region src/core/constants.ts
+/** Default definition validation policy for `createProgram` / `ProgramManager.add`. */
+var DEFAULT_PROGRAM_VALIDATE = true;
+/** Status tally precedence order — least to most resolved. */
+var STATUS_PRECEDENCE = Object.freeze([
+	"ineligible",
+	"referral",
+	"conditional",
+	"unrated",
+	"eligible"
+]);
+/** The deterministic authority decision for each global eligibility. */
+var ELIGIBILITY_DECISIONS = Object.freeze({
+	eligible: "approved",
+	ineligible: "denied",
+	referral: "submitted"
+});
+/** The reserved working-subject key a batch's aggregate projection is written under. */
+var AGGREGATE_KEY = "aggregate";
+/** The reserved working-subject key the authority's outcome projection is written under. */
+var OUTCOME_KEY = "outcome";
+//#endregion
+//#region src/core/errors.ts
+/**
+* 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.
+*/
+var ProgramError = class extends Error {
+	code;
+	context;
+	constructor(code, message, context) {
+		super(message);
+		this.name = "ProgramError";
+		this.code = code;
+		this.context = context;
+	}
+};
+/** Narrow a caught value to a {@link ProgramError}. */
+function isProgramError(value) {
+	return value instanceof ProgramError;
+}
+//#endregion
+//#region src/core/validators.ts
+/**
+* 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
+* ```
+*/
+var isDecision = literalOf("approved", "denied", "submitted");
+/**
+* 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
+* ```
+*/
+var isStatus = literalOf("ineligible", "referral", "conditional", "unrated", "eligible");
+/**
+* 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
+* ```
+*/
+var isProgramEffect = literalOf("notice", "limit");
+/**
+* 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
+* ```
+*/
+function isNotice(value) {
+	return recordOf({
+		id: isString,
+		message: isString,
+		scope: isString
+	}, ["scope"])(value);
+}
+/**
+* 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
+* ```
+*/
+function isAggregateDefinition(value) {
+	return recordOf({
+		fields: arrayOf(isFieldPath),
+		by: isFieldPath,
+		gates: isLogicalDefinition
+	}, ["by", "gates"])(value);
+}
+/**
+* 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
+* ```
+*/
+function isProgramDefinition(value) {
+	return recordOf({
+		id: isString,
+		name: isString,
+		description: isString,
+		qualification: isQualificationDefinition,
+		rating: isRatingDefinition,
+		notices: arrayOf(isNotice),
+		authority: isLogicalDefinition,
+		aggregate: isAggregateDefinition,
+		metadata: isJSONValue
+	}, [
+		"description",
+		"rating",
+		"notices",
+		"authority",
+		"aggregate",
+		"metadata"
+	])(value);
+}
+//#endregion
+//#region src/core/helpers.ts
+/**
+* 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
+* ```
+*/
+function copyJSONValue(value) {
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(copyJSONValue);
+	const copy = {};
+	for (const [key, entry] of Object.entries(value)) Object.defineProperty(copy, key, {
+		value: copyJSONValue(entry),
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return copy;
+}
+/**
+* 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
+* ```
+*/
+function hasReservedKey(subject) {
+	return Object.hasOwn(subject, "aggregate") || Object.hasOwn(subject, "outcome");
+}
+/**
+* Assert 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
+* ```
+*/
+function assertProgramSubject(subject) {
+	if (!isRecord(subject)) throw new ProgramError("MISMATCH", "Program subject must be a record");
+	if (hasReservedKey(subject)) {
+		const key = Object.hasOwn(subject, "aggregate") ? AGGREGATE_KEY : OUTCOME_KEY;
+		throw new ProgramError("RESERVED", `Subject contains a reserved program key '${key}'`, key);
+	}
+}
+/**
+* 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'
+* ```
+*/
+function selectProgramLines(lines, scopes) {
+	return lines.filter((line) => {
+		const eligibility = scopes[line.id];
+		return eligibility !== "ineligible" && eligibility !== "referral";
+	});
+}
+/**
+* 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'
+* ```
+*/
+function deriveStatus(definition, qualification, rating) {
+	if (qualification.eligibility === "ineligible") return "ineligible";
+	if (qualification.eligibility === "referral") return "referral";
+	if (Object.values(qualification.scopes).includes("referral")) return "referral";
+	const conditional = qualification.findings.some((finding) => finding.applied && (finding.effect === "condition" || finding.scope !== void 0 && finding.effect === "restriction"));
+	if (definition.rating === void 0) return conditional ? "conditional" : "eligible";
+	if (rating === void 0 || rating.lines.length === 0 || !rating.success) return "unrated";
+	return conditional ? "conditional" : "eligible";
+}
+/**
+* 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'
+* ```
+*/
+function decideEligibility(eligibility) {
+	return ELIGIBILITY_DECISIONS[eligibility];
+}
+/**
+* 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' })
+* ```
+*/
+function buildNotices(notices, subject) {
+	return notices.map((notice) => ({
+		id: notice.id,
+		effect: "notice",
+		applied: true,
+		...notice.scope === void 0 ? {} : { scope: notice.scope },
+		message: interpolateMessage(notice.message, subject),
+		premises: []
+	}));
+}
+/**
+* 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)
+* ```
+*/
+function buildLimits(definition, result, working, evaluator, labels) {
+	const output = [];
+	for (const entry of result.rules) {
+		if (!entry.applied) continue;
+		const rule = findRule(definition, entry.id);
+		if (rule === void 0) continue;
+		output.push({
+			id: entry.id,
+			effect: "limit",
+			applied: true,
+			...rule.description === void 0 ? {} : { message: interpolateMessage(rule.description, working) },
+			premises: logicalPremises(rule, working, evaluator, labels)
+		});
+	}
+	return output;
+}
+/**
+* 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 }
+* ```
+*/
+function buildOutcomeProjection(result) {
+	const total = result.rating?.total;
+	return {
+		id: result.id,
+		eligibility: result.eligibility,
+		status: result.status,
+		rated: result.rating !== void 0,
+		...total === void 0 ? {} : { total },
+		scopes: { ...result.qualification.scopes }
+	};
+}
+/**
+* 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')
+* ```
+*/
+function buildProgramResult(definition, qualification, rating, determinations, status, options) {
+	const authority = options?.authority;
+	const ratingTrace = rating === void 0 ? [] : rating.lines.flatMap((line) => line.worksheet.trace);
+	const ratingErrors = rating === void 0 ? [] : rating.lines.flatMap((line) => line.worksheet.errors);
+	const authorityTrace = authority === void 0 ? [] : [...authority.trace];
+	const authorityErrors = authority === void 0 ? [] : [...authority.errors];
+	const trace = [
+		...qualification.trace,
+		...ratingTrace,
+		...authorityTrace
+	];
+	const errors = [
+		...qualification.errors,
+		...ratingErrors,
+		...authorityErrors
+	];
+	const success = qualification.success && (rating === void 0 || rating.success) && authorityErrors.length === 0;
+	const limited = determinations.some((entry) => entry.effect === "limit" && entry.applied);
+	const decision = authority !== void 0 && success && !limited && status !== "unrated" ? decideEligibility(qualification.eligibility) : void 0;
+	return {
+		id: definition.id,
+		name: definition.name,
+		eligibility: qualification.eligibility,
+		status,
+		...decision === void 0 ? {} : { decision },
+		qualification,
+		...rating === void 0 ? {} : { rating },
+		determinations,
+		success,
+		trace,
+		errors
+	};
+}
+/**
+* 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' }
+* ```
+*/
+function buildQualificationSubject(subject, aggregate) {
+	if (aggregate === void 0) return subject;
+	return {
+		...subject,
+		[AGGREGATE_KEY]: {
+			count: aggregate.count,
+			sums: { ...aggregate.sums },
+			...aggregate.group === void 0 ? {} : { group: {
+				key: aggregate.group.key,
+				count: aggregate.group.count,
+				sums: { ...aggregate.group.sums }
+			} }
+		}
+	};
+}
+/**
+* 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) // []
+* ```
+*/
+function findMissingScopes(definition) {
+	const ids = new Set((definition.rating?.lines ?? []).map((line) => line.id));
+	const missing = /* @__PURE__ */ new Set();
+	for (const ruling of definition.qualification.rulings ?? []) if (ruling.scope !== void 0 && !ids.has(ruling.scope)) missing.add(ruling.scope);
+	for (const notice of definition.notices ?? []) if (notice.scope !== void 0 && !ids.has(notice.scope)) missing.add(notice.scope);
+	return [...missing];
+}
+/**
+* Assert a program definition's always-on construction invariants — missing
+* scope references and duplicate rating-line or notice ids.
+*
+* @remarks
+* These checks run at construction regardless of `options.validate` (unlike
+* {@link validateProgramDefinition}, the standalone report-shaped validator) —
+* 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
+*
+* @example
+* ```ts
+* import { assertProgramDefinition } from '@orkestrel/program'
+*
+* assertProgramDefinition(definition) // does not throw
+* ```
+*/
+function assertProgramDefinition(definition) {
+	const missing = findMissingScopes(definition);
+	if (missing.length > 0) throw new ProgramError("MISSING", `Unknown rating line reference: ${missing.join(", ")}`, definition.id);
+	const duplicateLines = findDuplicates(definition.rating?.lines ?? []);
+	if (duplicateLines.length > 0) throw new ProgramError("DUPLICATE", `Duplicate rating line id: ${duplicateLines.join(", ")}`, definition.id);
+	const duplicateNotices = findDuplicates(definition.notices ?? []);
+	if (duplicateNotices.length > 0) throw new ProgramError("DUPLICATE", `Duplicate notice id: ${duplicateNotices.join(", ")}`, definition.id);
+}
+/**
+* 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, ... }
+* ```
+*/
+function validateProgramDefinition(definition, qualifier, engine) {
+	if (!isProgramDefinition(definition)) return {
+		valid: false,
+		errors: ["Program definition has an invalid shape"],
+		warnings: []
+	};
+	const errors = [];
+	const warnings = [];
+	if (definition.id.length === 0) errors.push("Program id must not be empty");
+	if (definition.name.length === 0) errors.push("Program name must not be empty");
+	const qualification = qualifier.validate(definition.qualification);
+	errors.push(...qualification.errors.map((error) => `qualification: ${error}`));
+	warnings.push(...qualification.warnings.map((warning) => `qualification: ${warning}`));
+	const lines = new Set((definition.rating?.lines ?? []).map((line) => line.id));
+	if (definition.rating !== void 0 && lines.size !== definition.rating.lines.length) errors.push("rating: duplicate line id");
+	for (const ruling of definition.qualification.rulings ?? []) if (ruling.scope !== void 0 && !lines.has(ruling.scope)) errors.push(`Qualification ruling "${ruling.id}" references missing line "${ruling.scope}"`);
+	const notices = /* @__PURE__ */ new Set();
+	for (const notice of definition.notices ?? []) {
+		if (notices.has(notice.id)) errors.push(`Duplicate notice id "${notice.id}"`);
+		notices.add(notice.id);
+		if (notice.scope !== void 0 && !lines.has(notice.scope)) errors.push(`Notice "${notice.id}" references missing line "${notice.scope}"`);
+	}
+	const authority = definition.authority;
+	if (authority !== void 0) {
+		const validation = engine.validate(authority);
+		errors.push(...validation.errors.map((error) => `authority: ${error}`));
+		warnings.push(...validation.warnings.map((warning) => `authority: ${warning}`));
+	}
+	const aggregate = definition.aggregate;
+	if (aggregate !== void 0) {
+		const fields = /* @__PURE__ */ new Set();
+		for (const field of aggregate.fields) {
+			const key = formatField(field);
+			if (key.length === 0) errors.push("Aggregate fields must be non-empty");
+			if (fields.has(key)) errors.push(`Duplicate aggregate field "${key}"`);
+			fields.add(key);
+		}
+		if (aggregate.by !== void 0 && formatField(aggregate.by).length === 0) errors.push("Aggregate partition field must be non-empty");
+		if (aggregate.gates !== void 0) {
+			const validation = engine.validate(aggregate.gates);
+			errors.push(...validation.errors.map((error) => `aggregate: ${error}`));
+			warnings.push(...validation.warnings.map((warning) => `aggregate: ${warning}`));
+			if (aggregate.fields.length === 0) warnings.push("Aggregate gates are defined without aggregate fields");
+		}
+	}
+	if (definition.rating !== void 0 && definition.rating.lines.length === 0) warnings.push("Program rating has no lines");
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+/**
+* 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'
+* ```
+*/
+function formatGroupKey(subject, by) {
+	return String(resolveField(subject, by) ?? "");
+}
+/**
+* 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 }
+* ```
+*/
+function sumFields(sums, subject, fields) {
+	const next = { ...sums };
+	for (const field of fields) {
+		const key = formatField(field);
+		const value = resolveField(subject, field);
+		if (isFiniteNumber(value)) next[key] = (next[key] ?? 0) + value;
+	}
+	return next;
+}
+/**
+* Sum aggregate fields across a batch of subjects.
+*
+* @remarks
+* A {@link FieldPath} may be nested — a nested path sums a nested subject field
+* exactly like a top-level one, and `formatField` renders the dot-joined key the
+* returned record is keyed by. Only finite numbers contribute; a non-numeric or
+* absent value contributes zero (never a coercion).
+*
+* @param subjects - The batch of subjects
+* @param fields - The fields to sum
+* @returns A fresh record of dot-joined field to summed finite value
+*
+* @example
+* ```ts
+* import { aggregateSums } from '@orkestrel/program'
+*
+* aggregateSums([{ amount: 5 }, { amount: 3 }], ['amount']) // { amount: 8 }
+* ```
+*/
+function aggregateSums(subjects, fields) {
+	let sums = emptySums(fields);
+	for (const subject of subjects) sums = sumFields(sums, subject, fields);
+	return sums;
+}
+/**
+* Partition a batch of subjects by a field, summing aggregate fields per key.
+*
+* @remarks
+* The partition key is derived by {@link formatGroupKey}. Group order follows
+* first appearance in the subject array.
+*
+* @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
+*
+* @example
+* ```ts
+* import { aggregateGroups } from '@orkestrel/program'
+*
+* aggregateGroups([{ location: 'east', amount: 5 }], ['amount'], 'location')
+* ```
+*/
+function aggregateGroups(subjects, fields, by) {
+	if (by === void 0) return [];
+	const records = /* @__PURE__ */ new Map();
+	for (const subject of subjects) {
+		const key = formatGroupKey(subject, by);
+		const group = records.get(key);
+		if (group === void 0) records.set(key, [subject]);
+		else group.push(subject);
+	}
+	return [...records.entries()].map(([key, entries]) => ({
+		key,
+		count: entries.length,
+		sums: aggregateSums(entries, fields)
+	}));
+}
+/**
+* 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')
+* ```
+*/
+function buildAggregateProjection(subject, count, sums, groups, by) {
+	const group = by === void 0 ? void 0 : groups.find((entry) => entry.key === formatGroupKey(subject, by));
+	return {
+		count,
+		sums: { ...sums },
+		...group === void 0 ? {} : { group }
+	};
+}
+/**
+* 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 }, [])
+* ```
+*/
+function buildAggregateRecord(count, sums, groups) {
+	return { [AGGREGATE_KEY]: {
+		count,
+		sums,
+		groups
+	} };
+}
+/**
+* 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 }
+* ```
+*/
+function emptySums(fields) {
+	const sums = {};
+	for (const field of fields) sums[formatField(field)] = 0;
+	return sums;
+}
+/**
+* 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: {} } })
+* ```
+*/
+function completeTallies(entries) {
+	return {
+		ineligible: entries.ineligible ?? {
+			count: 0,
+			sums: {}
+		},
+		referral: entries.referral ?? {
+			count: 0,
+			sums: {}
+		},
+		conditional: entries.conditional ?? {
+			count: 0,
+			sums: {}
+		},
+		unrated: entries.unrated ?? {
+			count: 0,
+			sums: {}
+		},
+		eligible: entries.eligible ?? {
+			count: 0,
+			sums: {}
+		}
+	};
+}
+/**
+* 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'])
+* ```
+*/
+function emptyTallies(fields) {
+	const entries = {};
+	for (const status of STATUS_PRECEDENCE) entries[status] = {
+		count: 0,
+		sums: emptySums(fields)
+	};
+	return completeTallies(entries);
+}
+/**
+* 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'])
+* ```
+*/
+function tallyProgram(tallies, result, subject, fields) {
+	const status = result.status;
+	const current = tallies[status];
+	const sums = sumFields(current.sums, subject, fields);
+	return completeTallies({
+		...tallies,
+		[status]: {
+			count: current.count + 1,
+			sums
+		}
+	});
+}
+/**
+* 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 })
+* ```
+*/
+function buildAggregateResult(definition, subjects, determinations, groups, tallies, sums, options) {
+	const gates = options?.gates;
+	const gateTrace = gates === void 0 ? [] : [...gates.trace];
+	const gateErrors = gates === void 0 ? [] : [...gates.errors];
+	return {
+		id: definition.id,
+		name: definition.name,
+		subjects,
+		determinations,
+		groups,
+		tallies,
+		count: subjects.length,
+		sums,
+		success: subjects.every((entry) => entry.success) && gateErrors.length === 0,
+		trace: [...subjects.flatMap((entry) => entry.trace), ...gateTrace],
+		errors: [...subjects.flatMap((entry) => entry.errors), ...gateErrors]
+	};
+}
+//#endregion
+//#region src/core/programs/Program.ts
+/**
+* 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. `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.
+*/
+var Program = class {
+	#emitter;
+	#qualifier;
+	#rater;
+	#engine;
+	#evaluator;
+	#qualifierOwned;
+	#raterOwned;
+	#engineOwned;
+	#validate;
+	#labels;
+	#destroyed = false;
+	id;
+	name;
+	definition;
+	constructor(definition, options) {
+		assertProgramDefinition(definition);
+		this.id = definition.id;
+		this.name = definition.name;
+		this.definition = definition;
+		this.#emitter = new Emitter({
+			on: options?.on,
+			error: options?.error
+		});
+		this.#evaluator = createEvaluator();
+		this.#engineOwned = options?.engine === void 0;
+		this.#qualifierOwned = options?.qualifier === void 0;
+		this.#raterOwned = options?.rater === void 0;
+		this.#engine = options?.engine ?? createReason({
+			reasoners: [createQuantitativeReasoner(), createLogicalReasoner()],
+			bail: false
+		});
+		this.#qualifier = options?.qualifier ?? createQualifier({ engine: this.#engine });
+		this.#rater = options?.rater ?? createRater({ engine: this.#engine });
+		this.#validate = options?.validate ?? true;
+		this.#labels = options?.labels;
+		if (this.#validate) {
+			const validation = this.validate();
+			if (!validation.valid) {
+				this.destroy();
+				throw new ProgramError("DEFINITION", validation.errors.join("; "), definition.id);
+			}
+		}
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	execute(input) {
+		this.#alive();
+		if (isArray(input)) return this.#aggregate(input);
+		return this.#subject(input);
+	}
+	validate() {
+		this.#alive();
+		return validateProgramDefinition(this.definition, this.#qualifier, this.#engine);
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		if (this.#qualifierOwned) this.#qualifier.destroy();
+		if (this.#raterOwned) this.#rater.destroy();
+		if (this.#engineOwned) this.#engine.destroy();
+		this.#emitter.emit("destroy");
+		this.#emitter.destroy();
+	}
+	#subject(subject, aggregate) {
+		assertProgramSubject(subject);
+		const qualified = buildQualificationSubject(subject, aggregate);
+		const qualification = this.#qualifier.qualify(qualified, this.definition.qualification);
+		this.#emitter.emit("qualify", qualification);
+		if (!qualification.success || qualification.eligibility !== "eligible") return this.#finish(subject, qualification, void 0);
+		const lines = selectProgramLines(this.definition.rating?.lines ?? [], qualification.scopes);
+		const rating = lines.length === 0 ? void 0 : this.#rater.rate(lines, subject);
+		if (rating !== void 0) this.#emitter.emit("rate", rating);
+		return this.#finish(subject, qualification, rating);
+	}
+	#finish(subject, qualification, rating) {
+		const notices = buildNotices(this.definition.notices ?? [], subject);
+		for (const notice of notices) this.#emitter.emit("determine", notice);
+		const status = deriveStatus(this.definition, qualification, rating);
+		let result = buildProgramResult(this.definition, qualification, rating, notices, status);
+		const authority = this.definition.authority;
+		if (authority === void 0) {
+			this.#emitter.emit("execute", result);
+			return result;
+		}
+		const outcome = { [OUTCOME_KEY]: buildOutcomeProjection(result) };
+		const resolved = this.#engine.reason(outcome, authority);
+		if (resolved.reasoning !== "logical") throw new ProgramError("MISMATCH", "Authority returned non-logical reasoning", authority.id);
+		const limits = buildLimits(authority, resolved, outcome, this.#evaluator, this.#labels);
+		for (const limit of limits) this.#emitter.emit("determine", limit);
+		result = buildProgramResult(this.definition, qualification, rating, [...notices, ...limits], status, { authority: resolved });
+		if (result.decision !== void 0) this.#emitter.emit("decide", result.decision, result);
+		this.#emitter.emit("execute", result);
+		return result;
+	}
+	#aggregate(subjects) {
+		for (const subject of subjects) assertProgramSubject(subject);
+		const definition = this.definition.aggregate;
+		const fields = [...definition?.fields ?? []];
+		const sums = aggregateSums(subjects, fields);
+		const groups = aggregateGroups(subjects, fields, definition?.by);
+		let tallies = emptyTallies(fields);
+		const results = subjects.map((subject) => {
+			const projection = definition === void 0 ? void 0 : buildAggregateProjection(subject, subjects.length, sums, groups, definition.by);
+			const result = this.#subject(subject, projection);
+			tallies = tallyProgram(tallies, result, subject, fields);
+			return result;
+		});
+		const gates = this.#aggregateLimits(subjects.length, sums, groups);
+		const result = buildAggregateResult(this.definition, results, gates.determinations, groups, tallies, sums, gates.resolved === void 0 ? void 0 : { gates: gates.resolved });
+		this.#emitter.emit("aggregate", result);
+		return result;
+	}
+	#aggregateLimits(count, sums, groups) {
+		const gates = this.definition.aggregate?.gates;
+		if (gates === void 0) return { determinations: [] };
+		const record = buildAggregateRecord(count, sums, groups);
+		const resolved = this.#engine.reason(record, gates);
+		if (resolved.reasoning !== "logical") throw new ProgramError("MISMATCH", "Aggregate gates returned non-logical reasoning", gates.id);
+		const determinations = buildLimits(gates, resolved, record, this.#evaluator, this.#labels);
+		for (const determination of determinations) this.#emitter.emit("determine", determination);
+		return {
+			determinations,
+			resolved
+		};
+	}
+	#alive() {
+		if (this.#destroyed) throw new ProgramError("DESTROYED", "Program has been destroyed", this.id);
+	}
+};
+//#endregion
+//#region src/core/programs/ProgramManager.ts
+/**
+* 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'`.
+*/
+var ProgramManager = class {
+	#emitter;
+	#programs = [];
+	#qualifier;
+	#rater;
+	#engine;
+	#qualifierOwned;
+	#raterOwned;
+	#engineOwned;
+	#validate;
+	#labels;
+	#destroyed = false;
+	constructor(options) {
+		this.#emitter = new Emitter({
+			on: options?.on,
+			error: options?.error
+		});
+		this.#labels = options?.labels;
+		this.#engineOwned = options?.engine === void 0;
+		this.#qualifierOwned = options?.qualifier === void 0;
+		this.#raterOwned = options?.rater === void 0;
+		this.#engine = options?.engine ?? createReason({
+			reasoners: [createQuantitativeReasoner(), createLogicalReasoner()],
+			bail: false
+		});
+		this.#qualifier = options?.qualifier ?? createQualifier({ engine: this.#engine });
+		this.#rater = options?.rater ?? createRater({ engine: this.#engine });
+		this.#validate = options?.validate ?? true;
+		try {
+			for (const definition of options?.programs ?? []) this.add(definition);
+		} catch (error) {
+			this.destroy();
+			throw error;
+		}
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get size() {
+		this.#alive();
+		return this.#programs.length;
+	}
+	has(id) {
+		this.#alive();
+		return this.#programs.some((program) => program.id === id);
+	}
+	program(id) {
+		this.#alive();
+		return this.#programs.find((program) => program.id === id);
+	}
+	programs() {
+		this.#alive();
+		return [...this.#programs];
+	}
+	add(definition) {
+		this.#alive();
+		if (this.has(definition.id)) throw new ProgramError("DUPLICATE", `Program "${definition.id}" already exists`, definition.id);
+		const program = createProgram(definition, {
+			qualifier: this.#qualifier,
+			rater: this.#rater,
+			engine: this.#engine,
+			validate: this.#validate,
+			labels: this.#labels
+		});
+		this.#programs.push(program);
+		this.#emitter.emit("add", program.id);
+		return program;
+	}
+	remove(input) {
+		this.#alive();
+		if (input === void 0) {
+			this.#drain();
+			return;
+		}
+		if (Array.isArray(input)) {
+			let removed = true;
+			for (const id of input) removed = this.#removeOne(id) && removed;
+			return removed;
+		}
+		if (typeof input === "string") return this.#removeOne(input);
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#drain();
+		if (this.#qualifierOwned) this.#qualifier.destroy();
+		if (this.#raterOwned) this.#rater.destroy();
+		if (this.#engineOwned) this.#engine.destroy();
+		this.#emitter.emit("destroy");
+		this.#emitter.destroy();
+	}
+	#drain() {
+		for (const program of this.#programs.splice(0)) {
+			program.destroy();
+			this.#emitter.emit("remove", program.id);
+		}
+	}
+	#removeOne(id) {
+		const index = this.#programs.findIndex((program) => program.id === id);
+		if (index < 0) return false;
+		const removed = this.#programs.splice(index, 1)[0];
+		if (removed === void 0) return false;
+		removed.destroy();
+		this.#emitter.emit("remove", removed.id);
+		return true;
+	}
+	#alive() {
+		if (this.#destroyed) throw new ProgramError("DESTROYED", "Program manager has been destroyed");
+	}
+};
+//#endregion
+//#region src/core/factories.ts
+/**
+* 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()
+* ```
+*/
+function createProgram(definition, options) {
+	return new Program(definition, options);
+}
+/**
+* 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()
+* ```
+*/
+function createProgramManager(options) {
+	return new ProgramManager(options);
+}
+/**
+* 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] })
+* ```
+*/
+function programDefinition(id, name, qualification, rating, input) {
+	return {
+		id,
+		name,
+		qualification,
+		...rating === void 0 ? {} : { rating },
+		...input?.description === void 0 ? {} : { description: input.description },
+		...input?.notices === void 0 ? {} : { notices: [...input.notices] },
+		...input?.authority === void 0 ? {} : { authority: input.authority },
+		...input?.aggregate === void 0 ? {} : { aggregate: input.aggregate },
+		...input?.metadata === void 0 ? {} : { metadata: copyJSONValue(input.metadata) }
+	};
+}
+/**
+* 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')
+* ```
+*/
+function noticeDefinition(id, message, input) {
+	return {
+		id,
+		message,
+		...input?.scope === void 0 ? {} : { scope: input.scope }
+	};
+}
+/**
+* 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' })
+* ```
+*/
+function aggregateDefinition(fields, input) {
+	return {
+		fields: [...fields],
+		...input?.by === void 0 ? {} : { by: input.by },
+		...input?.gates === void 0 ? {} : { gates: input.gates }
+	};
+}
+//#endregion
+export { AGGREGATE_KEY, DEFAULT_PROGRAM_VALIDATE, ELIGIBILITY_DECISIONS, OUTCOME_KEY, Program, ProgramError, ProgramManager, STATUS_PRECEDENCE, aggregateDefinition, aggregateGroups, aggregateSums, assertProgramDefinition, assertProgramSubject, buildAggregateProjection, buildAggregateRecord, buildAggregateResult, buildLimits, buildNotices, buildOutcomeProjection, buildProgramResult, buildQualificationSubject, completeTallies, copyJSONValue, createProgram, createProgramManager, decideEligibility, deriveStatus, emptySums, emptyTallies, findMissingScopes, formatGroupKey, hasReservedKey, isAggregateDefinition, isDecision, isNotice, isProgramDefinition, isProgramEffect, isProgramError, isStatus, noticeDefinition, programDefinition, selectProgramLines, sumFields, tallyProgram, validateProgramDefinition };
+
+//# sourceMappingURL=index.js.map