@photivra/engine 2.18.0 → 2.19.0

package/dist/core/evidence-provenance.js

@@ -4,8 +4,8 @@
  * may reuse it. Parsers for one record and for a non-empty list of records.
  * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.
  */
-import { rejectUnknownFields } from "./record-validation.js";
 import { InvalidConfigurationError } from "./configuration-error.js";
+import { requireConfigRecord as requireRecord, requireConfigRecordString as requireNonEmptyString } from "./record-validation.js";
 const SOURCE_ORIGINS = new Set([
     "manufacturer",
     "third-party",
@@ -16,21 +16,6 @@ const REUSE_STATUSES = new Set([
     "reusable-data",
     "photivra-owned"
 ]);
-function requireRecord(value, path, allowedKeys) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new InvalidConfigurationError(`${path} must be an object.`);
-    }
-    if (allowedKeys !== null)
-        rejectUnknownFields(value, allowedKeys, path);
-    return value;
-}
-function requireNonEmptyString(record, key, path) {
-    const value = record[key];
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new InvalidConfigurationError(`${path}.${key} must be a non-empty string.`);
-    }
-    return value;
-}
 /**
  * Parses one provenance (evidence) record.
  *

package/dist/core/evidence-provenance.js.map

@@ -1 +1 @@
-{"version":3,"file":"evidence-provenance.js","sourceRoot":"","sources":["../../src/core/evidence-provenance.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Provenance records: where a scientific fact or data set came from, and whether Photivra\n * may reuse it. Parsers for one record and for a non-empty list of records.\n * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.\n */\n\nimport { rejectUnknownFields } from \"./record-validation.js\";\nimport { InvalidConfigurationError } from \"./configuration-error.js\";\n\ntype UnknownRecord = Record<string, unknown>;\n\nexport type EvidenceSourceOrigin =\n  | \"manufacturer\"\n  | \"third-party\"\n  | \"photivra\";\n\nexport type EvidenceReuseStatus =\n  | \"factual-reference-only\"\n  | \"reusable-data\"\n  | \"photivra-owned\";\n\n/**\n * Where one scientific fact or numeric data set came from, and what reuse rights apply.\n *\n * Being publicly available does not grant permission to copy. The engine stores the\n * source reference as metadata and never fetches it. A record is a declaration for a\n * human to review. It does not verify a calibration or a licence.\n */\nexport interface EvidenceProvenance {\n  /** Who originated the underlying fact/data. */\n  sourceOrigin: EvidenceSourceOrigin;\n  /**\n   * Public/stable source reference or Photivra evidence identifier.\n   *\n   * The engine does not fetch this reference at runtime.\n   */\n  sourceReference: string;\n  /**\n   * How Photivra may use the referenced material.\n   *\n   * This is independent of who the source is. A manufacturer or third party can\n   * publish material that is only a factual reference, or data explicitly licensed\n   * for reuse.\n   */\n  reuseStatus: EvidenceReuseStatus;\n  /** Required when reuseStatus is reusable-data. */\n  license?: string;\n  note?: string;\n}\n\nexport interface EvidenceBackedFact<T> {\n  value: T;\n  /** One or more independent evidence records supporting this fact. */\n  evidence: readonly EvidenceProvenance[];\n}\n\nconst SOURCE_ORIGINS = new Set<EvidenceSourceOrigin>([\n  \"manufacturer\",\n  \"third-party\",\n  \"photivra\"\n]);\n\nconst REUSE_STATUSES = new Set<EvidenceReuseStatus>([\n  \"factual-reference-only\",\n  \"reusable-data\",\n  \"photivra-owned\"\n]);\n\nfunction requireRecord(\n  value: unknown,\n  path: string,\n  allowedKeys: readonly string[] | null\n): UnknownRecord {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new InvalidConfigurationError(`${path} must be an object.`);\n  }\n  if (allowedKeys !== null) rejectUnknownFields(value, allowedKeys, path);\n  return value as UnknownRecord;\n}\n\nfunction requireNonEmptyString(\n  record: UnknownRecord,\n  key: string,\n  path: string\n): string {\n  const value = record[key];\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new InvalidConfigurationError(\n      `${path}.${key} must be a non-empty string.`\n    );\n  }\n  return value;\n}\n\n/**\n * Parses one provenance (evidence) record.\n *\n * Source origin and reuse status are independent of each other. The parser rejects\n * only combinations that contradict themselves.\n */\nexport function parseEvidenceProvenance(\n  value: unknown,\n  path: string\n): EvidenceProvenance {\n  const record = requireRecord(value, path, [\"sourceOrigin\", \"sourceReference\", \"reuseStatus\", \"license\", \"note\"]);\n  const sourceOrigin = requireNonEmptyString(record, \"sourceOrigin\", path);\n  const sourceReference = requireNonEmptyString(\n    record,\n    \"sourceReference\",\n    path\n  );\n  const reuseStatus = requireNonEmptyString(record, \"reuseStatus\", path);\n\n  if (!SOURCE_ORIGINS.has(sourceOrigin as EvidenceSourceOrigin)) {\n    throw new InvalidConfigurationError(`${path}.sourceOrigin is invalid.`);\n  }\n  if (!REUSE_STATUSES.has(reuseStatus as EvidenceReuseStatus)) {\n    throw new InvalidConfigurationError(`${path}.reuseStatus is invalid.`);\n  }\n\n  const typedOrigin = sourceOrigin as EvidenceSourceOrigin;\n  const typedReuseStatus = reuseStatus as EvidenceReuseStatus;\n\n  if (\n    typedReuseStatus === \"photivra-owned\" &&\n    typedOrigin !== \"photivra\"\n  ) {\n    throw new InvalidConfigurationError(\n      `${path}.photivra-owned evidence must have sourceOrigin \"photivra\".`\n    );\n  }\n\n  const license = record.license;\n  if (\n    license !== undefined &&\n    (typeof license !== \"string\" || license.trim().length === 0)\n  ) {\n    throw new InvalidConfigurationError(\n      `${path}.license must be a non-empty string when supplied.`\n    );\n  }\n  if (typedReuseStatus === \"reusable-data\" && license === undefined) {\n    throw new InvalidConfigurationError(\n      `${path}.license is required for reusable-data provenance.`\n    );\n  }\n\n  const note = record.note;\n  if (\n    note !== undefined &&\n    (typeof note !== \"string\" || note.trim().length === 0)\n  ) {\n    throw new InvalidConfigurationError(\n      `${path}.note must be a non-empty string when supplied.`\n    );\n  }\n\n  return {\n    sourceOrigin: typedOrigin,\n    sourceReference,\n    reuseStatus: typedReuseStatus,\n    ...(license === undefined ? {} : { license }),\n    ...(note === undefined ? {} : { note })\n  };\n}\n\n/**\n * Parses a non-empty evidence array.\n */\nexport function parseEvidenceList(\n  value: unknown,\n  path: string\n): readonly EvidenceProvenance[] {\n  if (!Array.isArray(value) || value.length === 0) {\n    throw new InvalidConfigurationError(\n      `${path} must be a non-empty array.`\n    );\n  }\n\n  return value.map((entry, index) =>\n    parseEvidenceProvenance(entry, `${path}[${index}]`)\n  );\n}\n"]}
+{"version":3,"file":"evidence-provenance.js","sourceRoot":"","sources":["../../src/core/evidence-provenance.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Provenance records: where a scientific fact or data set came from, and whether Photivra\n * may reuse it. Parsers for one record and for a non-empty list of records.\n * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.\n */\n\nimport { InvalidConfigurationError } from \"./configuration-error.js\";\nimport { requireConfigRecord as requireRecord, requireConfigRecordString as requireNonEmptyString } from \"./record-validation.js\";\n\n\nexport type EvidenceSourceOrigin =\n  | \"manufacturer\"\n  | \"third-party\"\n  | \"photivra\";\n\nexport type EvidenceReuseStatus =\n  | \"factual-reference-only\"\n  | \"reusable-data\"\n  | \"photivra-owned\";\n\n/**\n * Where one scientific fact or numeric data set came from, and what reuse rights apply.\n *\n * Being publicly available does not grant permission to copy. The engine stores the\n * source reference as metadata and never fetches it. A record is a declaration for a\n * human to review. It does not verify a calibration or a licence.\n */\nexport interface EvidenceProvenance {\n  /** Who originated the underlying fact/data. */\n  sourceOrigin: EvidenceSourceOrigin;\n  /**\n   * Public/stable source reference or Photivra evidence identifier.\n   *\n   * The engine does not fetch this reference at runtime.\n   */\n  sourceReference: string;\n  /**\n   * How Photivra may use the referenced material.\n   *\n   * This is independent of who the source is. A manufacturer or third party can\n   * publish material that is only a factual reference, or data explicitly licensed\n   * for reuse.\n   */\n  reuseStatus: EvidenceReuseStatus;\n  /** Required when reuseStatus is reusable-data. */\n  license?: string;\n  note?: string;\n}\n\nexport interface EvidenceBackedFact<T> {\n  value: T;\n  /** One or more independent evidence records supporting this fact. */\n  evidence: readonly EvidenceProvenance[];\n}\n\nconst SOURCE_ORIGINS = new Set<EvidenceSourceOrigin>([\n  \"manufacturer\",\n  \"third-party\",\n  \"photivra\"\n]);\n\nconst REUSE_STATUSES = new Set<EvidenceReuseStatus>([\n  \"factual-reference-only\",\n  \"reusable-data\",\n  \"photivra-owned\"\n]);\n\n/**\n * Parses one provenance (evidence) record.\n *\n * Source origin and reuse status are independent of each other. The parser rejects\n * only combinations that contradict themselves.\n */\nexport function parseEvidenceProvenance(\n  value: unknown,\n  path: string\n): EvidenceProvenance {\n  const record = requireRecord(value, path, [\"sourceOrigin\", \"sourceReference\", \"reuseStatus\", \"license\", \"note\"]);\n  const sourceOrigin = requireNonEmptyString(record, \"sourceOrigin\", path);\n  const sourceReference = requireNonEmptyString(\n    record,\n    \"sourceReference\",\n    path\n  );\n  const reuseStatus = requireNonEmptyString(record, \"reuseStatus\", path);\n\n  if (!SOURCE_ORIGINS.has(sourceOrigin as EvidenceSourceOrigin)) {\n    throw new InvalidConfigurationError(`${path}.sourceOrigin is invalid.`);\n  }\n  if (!REUSE_STATUSES.has(reuseStatus as EvidenceReuseStatus)) {\n    throw new InvalidConfigurationError(`${path}.reuseStatus is invalid.`);\n  }\n\n  const typedOrigin = sourceOrigin as EvidenceSourceOrigin;\n  const typedReuseStatus = reuseStatus as EvidenceReuseStatus;\n\n  if (\n    typedReuseStatus === \"photivra-owned\" &&\n    typedOrigin !== \"photivra\"\n  ) {\n    throw new InvalidConfigurationError(\n      `${path}.photivra-owned evidence must have sourceOrigin \"photivra\".`\n    );\n  }\n\n  const license = record.license;\n  if (\n    license !== undefined &&\n    (typeof license !== \"string\" || license.trim().length === 0)\n  ) {\n    throw new InvalidConfigurationError(\n      `${path}.license must be a non-empty string when supplied.`\n    );\n  }\n  if (typedReuseStatus === \"reusable-data\" && license === undefined) {\n    throw new InvalidConfigurationError(\n      `${path}.license is required for reusable-data provenance.`\n    );\n  }\n\n  const note = record.note;\n  if (\n    note !== undefined &&\n    (typeof note !== \"string\" || note.trim().length === 0)\n  ) {\n    throw new InvalidConfigurationError(\n      `${path}.note must be a non-empty string when supplied.`\n    );\n  }\n\n  return {\n    sourceOrigin: typedOrigin,\n    sourceReference,\n    reuseStatus: typedReuseStatus,\n    ...(license === undefined ? {} : { license }),\n    ...(note === undefined ? {} : { note })\n  };\n}\n\n/**\n * Parses a non-empty evidence array.\n */\nexport function parseEvidenceList(\n  value: unknown,\n  path: string\n): readonly EvidenceProvenance[] {\n  if (!Array.isArray(value) || value.length === 0) {\n    throw new InvalidConfigurationError(\n      `${path} must be a non-empty array.`\n    );\n  }\n\n  return value.map((entry, index) =>\n    parseEvidenceProvenance(entry, `${path}[${index}]`)\n  );\n}\n"]}

