oh-my-knowledge 0.48.0 → 0.49.0

package/dist/shared/artifact-graph.js

@@ -0,0 +1,224 @@
+import { normalizeRfc3339Timestamp } from './timestamp.js';
+const SOURCE_KINDS = new Set(['doctor', 'eval', 'observe']);
+const ARTIFACT_KINDS = new Set(['skill', 'prompt', 'agent', 'workflow']);
+const LAYERS = new Set(['definition', 'measurement', 'production']);
+const NODE_ROLES = new Set(['entity', 'observation', 'aggregate']);
+const NODE_KINDS = new Set([
+    'skill',
+    'skill_file',
+    'frontmatter',
+    'reference',
+    'script',
+    'tool',
+    'env',
+    'preflight',
+    'hard_rule',
+    'workflow',
+    'workflow_node',
+    'sample',
+    'assertion',
+    'variant',
+    'doctor_rule_result',
+    'eval_result',
+    'judge_dimension',
+    'diagnostic',
+    'trace_session',
+    'skill_invocation',
+    'tool_call',
+    'gap_signal',
+]);
+const STATUSES = new Set(['ok', 'warning', 'failed', 'skipped', 'unknown', 'not_measured']);
+const BINDING_STRENGTHS = new Set([
+    'content-hash',
+    'source-locator',
+    'runtime-trace',
+    'name-only',
+    'aggregate',
+    'explicit',
+]);
+const EDGE_KINDS = new Set([
+    'contains',
+    'declares',
+    'requires',
+    'references',
+    'defines_workflow',
+    'next_step',
+    'covers',
+    'evaluates',
+    'passes',
+    'fails',
+    'diagnoses',
+    'invokes',
+    'calls_tool',
+    'observes',
+    'signals_gap',
+    'derived_from',
+]);
+const EVIDENCE_SOURCE_KINDS = new Set([
+    'skill-file',
+    'doctor-report',
+    'eval-report',
+    'observe-report',
+    'trace',
+    'sample',
+    'managed-record',
+]);
+const SELECTOR_KINDS = new Set([
+    'json-pointer',
+    'line-range',
+    'sample-id',
+    'rule-id',
+    'trace-event-id',
+    'node-id',
+]);
+const SUMMARY_KINDS = new Set(['structure', 'coverage', 'risk', 'gap', 'workflow', 'collection']);
+const SUMMARY_SEVERITIES = new Set(['info', 'low', 'medium', 'high']);
+/** Validate a complete graph, including graph identities and referential integrity. */
+export function parseArtifactGraphDocument(value) {
+    if (!isRecord(value)
+        || value.documentKind !== 'artifact-graph'
+        || value.schemaVersion !== 1
+        || !nonEmptyString(value.graphId)
+        || normalizeRfc3339Timestamp(value.generatedAt) === undefined
+        || !isSource(value.source)
+        || !isScope(value.scope)
+        || !Array.isArray(value.nodes)
+        || !Array.isArray(value.edges)
+        || !value.nodes.every(isNode)
+        || !value.edges.every(isEdge)
+        || (value.summaries !== undefined
+            && (!Array.isArray(value.summaries) || !value.summaries.every(isSummary))))
+        return null;
+    const nodes = value.nodes;
+    const edges = value.edges;
+    const nodeIds = new Set(nodes.map((node) => node.id));
+    const stableKeys = new Set(nodes.map((node) => node.stableKey));
+    const edgeIds = new Set(edges.map((edge) => edge.id));
+    if (nodeIds.size !== nodes.length
+        || stableKeys.size !== nodes.length
+        || edgeIds.size !== edges.length
+        || edges.some((edge) => !nodeIds.has(edge.fromNodeId) || !nodeIds.has(edge.toNodeId)))
+        return null;
+    const summaries = (value.summaries ?? []);
+    if (summaries.some((summary) => summary.nodeIds?.some((id) => !nodeIds.has(id))
+        || summary.edgeIds?.some((id) => !edgeIds.has(id))))
+        return null;
+    return value;
+}
+function isSource(value) {
+    return isRecord(value)
+        && SOURCE_KINDS.has(String(value.sourceKind))
+        && nonEmptyString(value.sourceId)
+        && optionalString(value.sourcePath)
+        && optionalString(value.cliVersion);
+}
+function isScope(value) {
+    return isRecord(value)
+        && typeof value.cwd === 'string'
+        && (value.artifactKind === undefined
+            || ARTIFACT_KINDS.has(String(value.artifactKind)))
+        && [
+            value.skillName,
+            value.artifactHash,
+            value.sourceLocator,
+            value.sampleSetHash,
+        ].every(optionalString);
+}
+function isNode(value) {
+    return isRecord(value)
+        && nonEmptyString(value.id)
+        && nonEmptyString(value.stableKey)
+        && NODE_KINDS.has(String(value.nodeKind))
+        && NODE_ROLES.has(String(value.nodeRole))
+        && LAYERS.has(String(value.layer))
+        && nonEmptyString(value.label)
+        && optionalEnum(value.status, STATUSES)
+        && optionalRate(value.confidence)
+        && optionalBinding(value.binding)
+        && optionalMetrics(value.metrics)
+        && optionalAttrs(value.attrs)
+        && optionalEvidenceRefs(value.evidenceRefs);
+}
+function isEdge(value) {
+    return isRecord(value)
+        && nonEmptyString(value.id)
+        && nonEmptyString(value.fromNodeId)
+        && nonEmptyString(value.toNodeId)
+        && EDGE_KINDS.has(String(value.edgeKind))
+        && LAYERS.has(String(value.layer))
+        && optionalString(value.label)
+        && optionalEnum(value.status, STATUSES)
+        && optionalRate(value.confidence)
+        && (value.weight === undefined || isFiniteMetric(value.weight))
+        && optionalBinding(value.binding)
+        && optionalMetrics(value.metrics)
+        && optionalAttrs(value.attrs)
+        && optionalEvidenceRefs(value.evidenceRefs);
+}
+function isSummary(value) {
+    return isRecord(value)
+        && SUMMARY_KINDS.has(String(value.summaryKind))
+        && nonEmptyString(value.title)
+        && SUMMARY_SEVERITIES.has(String(value.severity))
+        && optionalStringArray(value.nodeIds)
+        && optionalStringArray(value.edgeIds)
+        && optionalEvidenceRefs(value.evidenceRefs);
+}
+function optionalBinding(value) {
+    return value === undefined || (isRecord(value)
+        && BINDING_STRENGTHS.has(String(value.bindingStrength))
+        && isRecord(value.keys)
+        && Object.values(value.keys).every((entry) => typeof entry === 'string'));
+}
+function optionalMetrics(value) {
+    return value === undefined || (isRecord(value) && Object.values(value).every(isFiniteMetric));
+}
+function optionalAttrs(value) {
+    return value === undefined || (isRecord(value)
+        && [value.display, value.producer, value.experimental].every((entry) => entry === undefined || isRecord(entry)));
+}
+function optionalEvidenceRefs(value) {
+    return value === undefined || (Array.isArray(value) && value.every(isEvidenceRef));
+}
+function isEvidenceRef(value) {
+    return isRecord(value)
+        && EVIDENCE_SOURCE_KINDS.has(String(value.sourceKind))
+        && [
+            value.sourceId,
+            value.path,
+            value.contentHash,
+            value.label,
+            value.snippet,
+        ].every(optionalString)
+        && (value.redaction === undefined
+            || value.redaction === 'none'
+            || value.redaction === 'truncated'
+            || value.redaction === 'redacted')
+        && (value.selector === undefined
+            || (isRecord(value.selector)
+                && SELECTOR_KINDS.has(String(value.selector.selectorKind))
+                && typeof value.selector.value === 'string'));
+}
+function optionalEnum(value, values) {
+    return value === undefined || values.has(String(value));
+}
+function optionalRate(value) {
+    return value === undefined || (typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1);
+}
+function isFiniteMetric(value) {
+    return typeof value === 'number'
+        && Number.isFinite(value)
+        && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
+}
+function optionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function optionalStringArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(nonEmptyString));
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/shared/assertion-types.d.ts

