@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/reference-data/catalog.d.ts

@@ -6,13 +6,6 @@ export declare const REFERENCE_DATA_CATALOG_VERSION: 1;
 export declare const ReferenceArtifactPathSchema: z.ZodString;
 /** Lowercase SHA-256 digest of one artifact's bytes. */
 export declare const ReferenceSha256Schema: z.ZodString;
-/**
- * Logical content format, independent of compression: a `.txt.gz` mapping table
- * is `tsv`, not `gz`. Agents pick a reader from this rather than guessing from
- * the extension, so it stays a free token instead of an enum — a new source must
- * remain cheap to add, and an unrecognized format degrades to "unknown reader"
- * rather than failing catalog validation.
- */
 export declare const ReferenceArtifactFormatSchema: z.ZodString;
 /**
  * One final file distributed for a reference dataset: a stable install-relative
@@ -35,12 +28,6 @@ export declare const ReferenceArtifactSchema: z.ZodObject<{
     format: z.ZodString;
     contents: z.ZodString;
 }, z.core.$strict>;
-/**
- * Common-name organism the dataset describes, lowercase (`human`, `mouse`, `rat`).
- * Omitted for species-agnostic or multi-species sources. This is the axis a wrong
- * choice is most silently wrong on — human regulons over mouse counts still run —
- * so it is a first-class field rather than something inferred from the id suffix.
- */
 export declare const ReferenceOrganismSchema: z.ZodString;
 /** Provenance and licensing information for one supported reference dataset. */
 export declare const ReferenceDatasetSchema: z.ZodObject<{
@@ -128,10 +115,10 @@ export type ReferenceInstallPlanDataset = ReferenceDataset & {
     readonly installPath: string;
 };
 /** Deterministic plan; every artifact carries the upstream URL it is fetched from. */
-export interface ReferenceInstallPlan {
+export type ReferenceInstallPlan = {
     readonly catalogVersion: typeof REFERENCE_DATA_CATALOG_VERSION;
     readonly datasets: readonly ReferenceInstallPlanDataset[];
-}
+};
 /** A requested dataset id was not present in the selected catalog. */
 export declare class UnknownReferenceDatasetError extends Error {
     readonly code: "unknown_reference_dataset";

package/dist/reference-data/catalog.js

@@ -1,10 +1,16 @@
 import { posix as posixPath } from "node:path";
 import { err, ok } from "neverthrow";
+import { presentGet } from "../lib/present.js";
+import { isUnknownArray } from "../lib/unknown-array.js";
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
 import { z } from "zod";
 /** Schema version for the checked-in reference-data catalog. */
 export const REFERENCE_DATA_CATALOG_VERSION = 1;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a dataset id is lowercase segments joined by one separator; the shape is the stable-id rule.
 const SAFE_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a version is alphanumeric segments joined by one separator; the shape is the path-segment rule.
 const SAFE_VERSION = /^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a lowercase SHA-256 digest is 64 hex digits, the fixed digest shape.
 const SHA256 = /^[a-f0-9]{64}$/;
 function isSafeRelativePath(value) {
     if (value.length === 0 || value.includes("\\") || value.startsWith("/"))
@@ -28,7 +34,9 @@ const ReferenceArtifactUrlSchema = z.url().refine((value) => value.startsWith("h
  * remain cheap to add, and an unrecognized format degrades to "unknown reader"
  * rather than failing catalog validation.
  */
-export const ReferenceArtifactFormatSchema = z.string().regex(/^[a-z0-9]+(?:[+-][a-z0-9]+)*$/, "Expected a lowercase format token");
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a format token is lowercase segments joined by one plus sign, the free-token rule the reader table keys on.
+const FORMAT_TOKEN_RE = /^[a-z0-9]+(?:[+-][a-z0-9]+)*$/;
+export const ReferenceArtifactFormatSchema = z.string().regex(FORMAT_TOKEN_RE, "Expected a lowercase format token");
 /**
  * One final file distributed for a reference dataset: a stable install-relative
  * path and the third-party https URL it is fetched from. The catalog carries no
@@ -56,7 +64,9 @@ export const ReferenceArtifactSchema = z.strictObject({
  * choice is most silently wrong on — human regulons over mouse counts still run —
  * so it is a first-class field rather than something inferred from the id suffix.
  */
-export const ReferenceOrganismSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[ -][a-z0-9]+)*$/, "Expected a lowercase organism common name");
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- an organism common name is lowercase words joined by a space or hyphen; the shape keeps the search axis one canonical form.
+const ORGANISM_NAME_RE = /^[a-z][a-z0-9]*(?:[ -][a-z0-9]+)*$/;
+export const ReferenceOrganismSchema = z.string().regex(ORGANISM_NAME_RE, "Expected a lowercase organism common name");
 /** Provenance and licensing information for one supported reference dataset. */
 export const ReferenceDatasetSchema = z.object({
     id: z.string().regex(SAFE_ID, "Expected a stable lowercase dataset id"),
@@ -109,12 +119,19 @@ export const ReferenceDataCatalogSchema = z
 export function referenceArtifactKey(dataset, artifact) {
     return `${dataset.id}/${dataset.version}/${artifact.path}`;
 }
+// The walk freezes the original container: a rebuild would freeze a copy and
+// leave the real value mutable. z.custom passes the value through on success, so
+// the check decides "record or array" without producing a second object.
+const FreezableContainer = z.custom((value) => isUnknownArray(value) || parseUnknownRecord(value) !== undefined);
 function deepFreeze(value) {
-    if (value && typeof value === "object" && !Object.isFrozen(value)) {
-        for (const nested of Object.values(value))
-            deepFreeze(nested);
-        Object.freeze(value);
-    }
+    const parsed = FreezableContainer.safeParse(value);
+    if (!parsed.success)
+        return value;
+    if (Object.isFrozen(parsed.data))
+        return value;
+    for (const nested of Object.values(parsed.data))
+        deepFreeze(nested);
+    Object.freeze(parsed.data);
     return value;
 }
 /**
@@ -2103,7 +2120,7 @@ export function resolveReferenceInstallPlanFromCatalogForTesting(datasetIds, cat
     return ok({
         catalogVersion: catalog.version,
         datasets: selectedIds.map((id) => {
-            const dataset = byId.get(id);
+            const dataset = presentGet(byId, id, "the selected dataset");
             return { ...dataset, installPath: `${dataset.id}/${dataset.version}` };
         }),
     });

package/dist/reference-data/receipt.d.ts

@@ -13,11 +13,11 @@ declare const ReferenceReceiptArtifactSchema: z.ZodObject<{
     sha256: z.ZodString;
 }, z.core.$strip>;
 /** The fields of a receipt that identify the installed content. */
-export interface ReferenceReceiptContent {
+export type ReferenceReceiptContent = {
     readonly datasetId: string;
     readonly datasetVersion: string;
     readonly artifacts: readonly ReferenceReceiptArtifact[];
-}
+};
 /**
  * The identity of the installed bytes, independent of the install time. Consumers outside the
  * harness recompute it, so the input bytes are a contract: the SHA-256 of the compact JSON array

package/dist/report-model/assert-rules.js

@@ -93,5 +93,5 @@ export function checkCitationAssertion(reference, expected, resolved) {
     if (expected === undefined || expected === resolved) {
         return undefined;
     }
-    return { reference, reason: "assertion-failed", detail: `expected ${String(expected)} but resolved citation ${resolved}` };
+    return { reference, reason: "assertion-failed", detail: `expected ${expected} but resolved citation ${resolved}` };
 }