package/dist/core/record-validation.d.ts

@@ -54,3 +54,57 @@ export declare const UNCERTAINTY_VARIANT_FIELDS: Readonly<Record<string, readonl
  * discriminator is left to the caller, which reports it with its own message.
  */
 export declare function rejectUnknownVariantFields(record: Readonly<Record<string, unknown>>, discriminator: string, allowedByVariant: Readonly<Record<string, readonly string[]>>, path: string): void;
+/** A plain object (not null, not an array) whose keys are on `allowedKeys` (null: any keys): `<path> must be an object.` */
+export declare function requireConfigRecord(value: unknown, path: string, allowedKeys: readonly string[] | null): Record<string, unknown>;
+/** `record[key]`, a string that is not blank: `<path>.<key> must be a non-empty string.` */
+export declare function requireConfigRecordString(record: Readonly<Record<string, unknown>>, key: string, path: string): string;
+/** A string that is not blank, returned as given: `<path> must be a non-empty string.` */
+export declare function requireConfigString(value: unknown, path: string): string;
+/** A string that is not blank, returned trimmed: `<path> must be a non-empty string.` */
+export declare function requireTrimmedConfigString(value: unknown, path: string): string;
+/** A finite number: `<path> must be finite.` */
+export declare function requireConfigFinite(value: unknown, path: string): number;
+/** A finite number: `<path> must be a finite number.` */
+export declare function requireConfigFiniteNumber(value: unknown, path: string): number;
+/** A finite number above zero: `<path> must be finite and greater than zero.` */
+export declare function requireConfigPositiveFinite(value: unknown, path: string): number;
+/** A finite number at least zero: `<path> must be finite and greater than or equal to zero.` */
+export declare function requireConfigNonNegativeFinite(value: unknown, path: string): number;
+/** A safe integer above zero: `<path> must be a positive safe integer.` */
+export declare function requireConfigPositiveSafeInteger(value: unknown, path: string): number;
+/** A safe integer at least zero: `<path> must be a non-negative safe integer.` */
+export declare function requireConfigNonNegativeSafeInteger(value: unknown, path: string): number;
+/** `"calibrated"` or `"approximation"`: `<path> is invalid.` */
+export declare function parseConfigScientificStatus(value: unknown, path: string): "calibrated" | "approximation";
+/** `"supported"`, `"unsupported"` or `"unknown"`: `<path> is invalid.` */
+export declare function parseConfigAvailability(value: unknown, path: string): "supported" | "unsupported" | "unknown";
+/** A finite number (scientific input): `<path> must be finite.` */
+export declare function requireInputFinite(value: unknown, path: string): number;
+/** A finite number above zero (scientific input): `<path> must be finite and greater than zero.` */
+export declare function requireInputPositiveFinite(value: unknown, path: string): number;
+/** A finite number at least zero (scientific input): `<path> must be finite and greater than or equal to zero.` */
+export declare function requireInputNonNegativeFinite(value: unknown, path: string): number;
+/** A safe integer at least zero (scientific input): `<path> must be a non-negative safe integer.` */
+export declare function requireInputNonNegativeSafeInteger(value: unknown, path: string): number;
+/** A finite number, name first (scientific input): `<name> must be finite.` */
+export declare function requireNamedFinite(name: string, value: unknown): number;
+/** Throws unless `value` is finite (scientific input): `<name> must be finite.` */
+export declare function assertNamedFinite(name: string, value: number): void;
+/** An array of distinct non-blank strings, each trimmed: `<path> must be an array.`, `<path> must not contain duplicates.` */
+export declare function parseConfigLimitations(value: unknown, path: string): readonly string[];
+/** A finite number above zero: `<path> must be finite.`, then `<path> must be greater than zero.` */
+export declare function requireConfigFiniteAboveZero(value: unknown, path: string): number;
+/** A finite number at least zero: `<path> must be finite.`, then `<path> must be greater than or equal to zero.` */
+export declare function requireConfigFiniteAtLeastZero(value: unknown, path: string): number;
+/** A finite number above zero: `<path> must be a finite number.`, then `<path> must be greater than zero.` */
+export declare function requireConfigNumberAboveZero(value: unknown, path: string): number;
+/** A finite number at least zero: `<path> must be a finite number.`, then `<path> must be greater than or equal to zero.` */
+export declare function requireConfigNumberAtLeastZero(value: unknown, path: string): number;
+/** A number from 0 through 1: `<path> must be a finite number.`, then `<path> must be a finite fraction from 0 through 1.` */
+export declare function requireConfigFraction(value: unknown, path: string): number;
+/** A number from 0 through 1: `<path> must be finite.`, then `<path> must lie from zero through one.` */
+export declare function requireConfigUnitInterval(value: unknown, path: string): number;
+/** A finite number above zero (scientific input): `<path> must be finite.`, then `<path> must be greater than zero.` */
+export declare function requireInputFiniteAboveZero(value: unknown, path: string): number;
+/** A finite number at least zero (scientific input): `<path> must be finite.`, then `<path> must be greater than or equal to zero.` */
+export declare function requireInputFiniteAtLeastZero(value: unknown, path: string): number;

package/dist/core/record-validation.js

@@ -6,6 +6,7 @@
  * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.
  */
 import { InvalidConfigurationError } from "./configuration-error.js";
+import { InvalidScientificInputError } from "./validation.js";
 /**
  * Checks that a value is a plain record whose keys are all on an allowlist. The caller
  * supplies the domain's schema and error messages.
@@ -115,4 +116,179 @@ export function rejectUnknownVariantFields(record, discriminator, allowedByVaria
         rejectUnknownFields(record, allowedByVariant[variant], path);
     }
 }
+// Field checks shared by the domain parsers, each with the one message every parser used for it (2.19.0: these were private
+// copies in up to 44 modules; one shared copy keeps the bundles smaller and the messages unchanged).
+/** A plain object (not null, not an array) whose keys are on `allowedKeys` (null: any keys): `<path> must be an object.` */
+export function requireConfigRecord(value, path, allowedKeys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new InvalidConfigurationError(path + " must be an object.");
+    if (allowedKeys !== null)
+        rejectUnknownFields(value, allowedKeys, path);
+    return value;
+}
+/** `record[key]`, a string that is not blank: `<path>.<key> must be a non-empty string.` */
+export function requireConfigRecordString(record, key, path) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new InvalidConfigurationError(path + "." + key + " must be a non-empty string.");
+    return value;
+}
+/** A string that is not blank, returned as given: `<path> must be a non-empty string.` */
+export function requireConfigString(value, path) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new InvalidConfigurationError(path + " must be a non-empty string.");
+    return value;
+}
+/** A string that is not blank, returned trimmed: `<path> must be a non-empty string.` */
+export function requireTrimmedConfigString(value, path) {
+    return requireConfigString(value, path).trim();
+}
+/** A finite number: `<path> must be finite.` */
+export function requireConfigFinite(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new InvalidConfigurationError(path + " must be finite.");
+    return value;
+}
+/** A finite number: `<path> must be a finite number.` */
+export function requireConfigFiniteNumber(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new InvalidConfigurationError(path + " must be a finite number.");
+    return value;
+}
+/** A finite number above zero: `<path> must be finite and greater than zero.` */
+export function requireConfigPositiveFinite(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        throw new InvalidConfigurationError(path + " must be finite and greater than zero.");
+    return value;
+}
+/** A finite number at least zero: `<path> must be finite and greater than or equal to zero.` */
+export function requireConfigNonNegativeFinite(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        throw new InvalidConfigurationError(path + " must be finite and greater than or equal to zero.");
+    return value;
+}
+/** A safe integer above zero: `<path> must be a positive safe integer.` */
+export function requireConfigPositiveSafeInteger(value, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+        throw new InvalidConfigurationError(path + " must be a positive safe integer.");
+    return value;
+}
+/** A safe integer at least zero: `<path> must be a non-negative safe integer.` */
+export function requireConfigNonNegativeSafeInteger(value, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        throw new InvalidConfigurationError(path + " must be a non-negative safe integer.");
+    return value;
+}
+/** `"calibrated"` or `"approximation"`: `<path> is invalid.` */
+export function parseConfigScientificStatus(value, path) {
+    if (value !== "calibrated" && value !== "approximation")
+        throw new InvalidConfigurationError(path + " is invalid.");
+    return value;
+}
+/** `"supported"`, `"unsupported"` or `"unknown"`: `<path> is invalid.` */
+export function parseConfigAvailability(value, path) {
+    if (value !== "supported" && value !== "unsupported" && value !== "unknown")
+        throw new InvalidConfigurationError(path + " is invalid.");
+    return value;
+}
+/** A finite number (scientific input): `<path> must be finite.` */
+export function requireInputFinite(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new InvalidScientificInputError(path + " must be finite.");
+    return value;
+}
+/** A finite number above zero (scientific input): `<path> must be finite and greater than zero.` */
+export function requireInputPositiveFinite(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        throw new InvalidScientificInputError(path + " must be finite and greater than zero.");
+    return value;
+}
+/** A finite number at least zero (scientific input): `<path> must be finite and greater than or equal to zero.` */
+export function requireInputNonNegativeFinite(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        throw new InvalidScientificInputError(path + " must be finite and greater than or equal to zero.");
+    return value;
+}
+/** A safe integer at least zero (scientific input): `<path> must be a non-negative safe integer.` */
+export function requireInputNonNegativeSafeInteger(value, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        throw new InvalidScientificInputError(path + " must be a non-negative safe integer.");
+    return value;
+}
+/** A finite number, name first (scientific input): `<name> must be finite.` */
+export function requireNamedFinite(name, value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new InvalidScientificInputError(name + " must be finite.");
+    return value;
+}
+/** Throws unless `value` is finite (scientific input): `<name> must be finite.` */
+export function assertNamedFinite(name, value) {
+    if (!Number.isFinite(value))
+        throw new InvalidScientificInputError(name + " must be finite.");
+}
+/** An array of distinct non-blank strings, each trimmed: `<path> must be an array.`, `<path> must not contain duplicates.` */
+export function parseConfigLimitations(value, path) {
+    if (!Array.isArray(value))
+        throw new InvalidConfigurationError(path + " must be an array.");
+    const parsed = value.map((entry, index) => requireTrimmedConfigString(entry, path + "[" + index + "]"));
+    if (new Set(parsed).size !== parsed.length)
+        throw new InvalidConfigurationError(path + " must not contain duplicates.");
+    return parsed;
+}
+/** A finite number above zero: `<path> must be finite.`, then `<path> must be greater than zero.` */
+export function requireConfigFiniteAboveZero(value, path) {
+    const parsed = requireConfigFinite(value, path);
+    if (parsed <= 0)
+        throw new InvalidConfigurationError(path + " must be greater than zero.");
+    return parsed;
+}
+/** A finite number at least zero: `<path> must be finite.`, then `<path> must be greater than or equal to zero.` */
+export function requireConfigFiniteAtLeastZero(value, path) {
+    const parsed = requireConfigFinite(value, path);
+    if (parsed < 0)
+        throw new InvalidConfigurationError(path + " must be greater than or equal to zero.");
+    return parsed;
+}
+/** A finite number above zero: `<path> must be a finite number.`, then `<path> must be greater than zero.` */
+export function requireConfigNumberAboveZero(value, path) {
+    const parsed = requireConfigFiniteNumber(value, path);
+    if (parsed <= 0)
+        throw new InvalidConfigurationError(path + " must be greater than zero.");
+    return parsed;
+}
+/** A finite number at least zero: `<path> must be a finite number.`, then `<path> must be greater than or equal to zero.` */
+export function requireConfigNumberAtLeastZero(value, path) {
+    const parsed = requireConfigFiniteNumber(value, path);
+    if (parsed < 0)
+        throw new InvalidConfigurationError(path + " must be greater than or equal to zero.");
+    return parsed;
+}
+/** A number from 0 through 1: `<path> must be a finite number.`, then `<path> must be a finite fraction from 0 through 1.` */
+export function requireConfigFraction(value, path) {
+    const parsed = requireConfigFiniteNumber(value, path);
+    if (parsed < 0 || parsed > 1)
+        throw new InvalidConfigurationError(path + " must be a finite fraction from 0 through 1.");
+    return parsed;
+}
+/** A number from 0 through 1: `<path> must be finite.`, then `<path> must lie from zero through one.` */
+export function requireConfigUnitInterval(value, path) {
+    const parsed = requireConfigFinite(value, path);
+    if (parsed < 0 || parsed > 1)
+        throw new InvalidConfigurationError(path + " must lie from zero through one.");
+    return parsed;
+}
+/** A finite number above zero (scientific input): `<path> must be finite.`, then `<path> must be greater than zero.` */
+export function requireInputFiniteAboveZero(value, path) {
+    const parsed = requireInputFinite(value, path);
+    if (parsed <= 0)
+        throw new InvalidScientificInputError(path + " must be greater than zero.");
+    return parsed;
+}
+/** A finite number at least zero (scientific input): `<path> must be finite.`, then `<path> must be greater than or equal to zero.` */
+export function requireInputFiniteAtLeastZero(value, path) {
+    const parsed = requireInputFinite(value, path);
+    if (parsed < 0)
+        throw new InvalidScientificInputError(path + " must be greater than or equal to zero.");
+    return parsed;
+}
 //# sourceMappingURL=record-validation.js.map