@@ -0,0 +1,8 @@
+export declare const SYNC_ASSERTION_TYPE_NAMES: readonly ["contains", "not_contains", "regex", "min_length", "max_length", "json_valid", "json_schema", "starts_with", "ends_with", "equals", "not_equals", "word_count_min", "word_count_max", "contains_all", "contains_any", "cost_max", "latency_max", "turns_max", "turns_min", "tools_called", "tools_not_called", "tools_count_max", "tools_count_min", "tool_output_contains", "tool_input_contains", "tool_input_not_contains", "mock_hit", "rouge_n_min", "levenshtein_max", "bleu_min", "assert-set"];
+export declare const ASYNC_ASSERTION_TYPE_NAMES: readonly ["semantic_similarity", "custom", "faithfulness", "answer_relevancy", "context_recall"];
+export type SyncAssertionType = typeof SYNC_ASSERTION_TYPE_NAMES[number];
+export type AsyncAssertionType = typeof ASYNC_ASSERTION_TYPE_NAMES[number];
+export type SupportedAssertionType = SyncAssertionType | AsyncAssertionType;
+export declare const SYNC_ASSERTION_TYPES: ReadonlySet<string>;
+export declare const ASYNC_ASSERTION_TYPES: ReadonlySet<string>;
+export declare const SUPPORTED_ASSERTION_TYPES: ReadonlySet<string>;

