@dailephd/my-dev-kit-lab 0.4.2 → 0.4.4

package/dist/src/evaluation/stageContextExpectations/validation.js

@@ -0,0 +1,768 @@
+const SCHEMA_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+const CASE_ID_PATTERN = /^CASE-[A-Z0-9]+(?:-[A-Z0-9]+)*-[0-9]{3}$/;
+const EXPECTATION_ID_PATTERN = /^(REQ|ALLOW|FORBID)-[A-Z0-9]+(?:-[A-Z0-9]+)*-[0-9]{3}$/;
+const INCLUSION_VALUES = ["required", "allowed", "forbidden"];
+const SOURCE_ARTIFACT_VALUES = [
+    "context-capsule",
+    "retrieval-audit-record",
+    "workflow-instruction-packet",
+    "full-workflow-library"
+];
+const CATEGORY_VALUES = [
+    "file",
+    "symbol",
+    "source-range",
+    "contract",
+    "validator",
+    "constant",
+    "error",
+    "schema-or-serializer",
+    "production-responsibility",
+    "test-file",
+    "fixture",
+    "factory",
+    "mock",
+    "setup-file",
+    "test-configuration",
+    "package-script",
+    "test-command",
+    "workflow",
+    "stage",
+    "command",
+    "rule",
+    "report-contract",
+    "provenance"
+];
+const PATH_CATEGORIES = [
+    "file",
+    "test-file",
+    "fixture",
+    "factory",
+    "mock",
+    "setup-file",
+    "test-configuration"
+];
+const SYMBOL_CATEGORIES = [
+    "symbol",
+    "contract",
+    "validator",
+    "constant",
+    "error",
+    "schema-or-serializer"
+];
+const WORKFLOW_STABLE_ID_CATEGORIES = [
+    "workflow",
+    "stage",
+    "command",
+    "rule",
+    "report-contract"
+];
+const INCLUSION_PREFIX = {
+    required: "REQ-",
+    allowed: "ALLOW-",
+    forbidden: "FORBID-"
+};
+const CONTEXT_ADEQUACY_STATUS_VALUES = [
+    "context sufficient for implementation",
+    "context sufficient with listed assumptions",
+    "context insufficient and more retrieval required",
+    "context conflict found and user or upstream stage decision required"
+];
+const FRESHNESS_STATE_VALUES = ["fresh", "stale", "unknown"];
+const PACKET_ADEQUACY_STATUS_VALUES = ["adequate", "inadequate"];
+function failure(sourcePath, code, message, extra) {
+    return { ok: false, sourcePath, code, message, ...extra };
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function hasDuplicates(values) {
+    return new Set(values).size !== values.length;
+}
+function requireNonEmptyString(root, key, fieldPath, sourcePath) {
+    const value = root[key];
+    if (value === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${fieldPath} is required.`, { fieldPath });
+    }
+    if (typeof value !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be a string.`, { fieldPath });
+    }
+    if (value.trim().length === 0) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be a nonempty string.`, { fieldPath });
+    }
+    return null;
+}
+export function validateStageContextExpectationFixtureV1(value, sourcePath) {
+    const root = value;
+    if (root.schemaVersion === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "schemaVersion is required.", { fieldPath: "schemaVersion" });
+    }
+    if (typeof root.schemaVersion !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "schemaVersion must be a string.", { fieldPath: "schemaVersion" });
+    }
+    if (!SCHEMA_VERSION_PATTERN.test(root.schemaVersion)) {
+        return failure(sourcePath, "INVALID_SCHEMA_VERSION", `schemaVersion "${root.schemaVersion}" does not match x.y.z.`, {
+            fieldPath: "schemaVersion",
+            actual: root.schemaVersion
+        });
+    }
+    const schemaVersionValue = root.schemaVersion;
+    const schemaMajor = Number(schemaVersionValue.split(".")[0]);
+    if (schemaMajor !== 1) {
+        return failure(sourcePath, "UNSUPPORTED_SCHEMA_MAJOR", `schemaVersion major "${schemaMajor}" is not supported.`, {
+            fieldPath: "schemaVersion",
+            actual: schemaVersionValue
+        });
+    }
+    if (root.caseId === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "caseId is required.", { fieldPath: "caseId" });
+    }
+    if (typeof root.caseId !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "caseId must be a string.", { fieldPath: "caseId" });
+    }
+    if (!CASE_ID_PATTERN.test(root.caseId)) {
+        return failure(sourcePath, "INVALID_CASE_ID", `caseId "${root.caseId}" does not match the required pattern.`, {
+            fieldPath: "caseId",
+            actual: root.caseId
+        });
+    }
+    const titleFailure = requireNonEmptyString(root, "title", "title", sourcePath);
+    if (titleFailure)
+        return titleFailure;
+    const descriptionFailure = requireNonEmptyString(root, "description", "description", sourcePath);
+    if (descriptionFailure)
+        return descriptionFailure;
+    if (root.expectedEvidence === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "expectedEvidence is required.", { fieldPath: "expectedEvidence" });
+    }
+    if (!Array.isArray(root.expectedEvidence)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "expectedEvidence must be an array.", { fieldPath: "expectedEvidence" });
+    }
+    if (root.expectedEvidence.length === 0) {
+        return failure(sourcePath, "EMPTY_EXPECTATION_SET", "expectedEvidence must contain at least one item.", {
+            fieldPath: "expectedEvidence"
+        });
+    }
+    if (root.expectedStates === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "expectedStates is required.", { fieldPath: "expectedStates" });
+    }
+    if (!isPlainObject(root.expectedStates)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "expectedStates must be an object.", { fieldPath: "expectedStates" });
+    }
+    if (root.warnings === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "warnings is required.", { fieldPath: "warnings" });
+    }
+    if (!isStringArray(root.warnings)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "warnings must be an array of strings.", { fieldPath: "warnings" });
+    }
+    const items = root.expectedEvidence;
+    for (let index = 0; index < items.length; index += 1) {
+        const itemFailure = validateExpectationItem(items[index], `expectedEvidence[${index}]`, sourcePath);
+        if (itemFailure)
+            return itemFailure;
+    }
+    const typedItems = items;
+    const seenIds = new Set();
+    for (let index = 0; index < typedItems.length; index += 1) {
+        const id = typedItems[index].expectationId;
+        if (seenIds.has(id)) {
+            return failure(sourcePath, "DUPLICATE_EXPECTATION_ID", `expectationId "${id}" is duplicated.`, {
+                fieldPath: `expectedEvidence[${index}].expectationId`,
+                actual: id
+            });
+        }
+        seenIds.add(id);
+    }
+    const seenTargets = new Map();
+    for (let index = 0; index < typedItems.length; index += 1) {
+        const item = typedItems[index];
+        const targetKey = buildTargetKey(item);
+        const inclusion = item.inclusion;
+        const existingInclusion = seenTargets.get(targetKey);
+        if (existingInclusion !== undefined) {
+            if (existingInclusion === inclusion) {
+                return failure(sourcePath, "DUPLICATE_EXPECTATION_TARGET", `Target "${targetKey}" is duplicated with the same inclusion.`, { fieldPath: `expectedEvidence[${index}]`, actual: targetKey });
+            }
+            return failure(sourcePath, "CONFLICTING_EXPECTATION_INCLUSION", `Target "${targetKey}" has conflicting inclusion values.`, { fieldPath: `expectedEvidence[${index}]`, actual: targetKey });
+        }
+        seenTargets.set(targetKey, inclusion);
+    }
+    const statesFailure = validateExpectedStates(root.expectedStates, sourcePath);
+    if (statesFailure)
+        return statesFailure;
+    if (root.producerReadinessExpectations !== undefined) {
+        const producerReadinessFailure = validateProducerReadinessExpectations(root.producerReadinessExpectations, sourcePath);
+        if (producerReadinessFailure)
+            return producerReadinessFailure;
+    }
+    return {
+        ok: true,
+        sourcePath,
+        schemaVersion: schemaVersionValue,
+        schemaMajor: 1,
+        fixture: value,
+        rawFixture: value
+    };
+}
+function validateExpectationItem(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const item = itemValue;
+    if (item.expectationId === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.expectationId is required.`, {
+            fieldPath: `${itemPath}.expectationId`
+        });
+    }
+    if (typeof item.expectationId !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectationId must be a string.`, {
+            fieldPath: `${itemPath}.expectationId`
+        });
+    }
+    if (item.inclusion === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.inclusion is required.`, {
+            fieldPath: `${itemPath}.inclusion`
+        });
+    }
+    if (typeof item.inclusion !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.inclusion must be a string.`, {
+            fieldPath: `${itemPath}.inclusion`
+        });
+    }
+    if (!INCLUSION_VALUES.includes(item.inclusion)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.inclusion "${item.inclusion}" is not valid.`, {
+            fieldPath: `${itemPath}.inclusion`,
+            actual: item.inclusion
+        });
+    }
+    if (item.sourceArtifact === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.sourceArtifact is required.`, {
+            fieldPath: `${itemPath}.sourceArtifact`
+        });
+    }
+    if (typeof item.sourceArtifact !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.sourceArtifact must be a string.`, {
+            fieldPath: `${itemPath}.sourceArtifact`
+        });
+    }
+    if (!SOURCE_ARTIFACT_VALUES.includes(item.sourceArtifact)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.sourceArtifact "${item.sourceArtifact}" is not valid.`, {
+            fieldPath: `${itemPath}.sourceArtifact`,
+            actual: item.sourceArtifact
+        });
+    }
+    if (item.category === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.category is required.`, {
+            fieldPath: `${itemPath}.category`
+        });
+    }
+    if (typeof item.category !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.category must be a string.`, {
+            fieldPath: `${itemPath}.category`
+        });
+    }
+    if (!CATEGORY_VALUES.includes(item.category)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.category "${item.category}" is not valid.`, {
+            fieldPath: `${itemPath}.category`,
+            actual: item.category
+        });
+    }
+    if (item.match === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.match is required.`, {
+            fieldPath: `${itemPath}.match`
+        });
+    }
+    if (!isPlainObject(item.match)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.match must be an object.`, {
+            fieldPath: `${itemPath}.match`
+        });
+    }
+    if (item.notes === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.notes is required.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    if (!isStringArray(item.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    const expectationId = item.expectationId;
+    if (!EXPECTATION_ID_PATTERN.test(expectationId)) {
+        return failure(sourcePath, "INVALID_EXPECTATION_ID", `${itemPath}.expectationId "${expectationId}" does not match the required pattern.`, { fieldPath: `${itemPath}.expectationId`, actual: expectationId });
+    }
+    const inclusion = item.inclusion;
+    const requiredPrefix = INCLUSION_PREFIX[inclusion];
+    if (!expectationId.startsWith(requiredPrefix)) {
+        return failure(sourcePath, "EXPECTATION_ID_PREFIX_MISMATCH", `${itemPath}.expectationId "${expectationId}" does not have the "${requiredPrefix}" prefix required by inclusion "${inclusion}".`, { fieldPath: `${itemPath}.expectationId`, actual: expectationId });
+    }
+    const category = item.category;
+    const sourceArtifact = item.sourceArtifact;
+    const pairFailure = validateCategorySourcePair(category, sourceArtifact, itemPath, sourcePath);
+    if (pairFailure)
+        return pairFailure;
+    const matchFailure = validateMatchFields(category, item.match, itemPath, sourcePath);
+    if (matchFailure)
+        return matchFailure;
+    return null;
+}
+function allowedSourceArtifactsForCategory(category) {
+    if (PATH_CATEGORIES.includes(category))
+        return ["context-capsule"];
+    if (SYMBOL_CATEGORIES.includes(category))
+        return ["context-capsule"];
+    if (category === "source-range")
+        return ["context-capsule"];
+    if (category === "production-responsibility")
+        return ["context-capsule", "retrieval-audit-record"];
+    if (category === "package-script")
+        return ["context-capsule"];
+    if (category === "test-command")
+        return ["context-capsule"];
+    if (WORKFLOW_STABLE_ID_CATEGORIES.includes(category)) {
+        return ["workflow-instruction-packet", "full-workflow-library"];
+    }
+    return SOURCE_ARTIFACT_VALUES;
+}
+function validateCategorySourcePair(category, sourceArtifact, itemPath, sourcePath) {
+    const allowed = allowedSourceArtifactsForCategory(category);
+    if (!allowed.includes(sourceArtifact)) {
+        return failure(sourcePath, "INVALID_CATEGORY_SOURCE_PAIR", `${itemPath} category "${category}" is not valid for sourceArtifact "${sourceArtifact}".`, { fieldPath: `${itemPath}.sourceArtifact`, actual: sourceArtifact });
+    }
+    return null;
+}
+function requireNonEmptyMatchString(match, key, itemPath, sourcePath) {
+    const value = match[key];
+    if (value === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.match.${key} is required.`, {
+            fieldPath: `${itemPath}.match.${key}`
+        });
+    }
+    if (typeof value !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.match.${key} must be a string.`, {
+            fieldPath: `${itemPath}.match.${key}`
+        });
+    }
+    if (value.trim().length === 0) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.match.${key} must be a nonempty string.`, {
+            fieldPath: `${itemPath}.match.${key}`
+        });
+    }
+    return null;
+}
+function validateMatchFields(category, match, itemPath, sourcePath) {
+    if (PATH_CATEGORIES.includes(category)) {
+        return requireNonEmptyMatchString(match, "path", itemPath, sourcePath);
+    }
+    if (SYMBOL_CATEGORIES.includes(category)) {
+        return requireNonEmptyMatchString(match, "symbolId", itemPath, sourcePath);
+    }
+    if (category === "source-range") {
+        const filePathFailure = requireNonEmptyMatchString(match, "filePath", itemPath, sourcePath);
+        if (filePathFailure)
+            return filePathFailure;
+        if (match.startLine === undefined) {
+            return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.match.startLine is required.`, {
+                fieldPath: `${itemPath}.match.startLine`
+            });
+        }
+        if (!isPositiveInteger(match.startLine)) {
+            return failure(sourcePath, "INVALID_SOURCE_RANGE", `${itemPath}.match.startLine must be a positive integer.`, {
+                fieldPath: `${itemPath}.match.startLine`,
+                actual: match.startLine
+            });
+        }
+        if (match.endLine === undefined) {
+            return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${itemPath}.match.endLine is required.`, {
+                fieldPath: `${itemPath}.match.endLine`
+            });
+        }
+        if (!isPositiveInteger(match.endLine)) {
+            return failure(sourcePath, "INVALID_SOURCE_RANGE", `${itemPath}.match.endLine must be a positive integer.`, {
+                fieldPath: `${itemPath}.match.endLine`,
+                actual: match.endLine
+            });
+        }
+        if (match.endLine < match.startLine) {
+            return failure(sourcePath, "INVALID_SOURCE_RANGE", `${itemPath}.match.endLine must be >= startLine.`, {
+                fieldPath: `${itemPath}.match.endLine`,
+                actual: match.endLine
+            });
+        }
+        return null;
+    }
+    if (category === "production-responsibility") {
+        return requireNonEmptyMatchString(match, "responsibilityId", itemPath, sourcePath);
+    }
+    if (category === "package-script") {
+        return requireNonEmptyMatchString(match, "name", itemPath, sourcePath);
+    }
+    if (category === "test-command") {
+        return requireNonEmptyMatchString(match, "commandText", itemPath, sourcePath);
+    }
+    if (WORKFLOW_STABLE_ID_CATEGORIES.includes(category)) {
+        return requireNonEmptyMatchString(match, "id", itemPath, sourcePath);
+    }
+    return requireNonEmptyMatchString(match, "evidenceId", itemPath, sourcePath);
+}
+function buildTargetKey(item) {
+    const category = item.category;
+    const sourceArtifact = item.sourceArtifact;
+    const match = item.match;
+    if (PATH_CATEGORIES.includes(category)) {
+        return `${sourceArtifact}|${category}|path:${match.path}`;
+    }
+    if (SYMBOL_CATEGORIES.includes(category)) {
+        return `${sourceArtifact}|${category}|symbolId:${match.symbolId}`;
+    }
+    if (category === "source-range") {
+        return `context-capsule|source-range|filePath:${match.filePath}|startLine:${match.startLine}|endLine:${match.endLine}`;
+    }
+    if (category === "production-responsibility") {
+        return `${sourceArtifact}|production-responsibility|responsibilityId:${match.responsibilityId}`;
+    }
+    if (category === "package-script") {
+        return `context-capsule|package-script|name:${match.name}`;
+    }
+    if (category === "test-command") {
+        return `context-capsule|test-command|commandText:${match.commandText}`;
+    }
+    if (WORKFLOW_STABLE_ID_CATEGORIES.includes(category)) {
+        return `${sourceArtifact}|${category}|id:${match.id}`;
+    }
+    return `${sourceArtifact}|provenance|evidenceId:${match.evidenceId}`;
+}
+function validateMyDevKitContextArtifactState(value, fieldPath, sourcePath) {
+    if (value === undefined)
+        return null;
+    if (!isPlainObject(value)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be an object.`, { fieldPath });
+    }
+    if (value.contextAdequacyStatus !== undefined &&
+        !CONTEXT_ADEQUACY_STATUS_VALUES.includes(value.contextAdequacyStatus)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${fieldPath}.contextAdequacyStatus is not valid.`, {
+            fieldPath: `${fieldPath}.contextAdequacyStatus`,
+            actual: value.contextAdequacyStatus
+        });
+    }
+    if (value.roleAdequacyStatus !== undefined &&
+        !CONTEXT_ADEQUACY_STATUS_VALUES.includes(value.roleAdequacyStatus)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${fieldPath}.roleAdequacyStatus is not valid.`, {
+            fieldPath: `${fieldPath}.roleAdequacyStatus`,
+            actual: value.roleAdequacyStatus
+        });
+    }
+    if (value.freshnessState !== undefined && !FRESHNESS_STATE_VALUES.includes(value.freshnessState)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${fieldPath}.freshnessState is not valid.`, {
+            fieldPath: `${fieldPath}.freshnessState`,
+            actual: value.freshnessState
+        });
+    }
+    if (value.truncated !== undefined && typeof value.truncated !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.truncated must be a boolean.`, {
+            fieldPath: `${fieldPath}.truncated`
+        });
+    }
+    if (value.fullFileFallbackUsed !== undefined && !isNonNegativeInteger(value.fullFileFallbackUsed)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.fullFileFallbackUsed must be a nonnegative integer.`, {
+            fieldPath: `${fieldPath}.fullFileFallbackUsed`,
+            actual: value.fullFileFallbackUsed
+        });
+    }
+    if (value.unresolvedItemIds !== undefined) {
+        if (!isStringArray(value.unresolvedItemIds) || value.unresolvedItemIds.some((entry) => entry.length === 0)) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.unresolvedItemIds must be an array of nonempty strings.`, {
+                fieldPath: `${fieldPath}.unresolvedItemIds`
+            });
+        }
+        if (hasDuplicates(value.unresolvedItemIds)) {
+            return failure(sourcePath, "DUPLICATE_EXPECTED_VALUE", `${fieldPath}.unresolvedItemIds contains duplicates.`, {
+                fieldPath: `${fieldPath}.unresolvedItemIds`
+            });
+        }
+    }
+    if (value.warningCount !== undefined && !isNonNegativeInteger(value.warningCount)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.warningCount must be a nonnegative integer.`, {
+            fieldPath: `${fieldPath}.warningCount`,
+            actual: value.warningCount
+        });
+    }
+    return null;
+}
+function validateWorkflowPacketState(value, sourcePath) {
+    const fieldPath = "expectedStates.workflowInstructionPacket";
+    if (value === undefined)
+        return null;
+    if (!isPlainObject(value)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be an object.`, { fieldPath });
+    }
+    if (value.adequacyStatus !== undefined && !PACKET_ADEQUACY_STATUS_VALUES.includes(value.adequacyStatus)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${fieldPath}.adequacyStatus is not valid.`, {
+            fieldPath: `${fieldPath}.adequacyStatus`,
+            actual: value.adequacyStatus
+        });
+    }
+    if (value.truncated !== undefined && typeof value.truncated !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.truncated must be a boolean.`, {
+            fieldPath: `${fieldPath}.truncated`
+        });
+    }
+    if (value.unresolvedReferences !== undefined) {
+        if (!isStringArray(value.unresolvedReferences)) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.unresolvedReferences must be an array of strings.`, {
+                fieldPath: `${fieldPath}.unresolvedReferences`
+            });
+        }
+        if (hasDuplicates(value.unresolvedReferences)) {
+            return failure(sourcePath, "DUPLICATE_EXPECTED_VALUE", `${fieldPath}.unresolvedReferences contains duplicates.`, {
+                fieldPath: `${fieldPath}.unresolvedReferences`
+            });
+        }
+    }
+    if (value.warningCount !== undefined && !isNonNegativeInteger(value.warningCount)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.warningCount must be a nonnegative integer.`, {
+            fieldPath: `${fieldPath}.warningCount`,
+            actual: value.warningCount
+        });
+    }
+    return null;
+}
+function validateTargetImmutabilityState(value, sourcePath) {
+    const fieldPath = "expectedStates.targetImmutability";
+    if (value === undefined)
+        return null;
+    if (!isPlainObject(value)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be an object.`, { fieldPath });
+    }
+    if (value.newMutationCount === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${fieldPath}.newMutationCount is required.`, {
+            fieldPath: `${fieldPath}.newMutationCount`
+        });
+    }
+    if (!isNonNegativeInteger(value.newMutationCount)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.newMutationCount must be a nonnegative integer.`, {
+            fieldPath: `${fieldPath}.newMutationCount`,
+            actual: value.newMutationCount
+        });
+    }
+    return null;
+}
+function validateExpectedStates(statesValue, sourcePath) {
+    const contextCapsuleFailure = validateMyDevKitContextArtifactState(statesValue.contextCapsule, "expectedStates.contextCapsule", sourcePath);
+    if (contextCapsuleFailure)
+        return contextCapsuleFailure;
+    const auditFailure = validateMyDevKitContextArtifactState(statesValue.retrievalAuditRecord, "expectedStates.retrievalAuditRecord", sourcePath);
+    if (auditFailure)
+        return auditFailure;
+    const packetFailure = validateWorkflowPacketState(statesValue.workflowInstructionPacket, sourcePath);
+    if (packetFailure)
+        return packetFailure;
+    const immutabilityFailure = validateTargetImmutabilityState(statesValue.targetImmutability, sourcePath);
+    if (immutabilityFailure)
+        return immutabilityFailure;
+    return null;
+}
+// v0.4.4 Batch 2: additive, optional producer/readiness expectation validation. Structural
+// classification only, mirroring the existing expectation-item validation conventions.
+const OWNER_INCLUSION_VALUES = ["required", "allowed", "forbidden"];
+const READINESS_KIND_VALUES = ["implementation", "test"];
+const READINESS_DECISION_VALUES = ["not-required", "ready", "refresh-required"];
+const CRITICALITY_VALUES = ["critical", "noncritical"];
+const PRODUCER_READINESS_SOURCE_ARTIFACT_VALUES = ["context-capsule", "retrieval-audit-record"];
+function requireNonEmptyExpectationId(item, itemPath, sourcePath) {
+    return requireNonEmptyString(item, "expectationId", `${itemPath}.expectationId`, sourcePath);
+}
+function validateOwnerExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    if (!OWNER_INCLUSION_VALUES.includes(itemValue.inclusion)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.inclusion is not valid.`, {
+            fieldPath: `${itemPath}.inclusion`,
+            actual: itemValue.inclusion
+        });
+    }
+    if (!PRODUCER_READINESS_SOURCE_ARTIFACT_VALUES.includes(itemValue.sourceArtifact)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.sourceArtifact is not valid.`, {
+            fieldPath: `${itemPath}.sourceArtifact`,
+            actual: itemValue.sourceArtifact
+        });
+    }
+    const ownerIdFailure = requireNonEmptyString(itemValue, "ownerId", `${itemPath}.ownerId`, sourcePath);
+    if (ownerIdFailure)
+        return ownerIdFailure;
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateAllocationExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    const groupIdFailure = requireNonEmptyString(itemValue, "groupId", `${itemPath}.groupId`, sourcePath);
+    if (groupIdFailure)
+        return groupIdFailure;
+    if (itemValue.expectedCapacity !== undefined && itemValue.expectedCapacity !== null && !isNonNegativeInteger(itemValue.expectedCapacity)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedCapacity must be a nonnegative integer or null.`, {
+            fieldPath: `${itemPath}.expectedCapacity`
+        });
+    }
+    if (itemValue.expectedUsedReservation !== undefined &&
+        itemValue.expectedUsedReservation !== null &&
+        !isNonNegativeInteger(itemValue.expectedUsedReservation)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedUsedReservation must be a nonnegative integer or null.`, {
+            fieldPath: `${itemPath}.expectedUsedReservation`
+        });
+    }
+    if (itemValue.expectedRequiredEvidenceIds !== undefined && !isStringArray(itemValue.expectedRequiredEvidenceIds)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedRequiredEvidenceIds must be an array of strings.`, {
+            fieldPath: `${itemPath}.expectedRequiredEvidenceIds`
+        });
+    }
+    if (itemValue.expectedOmitted !== undefined && typeof itemValue.expectedOmitted !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedOmitted must be a boolean.`, {
+            fieldPath: `${itemPath}.expectedOmitted`
+        });
+    }
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateReadinessExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    if (!READINESS_KIND_VALUES.includes(itemValue.kind)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.kind is not valid.`, {
+            fieldPath: `${itemPath}.kind`,
+            actual: itemValue.kind
+        });
+    }
+    if (itemValue.allowedDecisions !== undefined) {
+        if (!isStringArray(itemValue.allowedDecisions) || itemValue.allowedDecisions.some((d) => !READINESS_DECISION_VALUES.includes(d))) {
+            return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.allowedDecisions contains an invalid decision value.`, {
+                fieldPath: `${itemPath}.allowedDecisions`
+            });
+        }
+    }
+    if (itemValue.expectedClassification !== undefined && typeof itemValue.expectedClassification !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedClassification must be a string.`, {
+            fieldPath: `${itemPath}.expectedClassification`
+        });
+    }
+    if (itemValue.expectedIssueCodes !== undefined && !isStringArray(itemValue.expectedIssueCodes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedIssueCodes must be an array of strings.`, {
+            fieldPath: `${itemPath}.expectedIssueCodes`
+        });
+    }
+    if (itemValue.expectedPrimaryIssueCode !== undefined && typeof itemValue.expectedPrimaryIssueCode !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.expectedPrimaryIssueCode must be a string.`, {
+            fieldPath: `${itemPath}.expectedPrimaryIssueCode`
+        });
+    }
+    if (itemValue.notApplicable !== undefined && typeof itemValue.notApplicable !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notApplicable must be a boolean.`, {
+            fieldPath: `${itemPath}.notApplicable`
+        });
+    }
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateCriticalityExpectation(itemValue, itemPath, sourcePath) {
+    if (!isPlainObject(itemValue)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath} must be an object.`, { fieldPath: itemPath });
+    }
+    const idFailure = requireNonEmptyExpectationId(itemValue, itemPath, sourcePath);
+    if (idFailure)
+        return idFailure;
+    const responsibilityIdFailure = requireNonEmptyString(itemValue, "responsibilityId", `${itemPath}.responsibilityId`, sourcePath);
+    if (responsibilityIdFailure)
+        return responsibilityIdFailure;
+    if (!CRITICALITY_VALUES.includes(itemValue.expectedCriticality)) {
+        return failure(sourcePath, "INVALID_LITERAL_VALUE", `${itemPath}.expectedCriticality is not valid.`, {
+            fieldPath: `${itemPath}.expectedCriticality`,
+            actual: itemValue.expectedCriticality
+        });
+    }
+    if (typeof itemValue.applicable !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.applicable must be a boolean.`, {
+            fieldPath: `${itemPath}.applicable`
+        });
+    }
+    if (typeof itemValue.requiresFullMapping !== "boolean") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.requiresFullMapping must be a boolean.`, {
+            fieldPath: `${itemPath}.requiresFullMapping`
+        });
+    }
+    if (itemValue.notes === undefined || !isStringArray(itemValue.notes)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${itemPath}.notes must be an array of strings.`, {
+            fieldPath: `${itemPath}.notes`
+        });
+    }
+    return null;
+}
+function validateProducerReadinessExpectations(value, sourcePath) {
+    const fieldPath = "producerReadinessExpectations";
+    if (!isPlainObject(value)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath} must be an object.`, { fieldPath });
+    }
+    const lists = [
+        ["ownerExpectations", value.ownerExpectations, validateOwnerExpectation],
+        ["allocationExpectations", value.allocationExpectations, validateAllocationExpectation],
+        ["readinessExpectations", value.readinessExpectations, validateReadinessExpectation],
+        ["criticalityExpectations", value.criticalityExpectations, validateCriticalityExpectation]
+    ];
+    const seenIds = new Set();
+    for (const [key, listValue, validateItem] of lists) {
+        if (listValue === undefined)
+            continue;
+        if (!Array.isArray(listValue)) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${fieldPath}.${key} must be an array.`, {
+                fieldPath: `${fieldPath}.${key}`
+            });
+        }
+        for (let index = 0; index < listValue.length; index += 1) {
+            const itemPath = `${fieldPath}.${key}[${index}]`;
+            const itemFailure = validateItem(listValue[index], itemPath, sourcePath);
+            if (itemFailure)
+                return itemFailure;
+            const id = listValue[index].expectationId;
+            if (seenIds.has(id)) {
+                return failure(sourcePath, "DUPLICATE_PRODUCER_READINESS_EXPECTATION_ID", `${itemPath}.expectationId "${id}" is duplicated.`, {
+                    fieldPath: `${itemPath}.expectationId`,
+                    actual: id
+                });
+            }
+            seenIds.add(id);
+        }
+    }
+    return null;
+}