package/dist/core/record-validation.js.map

@@ -1 +1 @@
-{"version":3,"file":"record-validation.js","sourceRoot":"","sources":["../../src/core/record-validation.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared input checks used by the domain parsers: plain-record and allowed-key checks, the\n * public identifier grammar, and guards for the top-level argument of a public function.\n * Each domain keeps its own schema and error messages.\n * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.\n */\n\nimport { InvalidConfigurationError } from \"./configuration-error.js\";\n\n/**\n * Checks that a value is a plain record whose keys are all on an allowlist. The caller\n * supplies the domain's schema and error messages.\n *\n * Returns the original record. It does not copy, freeze or strip fields, require missing\n * fields, or check child values. Like the domain parsers, it checks own enumerable string keys.\n * From 2.0.0 an unknown key also names the field: `<message> Unknown field \"<field>\".`\n */\nexport function requireAllowlistedRecord(\n  value: unknown, allowedKeys: readonly string[], message: string\n): Record<string, unknown> {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new InvalidConfigurationError(message);\n  }\n  for (const key in value) {\n    if (Object.hasOwn(value, key) && !allowedKeys.includes(key)) {\n      throw new InvalidConfigurationError(`${message} Unknown field ${JSON.stringify(key)}.`);\n    }\n  }\n  return value as Record<string, unknown>;\n}\n\n/**\n * Shared grammar for public identifiers: 1–128 ASCII characters. The first is a letter or\n * digit. The rest are letters, digits, dot, underscore, colon or hyphen.\n *\n * The identifier is opaque: no trimming, case conversion or path/URL interpretation. Each\n * domain decides what the identifier means and keeps its exact error message.\n */\nexport function requirePublicOpaqueId(value: unknown, message: string): string {\n  if (!isPublicOpaqueId(value)) {\n    throw new InvalidConfigurationError(message);\n  }\n  return value;\n}\n\n/** Same grammar for domains that combine ID rejection with other field checks. */\nexport function isPublicOpaqueId(value: unknown): value is string {\n  return typeof value === \"string\" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value);\n}\n\n/**\n * Guard for a public function's input object. If it receives null, a primitive or an array,\n * it throws the domain's InvalidConfigurationError, never a raw TypeError from reading a\n * property. It does not check fields.\n */\nexport function requireInputObject(value: unknown, label: string): void {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new InvalidConfigurationError(`${label} must be an object.`);\n  }\n}\n\n/** Root-function input guard for a required array argument; see requireInputObject. */\nexport function requireInputArray(value: unknown, label: string): void {\n  if (!Array.isArray(value)) {\n    throw new InvalidConfigurationError(`${label} must be an array.`);\n  }\n}\n\n/**\n * Input object guard for simple scalar calculators that also rejects unknown keys. A misspelled\n * or wrong-unit field (for example focusDistanceMm instead of focusDistanceM) is never silently ignored.\n */\nexport function requireInputKeys(value: unknown, functionName: string, allowedKeys: readonly string[]): void {\n  requireInputObject(value, `${functionName} input`);\n  // for-in over own keys avoids allocating a key array on hot scalar paths.\n  for (const key in value as object) {\n    if (Object.hasOwn(value as object, key) && !allowedKeys.includes(key)) {\n      throw new InvalidConfigurationError(`${functionName} input has unknown field ${JSON.stringify(key)}.`);\n    }\n  }\n}\n\n/**\n * Rejects any own enumerable key of a versioned or engine record that is not on its allowlist, with\n * the message `<path> has unknown field \"<field>\".` The caller has already checked that `record` is\n * a plain object. Used at every object level of the `parse*()` record parsers, so a misspelled or\n * stale field in a stored profile fails instead of being silently dropped.\n */\nexport function rejectUnknownFields(record: object, allowedKeys: readonly string[], path: string): void {\n  for (const key in record) {\n    if (Object.hasOwn(record, key) && !allowedKeys.includes(key)) {\n      throw new InvalidConfigurationError(`${path} has unknown field ${JSON.stringify(key)}.`);\n    }\n  }\n}\n\n/**\n * Checks the fixed-value flags that a parser writes into its own output (for example\n * `sceneRadianceCalculated: false`). They may be passed back in, so a parsed record parses again,\n * but only with exactly the fixed value; any other value is rejected rather than ignored.\n */\nexport function requireFixedFieldsWhenPresent(\n  record: Readonly<Record<string, unknown>>, fixed: Readonly<Record<string, boolean | string>>, path: string\n): void {\n  for (const key of Object.keys(fixed)) {\n    if (record[key] !== undefined && record[key] !== fixed[key]) {\n      throw new InvalidConfigurationError(`${path}.${key} must be ${JSON.stringify(fixed[key])} when supplied.`);\n    }\n  }\n}\n\n/**\n * Fields of the shared relative / not-quantified uncertainty union used by many evidence-backed\n * profiles: `{ kind: \"relative\", fraction, basis }` or `{ kind: \"not-quantified\", limitation }`.\n */\nexport const UNCERTAINTY_VARIANT_FIELDS: Readonly<Record<string, readonly string[]>> = /* @__PURE__ */ Object.freeze({\n  relative: /* @__PURE__ */ Object.freeze([\"kind\", \"fraction\", \"basis\"]),\n  \"not-quantified\": /* @__PURE__ */ Object.freeze([\"kind\", \"limitation\"])\n});\n\n/**\n * For a record whose allowed fields depend on a discriminator (for example `kind` or\n * `schemaVersion`), rejects fields that the selected variant does not define. An unrecognized\n * discriminator is left to the caller, which reports it with its own message.\n */\nexport function rejectUnknownVariantFields(\n  record: Readonly<Record<string, unknown>>, discriminator: string,\n  allowedByVariant: Readonly<Record<string, readonly string[]>>, path: string\n): void {\n  const variant = record[discriminator];\n  if (typeof variant === \"string\" && Object.hasOwn(allowedByVariant, variant)) {\n    rejectUnknownFields(record, allowedByVariant[variant]!, path);\n  }\n}\n"]}
+{"version":3,"file":"record-validation.js","sourceRoot":"","sources":["../../src/core/record-validation.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared input checks used by the domain parsers: plain-record and allowed-key checks, the\n * public identifier grammar, and guards for the top-level argument of a public function.\n * Each domain keeps its own schema and error messages.\n * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.\n */\n\nimport { InvalidConfigurationError } from \"./configuration-error.js\";\nimport { InvalidScientificInputError } from \"./validation.js\";\n\n/**\n * Checks that a value is a plain record whose keys are all on an allowlist. The caller\n * supplies the domain's schema and error messages.\n *\n * Returns the original record. It does not copy, freeze or strip fields, require missing\n * fields, or check child values. Like the domain parsers, it checks own enumerable string keys.\n * From 2.0.0 an unknown key also names the field: `<message> Unknown field \"<field>\".`\n */\nexport function requireAllowlistedRecord(\n  value: unknown, allowedKeys: readonly string[], message: string\n): Record<string, unknown> {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new InvalidConfigurationError(message);\n  }\n  for (const key in value) {\n    if (Object.hasOwn(value, key) && !allowedKeys.includes(key)) {\n      throw new InvalidConfigurationError(`${message} Unknown field ${JSON.stringify(key)}.`);\n    }\n  }\n  return value as Record<string, unknown>;\n}\n\n/**\n * Shared grammar for public identifiers: 1–128 ASCII characters. The first is a letter or\n * digit. The rest are letters, digits, dot, underscore, colon or hyphen.\n *\n * The identifier is opaque: no trimming, case conversion or path/URL interpretation. Each\n * domain decides what the identifier means and keeps its exact error message.\n */\nexport function requirePublicOpaqueId(value: unknown, message: string): string {\n  if (!isPublicOpaqueId(value)) {\n    throw new InvalidConfigurationError(message);\n  }\n  return value;\n}\n\n/** Same grammar for domains that combine ID rejection with other field checks. */\nexport function isPublicOpaqueId(value: unknown): value is string {\n  return typeof value === \"string\" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value);\n}\n\n/**\n * Guard for a public function's input object. If it receives null, a primitive or an array,\n * it throws the domain's InvalidConfigurationError, never a raw TypeError from reading a\n * property. It does not check fields.\n */\nexport function requireInputObject(value: unknown, label: string): void {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new InvalidConfigurationError(`${label} must be an object.`);\n  }\n}\n\n/** Root-function input guard for a required array argument; see requireInputObject. */\nexport function requireInputArray(value: unknown, label: string): void {\n  if (!Array.isArray(value)) {\n    throw new InvalidConfigurationError(`${label} must be an array.`);\n  }\n}\n\n/**\n * Input object guard for simple scalar calculators that also rejects unknown keys. A misspelled\n * or wrong-unit field (for example focusDistanceMm instead of focusDistanceM) is never silently ignored.\n */\nexport function requireInputKeys(value: unknown, functionName: string, allowedKeys: readonly string[]): void {\n  requireInputObject(value, `${functionName} input`);\n  // for-in over own keys avoids allocating a key array on hot scalar paths.\n  for (const key in value as object) {\n    if (Object.hasOwn(value as object, key) && !allowedKeys.includes(key)) {\n      throw new InvalidConfigurationError(`${functionName} input has unknown field ${JSON.stringify(key)}.`);\n    }\n  }\n}\n\n/**\n * Rejects any own enumerable key of a versioned or engine record that is not on its allowlist, with\n * the message `<path> has unknown field \"<field>\".` The caller has already checked that `record` is\n * a plain object. Used at every object level of the `parse*()` record parsers, so a misspelled or\n * stale field in a stored profile fails instead of being silently dropped.\n */\nexport function rejectUnknownFields(record: object, allowedKeys: readonly string[], path: string): void {\n  for (const key in record) {\n    if (Object.hasOwn(record, key) && !allowedKeys.includes(key)) {\n      throw new InvalidConfigurationError(`${path} has unknown field ${JSON.stringify(key)}.`);\n    }\n  }\n}\n\n/**\n * Checks the fixed-value flags that a parser writes into its own output (for example\n * `sceneRadianceCalculated: false`). They may be passed back in, so a parsed record parses again,\n * but only with exactly the fixed value; any other value is rejected rather than ignored.\n */\nexport function requireFixedFieldsWhenPresent(\n  record: Readonly<Record<string, unknown>>, fixed: Readonly<Record<string, boolean | string>>, path: string\n): void {\n  for (const key of Object.keys(fixed)) {\n    if (record[key] !== undefined && record[key] !== fixed[key]) {\n      throw new InvalidConfigurationError(`${path}.${key} must be ${JSON.stringify(fixed[key])} when supplied.`);\n    }\n  }\n}\n\n/**\n * Fields of the shared relative / not-quantified uncertainty union used by many evidence-backed\n * profiles: `{ kind: \"relative\", fraction, basis }` or `{ kind: \"not-quantified\", limitation }`.\n */\nexport const UNCERTAINTY_VARIANT_FIELDS: Readonly<Record<string, readonly string[]>> = /* @__PURE__ */ Object.freeze({\n  relative: /* @__PURE__ */ Object.freeze([\"kind\", \"fraction\", \"basis\"]),\n  \"not-quantified\": /* @__PURE__ */ Object.freeze([\"kind\", \"limitation\"])\n});\n\n/**\n * For a record whose allowed fields depend on a discriminator (for example `kind` or\n * `schemaVersion`), rejects fields that the selected variant does not define. An unrecognized\n * discriminator is left to the caller, which reports it with its own message.\n */\nexport function rejectUnknownVariantFields(\n  record: Readonly<Record<string, unknown>>, discriminator: string,\n  allowedByVariant: Readonly<Record<string, readonly string[]>>, path: string\n): void {\n  const variant = record[discriminator];\n  if (typeof variant === \"string\" && Object.hasOwn(allowedByVariant, variant)) {\n    rejectUnknownFields(record, allowedByVariant[variant]!, path);\n  }\n}\n\n// Field checks shared by the domain parsers, each with the one message every parser used for it (2.19.0: these were private\n// copies in up to 44 modules; one shared copy keeps the bundles smaller and the messages unchanged).\n\n/** A plain object (not null, not an array) whose keys are on `allowedKeys` (null: any keys): `<path> must be an object.` */\nexport function requireConfigRecord(value: unknown, path: string, allowedKeys: readonly string[] | null): Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) throw new InvalidConfigurationError(path + \" must be an object.\");\n  if (allowedKeys !== null) rejectUnknownFields(value, allowedKeys, path);\n  return value as Record<string, unknown>;\n}\n/** `record[key]`, a string that is not blank: `<path>.<key> must be a non-empty string.` */\nexport function requireConfigRecordString(record: Readonly<Record<string, unknown>>, key: string, path: string): string {\n  const value = record[key];\n  if (typeof value !== \"string\" || value.trim().length === 0) throw new InvalidConfigurationError(path + \".\" + key + \" must be a non-empty string.\");\n  return value;\n}\n/** A string that is not blank, returned as given: `<path> must be a non-empty string.` */\nexport function requireConfigString(value: unknown, path: string): string {\n  if (typeof value !== \"string\" || value.trim().length === 0) throw new InvalidConfigurationError(path + \" must be a non-empty string.\");\n  return value;\n}\n/** A string that is not blank, returned trimmed: `<path> must be a non-empty string.` */\nexport function requireTrimmedConfigString(value: unknown, path: string): string {\n  return requireConfigString(value, path).trim();\n}\n/** A finite number: `<path> must be finite.` */\nexport function requireConfigFinite(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) throw new InvalidConfigurationError(path + \" must be finite.\");\n  return value;\n}\n/** A finite number: `<path> must be a finite number.` */\nexport function requireConfigFiniteNumber(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) throw new InvalidConfigurationError(path + \" must be a finite number.\");\n  return value;\n}\n/** A finite number above zero: `<path> must be finite and greater than zero.` */\nexport function requireConfigPositiveFinite(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value <= 0) throw new InvalidConfigurationError(path + \" must be finite and greater than zero.\");\n  return value;\n}\n/** A finite number at least zero: `<path> must be finite and greater than or equal to zero.` */\nexport function requireConfigNonNegativeFinite(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value < 0) throw new InvalidConfigurationError(path + \" must be finite and greater than or equal to zero.\");\n  return value;\n}\n/** A safe integer above zero: `<path> must be a positive safe integer.` */\nexport function requireConfigPositiveSafeInteger(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isSafeInteger(value) || value <= 0) throw new InvalidConfigurationError(path + \" must be a positive safe integer.\");\n  return value;\n}\n/** A safe integer at least zero: `<path> must be a non-negative safe integer.` */\nexport function requireConfigNonNegativeSafeInteger(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isSafeInteger(value) || value < 0) throw new InvalidConfigurationError(path + \" must be a non-negative safe integer.\");\n  return value;\n}\n/** `\"calibrated\"` or `\"approximation\"`: `<path> is invalid.` */\nexport function parseConfigScientificStatus(value: unknown, path: string): \"calibrated\" | \"approximation\" {\n  if (value !== \"calibrated\" && value !== \"approximation\") throw new InvalidConfigurationError(path + \" is invalid.\");\n  return value;\n}\n/** `\"supported\"`, `\"unsupported\"` or `\"unknown\"`: `<path> is invalid.` */\nexport function parseConfigAvailability(value: unknown, path: string): \"supported\" | \"unsupported\" | \"unknown\" {\n  if (value !== \"supported\" && value !== \"unsupported\" && value !== \"unknown\") throw new InvalidConfigurationError(path + \" is invalid.\");\n  return value;\n}\n/** A finite number (scientific input): `<path> must be finite.` */\nexport function requireInputFinite(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) throw new InvalidScientificInputError(path + \" must be finite.\");\n  return value;\n}\n/** A finite number above zero (scientific input): `<path> must be finite and greater than zero.` */\nexport function requireInputPositiveFinite(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value <= 0) throw new InvalidScientificInputError(path + \" must be finite and greater than zero.\");\n  return value;\n}\n/** A finite number at least zero (scientific input): `<path> must be finite and greater than or equal to zero.` */\nexport function requireInputNonNegativeFinite(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value < 0) throw new InvalidScientificInputError(path + \" must be finite and greater than or equal to zero.\");\n  return value;\n}\n/** A safe integer at least zero (scientific input): `<path> must be a non-negative safe integer.` */\nexport function requireInputNonNegativeSafeInteger(value: unknown, path: string): number {\n  if (typeof value !== \"number\" || !Number.isSafeInteger(value) || value < 0) throw new InvalidScientificInputError(path + \" must be a non-negative safe integer.\");\n  return value;\n}\n/** A finite number, name first (scientific input): `<name> must be finite.` */\nexport function requireNamedFinite(name: string, value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) throw new InvalidScientificInputError(name + \" must be finite.\");\n  return value;\n}\n/** Throws unless `value` is finite (scientific input): `<name> must be finite.` */\nexport function assertNamedFinite(name: string, value: number): void {\n  if (!Number.isFinite(value)) throw new InvalidScientificInputError(name + \" must be finite.\");\n}\n/** An array of distinct non-blank strings, each trimmed: `<path> must be an array.`, `<path> must not contain duplicates.` */\nexport function parseConfigLimitations(value: unknown, path: string): readonly string[] {\n  if (!Array.isArray(value)) throw new InvalidConfigurationError(path + \" must be an array.\");\n  const parsed = value.map((entry, index) => requireTrimmedConfigString(entry, path + \"[\" + index + \"]\"));\n  if (new Set(parsed).size !== parsed.length) throw new InvalidConfigurationError(path + \" must not contain duplicates.\");\n  return parsed;\n}\n/** A finite number above zero: `<path> must be finite.`, then `<path> must be greater than zero.` */\nexport function requireConfigFiniteAboveZero(value: unknown, path: string): number {\n  const parsed = requireConfigFinite(value, path);\n  if (parsed <= 0) throw new InvalidConfigurationError(path + \" must be greater than zero.\");\n  return parsed;\n}\n/** A finite number at least zero: `<path> must be finite.`, then `<path> must be greater than or equal to zero.` */\nexport function requireConfigFiniteAtLeastZero(value: unknown, path: string): number {\n  const parsed = requireConfigFinite(value, path);\n  if (parsed < 0) throw new InvalidConfigurationError(path + \" must be greater than or equal to zero.\");\n  return parsed;\n}\n/** A finite number above zero: `<path> must be a finite number.`, then `<path> must be greater than zero.` */\nexport function requireConfigNumberAboveZero(value: unknown, path: string): number {\n  const parsed = requireConfigFiniteNumber(value, path);\n  if (parsed <= 0) throw new InvalidConfigurationError(path + \" must be greater than zero.\");\n  return parsed;\n}\n/** A finite number at least zero: `<path> must be a finite number.`, then `<path> must be greater than or equal to zero.` */\nexport function requireConfigNumberAtLeastZero(value: unknown, path: string): number {\n  const parsed = requireConfigFiniteNumber(value, path);\n  if (parsed < 0) throw new InvalidConfigurationError(path + \" must be greater than or equal to zero.\");\n  return parsed;\n}\n/** A number from 0 through 1: `<path> must be a finite number.`, then `<path> must be a finite fraction from 0 through 1.` */\nexport function requireConfigFraction(value: unknown, path: string): number {\n  const parsed = requireConfigFiniteNumber(value, path);\n  if (parsed < 0 || parsed > 1) throw new InvalidConfigurationError(path + \" must be a finite fraction from 0 through 1.\");\n  return parsed;\n}\n/** A number from 0 through 1: `<path> must be finite.`, then `<path> must lie from zero through one.` */\nexport function requireConfigUnitInterval(value: unknown, path: string): number {\n  const parsed = requireConfigFinite(value, path);\n  if (parsed < 0 || parsed > 1) throw new InvalidConfigurationError(path + \" must lie from zero through one.\");\n  return parsed;\n}\n/** A finite number above zero (scientific input): `<path> must be finite.`, then `<path> must be greater than zero.` */\nexport function requireInputFiniteAboveZero(value: unknown, path: string): number {\n  const parsed = requireInputFinite(value, path);\n  if (parsed <= 0) throw new InvalidScientificInputError(path + \" must be greater than zero.\");\n  return parsed;\n}\n/** A finite number at least zero (scientific input): `<path> must be finite.`, then `<path> must be greater than or equal to zero.` */\nexport function requireInputFiniteAtLeastZero(value: unknown, path: string): number {\n  const parsed = requireInputFinite(value, path);\n  if (parsed < 0) throw new InvalidScientificInputError(path + \" must be greater than or equal to zero.\");\n  return parsed;\n}\n"]}