package/dist/shared/assertion-types.js

@@ -0,0 +1,46 @@
+export const SYNC_ASSERTION_TYPE_NAMES = [
+    'contains',
+    'not_contains',
+    'regex',
+    'min_length',
+    'max_length',
+    'json_valid',
+    'json_schema',
+    'starts_with',
+    'ends_with',
+    'equals',
+    'not_equals',
+    'word_count_min',
+    'word_count_max',
+    'contains_all',
+    'contains_any',
+    'cost_max',
+    'latency_max',
+    'turns_max',
+    'turns_min',
+    'tools_called',
+    'tools_not_called',
+    'tools_count_max',
+    'tools_count_min',
+    'tool_output_contains',
+    'tool_input_contains',
+    'tool_input_not_contains',
+    'mock_hit',
+    'rouge_n_min',
+    'levenshtein_max',
+    'bleu_min',
+    'assert-set',
+];
+export const ASYNC_ASSERTION_TYPE_NAMES = [
+    'semantic_similarity',
+    'custom',
+    'faithfulness',
+    'answer_relevancy',
+    'context_recall',
+];
+export const SYNC_ASSERTION_TYPES = new Set(SYNC_ASSERTION_TYPE_NAMES);
+export const ASYNC_ASSERTION_TYPES = new Set(ASYNC_ASSERTION_TYPE_NAMES);
+export const SUPPORTED_ASSERTION_TYPES = new Set([
+    ...SYNC_ASSERTION_TYPE_NAMES,
+    ...ASYNC_ASSERTION_TYPE_NAMES,
+]);

package/dist/shared/atomic-json.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Publish JSON with a same-directory rename so readers never observe a partial file.
+ */
+export declare function writeJsonFileAtomic(path: string, value: unknown): void;
+/**
+ * Async counterpart of {@link writeJsonFileAtomic}.
+ */
+export declare function writeJsonFileAtomicAsync(path: string, value: unknown): Promise<void>;

package/dist/shared/atomic-json.js

@@ -0,0 +1,33 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { mkdir, rename, rm, writeFile, } from 'node:fs/promises';
+import { dirname } from 'node:path';
+/**
+ * Publish JSON with a same-directory rename so readers never observe a partial file.
+ */
+export function writeJsonFileAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(tempPath, JSON.stringify(value, null, 2));
+        renameSync(tempPath, path);
+    }
+    finally {
+        if (existsSync(tempPath))
+            rmSync(tempPath, { force: true });
+    }
+}
+/**
+ * Async counterpart of {@link writeJsonFileAtomic}.
+ */
+export async function writeJsonFileAtomicAsync(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(tempPath, JSON.stringify(value, null, 2));
+        await rename(tempPath, path);
+    }
+    finally {
+        await rm(tempPath, { force: true });
+    }
+}

package/dist/shared/diagnosis-schema.d.ts

@@ -0,0 +1,9 @@
+import type { DiagnosisBundle } from '../types/diagnosis.js';
+/**
+ * Validate the persisted Diagnosis contract before downstream projections use it.
+ *
+ * Keep this parser independent from observe-inbox: doctor and eval can produce the
+ * same source-neutral bundle, and every persistence boundary should share one
+ * contract instead of maintaining source-specific casts.
+ */
+export declare function parseDiagnosisBundle(value: unknown): DiagnosisBundle | null;

package/dist/shared/diagnosis-schema.js

@@ -0,0 +1,181 @@
+import { isRfc3339Timestamp } from './timestamp.js';
+const DIAGNOSIS_TYPES = new Set([
+    'definition_gap',
+    'runtime_issue',
+    'user_feedback_pattern',
+    'eval_failure',
+    'sample_design_issue',
+    'doctor_gap',
+    'standard_candidate',
+    'maintenance_issue',
+]);
+const DIAGNOSIS_SEVERITIES = new Set(['high', 'medium', 'low', 'info']);
+const DIAGNOSIS_AUDIENCES = new Set(['skill-author', 'sample-author', 'omk-maintainer', 'reviewer']);
+const DIAGNOSIS_LIFECYCLES = new Set(['detected', 'candidate', 'confirmed', 'rejected', 'resolved', 'stale']);
+const DIAGNOSIS_SCOPES = new Set(['skill', 'definition', 'session', 'sample']);
+const DIAGNOSIS_SOURCES = new Set(['observe', 'doctor', 'eval']);
+const DIAGNOSIS_PRODUCERS = new Set(['deterministic_rule', 'llm_soft', 'manual']);
+const DIAGNOSIS_PATCH_TARGETS = new Set([
+    'skill',
+    'sample-environment',
+    'sample-mocks',
+    'doctor-rule',
+    'definition',
+]);
+/**
+ * Validate the persisted Diagnosis contract before downstream projections use it.
+ *
+ * Keep this parser independent from observe-inbox: doctor and eval can produce the
+ * same source-neutral bundle, and every persistence boundary should share one
+ * contract instead of maintaining source-specific casts.
+ */
+export function parseDiagnosisBundle(value) {
+    if (!isRecord(value) || value.schemaVersion !== 1 || !isTimestamp(value.generatedAt))
+        return null;
+    if (!isSourceCoverage(value.sourceCoverage) || !isRecord(value.bySkill))
+        return null;
+    const diagnosisIds = new Set();
+    const stableKeys = new Set();
+    const occurrenceIds = new Set();
+    for (const [skillName, diagnoses] of Object.entries(value.bySkill)) {
+        if (!isNonEmptyString(skillName) || !Array.isArray(diagnoses))
+            return null;
+        for (const diagnosis of diagnoses) {
+            if (!isDiagnosis(diagnosis, skillName, value.sourceCoverage)
+                || diagnosisIds.has(diagnosis.id)
+                || stableKeys.has(diagnosis.stableKey))
+                return null;
+            diagnosisIds.add(diagnosis.id);
+            stableKeys.add(diagnosis.stableKey);
+            for (const occurrence of diagnosis.occurrences) {
+                if (occurrenceIds.has(occurrence.id))
+                    return null;
+                occurrenceIds.add(occurrence.id);
+            }
+        }
+    }
+    return value;
+}
+function isDiagnosis(value, skillName, sourceCoverage) {
+    if (!isRecord(value))
+        return false;
+    if (!isNonEmptyString(value.id)
+        || !isNonEmptyString(value.stableKey)
+        || value.skillName !== skillName
+        || !isEnum(value.type, DIAGNOSIS_TYPES)
+        || !isNonEmptyString(value.signal)
+        || !isNonEmptyString(value.title)
+        || !isOptionalString(value.summary)
+        || !isEnum(value.severity, DIAGNOSIS_SEVERITIES)
+        || !isEnum(value.audience, DIAGNOSIS_AUDIENCES)
+        || !isEnum(value.lifecycle, DIAGNOSIS_LIFECYCLES)
+        || !isScope(value.scope, skillName)
+        || !Array.isArray(value.occurrences)
+        || !isNonNegativeInteger(value.occurrenceCount)
+        || value.occurrenceCount < value.occurrences.length
+        || !isOptionalString(value.evidenceSummary)
+        || !isOptionalString(value.recommendation)
+        || !isOptionalString(value.command)
+        || !isOptionalPatch(value.patch))
+        return false;
+    const occurrenceIds = new Set();
+    const stableKey = value.stableKey;
+    return value.occurrences.every((occurrence) => {
+        if (!isOccurrence(occurrence, stableKey, sourceCoverage)
+            || occurrenceIds.has(occurrence.id))
+            return false;
+        occurrenceIds.add(occurrence.id);
+        return true;
+    });
+}
+function isScope(value, skillName) {
+    if (!isRecord(value) || !isEnum(value.primary, DIAGNOSIS_SCOPES) || !isRecord(value.refs))
+        return false;
+    const refs = value.refs;
+    if (refs.skillName !== skillName)
+        return false;
+    return [
+        'traceId',
+        'sessionId',
+        'invocationId',
+        'sampleId',
+        'ruleId',
+        'workflowId',
+        'sourceTrace',
+    ].every((key) => isOptionalString(refs[key]));
+}
+function isOccurrence(value, stableKey, sourceCoverage) {
+    if (!isRecord(value))
+        return false;
+    if (!isNonEmptyString(value.id)
+        || value.diagnosisStableKey !== stableKey
+        || !isEnum(value.source, DIAGNOSIS_SOURCES)
+        || sourceCoverage[value.source] !== true
+        || !isNonEmptyString(value.sourceId)
+        || !isNonEmptyString(value.sourceKind)
+        || !isOptionalTimestamp(value.timestamp)
+        || !isOptionalEnum(value.severity, DIAGNOSIS_SEVERITIES)
+        || !Array.isArray(value.evidenceRefs)
+        || !value.evidenceRefs.every(isEvidenceRef)
+        || !isOptionalString(value.rawRef)
+        || !isEnum(value.producer, DIAGNOSIS_PRODUCERS)
+        || (value.payload !== undefined && !isRecord(value.payload)))
+        return false;
+    return true;
+}
+function isEvidenceRef(value) {
+    if (!isRecord(value) || !isNonEmptyString(value.id) || !isNonEmptyString(value.kind))
+        return false;
+    if (![
+        'traceId',
+        'sourceTrace',
+        'sessionId',
+        'messageUuid',
+        'toolUseId',
+        'label',
+        'snippet',
+    ].every((key) => isOptionalString(value[key]))
+        || !['messageIndex', 'logicalMessageIndex', 'sourceLineIndex']
+            .every((key) => value[key] === undefined || isNonNegativeInteger(value[key]))
+        || !isOptionalTimestamp(value.timestamp))
+        return false;
+    return true;
+}
+function isOptionalPatch(value) {
+    if (value === undefined)
+        return true;
+    return isRecord(value)
+        && isEnum(value.target, DIAGNOSIS_PATCH_TARGETS)
+        && isNonEmptyString(value.location)
+        && isNonEmptyString(value.snippet);
+}
+function isSourceCoverage(value) {
+    return isRecord(value)
+        && typeof value.observe === 'boolean'
+        && typeof value.doctor === 'boolean'
+        && typeof value.eval === 'boolean';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isTimestamp(value) {
+    return isRfc3339Timestamp(value);
+}
+function isOptionalTimestamp(value) {
+    return value === undefined || isTimestamp(value);
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isEnum(value, allowed) {
+    return typeof value === 'string' && allowed.has(value);
+}
+function isOptionalEnum(value, allowed) {
+    return value === undefined || isEnum(value, allowed);
+}

package/dist/shared/doctor-report.d.ts

@@ -0,0 +1,3 @@
+import type { DoctorReport } from '../types/index.js';
+/** Parse a persisted doctor report without trusting JSON casts at Studio boundaries. */
+export declare function parseDoctorReport(value: unknown): DoctorReport | null;

package/dist/shared/doctor-report.js

@@ -0,0 +1,103 @@
+import { normalizeRfc3339Timestamp } from './timestamp.js';
+const RULE_STATUSES = new Set(['pass', 'warn', 'fail', 'skipped']);
+const SEVERITIES = new Set(['fatal', 'warn', 'info']);
+const SKILL_STATUSES = new Set(['pass', 'warn', 'fail']);
+const OUTCOMES = new Set(['passed', 'warnings_only', 'failed']);
+/** Parse a persisted doctor report without trusting JSON casts at Studio boundaries. */
+export function parseDoctorReport(value) {
+    if (!isRecord(value)
+        || value.kind !== 'doctor'
+        || typeof value.schemaVersion !== 'string'
+        || value.schemaVersion.length === 0
+        || typeof value.id !== 'string'
+        || value.id.length === 0
+        || normalizeRfc3339Timestamp(value.timestamp) === undefined
+        || !allStrings([
+            value.cliVersion,
+            value.cwd,
+            value.executorName,
+            value.model,
+        ])
+        || !Array.isArray(value.skills)
+        || !OUTCOMES.has(String(value.outcome))
+        || !isCountRecord(value.totals, ['pass', 'warn', 'fail'])
+        || !isCountRecord(value.ruleStats, ['pass', 'warn', 'fail', 'skipped', 'total']))
+        return null;
+    const skills = value.skills;
+    if (!skills.every(isDoctorSkillReport))
+        return null;
+    const totals = value.totals;
+    const ruleStats = value.ruleStats;
+    const expectedTotals = { pass: 0, warn: 0, fail: 0 };
+    const expectedRuleStats = { pass: 0, warn: 0, fail: 0, skipped: 0 };
+    for (const skill of skills) {
+        expectedTotals[skill.status] += 1;
+        for (const result of skill.results) {
+            expectedRuleStats[result.status] += 1;
+        }
+    }
+    const ruleTotal = Object.values(expectedRuleStats).reduce((sum, count) => sum + count, 0);
+    if (!sameCounts(totals, expectedTotals)
+        || !sameCounts(ruleStats, expectedRuleStats)
+        || ruleStats.total !== ruleTotal)
+        return null;
+    const expectedOutcome = totals.fail > 0
+        ? 'failed'
+        : totals.warn > 0
+            ? 'warnings_only'
+            : 'passed';
+    return value.outcome === expectedOutcome ? value : null;
+}
+function isDoctorSkillReport(value) {
+    if (!isRecord(value)
+        || typeof value.skillName !== 'string'
+        || value.skillName.length === 0
+        || typeof value.skillPath !== 'string'
+        || !Array.isArray(value.results)
+        || !SKILL_STATUSES.has(String(value.status))
+        || !value.results.every(isDoctorRuleResult))
+        return false;
+    return value.status === classifySkillStatus(value.results);
+}
+function isDoctorRuleResult(value) {
+    return isRecord(value)
+        && allStrings([value.ruleId, value.labelKey, value.message])
+        && String(value.ruleId).length > 0
+        && String(value.labelKey).length > 0
+        && SEVERITIES.has(String(value.severity))
+        && RULE_STATUSES.has(String(value.status))
+        && isNonNegativeNumber(value.durationMs)
+        && (value.hint === undefined || typeof value.hint === 'string')
+        && (value.groupId === undefined || typeof value.groupId === 'string')
+        && (value.detail === undefined || isRecord(value.detail));
+}
+function classifySkillStatus(results) {
+    if (results.some((result) => result.status === 'fail' && result.severity === 'fatal')) {
+        return 'fail';
+    }
+    if (results.some((result) => result.status === 'warn' || result.status === 'fail')) {
+        return 'warn';
+    }
+    return 'pass';
+}
+function isCountRecord(value, keys) {
+    return isRecord(value) && keys.every((key) => isNonNegativeInteger(value[key]));
+}
+function sameCounts(actual, expected) {
+    return Object.entries(expected).every(([key, count]) => actual[key] === count);
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isNonNegativeNumber(value) {
+    return typeof value === 'number'
+        && Number.isFinite(value)
+        && value >= 0
+        && value <= Number.MAX_SAFE_INTEGER;
+}
+function allStrings(values) {
+    return values.every((value) => typeof value === 'string');
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/shared/evaluation-job.d.ts

@@ -0,0 +1,6 @@
+import type { EvaluationJob, EvaluationRequest, EvaluationRun } from '../types/index.js';
+export declare function isSafeEvaluationJobId(value: unknown): value is string;
+export declare function isValidEvaluationRequest(value: unknown): value is EvaluationRequest;
+export declare function isValidEvaluationRun(value: unknown, expectedRunId?: string): value is EvaluationRun;
+export declare function isValidEvaluationJob(value: unknown, expectedJobId?: string): value is EvaluationJob;
+export declare function evaluationRequestsEqual(left: EvaluationRequest, right: EvaluationRequest): boolean;