package/dist/core/scientific-assurance.js

@@ -10,7 +10,7 @@
 import { validateCalculationQuality } from "./calculation-result.js";
 import { InvalidScientificInputError } from "./validation.js";
 import { parseEvidenceProvenance } from "./evidence-provenance.js";
-import { requireInputKeys } from "./record-validation.js";
+import { requireInputKeys, requireTrimmedConfigString as requireNonEmptyString, requireInputNonNegativeFinite as requireNonNegativeFinite } from "./record-validation.js";
 import { InvalidConfigurationError } from "./configuration-error.js";
 export const SCIENTIFIC_ASSURANCE_CONTRACT_VERSION = "0.1.0";
 const SCIENTIFIC_STATUSES = new Set([
@@ -29,23 +29,6 @@ const SOURCE_KINDS = new Set([
     "model",
     "fixture"
 ]);
-function requireNonEmptyString(value, path) {
-    if (typeof value !== "string" ||
-        value.trim().length === 0) {
-        throw new InvalidConfigurationError(path +
-            " must be a non-empty string.");
-    }
-    return value.trim();
-}
-function requireNonNegativeFinite(value, path) {
-    if (typeof value !== "number" ||
-        !Number.isFinite(value) ||
-        value < 0) {
-        throw new InvalidScientificInputError(path +
-            " must be finite and greater than or equal to zero.");
-    }
-    return value;
-}
 function validateSourceIdentity(value, path) {
     if (!SOURCE_KINDS.has(value.kind)) {
         throw new InvalidConfigurationError(path + ".kind is invalid.");

package/dist/core/scientific-assurance.js.map

@@ -1 +1 @@
-{"version":3,"file":"scientific-assurance.js","sourceRoot":"","sources":["../../src/core/scientific-assurance.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;GAOG;AAEH,OAAO,EACL,0BAA0B,EAE3B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EACL,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAErE,MAAM,CAAC,MAAM,qCAAqC,GAChD,OAAgB,CAAC;AA0InB,MAAM,mBAAmB,GACvB,IAAI,GAAG,CAA4B;IACjC,YAAY;IACZ,eAAe;IACf,SAAS;CACV,CAAC,CAAC;AAEL,MAAM,WAAW,GACf,IAAI,GAAG,CAA+B;IACpC,sBAAsB;IACtB,2BAA2B;IAC3B,gBAAgB;CACjB,CAAC,CAAC;AAEL,MAAM,YAAY,GAChB,IAAI,GAAG,CAAgC;IACrC,SAAS;IACT,QAAQ;IACR,OAAO;IACP,SAAS;CACV,CAAC,CAAC;AAEL,SAAS,qBAAqB,CAC5B,KAAc,EACd,IAAY;IAEZ,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EACzB,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,IAAI;YACF,8BAA8B,CACjC,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC;AACtB,CAAC;AAED,SAAS,wBAAwB,CAC/B,KAAc,EACd,IAAY;IAEZ,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QACvB,KAAK,GAAG,CAAC,EACT,CAAC;QACD,MAAM,IAAI,2BAA2B,CACnC,IAAI;YACF,oDAAoD,CACvD,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,sBAAsB,CAC7B,KACmC,EACnC,IAAY;IAEZ,IACE,CAAC,YAAY,CAAC,GAAG,CACf,KAAK,CAAC,IACyB,CAChC,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,IAAI,GAAG,mBAAmB,CAC3B,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,EAAE,EACA,qBAAqB,CACnB,KAAK,CAAC,EAAE,EACR,IAAI,GAAG,KAAK,CACb;QACH,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS;YAC7B,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC;gBACE,OAAO,EACL,qBAAqB,CACnB,KAAK,CAAC,OAAO,EACb,IAAI,GAAG,UAAU,CAClB;aACJ,CAAC;KACP,CAAC;AACJ,CAAC;AAED,SAAS,mBAAmB,CAC1B,KACyC,EACzC,IAAY;IAEZ,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC9B,MAAM,QAAQ,GACZ,wBAAwB,CACtB,KAAK,CAAC,QAAQ,EACd,IAAI,GAAG,WAAW,CACnB,CAAC;QACJ,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,2BAA2B,CACnC,IAAI;gBACF,8CAA8C,CACjD,CAAC;QACJ,CAAC;QACD,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,QAAQ;YACR,KAAK,EACH,qBAAqB,CACnB,KAAK,CAAC,KAAK,EACX,IAAI,GAAG,QAAQ,CAChB;SACJ,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC9B,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,SAAS,EACP,wBAAwB,CACtB,KAAK,CAAC,SAAS,EACf,IAAI,GAAG,YAAY,CACpB;YACH,IAAI,EACF,qBAAqB,CACnB,KAAK,CAAC,IAAI,EACV,IAAI,GAAG,OAAO,CACf;YACH,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS;gBAC3B,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC;oBACE,KAAK,EACH,qBAAqB,CACnB,KAAK,CAAC,KAAK,EACX,IAAI,GAAG,QAAQ,CAChB;iBACJ,CAAC;SACP,CAAC;IACJ,CAAC;IAED,IACE,KAAK,CAAC,IAAI;QACV,qBAAqB,EACrB,CAAC;QACD,0BAA0B,CACxB,KAAK,CAAC,OAAO,CACd,CAAC;QACF,IACE,KAAK,CAAC,OAAO;aACV,WAAW;YACZ,SAAS;YACX,KAAK,CAAC,OAAO;iBACV,WAAW,CAAC,MAAM;gBACnB,CAAC,EACH,CAAC;YACD,MAAM,IAAI,2BAA2B,CACnC,IAAI;gBACF,4GAA4G,CAC/G,CAAC;QACJ,CAAC;QACD,OAAO;YACL,IAAI,EACF,qBAAqB;YACvB,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC;IACJ,CAAC;IAED,IACE,KAAK,CAAC,IAAI;QACV,gBAAgB,EAChB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,UAAU,EACR,qBAAqB,CACnB,KAAK,CAAC,UAAU,EAChB,IAAI,GAAG,aAAa,CACrB;SACJ,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,SAAS;YACf,UAAU,EACR,qBAAqB,CACnB,KAAK,CAAC,UAAU,EAChB,IAAI,GAAG,aAAa,CACrB;SACJ,CAAC;IACJ,CAAC;IAED,IACE,KAAK,CAAC,IAAI;QACV,gBAAgB,EAChB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,MAAM,EACJ,qBAAqB,CACnB,KAAK,CAAC,MAAM,EACZ,IAAI,GAAG,SAAS,CACjB;SACJ,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,yBAAyB,CACjC,IAAI,GAAG,mBAAmB,CAC3B,CAAC;AACJ,CAAC;AAED,SAAS,mBAAmB,CAC1B,KAAwB,EACxB,IAAY;IAEZ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,yBAAyB,CACjC,IAAI,GAAG,oBAAoB,CAC5B,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GACV,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACzB,qBAAqB,CACnB,KAAK,EACL,IAAI;QACF,GAAG;QACH,KAAK;QACL,GAAG,CACN,CACF,CAAC;IAEJ,IACE,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI;QACpB,MAAM,CAAC,MAAM,EACb,CAAC;QACD,MAAM,IAAI,2BAA2B,CACnC,IAAI;YACF,+BAA+B,CAClC,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,iBAAiB,CACxB,KAC8B,EAC9B,KAAa;IAEb,MAAM,IAAI,GACR,aAAa;QACb,KAAK;QACL,GAAG,CAAC;IAEN,IACE,OAAO,KAAK,CAAC,QAAQ;QACrB,SAAS,EACT,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,IAAI;YACF,4BAA4B,CAC/B,CAAC;IACJ,CAAC;IAED,IACE,CAAC,WAAW,CAAC,GAAG,CACd,KAAK,CAAC,SACwB,CAC/B,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,IAAI;YACF,wBAAwB,CAC3B,CAAC;IACJ,CAAC;IAED,IACE,CAAC,mBAAmB,CAAC,GAAG,CACtB,KAAK,CAAC,gBACqB,CAC5B,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,IAAI;YACF,+BAA+B,CAClC,CAAC;IACJ,CAAC;IAED,IACE,KAAK,CAAC,SAAS;QACb,sBAAsB;QACxB,KAAK,CAAC,mBAAmB;YACvB,UAAU,EACZ,CAAC;QACD,MAAM,IAAI,2BAA2B,CACnC,IAAI;YACF,4EAA4E,CAC/E,CAAC;IACJ,CAAC;IAED,IACE,KAAK,CAAC,mBAAmB;QACvB,UAAU;QACZ,KAAK,CAAC,mBAAmB;YACvB,cAAc,EAChB,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,IAAI;YACF,kCAAkC,CACrC,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,yBAAyB,CACjC,IAAI;YACF,6BAA6B,CAChC,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GACZ,KAAK,CAAC,QAAQ,CAAC,GAAG,CAChB,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE,CACvB,uBAAuB,CACrB,KAAK,EACL,IAAI;QACF,YAAY;QACZ,aAAa;QACb,GAAG,CACN,CACJ,CAAC;IAEJ,OAAO;QACL,WAAW,EACT,qBAAqB,CACnB,KAAK,CAAC,WAAW,EACjB,IAAI,GAAG,cAAc,CACtB;QACH,IAAI,EACF,qBAAqB,CACnB,KAAK,CAAC,IAAI,EACV,IAAI,GAAG,OAAO,CACf;QACH,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,cAAc,EACZ,sBAAsB,CACpB,KAAK,CAAC,cAAc,EACpB,IAAI;YACF,iBAAiB,CACpB;QACH,SAAS,EACP,KAAK,CAAC,SAAS;QACjB,gBAAgB,EACd,KAAK,CAAC,gBAAgB;QACxB,mBAAmB,EACjB,KAAK,CAAC,mBAAmB;QAC3B,QAAQ;QACR,WAAW,EACT,mBAAmB,CACjB,KAAK,CAAC,WAAW,EACjB,IAAI,GAAG,cAAc,CACtB;QACH,WAAW,EACT,mBAAmB,CACjB,KAAK,CAAC,WAAW,EACjB,IAAI,GAAG,cAAc,CACtB;KACJ,CAAC;AACJ,CAAC;AAED,SAAS,UAAU,CACjB,KAC2B;IAE3B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,CAAC,CAAC;IACX,CAAC;IACD,IACE,KAAK,KAAK,eAAe,EACzB,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAS,mBAAmB,CAC1B,QACyC;IAEzC,MAAM,OAAO,GACX,QAAQ,CAAC,MAAM,CACb,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CAAC,IAAI;QAC1B,SAAS,CACZ,CAAC;IAEJ,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,YAAY,EACV,OAAO,CAAC,GAAG,CACT,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB;YACH,UAAU,EACR,uGAAuG;SAC1G,CAAC;IACJ,CAAC;IAED,MAAM,YAAY,GAChB,QAAQ,CAAC,MAAM,CACb,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CAAC,IAAI;QAC1B,gBAAgB,CACnB,CAAC;IAEJ,IACE,YAAY,CAAC,MAAM,GAAG,CAAC,EACvB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,YAAY,EACV,YAAY,CAAC,GAAG,CACd,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB;YACH,UAAU,EACR,mHAAmH;SACtH,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GACd,QAAQ,CAAC,MAAM,CACb,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CAAC,IAAI;QACxB,UAAU;QACZ,SAAS,CAAC,WAAW,CAAC,IAAI;YACxB,UAAU;QACZ,SAAS,CAAC,WAAW,CAAC,IAAI;YACxB,qBAAqB,CAC1B,CAAC;IAEJ,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,YAAY,EACV,UAAU,CAAC,GAAG,CACZ,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB;YACH,UAAU,EACR,sJAAsJ;SACzJ,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,gBAAgB;QACtB,YAAY,EACV,QAAQ,CAAC,GAAG,CACV,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB;QACH,UAAU,EACR,2FAA2F;KAC9F,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,KACiC;IAEjC,gBAAgB,CAAC,KAAK,EAAE,4BAA4B,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;IACtE,IACE,CAAC,KAAK,CAAC,OAAO,CACZ,KAAK,CAAC,UAAU,CACjB;QACD,KAAK,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAC7B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,uCAAuC,CACxC,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GACd,KAAK,CAAC,UAAU,CAAC,GAAG,CAClB,iBAAiB,CAClB,CAAC;IAEJ,MAAM,GAAG,GACP,UAAU,CAAC,GAAG,CACZ,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB,CAAC;IAEJ,IACE,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI;QACjB,GAAG,CAAC,MAAM,EACV,CAAC;QACD,MAAM,IAAI,2BAA2B,CACnC,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GACZ,UAAU,CAAC,MAAM,CACf,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,QAAQ,CACrB,CAAC;IAEJ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,2BAA2B,CACnC,+DAA+D,CAChE,CAAC;IACJ,CAAC;IAED,IAAI,WAAW,GACb,MAAM,CAAC,iBAAiB,CAAC;IAE3B,KAAK,MAAM,SAAS,IAAI,QAAQ,EAAE,CAAC;QACjC,WAAW;YACT,IAAI,CAAC,GAAG,CACN,WAAW,EACX,UAAU,CACR,SAAS,CAAC,gBAAgB,CAC3B,CACF,CAAC;IACN,CAAC;IAED,MAAM,OAAO,GACX,QAAQ,CAAC,MAAM,CACb,CAAC,SAAS,EAAE,EAAE,CACZ,UAAU,CACR,SAAS,CAAC,gBAAgB,CAC3B,KAAK,WAAW,CACpB,CAAC;IAEJ,MAAM,gBAAgB,GACpB,WAAW,KAAK,CAAC;QACf,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,WAAW,KAAK,CAAC;YACjB,CAAC,CAAC,eAAe;YACjB,CAAC,CAAC,YAAY,CAAC;IAErB,MAAM,uBAAuB,GAC3B,QAAQ,CAAC,MAAM,CACb,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS;SACN,mBAAmB;QACpB,UAAU;QACZ,SAAS,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAClC,CAAC;IAEJ,MAAM,gBAAgB,GAElB,uBAAuB,CAAC,MAAM;QAC9B,CAAC;QACC,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,gBAAgB,CAAC;IAEzB,MAAM,2BAA2B,GAC/B,uBAAuB,CAAC,MAAM;QAC9B,CAAC;QACC,CAAC,CAAC,uBAAuB,CAAC,GAAG,CACzB,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB;QACH,CAAC,CAAC,OAAO,CAAC,GAAG,CACT,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB,CAAC;IAER,OAAO;QACL,OAAO,EACL,qCAAqC;QACvC,gBAAgB;QAChB,2BAA2B;QAC3B,cAAc,EACZ,uBAAuB;aACpB,MAAM,KAAK,CAAC;YACb,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,2BAA2B;QACjC,mCAAmC,EACjC,uBAAuB,CAAC,GAAG,CACzB,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,WAAW,CACxB;QACH,WAAW,EACT,mBAAmB,CACjB,QAAQ,CACT;QACH,UAAU;QACV,0BAA0B,EACxB,IAAI;QACN,6BAA6B,EAC3B,IAAI;QACN,qCAAqC,EACnC,KAAK;QACP,mCAAmC,EACjC,KAAK;KACR,CAAC;AACJ,CAAC","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Combines the scientific status, evidence and uncertainty of several pipeline stages into one\n * record, without inventing a single numeric uncertainty.\n *\n * The combined status can be no better than the weakest required input. Each component's\n * evidence and uncertainty is kept exactly as given, after validation.\n * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.\n */\n\nimport {\n  validateCalculationQuality,\n  type CalculationQuality\n} from \"./calculation-result.js\";\nimport { InvalidScientificInputError } from \"./validation.js\";\nimport {\n  parseEvidenceProvenance,\n  type EvidenceProvenance\n} from \"./evidence-provenance.js\";\nimport { requireInputKeys } from \"./record-validation.js\";\nimport { InvalidConfigurationError } from \"./configuration-error.js\";\n\nexport const SCIENTIFIC_ASSURANCE_CONTRACT_VERSION =\n  \"0.1.0\" as const;\n\nexport type ScientificAssuranceStatus =\n  | \"calibrated\"\n  | \"approximation\"\n  | \"unknown\";\n\nexport type ScientificAssuranceBasisKind =\n  | \"evidence-backed-fact\"\n  | \"photivra-model-assumption\"\n  | \"not-applicable\";\n\nexport type ScientificAssuranceSourceKind =\n  | \"profile\"\n  | \"result\"\n  | \"model\"\n  | \"fixture\";\n\nexport interface ScientificAssuranceSourceIdentity {\n  kind: ScientificAssuranceSourceKind;\n  id: string;\n  version?: string;\n}\n\nexport type ScientificAssuranceComponentUncertainty =\n  | {\n      kind: \"relative\";\n      fraction: number;\n      basis: string;\n    }\n  | {\n      kind: \"absolute\";\n      plusMinus: number;\n      unit: string;\n      basis?: string;\n    }\n  | {\n      kind: \"calculation-quality\";\n      quality: CalculationQuality;\n    }\n  | {\n      kind: \"not-quantified\";\n      limitation: string;\n    }\n  | {\n      kind: \"unknown\";\n      limitation: string;\n    }\n  | {\n      kind: \"not-applicable\";\n      reason: string;\n    };\n\nexport interface ScientificAssuranceComponent {\n  componentId: string;\n  role: string;\n  required: boolean;\n  sourceIdentity:\n    ScientificAssuranceSourceIdentity;\n  basisKind:\n    ScientificAssuranceBasisKind;\n  scientificStatus:\n    ScientificAssuranceStatus;\n  evidenceRequirement:\n    | \"required\"\n    | \"not-required\";\n  evidence:\n    readonly EvidenceProvenance[];\n  uncertainty:\n    ScientificAssuranceComponentUncertainty;\n  limitations:\n    readonly string[];\n}\n\nexport type ComposedScientificUncertaintyStatus =\n  | {\n      kind: \"unknown\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    }\n  | {\n      kind: \"not-quantified\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    }\n  | {\n      kind: \"not-propagated\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    }\n  | {\n      kind: \"not-applicable\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    };\n\n/**\n * Combined status and kept evidence for one declared scientific result across stages.\n *\n * - A required input that is incomplete or approximate limits the combined status.\n * - Deterministic processing cannot turn an approximation into a calibration.\n * - Uncertainty components stay separate unless an explicit mathematical propagation\n *   model justifies combining them.\n * - A count of successful stages is not an accuracy bound.\n */\nexport interface ComposedScientificAssurance {\n  version:\n    typeof SCIENTIFIC_ASSURANCE_CONTRACT_VERSION;\n  scientificStatus:\n    ScientificAssuranceStatus;\n  weakestRequiredComponentIds:\n    readonly string[];\n  evidenceStatus:\n    | \"complete\"\n    | \"missing-required-evidence\";\n  missingRequiredEvidenceComponentIds:\n    readonly string[];\n  uncertainty:\n    ComposedScientificUncertaintyStatus;\n  components:\n    readonly ScientificAssuranceComponent[];\n  componentEvidencePreserved: true;\n  componentUncertaintyPreserved: true;\n  aggregateNumericUncertaintyFabricated:\n    false;\n  downstreamStatusPromotedAboveInputs:\n    false;\n}\n\nexport interface ComposeScientificAssuranceInput {\n  components:\n    readonly ScientificAssuranceComponent[];\n}\n\nconst SCIENTIFIC_STATUSES =\n  new Set<ScientificAssuranceStatus>([\n    \"calibrated\",\n    \"approximation\",\n    \"unknown\"\n  ]);\n\nconst BASIS_KINDS =\n  new Set<ScientificAssuranceBasisKind>([\n    \"evidence-backed-fact\",\n    \"photivra-model-assumption\",\n    \"not-applicable\"\n  ]);\n\nconst SOURCE_KINDS =\n  new Set<ScientificAssuranceSourceKind>([\n    \"profile\",\n    \"result\",\n    \"model\",\n    \"fixture\"\n  ]);\n\nfunction requireNonEmptyString(\n  value: unknown,\n  path: string\n): string {\n  if (\n    typeof value !== \"string\" ||\n    value.trim().length === 0\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \" must be a non-empty string.\"\n    );\n  }\n  return value.trim();\n}\n\nfunction requireNonNegativeFinite(\n  value: unknown,\n  path: string\n): number {\n  if (\n    typeof value !== \"number\" ||\n    !Number.isFinite(value) ||\n    value < 0\n  ) {\n    throw new InvalidScientificInputError(\n      path +\n        \" must be finite and greater than or equal to zero.\"\n    );\n  }\n  return value;\n}\n\nfunction validateSourceIdentity(\n  value:\n    ScientificAssuranceSourceIdentity,\n  path: string\n): ScientificAssuranceSourceIdentity {\n  if (\n    !SOURCE_KINDS.has(\n      value.kind as\n        ScientificAssuranceSourceKind\n    )\n  ) {\n    throw new InvalidConfigurationError(\n      path + \".kind is invalid.\"\n    );\n  }\n\n  return {\n    kind: value.kind,\n    id:\n      requireNonEmptyString(\n        value.id,\n        path + \".id\"\n      ),\n    ...(value.version === undefined\n      ? {}\n      : {\n          version:\n            requireNonEmptyString(\n              value.version,\n              path + \".version\"\n            )\n        })\n  };\n}\n\nfunction validateUncertainty(\n  value:\n    ScientificAssuranceComponentUncertainty,\n  path: string\n): ScientificAssuranceComponentUncertainty {\n  if (value.kind === \"relative\") {\n    const fraction =\n      requireNonNegativeFinite(\n        value.fraction,\n        path + \".fraction\"\n      );\n    if (fraction > 1) {\n      throw new InvalidScientificInputError(\n        path +\n          \".fraction must be less than or equal to one.\"\n      );\n    }\n    return {\n      kind: \"relative\",\n      fraction,\n      basis:\n        requireNonEmptyString(\n          value.basis,\n          path + \".basis\"\n        )\n    };\n  }\n\n  if (value.kind === \"absolute\") {\n    return {\n      kind: \"absolute\",\n      plusMinus:\n        requireNonNegativeFinite(\n          value.plusMinus,\n          path + \".plusMinus\"\n        ),\n      unit:\n        requireNonEmptyString(\n          value.unit,\n          path + \".unit\"\n        ),\n      ...(value.basis === undefined\n        ? {}\n        : {\n            basis:\n              requireNonEmptyString(\n                value.basis,\n                path + \".basis\"\n              )\n          })\n    };\n  }\n\n  if (\n    value.kind ===\n    \"calculation-quality\"\n  ) {\n    validateCalculationQuality(\n      value.quality\n    );\n    if (\n      value.quality\n        .uncertainty ===\n        undefined ||\n      value.quality\n        .uncertainty.length ===\n        0\n    ) {\n      throw new InvalidScientificInputError(\n        path +\n          \".quality must include quantified uncertainty components; use another semantic uncertainty state otherwise.\"\n      );\n    }\n    return {\n      kind:\n        \"calculation-quality\",\n      quality: value.quality\n    };\n  }\n\n  if (\n    value.kind ===\n    \"not-quantified\"\n  ) {\n    return {\n      kind: \"not-quantified\",\n      limitation:\n        requireNonEmptyString(\n          value.limitation,\n          path + \".limitation\"\n        )\n    };\n  }\n\n  if (value.kind === \"unknown\") {\n    return {\n      kind: \"unknown\",\n      limitation:\n        requireNonEmptyString(\n          value.limitation,\n          path + \".limitation\"\n        )\n    };\n  }\n\n  if (\n    value.kind ===\n    \"not-applicable\"\n  ) {\n    return {\n      kind: \"not-applicable\",\n      reason:\n        requireNonEmptyString(\n          value.reason,\n          path + \".reason\"\n        )\n    };\n  }\n\n  throw new InvalidConfigurationError(\n    path + \".kind is invalid.\"\n  );\n}\n\nfunction validateLimitations(\n  value: readonly string[],\n  path: string\n): readonly string[] {\n  if (!Array.isArray(value)) {\n    throw new InvalidConfigurationError(\n      path + \" must be an array.\"\n    );\n  }\n\n  const parsed =\n    value.map((entry, index) =>\n      requireNonEmptyString(\n        entry,\n        path +\n          \"[\" +\n          index +\n          \"]\"\n      )\n    );\n\n  if (\n    new Set(parsed).size !==\n    parsed.length\n  ) {\n    throw new InvalidScientificInputError(\n      path +\n        \" must not contain duplicates.\"\n    );\n  }\n\n  return parsed;\n}\n\nfunction validateComponent(\n  value:\n    ScientificAssuranceComponent,\n  index: number\n): ScientificAssuranceComponent {\n  const path =\n    \"components[\" +\n    index +\n    \"]\";\n\n  if (\n    typeof value.required !==\n    \"boolean\"\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".required must be boolean.\"\n    );\n  }\n\n  if (\n    !BASIS_KINDS.has(\n      value.basisKind as\n        ScientificAssuranceBasisKind\n    )\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".basisKind is invalid.\"\n    );\n  }\n\n  if (\n    !SCIENTIFIC_STATUSES.has(\n      value.scientificStatus as\n        ScientificAssuranceStatus\n    )\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".scientificStatus is invalid.\"\n    );\n  }\n\n  if (\n    value.basisKind ===\n      \"evidence-backed-fact\" &&\n    value.evidenceRequirement !==\n      \"required\"\n  ) {\n    throw new InvalidScientificInputError(\n      path +\n        '.basisKind \"evidence-backed-fact\" requires evidenceRequirement \"required\".'\n    );\n  }\n\n  if (\n    value.evidenceRequirement !==\n      \"required\" &&\n    value.evidenceRequirement !==\n      \"not-required\"\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".evidenceRequirement is invalid.\"\n    );\n  }\n\n  if (!Array.isArray(value.evidence)) {\n    throw new InvalidConfigurationError(\n      path +\n        \".evidence must be an array.\"\n    );\n  }\n\n  const evidence =\n    value.evidence.map(\n      (entry, evidenceIndex) =>\n        parseEvidenceProvenance(\n          entry,\n          path +\n            \".evidence[\" +\n            evidenceIndex +\n            \"]\"\n        )\n    );\n\n  return {\n    componentId:\n      requireNonEmptyString(\n        value.componentId,\n        path + \".componentId\"\n      ),\n    role:\n      requireNonEmptyString(\n        value.role,\n        path + \".role\"\n      ),\n    required: value.required,\n    sourceIdentity:\n      validateSourceIdentity(\n        value.sourceIdentity,\n        path +\n          \".sourceIdentity\"\n      ),\n    basisKind:\n      value.basisKind,\n    scientificStatus:\n      value.scientificStatus,\n    evidenceRequirement:\n      value.evidenceRequirement,\n    evidence,\n    uncertainty:\n      validateUncertainty(\n        value.uncertainty,\n        path + \".uncertainty\"\n      ),\n    limitations:\n      validateLimitations(\n        value.limitations,\n        path + \".limitations\"\n      )\n  };\n}\n\nfunction statusRank(\n  value:\n    ScientificAssuranceStatus\n): number {\n  if (value === \"unknown\") {\n    return 0;\n  }\n  if (\n    value === \"approximation\"\n  ) {\n    return 1;\n  }\n  return 2;\n}\n\nfunction composedUncertainty(\n  required:\n    readonly ScientificAssuranceComponent[]\n): ComposedScientificUncertaintyStatus {\n  const unknown =\n    required.filter(\n      (component) =>\n        component.uncertainty.kind ===\n        \"unknown\"\n    );\n\n  if (unknown.length > 0) {\n    return {\n      kind: \"unknown\",\n      componentIds:\n        unknown.map(\n          (component) =>\n            component.componentId\n        ),\n      limitation:\n        \"At least one required component has unknown uncertainty; no aggregate numeric uncertainty is claimed.\"\n    };\n  }\n\n  const unquantified =\n    required.filter(\n      (component) =>\n        component.uncertainty.kind ===\n        \"not-quantified\"\n    );\n\n  if (\n    unquantified.length > 0\n  ) {\n    return {\n      kind: \"not-quantified\",\n      componentIds:\n        unquantified.map(\n          (component) =>\n            component.componentId\n        ),\n      limitation:\n        \"At least one required component has unquantified uncertainty; absence of a numeric bound is not zero uncertainty.\"\n    };\n  }\n\n  const quantified =\n    required.filter(\n      (component) =>\n        component.uncertainty.kind ===\n          \"relative\" ||\n        component.uncertainty.kind ===\n          \"absolute\" ||\n        component.uncertainty.kind ===\n          \"calculation-quality\"\n    );\n\n  if (quantified.length > 0) {\n    return {\n      kind: \"not-propagated\",\n      componentIds:\n        quantified.map(\n          (component) =>\n            component.componentId\n        ),\n      limitation:\n        \"Quantified component uncertainties are preserved but are not numerically combined without an explicit propagation model and correlation assumptions.\"\n    };\n  }\n\n  return {\n    kind: \"not-applicable\",\n    componentIds:\n      required.map(\n        (component) =>\n          component.componentId\n      ),\n    limitation:\n      \"No required component declares a quantitative uncertainty applicable to this composition.\"\n  };\n}\n\n/**\n * Combines the scientific status, evidence and uncertainty of several inputs into one\n * record, without inventing a single numeric uncertainty.\n *\n * The combined status can be no better than the weakest required input. Each component's\n * evidence and uncertainty is kept exactly as given, after validation.\n */\nexport function composeScientificAssurance(\n  input:\n    ComposeScientificAssuranceInput\n): ComposedScientificAssurance {\n  requireInputKeys(input, \"composeScientificAssurance\", [\"components\"]);\n  if (\n    !Array.isArray(\n      input.components\n    ) ||\n    input.components.length === 0\n  ) {\n    throw new InvalidConfigurationError(\n      \"components must be a non-empty array.\"\n    );\n  }\n\n  const components =\n    input.components.map(\n      validateComponent\n    );\n\n  const ids =\n    components.map(\n      (component) =>\n        component.componentId\n    );\n\n  if (\n    new Set(ids).size !==\n    ids.length\n  ) {\n    throw new InvalidScientificInputError(\n      \"components must not contain duplicate componentId values.\"\n    );\n  }\n\n  const required =\n    components.filter(\n      (component) =>\n        component.required\n    );\n\n  if (required.length === 0) {\n    throw new InvalidScientificInputError(\n      \"At least one scientific-assurance component must be required.\"\n    );\n  }\n\n  let weakestRank =\n    Number.POSITIVE_INFINITY;\n\n  for (const component of required) {\n    weakestRank =\n      Math.min(\n        weakestRank,\n        statusRank(\n          component.scientificStatus\n        )\n      );\n  }\n\n  const weakest =\n    required.filter(\n      (component) =>\n        statusRank(\n          component.scientificStatus\n        ) === weakestRank\n    );\n\n  const statusFromInputs =\n    weakestRank === 0\n      ? \"unknown\"\n      : weakestRank === 1\n        ? \"approximation\"\n        : \"calibrated\";\n\n  const missingRequiredEvidence =\n    required.filter(\n      (component) =>\n        component\n          .evidenceRequirement ===\n          \"required\" &&\n        component.evidence.length === 0\n    );\n\n  const scientificStatus:\n    ScientificAssuranceStatus =\n      missingRequiredEvidence.length >\n      0\n        ? \"unknown\"\n        : statusFromInputs;\n\n  const weakestRequiredComponentIds =\n    missingRequiredEvidence.length >\n    0\n      ? missingRequiredEvidence.map(\n          (component) =>\n            component.componentId\n        )\n      : weakest.map(\n          (component) =>\n            component.componentId\n        );\n\n  return {\n    version:\n      SCIENTIFIC_ASSURANCE_CONTRACT_VERSION,\n    scientificStatus,\n    weakestRequiredComponentIds,\n    evidenceStatus:\n      missingRequiredEvidence\n        .length === 0\n        ? \"complete\"\n        : \"missing-required-evidence\",\n    missingRequiredEvidenceComponentIds:\n      missingRequiredEvidence.map(\n        (component) =>\n          component.componentId\n      ),\n    uncertainty:\n      composedUncertainty(\n        required\n      ),\n    components,\n    componentEvidencePreserved:\n      true,\n    componentUncertaintyPreserved:\n      true,\n    aggregateNumericUncertaintyFabricated:\n      false,\n    downstreamStatusPromotedAboveInputs:\n      false\n  };\n}\n"]}
+{"version":3,"file":"scientific-assurance.js","sourceRoot":"","sources":["../../src/core/scientific-assurance.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Combines the scientific status, evidence and uncertainty of several pipeline stages into one\n * record, without inventing a single numeric uncertainty.\n *\n * The combined status can be no better than the weakest required input. Each component's\n * evidence and uncertainty is kept exactly as given, after validation.\n * @see docs/API_STYLE.md for equations, coordinate/unit conventions, blockers and support limits.\n */\n\nimport {\n  validateCalculationQuality,\n  type CalculationQuality\n} from \"./calculation-result.js\";\nimport { InvalidScientificInputError } from \"./validation.js\";\nimport {\n  parseEvidenceProvenance,\n  type EvidenceProvenance\n} from \"./evidence-provenance.js\";\nimport { requireInputKeys, requireTrimmedConfigString as requireNonEmptyString, requireInputNonNegativeFinite as requireNonNegativeFinite } from \"./record-validation.js\";\nimport { InvalidConfigurationError } from \"./configuration-error.js\";\n\nexport const SCIENTIFIC_ASSURANCE_CONTRACT_VERSION =\n  \"0.1.0\" as const;\n\nexport type ScientificAssuranceStatus =\n  | \"calibrated\"\n  | \"approximation\"\n  | \"unknown\";\n\nexport type ScientificAssuranceBasisKind =\n  | \"evidence-backed-fact\"\n  | \"photivra-model-assumption\"\n  | \"not-applicable\";\n\nexport type ScientificAssuranceSourceKind =\n  | \"profile\"\n  | \"result\"\n  | \"model\"\n  | \"fixture\";\n\nexport interface ScientificAssuranceSourceIdentity {\n  kind: ScientificAssuranceSourceKind;\n  id: string;\n  version?: string;\n}\n\nexport type ScientificAssuranceComponentUncertainty =\n  | {\n      kind: \"relative\";\n      fraction: number;\n      basis: string;\n    }\n  | {\n      kind: \"absolute\";\n      plusMinus: number;\n      unit: string;\n      basis?: string;\n    }\n  | {\n      kind: \"calculation-quality\";\n      quality: CalculationQuality;\n    }\n  | {\n      kind: \"not-quantified\";\n      limitation: string;\n    }\n  | {\n      kind: \"unknown\";\n      limitation: string;\n    }\n  | {\n      kind: \"not-applicable\";\n      reason: string;\n    };\n\nexport interface ScientificAssuranceComponent {\n  componentId: string;\n  role: string;\n  required: boolean;\n  sourceIdentity:\n    ScientificAssuranceSourceIdentity;\n  basisKind:\n    ScientificAssuranceBasisKind;\n  scientificStatus:\n    ScientificAssuranceStatus;\n  evidenceRequirement:\n    | \"required\"\n    | \"not-required\";\n  evidence:\n    readonly EvidenceProvenance[];\n  uncertainty:\n    ScientificAssuranceComponentUncertainty;\n  limitations:\n    readonly string[];\n}\n\nexport type ComposedScientificUncertaintyStatus =\n  | {\n      kind: \"unknown\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    }\n  | {\n      kind: \"not-quantified\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    }\n  | {\n      kind: \"not-propagated\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    }\n  | {\n      kind: \"not-applicable\";\n      componentIds:\n        readonly string[];\n      limitation: string;\n    };\n\n/**\n * Combined status and kept evidence for one declared scientific result across stages.\n *\n * - A required input that is incomplete or approximate limits the combined status.\n * - Deterministic processing cannot turn an approximation into a calibration.\n * - Uncertainty components stay separate unless an explicit mathematical propagation\n *   model justifies combining them.\n * - A count of successful stages is not an accuracy bound.\n */\nexport interface ComposedScientificAssurance {\n  version:\n    typeof SCIENTIFIC_ASSURANCE_CONTRACT_VERSION;\n  scientificStatus:\n    ScientificAssuranceStatus;\n  weakestRequiredComponentIds:\n    readonly string[];\n  evidenceStatus:\n    | \"complete\"\n    | \"missing-required-evidence\";\n  missingRequiredEvidenceComponentIds:\n    readonly string[];\n  uncertainty:\n    ComposedScientificUncertaintyStatus;\n  components:\n    readonly ScientificAssuranceComponent[];\n  componentEvidencePreserved: true;\n  componentUncertaintyPreserved: true;\n  aggregateNumericUncertaintyFabricated:\n    false;\n  downstreamStatusPromotedAboveInputs:\n    false;\n}\n\nexport interface ComposeScientificAssuranceInput {\n  components:\n    readonly ScientificAssuranceComponent[];\n}\n\nconst SCIENTIFIC_STATUSES =\n  new Set<ScientificAssuranceStatus>([\n    \"calibrated\",\n    \"approximation\",\n    \"unknown\"\n  ]);\n\nconst BASIS_KINDS =\n  new Set<ScientificAssuranceBasisKind>([\n    \"evidence-backed-fact\",\n    \"photivra-model-assumption\",\n    \"not-applicable\"\n  ]);\n\nconst SOURCE_KINDS =\n  new Set<ScientificAssuranceSourceKind>([\n    \"profile\",\n    \"result\",\n    \"model\",\n    \"fixture\"\n  ]);\n\nfunction validateSourceIdentity(\n  value:\n    ScientificAssuranceSourceIdentity,\n  path: string\n): ScientificAssuranceSourceIdentity {\n  if (\n    !SOURCE_KINDS.has(\n      value.kind as\n        ScientificAssuranceSourceKind\n    )\n  ) {\n    throw new InvalidConfigurationError(\n      path + \".kind is invalid.\"\n    );\n  }\n\n  return {\n    kind: value.kind,\n    id:\n      requireNonEmptyString(\n        value.id,\n        path + \".id\"\n      ),\n    ...(value.version === undefined\n      ? {}\n      : {\n          version:\n            requireNonEmptyString(\n              value.version,\n              path + \".version\"\n            )\n        })\n  };\n}\n\nfunction validateUncertainty(\n  value:\n    ScientificAssuranceComponentUncertainty,\n  path: string\n): ScientificAssuranceComponentUncertainty {\n  if (value.kind === \"relative\") {\n    const fraction =\n      requireNonNegativeFinite(\n        value.fraction,\n        path + \".fraction\"\n      );\n    if (fraction > 1) {\n      throw new InvalidScientificInputError(\n        path +\n          \".fraction must be less than or equal to one.\"\n      );\n    }\n    return {\n      kind: \"relative\",\n      fraction,\n      basis:\n        requireNonEmptyString(\n          value.basis,\n          path + \".basis\"\n        )\n    };\n  }\n\n  if (value.kind === \"absolute\") {\n    return {\n      kind: \"absolute\",\n      plusMinus:\n        requireNonNegativeFinite(\n          value.plusMinus,\n          path + \".plusMinus\"\n        ),\n      unit:\n        requireNonEmptyString(\n          value.unit,\n          path + \".unit\"\n        ),\n      ...(value.basis === undefined\n        ? {}\n        : {\n            basis:\n              requireNonEmptyString(\n                value.basis,\n                path + \".basis\"\n              )\n          })\n    };\n  }\n\n  if (\n    value.kind ===\n    \"calculation-quality\"\n  ) {\n    validateCalculationQuality(\n      value.quality\n    );\n    if (\n      value.quality\n        .uncertainty ===\n        undefined ||\n      value.quality\n        .uncertainty.length ===\n        0\n    ) {\n      throw new InvalidScientificInputError(\n        path +\n          \".quality must include quantified uncertainty components; use another semantic uncertainty state otherwise.\"\n      );\n    }\n    return {\n      kind:\n        \"calculation-quality\",\n      quality: value.quality\n    };\n  }\n\n  if (\n    value.kind ===\n    \"not-quantified\"\n  ) {\n    return {\n      kind: \"not-quantified\",\n      limitation:\n        requireNonEmptyString(\n          value.limitation,\n          path + \".limitation\"\n        )\n    };\n  }\n\n  if (value.kind === \"unknown\") {\n    return {\n      kind: \"unknown\",\n      limitation:\n        requireNonEmptyString(\n          value.limitation,\n          path + \".limitation\"\n        )\n    };\n  }\n\n  if (\n    value.kind ===\n    \"not-applicable\"\n  ) {\n    return {\n      kind: \"not-applicable\",\n      reason:\n        requireNonEmptyString(\n          value.reason,\n          path + \".reason\"\n        )\n    };\n  }\n\n  throw new InvalidConfigurationError(\n    path + \".kind is invalid.\"\n  );\n}\n\nfunction validateLimitations(\n  value: readonly string[],\n  path: string\n): readonly string[] {\n  if (!Array.isArray(value)) {\n    throw new InvalidConfigurationError(\n      path + \" must be an array.\"\n    );\n  }\n\n  const parsed =\n    value.map((entry, index) =>\n      requireNonEmptyString(\n        entry,\n        path +\n          \"[\" +\n          index +\n          \"]\"\n      )\n    );\n\n  if (\n    new Set(parsed).size !==\n    parsed.length\n  ) {\n    throw new InvalidScientificInputError(\n      path +\n        \" must not contain duplicates.\"\n    );\n  }\n\n  return parsed;\n}\n\nfunction validateComponent(\n  value:\n    ScientificAssuranceComponent,\n  index: number\n): ScientificAssuranceComponent {\n  const path =\n    \"components[\" +\n    index +\n    \"]\";\n\n  if (\n    typeof value.required !==\n    \"boolean\"\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".required must be boolean.\"\n    );\n  }\n\n  if (\n    !BASIS_KINDS.has(\n      value.basisKind as\n        ScientificAssuranceBasisKind\n    )\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".basisKind is invalid.\"\n    );\n  }\n\n  if (\n    !SCIENTIFIC_STATUSES.has(\n      value.scientificStatus as\n        ScientificAssuranceStatus\n    )\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".scientificStatus is invalid.\"\n    );\n  }\n\n  if (\n    value.basisKind ===\n      \"evidence-backed-fact\" &&\n    value.evidenceRequirement !==\n      \"required\"\n  ) {\n    throw new InvalidScientificInputError(\n      path +\n        '.basisKind \"evidence-backed-fact\" requires evidenceRequirement \"required\".'\n    );\n  }\n\n  if (\n    value.evidenceRequirement !==\n      \"required\" &&\n    value.evidenceRequirement !==\n      \"not-required\"\n  ) {\n    throw new InvalidConfigurationError(\n      path +\n        \".evidenceRequirement is invalid.\"\n    );\n  }\n\n  if (!Array.isArray(value.evidence)) {\n    throw new InvalidConfigurationError(\n      path +\n        \".evidence must be an array.\"\n    );\n  }\n\n  const evidence =\n    value.evidence.map(\n      (entry, evidenceIndex) =>\n        parseEvidenceProvenance(\n          entry,\n          path +\n            \".evidence[\" +\n            evidenceIndex +\n            \"]\"\n        )\n    );\n\n  return {\n    componentId:\n      requireNonEmptyString(\n        value.componentId,\n        path + \".componentId\"\n      ),\n    role:\n      requireNonEmptyString(\n        value.role,\n        path + \".role\"\n      ),\n    required: value.required,\n    sourceIdentity:\n      validateSourceIdentity(\n        value.sourceIdentity,\n        path +\n          \".sourceIdentity\"\n      ),\n    basisKind:\n      value.basisKind,\n    scientificStatus:\n      value.scientificStatus,\n    evidenceRequirement:\n      value.evidenceRequirement,\n    evidence,\n    uncertainty:\n      validateUncertainty(\n        value.uncertainty,\n        path + \".uncertainty\"\n      ),\n    limitations:\n      validateLimitations(\n        value.limitations,\n        path + \".limitations\"\n      )\n  };\n}\n\nfunction statusRank(\n  value:\n    ScientificAssuranceStatus\n): number {\n  if (value === \"unknown\") {\n    return 0;\n  }\n  if (\n    value === \"approximation\"\n  ) {\n    return 1;\n  }\n  return 2;\n}\n\nfunction composedUncertainty(\n  required:\n    readonly ScientificAssuranceComponent[]\n): ComposedScientificUncertaintyStatus {\n  const unknown =\n    required.filter(\n      (component) =>\n        component.uncertainty.kind ===\n        \"unknown\"\n    );\n\n  if (unknown.length > 0) {\n    return {\n      kind: \"unknown\",\n      componentIds:\n        unknown.map(\n          (component) =>\n            component.componentId\n        ),\n      limitation:\n        \"At least one required component has unknown uncertainty; no aggregate numeric uncertainty is claimed.\"\n    };\n  }\n\n  const unquantified =\n    required.filter(\n      (component) =>\n        component.uncertainty.kind ===\n        \"not-quantified\"\n    );\n\n  if (\n    unquantified.length > 0\n  ) {\n    return {\n      kind: \"not-quantified\",\n      componentIds:\n        unquantified.map(\n          (component) =>\n            component.componentId\n        ),\n      limitation:\n        \"At least one required component has unquantified uncertainty; absence of a numeric bound is not zero uncertainty.\"\n    };\n  }\n\n  const quantified =\n    required.filter(\n      (component) =>\n        component.uncertainty.kind ===\n          \"relative\" ||\n        component.uncertainty.kind ===\n          \"absolute\" ||\n        component.uncertainty.kind ===\n          \"calculation-quality\"\n    );\n\n  if (quantified.length > 0) {\n    return {\n      kind: \"not-propagated\",\n      componentIds:\n        quantified.map(\n          (component) =>\n            component.componentId\n        ),\n      limitation:\n        \"Quantified component uncertainties are preserved but are not numerically combined without an explicit propagation model and correlation assumptions.\"\n    };\n  }\n\n  return {\n    kind: \"not-applicable\",\n    componentIds:\n      required.map(\n        (component) =>\n          component.componentId\n      ),\n    limitation:\n      \"No required component declares a quantitative uncertainty applicable to this composition.\"\n  };\n}\n\n/**\n * Combines the scientific status, evidence and uncertainty of several inputs into one\n * record, without inventing a single numeric uncertainty.\n *\n * The combined status can be no better than the weakest required input. Each component's\n * evidence and uncertainty is kept exactly as given, after validation.\n */\nexport function composeScientificAssurance(\n  input:\n    ComposeScientificAssuranceInput\n): ComposedScientificAssurance {\n  requireInputKeys(input, \"composeScientificAssurance\", [\"components\"]);\n  if (\n    !Array.isArray(\n      input.components\n    ) ||\n    input.components.length === 0\n  ) {\n    throw new InvalidConfigurationError(\n      \"components must be a non-empty array.\"\n    );\n  }\n\n  const components =\n    input.components.map(\n      validateComponent\n    );\n\n  const ids =\n    components.map(\n      (component) =>\n        component.componentId\n    );\n\n  if (\n    new Set(ids).size !==\n    ids.length\n  ) {\n    throw new InvalidScientificInputError(\n      \"components must not contain duplicate componentId values.\"\n    );\n  }\n\n  const required =\n    components.filter(\n      (component) =>\n        component.required\n    );\n\n  if (required.length === 0) {\n    throw new InvalidScientificInputError(\n      \"At least one scientific-assurance component must be required.\"\n    );\n  }\n\n  let weakestRank =\n    Number.POSITIVE_INFINITY;\n\n  for (const component of required) {\n    weakestRank =\n      Math.min(\n        weakestRank,\n        statusRank(\n          component.scientificStatus\n        )\n      );\n  }\n\n  const weakest =\n    required.filter(\n      (component) =>\n        statusRank(\n          component.scientificStatus\n        ) === weakestRank\n    );\n\n  const statusFromInputs =\n    weakestRank === 0\n      ? \"unknown\"\n      : weakestRank === 1\n        ? \"approximation\"\n        : \"calibrated\";\n\n  const missingRequiredEvidence =\n    required.filter(\n      (component) =>\n        component\n          .evidenceRequirement ===\n          \"required\" &&\n        component.evidence.length === 0\n    );\n\n  const scientificStatus:\n    ScientificAssuranceStatus =\n      missingRequiredEvidence.length >\n      0\n        ? \"unknown\"\n        : statusFromInputs;\n\n  const weakestRequiredComponentIds =\n    missingRequiredEvidence.length >\n    0\n      ? missingRequiredEvidence.map(\n          (component) =>\n            component.componentId\n        )\n      : weakest.map(\n          (component) =>\n            component.componentId\n        );\n\n  return {\n    version:\n      SCIENTIFIC_ASSURANCE_CONTRACT_VERSION,\n    scientificStatus,\n    weakestRequiredComponentIds,\n    evidenceStatus:\n      missingRequiredEvidence\n        .length === 0\n        ? \"complete\"\n        : \"missing-required-evidence\",\n    missingRequiredEvidenceComponentIds:\n      missingRequiredEvidence.map(\n        (component) =>\n          component.componentId\n      ),\n    uncertainty:\n      composedUncertainty(\n        required\n      ),\n    components,\n    componentEvidencePreserved:\n      true,\n    componentUncertaintyPreserved:\n      true,\n    aggregateNumericUncertaintyFabricated:\n      false,\n    downstreamStatusPromotedAboveInputs:\n      false\n  };\n}\n"]}

package/dist/core/shared-helpers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Small helpers shared by several modules (2.19.0: these were private copies in each; one shared copy keeps the bundles
+ * smaller). Behaviour is unchanged.
+ */
+/** Freezes a value and every object it holds, depth first; already frozen objects are left as they are. */
+export declare function deepFreeze<T>(value: T): T;
+/** A deep copy of JSON data. */
+export declare function cloneJson<T>(value: T): T;
+/** A running sum with Kahan compensation. */
+export interface CompensatedSum {
+    sum: number;
+    correction: number;
+}
+/** Adds `value` to a Kahan-compensated sum (Kahan 1965). */
+export declare function addCompensated(state: CompensatedSum, value: number): void;
+/** Whether two points (or sites) have the same x and y. */
+export declare function sameSite(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}): boolean;
+/** The whole raster as a rectangle at the origin. */
+export declare function fullRect(raster: {
+    pixelWidth: number;
+    pixelHeight: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};