@daihum/record-formats 0.1.0 → 0.1.1

package/dist/archive-description/index.js

@@ -0,0 +1,1256 @@
+import { i as hasFormatErrors, n as formatFail, r as formatOk, t as createFormatIssue } from "../result-Cl7IY6PN.js";
+import "../xml-DXtayJiw.js";
+import { h as validateEad3 } from "../ead3-DM2in-ck.js";
+
+//#region src/archive-description/types.ts
+const ARCHIVE_DESCRIPTION_SCHEMA = "archive-description.v1";
+
+//#endregion
+//#region src/archive-description/identity.ts
+const ARCHIVE_DESCRIPTION_SCHEMA_ID = "https://daihum.dev/schema/record-formats/archive-description.v1.json";
+const ARCHIVE_DESCRIPTION_SCHEMA_TITLE = "DAIHUM Archive Description";
+const ARCHIVE_DESCRIPTION_SCHEMA_VERSION = ARCHIVE_DESCRIPTION_SCHEMA;
+function canonicalJson(value) {
+	return JSON.stringify(value, (_key, item) => {
+		if (item && typeof item === "object" && !Array.isArray(item)) {
+			const record = item;
+			return Object.keys(record).sort().reduce((result, key) => {
+				result[key] = record[key];
+				return result;
+			}, {});
+		}
+		return item;
+	});
+}
+function contentHash(input) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let index = 0; index < input.length; index += 1) {
+		const code = input.charCodeAt(index);
+		h1 = Math.imul(h1 ^ code, 2654435761);
+		h2 = Math.imul(h2 ^ code, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+	h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+	h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
+}
+
+//#endregion
+//#region src/archive-description/rfc3339.ts
+const RFC3339_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:[Zz]|([+-])(\d{2}):(\d{2}))$/;
+function isLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function daysInMonth(year, month) {
+	if (month === 2) return isLeapYear(year) ? 29 : 28;
+	return [
+		4,
+		6,
+		9,
+		11
+	].includes(month) ? 30 : 31;
+}
+function isValidLeapSecond(year, month, day, hour, minute, offsetSign, offsetHour, offsetMinute) {
+	const signedOffset = offsetSign === "-" ? -1 : 1;
+	const utc = /* @__PURE__ */ new Date(Date.UTC(year, month - 1, day, hour, minute, 59) - signedOffset * (offsetHour * 60 + offsetMinute) * 6e4);
+	return utc.getUTCHours() === 23 && utc.getUTCMinutes() === 59 && (utc.getUTCMonth() === 5 && utc.getUTCDate() === 30 || utc.getUTCMonth() === 11 && utc.getUTCDate() === 31);
+}
+/** Strict RFC 3339 date-time validation, including calendar and leap-second checks. */
+function isRfc3339DateTime(value) {
+	const match = RFC3339_DATE_TIME.exec(value);
+	if (!match) return false;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	const hour = Number(match[4]);
+	const minute = Number(match[5]);
+	const second = Number(match[6]);
+	const offsetHour = Number(match[8] ?? 0);
+	const offsetMinute = Number(match[9] ?? 0);
+	if (year < 1 || month < 1 || month > 12) return false;
+	if (day < 1 || day > daysInMonth(year, month)) return false;
+	if (hour > 23 || minute > 59 || offsetHour > 23 || offsetMinute > 59) return false;
+	if (second < 60) return true;
+	if (second > 60) return false;
+	return isValidLeapSecond(year, month, day, hour, minute, match[7], offsetHour, offsetMinute);
+}
+
+//#endregion
+//#region src/archive-description/archive-description.ts
+const ARCHIVE_DESCRIPTION_FORMAT_ID = "archive-description";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isDateTimeString(value) {
+	return typeof value === "string" && isRfc3339DateTime(value);
+}
+function validateAllowedKeys(value, allowed, path, issues) {
+	for (const key of Object.keys(value)) if (!allowed.has(key)) issues.push(issue({
+		code: "archive.property.unknown",
+		path: path ? `${path}.${key}` : key,
+		message: `Unknown archive-description property "${key}".`
+	}));
+}
+function validateOptionalStrings(value, fields, path, issues) {
+	for (const field of fields) if (value[field] !== void 0 && typeof value[field] !== "string") issues.push(issue({
+		code: "archive.string.invalid",
+		path: path ? `${path}.${field}` : field,
+		message: `${path ? `${path}.` : ""}${field} must be a string.`
+	}));
+}
+function issue(params) {
+	return createFormatIssue({
+		severity: params.severity ?? "error",
+		format: ARCHIVE_DESCRIPTION_FORMAT_ID,
+		code: params.code,
+		path: params.path,
+		message: params.message,
+		...params.cause !== void 0 ? { cause: params.cause } : {}
+	});
+}
+function validateStringArray(value, path, issues) {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) {
+		issues.push(issue({
+			code: "archive.array.required",
+			path,
+			message: `${path} must be an array.`
+		}));
+		return;
+	}
+	value.forEach((item, index) => {
+		if (!isNonEmptyString(item)) issues.push(issue({
+			code: "archive.string.required",
+			path: `${path}.${index}`,
+			message: `${path}.${index} must be a non-empty string.`
+		}));
+	});
+}
+function validateProvenance(value, path, issues) {
+	if (!isRecord(value)) {
+		issues.push(issue({
+			code: "archive.provenance.required",
+			path,
+			message: `${path} is required.`
+		}));
+		return false;
+	}
+	validateAllowedKeys(value, new Set([
+		"createdBy",
+		"createdAt",
+		"method",
+		"rules",
+		"tool",
+		"model",
+		"reviewStatus",
+		"reviewedBy",
+		"reviewedAt"
+	]), path, issues);
+	for (const field of [
+		"createdBy",
+		"createdAt",
+		"method"
+	]) if (!isNonEmptyString(value[field])) issues.push(issue({
+		code: `archive.provenance.${field}.required`,
+		path: `${path}.${field}`,
+		message: `${path}.${field} is required.`
+	}));
+	if (isNonEmptyString(value["createdAt"]) && !isDateTimeString(value["createdAt"])) issues.push(issue({
+		code: "archive.provenance.createdAt.invalid",
+		path: `${path}.createdAt`,
+		message: `${path}.createdAt must be an RFC 3339 date-time.`
+	}));
+	validateStringArray(value["rules"], `${path}.rules`, issues);
+	validateOptionalStrings(value, [
+		"tool",
+		"model",
+		"reviewedBy",
+		"reviewedAt"
+	], path, issues);
+	if (value["reviewedAt"] !== void 0 && !isDateTimeString(value["reviewedAt"])) issues.push(issue({
+		code: "archive.provenance.reviewedAt.invalid",
+		path: `${path}.reviewedAt`,
+		message: `${path}.reviewedAt must be an RFC 3339 date-time.`
+	}));
+	if (value["reviewStatus"] !== void 0 && ![
+		"unreviewed",
+		"needs_review",
+		"accepted",
+		"rejected"
+	].includes(String(value["reviewStatus"]))) issues.push(issue({
+		code: "archive.provenance.reviewStatus.invalid",
+		path: `${path}.reviewStatus`,
+		message: "Provenance reviewStatus is invalid."
+	}));
+	if (isNonEmptyString(value["method"]) && value["method"].startsWith("model:") && !isNonEmptyString(value["model"])) issues.push(issue({
+		severity: "warning",
+		code: "archive.provenance.model.recommended",
+		path: `${path}.model`,
+		message: "Machine-generated descriptions should identify the model."
+	}));
+	return true;
+}
+function validateExtensions(value, path, issues) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		issues.push(issue({
+			code: "archive.extensions.invalid",
+			path,
+			message: `${path} must be an object.`
+		}));
+		return;
+	}
+	validateAllowedKeys(value, new Set(["ead3", "vendor"]), path, issues);
+	if (value["ead3"] !== void 0 && !isRecord(value["ead3"])) issues.push(issue({
+		code: "archive.extensions.value.invalid",
+		path: `${path}.ead3`,
+		message: `${path}.ead3 must be an object.`
+	}));
+	if (value["vendor"] !== void 0) if (!Array.isArray(value["vendor"])) issues.push(issue({
+		code: "archive.extensions.value.invalid",
+		path: `${path}.vendor`,
+		message: `${path}.vendor must be an array.`
+	}));
+	else value["vendor"].forEach((extension, index) => {
+		const extensionPath = `${path}.vendor.${index}`;
+		if (!isRecord(extension)) {
+			issues.push(issue({
+				code: "archive.vendorExtension.invalid",
+				path: extensionPath,
+				message: "Vendor extension must be an object."
+			}));
+			return;
+		}
+		validateAllowedKeys(extension, new Set([
+			"namespace",
+			"name",
+			"value"
+		]), extensionPath, issues);
+		for (const field of ["namespace", "name"]) if (!isNonEmptyString(extension[field])) issues.push(issue({
+			code: `archive.vendorExtension.${field}.required`,
+			path: `${extensionPath}.${field}`,
+			message: `Vendor extension ${field} is required.`
+		}));
+		if (!Object.prototype.hasOwnProperty.call(extension, "value")) issues.push(issue({
+			code: "archive.vendorExtension.value.required",
+			path: `${extensionPath}.value`,
+			message: "Vendor extension value is required."
+		}));
+	});
+}
+function validateSourceRecords(value, path, issues) {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) {
+		issues.push(issue({
+			code: "archive.sourceRecords.invalid",
+			path,
+			message: `${path} must be an array.`
+		}));
+		return;
+	}
+	value.forEach((sourceRecord, index) => {
+		const itemPath = `${path}.${index}`;
+		if (!isRecord(sourceRecord)) {
+			issues.push(issue({
+				code: "archive.sourceRecord.invalid",
+				path: itemPath,
+				message: `${itemPath} must be an object.`
+			}));
+			return;
+		}
+		validateAllowedKeys(sourceRecord, new Set([
+			"id",
+			"producer",
+			"format",
+			"source",
+			"retrievedAt",
+			"raw",
+			"mappedFields",
+			"unmappedFields",
+			"diagnostics"
+		]), itemPath, issues);
+		for (const field of ["id", "producer"]) if (!isNonEmptyString(sourceRecord[field])) issues.push(issue({
+			code: `archive.sourceRecord.${field}.required`,
+			path: `${itemPath}.${field}`,
+			message: `${itemPath}.${field} is required.`
+		}));
+		validateOptionalStrings(sourceRecord, [
+			"format",
+			"source",
+			"retrievedAt"
+		], itemPath, issues);
+		if (sourceRecord["retrievedAt"] !== void 0 && !isDateTimeString(sourceRecord["retrievedAt"])) issues.push(issue({
+			code: "archive.sourceRecord.retrievedAt.invalid",
+			path: `${itemPath}.retrievedAt`,
+			message: `${itemPath}.retrievedAt must be an RFC 3339 date-time.`
+		}));
+		validateStringArray(sourceRecord["mappedFields"], `${itemPath}.mappedFields`, issues);
+		if (sourceRecord["diagnostics"] !== void 0) if (!Array.isArray(sourceRecord["diagnostics"])) issues.push(issue({
+			code: "archive.sourceRecord.diagnostics.invalid",
+			path: `${itemPath}.diagnostics`,
+			message: "Source diagnostics must be an array."
+		}));
+		else sourceRecord["diagnostics"].forEach((diagnostic, diagnosticIndex) => {
+			const diagnosticPath = `${itemPath}.diagnostics.${diagnosticIndex}`;
+			if (!isRecord(diagnostic)) {
+				issues.push(issue({
+					code: "archive.sourceDiagnostic.invalid",
+					path: diagnosticPath,
+					message: "Source diagnostic must be an object."
+				}));
+				return;
+			}
+			validateAllowedKeys(diagnostic, new Set([
+				"severity",
+				"code",
+				"message",
+				"path"
+			]), diagnosticPath, issues);
+			if (![
+				"error",
+				"warning",
+				"info"
+			].includes(String(diagnostic["severity"]))) issues.push(issue({
+				code: "archive.sourceDiagnostic.severity.invalid",
+				path: `${diagnosticPath}.severity`,
+				message: "Source diagnostic severity is invalid."
+			}));
+			for (const field of ["code", "message"]) if (!isNonEmptyString(diagnostic[field])) issues.push(issue({
+				code: `archive.sourceDiagnostic.${field}.required`,
+				path: `${diagnosticPath}.${field}`,
+				message: `Source diagnostic ${field} is required.`
+			}));
+			validateStringArray(diagnostic["path"], `${diagnosticPath}.path`, issues);
+		});
+	});
+}
+function validateNode(value, path, issues, nodeIds, seenObjects) {
+	if (!isRecord(value)) {
+		issues.push(issue({
+			code: "archive.node.required",
+			path,
+			message: `${path} must be an object.`
+		}));
+		return false;
+	}
+	if (seenObjects.has(value)) {
+		issues.push(issue({
+			code: "archive.node.cycle",
+			path,
+			message: "Archive description nodes must not form cycles."
+		}));
+		return false;
+	}
+	seenObjects.add(value);
+	validateAllowedKeys(value, new Set([
+		"id",
+		"level",
+		"otherLevel",
+		"title",
+		"referenceCode",
+		"repository",
+		"dates",
+		"extent",
+		"creator",
+		"creatorStatus",
+		"abstract",
+		"scopeContent",
+		"arrangement",
+		"accessRestriction",
+		"useRestriction",
+		"language",
+		"biographicalHistory",
+		"custodialHistory",
+		"acquisitionInformation",
+		"appraisal",
+		"processingInformation",
+		"relatedMaterial",
+		"separatedMaterial",
+		"preferredCitation",
+		"notes",
+		"accessPoints",
+		"targets",
+		"provenance",
+		"subItems",
+		"extensions"
+	]), path, issues);
+	validateOptionalStrings(value, [
+		"otherLevel",
+		"referenceCode",
+		"repository",
+		"extent",
+		"creator",
+		"abstract",
+		"scopeContent",
+		"arrangement",
+		"accessRestriction",
+		"useRestriction",
+		"language",
+		"biographicalHistory",
+		"custodialHistory",
+		"acquisitionInformation",
+		"appraisal",
+		"processingInformation",
+		"relatedMaterial",
+		"separatedMaterial",
+		"preferredCitation"
+	], path, issues);
+	const id = value["id"];
+	if (!isNonEmptyString(id)) issues.push(issue({
+		code: "archive.node.id.required",
+		path: `${path}.id`,
+		message: "Node id is required."
+	}));
+	else if (nodeIds.has(id)) issues.push(issue({
+		code: "archive.node.id.duplicate",
+		path: `${path}.id`,
+		message: `Node id "${id}" is duplicated.`
+	}));
+	else nodeIds.add(id);
+	const levels = new Set([
+		"collection",
+		"series",
+		"subseries",
+		"file",
+		"item",
+		"otherlevel"
+	]);
+	if (!isNonEmptyString(value["level"]) || !levels.has(value["level"])) issues.push(issue({
+		code: "archive.node.level.invalid",
+		path: `${path}.level`,
+		message: "Node level must be a supported archival description level."
+	}));
+	if (value["level"] === "otherlevel" && !isNonEmptyString(value["otherLevel"])) issues.push(issue({
+		code: "archive.node.otherLevel.required",
+		path: `${path}.otherLevel`,
+		message: "otherLevel is required when level is otherlevel."
+	}));
+	if (value["creatorStatus"] !== void 0 && ![
+		"known",
+		"unknown",
+		"not_applicable"
+	].includes(String(value["creatorStatus"]))) issues.push(issue({
+		code: "archive.node.creatorStatus.invalid",
+		path: `${path}.creatorStatus`,
+		message: "Node creatorStatus is invalid."
+	}));
+	if (!isNonEmptyString(value["title"])) issues.push(issue({
+		code: "archive.node.title.required",
+		path: `${path}.title`,
+		message: "Node title is required."
+	}));
+	if (value["dates"] !== void 0) if (!Array.isArray(value["dates"])) issues.push(issue({
+		code: "archive.node.dates.invalid",
+		path: `${path}.dates`,
+		message: "Node dates must be an array."
+	}));
+	else value["dates"].forEach((date, index) => {
+		if (!isRecord(date) || !isNonEmptyString(date["expression"])) issues.push(issue({
+			code: "archive.node.date.expression.required",
+			path: `${path}.dates.${index}.expression`,
+			message: "Each date must have a non-empty expression."
+		}));
+		else {
+			validateAllowedKeys(date, new Set([
+				"expression",
+				"normalized",
+				"type",
+				"certainty"
+			]), `${path}.dates.${index}`, issues);
+			validateOptionalStrings(date, [
+				"normalized",
+				"type",
+				"certainty"
+			], `${path}.dates.${index}`, issues);
+		}
+	});
+	if (value["accessPoints"] !== void 0) if (!Array.isArray(value["accessPoints"])) issues.push(issue({
+		code: "archive.node.accessPoints.invalid",
+		path: `${path}.accessPoints`,
+		message: "Node accessPoints must be an array."
+	}));
+	else value["accessPoints"].forEach((accessPoint, index) => {
+		if (!isRecord(accessPoint) || !isNonEmptyString(accessPoint["type"]) || !isNonEmptyString(accessPoint["label"])) issues.push(issue({
+			code: "archive.node.accessPoint.invalid",
+			path: `${path}.accessPoints.${index}`,
+			message: "Each access point must have a non-empty type and label."
+		}));
+		else {
+			validateAllowedKeys(accessPoint, new Set([
+				"type",
+				"label",
+				"identifier",
+				"source"
+			]), `${path}.accessPoints.${index}`, issues);
+			validateOptionalStrings(accessPoint, ["identifier", "source"], `${path}.accessPoints.${index}`, issues);
+		}
+	});
+	if (value["targets"] !== void 0) if (!Array.isArray(value["targets"])) issues.push(issue({
+		code: "archive.node.targets.invalid",
+		path: `${path}.targets`,
+		message: "Node targets must be an array."
+	}));
+	else value["targets"].forEach((target, index) => {
+		if (!isRecord(target) || !isNonEmptyString(target["kind"]) || !isNonEmptyString(target["id"])) issues.push(issue({
+			code: "archive.node.target.invalid",
+			path: `${path}.targets.${index}`,
+			message: "Each target must have a non-empty kind and id."
+		}));
+		else {
+			validateAllowedKeys(target, new Set([
+				"kind",
+				"id",
+				"href",
+				"label",
+				"role",
+				"locator",
+				"metadata"
+			]), `${path}.targets.${index}`, issues);
+			validateOptionalStrings(target, [
+				"href",
+				"label",
+				"role"
+			], `${path}.targets.${index}`, issues);
+			for (const field of ["locator", "metadata"]) if (target[field] !== void 0 && !isRecord(target[field])) issues.push(issue({
+				code: "archive.node.target.object.invalid",
+				path: `${path}.targets.${index}.${field}`,
+				message: `Target ${field} must be an object.`
+			}));
+		}
+	});
+	if (value["provenance"] !== void 0) validateProvenance(value["provenance"], `${path}.provenance`, issues);
+	validateStringArray(value["notes"], `${path}.notes`, issues);
+	validateExtensions(value["extensions"], `${path}.extensions`, issues);
+	if (value["subItems"] !== void 0) if (!Array.isArray(value["subItems"])) issues.push(issue({
+		code: "archive.node.subItems.invalid",
+		path: `${path}.subItems`,
+		message: "Node subItems must be an array."
+	}));
+	else value["subItems"].forEach((child, index) => {
+		validateNode(child, `${path}.subItems.${index}`, issues, nodeIds, seenObjects);
+	});
+	seenObjects.delete(value);
+	return true;
+}
+function validateArchiveDescription(value) {
+	const issues = [];
+	if (!isRecord(value)) return [issue({
+		code: "archive.record.required",
+		path: "",
+		message: "Archive description record must be an object."
+	})];
+	validateAllowedKeys(value, new Set([
+		"schema",
+		"recordId",
+		"title",
+		"maintenanceStatus",
+		"language",
+		"agencyName",
+		"description",
+		"provenance",
+		"sourceRecords",
+		"extensions"
+	]), "", issues);
+	if (value["schema"] !== ARCHIVE_DESCRIPTION_SCHEMA) issues.push(issue({
+		code: "archive.schema.invalid",
+		path: "schema",
+		message: `Archive description schema must be ${ARCHIVE_DESCRIPTION_SCHEMA}.`
+	}));
+	if (!isNonEmptyString(value["recordId"])) issues.push(issue({
+		code: "archive.recordId.required",
+		path: "recordId",
+		message: "Record id is required."
+	}));
+	if (!isNonEmptyString(value["title"])) issues.push(issue({
+		code: "archive.title.required",
+		path: "title",
+		message: "Finding-aid title is required."
+	}));
+	validateOptionalStrings(value, ["language", "agencyName"], "", issues);
+	if (value["maintenanceStatus"] !== void 0 && ![
+		"new",
+		"revised",
+		"deleted",
+		"derived",
+		"unknown"
+	].includes(String(value["maintenanceStatus"]))) issues.push(issue({
+		code: "archive.maintenanceStatus.invalid",
+		path: "maintenanceStatus",
+		message: "Maintenance status is invalid."
+	}));
+	validateProvenance(value["provenance"], "provenance", issues);
+	validateSourceRecords(value["sourceRecords"], "sourceRecords", issues);
+	validateExtensions(value["extensions"], "extensions", issues);
+	validateNode(value["description"], "description", issues, /* @__PURE__ */ new Set(), /* @__PURE__ */ new WeakSet());
+	if (isRecord(value["description"]) && value["description"]["level"] !== "collection") issues.push(issue({
+		code: "archive.root.level.collection.required",
+		path: "description.level",
+		message: "The root description node must have collection level."
+	}));
+	return issues;
+}
+function parseArchiveDescriptionJson(input) {
+	let value;
+	try {
+		value = JSON.parse(input);
+	} catch (cause) {
+		return formatFail([issue({
+			code: "archive.json.invalid",
+			path: "",
+			message: "Archive description JSON is invalid.",
+			cause
+		})]);
+	}
+	const issues = validateArchiveDescription(value);
+	return hasFormatErrors(issues) ? formatFail(issues, value) : formatOk(value, issues);
+}
+function canonicalize(value) {
+	return JSON.parse(canonicalJson(value));
+}
+function serializeArchiveDescriptionJson(record, options = {}) {
+	const issues = validateArchiveDescription(record);
+	if (hasFormatErrors(issues)) return formatFail(issues);
+	const canonical = canonicalize(record);
+	const format = options.format ?? true;
+	return formatOk(JSON.stringify(canonical, null, format ? 2 : void 0), issues);
+}
+const archiveDescriptionAdapter = {
+	format: ARCHIVE_DESCRIPTION_FORMAT_ID,
+	parse: parseArchiveDescriptionJson,
+	serialize: serializeArchiveDescriptionJson,
+	validate: validateArchiveDescription,
+	detect(input) {
+		try {
+			return JSON.parse(input)?.schema === ARCHIVE_DESCRIPTION_SCHEMA;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+//#region src/archive-description/dacs.ts
+const DACS_PROFILE_ID = "daihum.record-formats.archive-description.dacs.v1";
+function text(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function dacsIssue(path, code, message) {
+	return createFormatIssue({
+		severity: "error",
+		format: DACS_PROFILE_ID,
+		path,
+		code,
+		message
+	});
+}
+function validateMinimum(node, path, repositoryFallback) {
+	const issues = [];
+	if (!text(node.referenceCode)) issues.push(dacsIssue(`${path}.referenceCode`, "dacs.referenceCode.required", "DACS minimum description requires a reference code."));
+	if (!text(node.repository) && !text(repositoryFallback)) issues.push(dacsIssue(`${path}.repository`, "dacs.repository.required", "DACS minimum description requires repository identification."));
+	if (!text(node.title)) issues.push(dacsIssue(`${path}.title`, "dacs.title.required", "DACS minimum description requires a title."));
+	if (!node.dates?.some((date) => text(date.expression))) issues.push(dacsIssue(`${path}.dates`, "dacs.dates.required", "DACS minimum description requires a date expression."));
+	if (!text(node.extent)) issues.push(dacsIssue(`${path}.extent`, "dacs.extent.required", "DACS minimum description requires extent."));
+	if (!text(node.creator) && node.creatorStatus !== "unknown" && node.creatorStatus !== "not_applicable") issues.push(dacsIssue(`${path}.creator`, "dacs.creator.required_or_unknown", "DACS minimum description requires a creator or an explicit unknown/not-applicable status."));
+	if (!text(node.scopeContent)) issues.push(dacsIssue(`${path}.scopeContent`, "dacs.scopeContent.required", "DACS minimum description requires scope and content."));
+	if (!text(node.accessRestriction)) issues.push(dacsIssue(`${path}.accessRestriction`, "dacs.accessRestriction.required", "DACS minimum description requires conditions governing access, including an explicit unrestricted statement."));
+	if (!text(node.language)) issues.push(dacsIssue(`${path}.language`, "dacs.language.required", "DACS minimum description requires language/script information."));
+	return issues;
+}
+function walk(node, path, issues, options, repositoryFallback) {
+	if (options.requireMinimumAtEveryLevel) issues.push(...validateMinimum(node, path, repositoryFallback));
+	node.subItems?.forEach((child, index) => {
+		walk(child, `${path}.subItems.${index}`, issues, options, repositoryFallback);
+	});
+}
+function validateDacsArchiveDescription(record, options = {}) {
+	const issues = validateMinimum(record.description, "description", void 0);
+	if (record.description.subItems?.length && record.description.level !== "collection") issues.push(dacsIssue("description.level", "dacs.multilevel.root.collection.required", "A multilevel finding aid must begin with a collection-level root."));
+	record.description.subItems?.forEach((child, index) => {
+		walk(child, `description.subItems.${index}`, issues, options, record.description.repository);
+	});
+	return issues;
+}
+
+//#endregion
+//#region src/archive-description/ead3-projection.ts
+const ARCHIVE_DESCRIPTION_EAD3_PROJECTION_ID = "daihum.record-formats.archive-description.ead3.v1";
+const ACCESS_POINT_TYPES = new Set([
+	"person",
+	"family",
+	"organization",
+	"place",
+	"subject",
+	"documentaryForm",
+	"occupation",
+	"function"
+]);
+function projectionIssue(params) {
+	return createFormatIssue({
+		severity: params.severity ?? "warning",
+		format: ARCHIVE_DESCRIPTION_EAD3_PROJECTION_ID,
+		code: params.code,
+		path: params.path,
+		message: params.message
+	});
+}
+function ead3Extensions(value) {
+	return value;
+}
+function dateToEad3(date, path, issues) {
+	if (date.certainty) issues.push(projectionIssue({
+		code: "archive.ead3.date.certainty.loss",
+		path: `${path}.certainty`,
+		message: "EAD3 common-element projection does not model date certainty."
+	}));
+	return {
+		expression: date.expression,
+		...date.normalized ? { normalized: date.normalized } : {},
+		...date.type ? { type: date.type } : {}
+	};
+}
+function accessPointToEad3(accessPoint, path, issues) {
+	if (!ACCESS_POINT_TYPES.has(accessPoint.type)) {
+		issues.push(projectionIssue({
+			code: "archive.ead3.accessPoint.type.unsupported",
+			path: `${path}.type`,
+			message: `Access point type "${accessPoint.type}" is not represented by the EAD3 projection.`
+		}));
+		return;
+	}
+	return {
+		type: accessPoint.type,
+		label: accessPoint.label,
+		...accessPoint.identifier ? { identifier: accessPoint.identifier } : {},
+		...accessPoint.source ? { source: accessPoint.source } : {}
+	};
+}
+function targetToEad3(target, path, issues) {
+	if (!target.href) {
+		issues.push(projectionIssue({
+			code: "archive.ead3.target.href.required",
+			path: `${path}.href`,
+			message: "Target has no href and cannot be projected to an EAD3 digital object."
+		}));
+		return;
+	}
+	return {
+		href: target.href,
+		...target.label ? { label: target.label } : {},
+		...target.role ? { role: target.role } : {},
+		targetKind: target.kind,
+		sourceRef: {
+			kind: target.kind,
+			id: target.id,
+			...target.label ? { label: target.label } : {},
+			...target.locator ? { locator: target.locator } : {},
+			...target.metadata ? { metadata: target.metadata } : {}
+		}
+	};
+}
+function nodeToEad3(node, path, issues) {
+	if (node.provenance) issues.push(projectionIssue({
+		code: "archive.ead3.node.provenance.loss",
+		path: `${path}.provenance`,
+		message: "Node provenance remains canonical metadata and is not represented in EAD3."
+	}));
+	if (node.creatorStatus && node.creatorStatus !== "known") issues.push(projectionIssue({
+		code: "archive.ead3.creatorStatus.loss",
+		path: `${path}.creatorStatus`,
+		message: "Explicit unknown/not-applicable creator status is not represented in EAD3."
+	}));
+	if (node.extensions?.vendor) issues.push(projectionIssue({
+		code: "archive.ead3.vendorExtension.loss",
+		path: `${path}.extensions.vendor`,
+		message: "Vendor extension facts remain canonical and are not represented in EAD3."
+	}));
+	const accessPoints = node.accessPoints?.map((value, index) => accessPointToEad3(value, `${path}.accessPoints.${index}`, issues)).filter((value) => Boolean(value));
+	const digitalObjects = node.targets?.map((value, index) => targetToEad3(value, `${path}.targets.${index}`, issues)).filter((value) => Boolean(value));
+	const extensions = ead3Extensions(node.extensions?.ead3);
+	return {
+		id: node.id,
+		level: node.level,
+		...node.otherLevel ? { otherLevel: node.otherLevel } : {},
+		title: node.title,
+		...node.referenceCode ? { referenceCode: node.referenceCode } : {},
+		...node.repository ? { repository: node.repository } : {},
+		...node.dates?.length ? { dates: node.dates.map((date, index) => dateToEad3(date, `${path}.dates.${index}`, issues)) } : {},
+		...node.extent ? { extent: node.extent } : {},
+		...node.creator ? { creator: node.creator } : {},
+		...node.abstract ? { abstract: node.abstract } : {},
+		...node.scopeContent ? { scopeContent: node.scopeContent } : {},
+		...node.arrangement ? { arrangement: node.arrangement } : {},
+		...node.accessRestriction ? { accessRestriction: node.accessRestriction } : {},
+		...node.useRestriction ? { useRestriction: node.useRestriction } : {},
+		...node.language ? { language: node.language } : {},
+		...node.biographicalHistory ? { biographicalHistory: node.biographicalHistory } : {},
+		...node.custodialHistory ? { custodialHistory: node.custodialHistory } : {},
+		...node.acquisitionInformation ? { acquisitionInformation: node.acquisitionInformation } : {},
+		...node.appraisal ? { appraisal: node.appraisal } : {},
+		...node.processingInformation ? { processingInformation: node.processingInformation } : {},
+		...node.relatedMaterial ? { relatedMaterial: node.relatedMaterial } : {},
+		...node.separatedMaterial ? { separatedMaterial: node.separatedMaterial } : {},
+		...node.preferredCitation ? { preferredCitation: node.preferredCitation } : {},
+		...node.notes?.length ? { notes: node.notes } : {},
+		...accessPoints?.length ? { accessPoints } : {},
+		...digitalObjects?.length ? { digitalObjects } : {},
+		...node.subItems?.length ? { components: node.subItems.map((child, index) => nodeToEad3(child, `${path}.subItems.${index}`, issues)) } : {},
+		...extensions ? { extensions } : {}
+	};
+}
+function archiveDescriptionToEad3(record) {
+	const issues = [...validateArchiveDescription(record)];
+	if (hasFormatErrors(issues)) return formatFail(issues);
+	issues.push(projectionIssue({
+		code: "archive.ead3.provenance.loss",
+		path: "provenance",
+		message: "Record provenance remains canonical metadata and is not represented in EAD3."
+	}));
+	if (record.sourceRecords?.length) issues.push(projectionIssue({
+		code: "archive.ead3.sourceRecords.loss",
+		path: "sourceRecords",
+		message: "Source records remain canonical provenance and are not represented in EAD3."
+	}));
+	if (record.extensions?.vendor) issues.push(projectionIssue({
+		code: "archive.ead3.vendorExtension.loss",
+		path: "extensions.vendor",
+		message: "Vendor extension facts remain canonical and are not represented in EAD3."
+	}));
+	const extensions = ead3Extensions(record.extensions?.ead3);
+	const findingAid = {
+		recordId: record.recordId,
+		title: record.title,
+		...record.maintenanceStatus ? { maintenanceStatus: record.maintenanceStatus } : {},
+		...record.language ? { language: record.language } : {},
+		...record.agencyName ? { agencyName: record.agencyName } : {},
+		description: nodeToEad3(record.description, "description", issues),
+		...extensions ? { extensions } : {}
+	};
+	issues.push(...validateEad3(findingAid));
+	return hasFormatErrors(issues) ? formatFail(issues, findingAid) : formatOk(findingAid, issues);
+}
+function targetFromEad3(target, path, issues) {
+	const label = target.label ?? target.sourceRef?.label;
+	if (target.hrefPolicy) issues.push(projectionIssue({
+		code: "ead3.archive.target.hrefPolicy.loss",
+		path: `${path}.hrefPolicy`,
+		message: "EAD3 href policy is not modeled by the canonical target reference."
+	}));
+	if (target.provenance) issues.push(projectionIssue({
+		code: "ead3.archive.target.provenance.loss",
+		path: `${path}.provenance`,
+		message: "EAD3 target provenance is not modeled by the canonical target reference."
+	}));
+	if (target.extensions) issues.push(projectionIssue({
+		code: "ead3.archive.target.extensions.loss",
+		path: `${path}.extensions`,
+		message: "EAD3 target XML extensions are not modeled by the canonical target reference."
+	}));
+	if (target.sourceRef?.label && target.label && target.sourceRef.label !== target.label) issues.push(projectionIssue({
+		code: "ead3.archive.target.sourceLabel.loss",
+		path: `${path}.sourceRef.label`,
+		message: "Distinct EAD3 digital-object and source-reference labels cannot both occupy the canonical target label."
+	}));
+	if (target.sourceRef && target.targetKind && target.sourceRef.kind !== target.targetKind) issues.push(projectionIssue({
+		code: "ead3.archive.target.targetKind.loss",
+		path: `${path}.targetKind`,
+		message: "Distinct EAD3 targetKind and sourceRef.kind cannot both occupy the canonical target kind."
+	}));
+	return {
+		kind: target.sourceRef?.kind ?? target.targetKind ?? "external-uri",
+		id: target.sourceRef?.id ?? target.href,
+		href: target.href,
+		...label ? { label } : {},
+		...target.role ? { role: target.role } : {},
+		...target.sourceRef?.locator ? { locator: target.sourceRef.locator } : {},
+		...target.sourceRef?.metadata ? { metadata: target.sourceRef.metadata } : {}
+	};
+}
+function dateFromEad3(date, path, issues) {
+	if (date.extensions) issues.push(projectionIssue({
+		code: "ead3.archive.date.extension.loss",
+		path: `${path}.extensions`,
+		message: "EAD3 date XML extensions are not modeled by the canonical date."
+	}));
+	return {
+		expression: date.expression,
+		...date.normalized ? { normalized: date.normalized } : {},
+		...date.type ? { type: date.type } : {}
+	};
+}
+function accessPointFromEad3(value, path, issues) {
+	if (value.extensions) issues.push(projectionIssue({
+		code: "ead3.archive.accessPoint.extension.loss",
+		path: `${path}.extensions`,
+		message: "EAD3 access-point XML extensions are not modeled by the canonical access point."
+	}));
+	return {
+		type: value.type,
+		label: value.label,
+		...value.identifier ? { identifier: value.identifier } : {},
+		...value.source ? { source: value.source } : {}
+	};
+}
+function resolveNodeId(component, path, options, issues) {
+	const id = component.id ?? component.referenceCode ?? options.nodeId?.(component, path);
+	if (id) return id;
+	issues.push(projectionIssue({
+		severity: "error",
+		code: "ead3.archive.nodeId.required",
+		path: `${path}.id`,
+		message: "EAD3 component needs an id, a reference code, or an explicit stable nodeId resolver."
+	}));
+	return "";
+}
+function nodeFromEad3(component, path, options, issues) {
+	return {
+		id: resolveNodeId(component, path, options, issues),
+		level: component.level,
+		...component.otherLevel ? { otherLevel: component.otherLevel } : {},
+		title: component.title,
+		...component.referenceCode ? { referenceCode: component.referenceCode } : {},
+		...component.repository ? { repository: component.repository } : {},
+		...component.dates?.length ? { dates: component.dates.map((date, index) => dateFromEad3(date, `${path}.dates.${index}`, issues)) } : {},
+		...component.extent ? { extent: component.extent } : {},
+		...component.creator ? {
+			creator: component.creator,
+			creatorStatus: "known"
+		} : {},
+		...component.abstract ? { abstract: component.abstract } : {},
+		...component.scopeContent ? { scopeContent: component.scopeContent } : {},
+		...component.arrangement ? { arrangement: component.arrangement } : {},
+		...component.accessRestriction ? { accessRestriction: component.accessRestriction } : {},
+		...component.useRestriction ? { useRestriction: component.useRestriction } : {},
+		...component.language ? { language: component.language } : {},
+		...component.biographicalHistory ? { biographicalHistory: component.biographicalHistory } : {},
+		...component.custodialHistory ? { custodialHistory: component.custodialHistory } : {},
+		...component.acquisitionInformation ? { acquisitionInformation: component.acquisitionInformation } : {},
+		...component.appraisal ? { appraisal: component.appraisal } : {},
+		...component.processingInformation ? { processingInformation: component.processingInformation } : {},
+		...component.relatedMaterial ? { relatedMaterial: component.relatedMaterial } : {},
+		...component.separatedMaterial ? { separatedMaterial: component.separatedMaterial } : {},
+		...component.preferredCitation ? { preferredCitation: component.preferredCitation } : {},
+		...component.notes?.length ? { notes: component.notes } : {},
+		...component.accessPoints?.length ? { accessPoints: component.accessPoints.map((value, index) => accessPointFromEad3(value, `${path}.accessPoints.${index}`, issues)) } : {},
+		...component.digitalObjects?.length ? { targets: component.digitalObjects.map((target, index) => targetFromEad3(target, `${path}.digitalObjects.${index}`, issues)) } : {},
+		...component.components?.length ? { subItems: component.components.map((child, index) => nodeFromEad3(child, `${path}.components.${index}`, options, issues)) } : {},
+		...component.extensions ? { extensions: { ead3: component.extensions } } : {}
+	};
+}
+function archiveDescriptionFromEad3(findingAid, options) {
+	const issues = [...validateEad3(findingAid)];
+	const record = {
+		schema: ARCHIVE_DESCRIPTION_SCHEMA,
+		recordId: findingAid.recordId,
+		title: findingAid.title,
+		...findingAid.maintenanceStatus ? { maintenanceStatus: findingAid.maintenanceStatus } : {},
+		...findingAid.language ? { language: findingAid.language } : {},
+		...findingAid.agencyName ? { agencyName: findingAid.agencyName } : {},
+		description: nodeFromEad3(findingAid.description, "description", options, issues),
+		provenance: options.provenance,
+		...options.sourceRecord ? { sourceRecords: [options.sourceRecord] } : {},
+		...findingAid.extensions ? { extensions: { ead3: findingAid.extensions } } : {}
+	};
+	issues.push(...validateArchiveDescription(record));
+	return hasFormatErrors(issues) ? formatFail(issues, record) : formatOk(record, issues);
+}
+
+//#endregion
+//#region src/archive-description/json-schema.ts
+const nonEmptyStringSchema = {
+	type: "string",
+	minLength: 1,
+	pattern: "\\S"
+};
+const provenanceSchema = {
+	type: "object",
+	required: [
+		"createdBy",
+		"createdAt",
+		"method"
+	],
+	properties: {
+		createdBy: nonEmptyStringSchema,
+		createdAt: {
+			type: "string",
+			format: "date-time"
+		},
+		method: nonEmptyStringSchema,
+		rules: {
+			type: "array",
+			items: nonEmptyStringSchema
+		},
+		tool: { type: "string" },
+		model: { type: "string" },
+		reviewStatus: {
+			type: "string",
+			enum: [
+				"unreviewed",
+				"needs_review",
+				"accepted",
+				"rejected"
+			]
+		},
+		reviewedBy: { type: "string" },
+		reviewedAt: {
+			type: "string",
+			format: "date-time"
+		}
+	},
+	additionalProperties: false
+};
+const extensionsSchema = {
+	type: "object",
+	properties: {
+		ead3: {
+			type: "object",
+			additionalProperties: true
+		},
+		vendor: {
+			type: "array",
+			items: {
+				type: "object",
+				required: [
+					"namespace",
+					"name",
+					"value"
+				],
+				properties: {
+					namespace: nonEmptyStringSchema,
+					name: nonEmptyStringSchema,
+					value: {}
+				},
+				additionalProperties: false
+			}
+		}
+	},
+	additionalProperties: false
+};
+const dateSchema = {
+	type: "object",
+	required: ["expression"],
+	properties: {
+		expression: nonEmptyStringSchema,
+		normalized: { type: "string" },
+		type: { type: "string" },
+		certainty: { type: "string" }
+	},
+	additionalProperties: false
+};
+const accessPointSchema = {
+	type: "object",
+	required: ["type", "label"],
+	properties: {
+		type: nonEmptyStringSchema,
+		label: nonEmptyStringSchema,
+		identifier: { type: "string" },
+		source: { type: "string" }
+	},
+	additionalProperties: false
+};
+const targetRefSchema = {
+	type: "object",
+	required: ["kind", "id"],
+	properties: {
+		kind: nonEmptyStringSchema,
+		id: nonEmptyStringSchema,
+		href: { type: "string" },
+		label: { type: "string" },
+		role: { type: "string" },
+		locator: {
+			type: "object",
+			additionalProperties: true
+		},
+		metadata: {
+			type: "object",
+			additionalProperties: true
+		}
+	},
+	additionalProperties: false
+};
+const sourceRecordSchema = {
+	type: "object",
+	required: ["id", "producer"],
+	properties: {
+		id: nonEmptyStringSchema,
+		producer: nonEmptyStringSchema,
+		format: { type: "string" },
+		source: { type: "string" },
+		retrievedAt: {
+			type: "string",
+			format: "date-time"
+		},
+		raw: {},
+		mappedFields: {
+			type: "array",
+			items: nonEmptyStringSchema
+		},
+		unmappedFields: {},
+		diagnostics: {
+			type: "array",
+			items: {
+				type: "object",
+				required: [
+					"severity",
+					"code",
+					"message"
+				],
+				properties: {
+					severity: {
+						type: "string",
+						enum: [
+							"error",
+							"warning",
+							"info"
+						]
+					},
+					code: nonEmptyStringSchema,
+					message: nonEmptyStringSchema,
+					path: {
+						type: "array",
+						items: nonEmptyStringSchema
+					}
+				},
+				additionalProperties: false
+			}
+		}
+	},
+	additionalProperties: false
+};
+const nodeProperties = {
+	id: nonEmptyStringSchema,
+	level: {
+		type: "string",
+		enum: [
+			"collection",
+			"series",
+			"subseries",
+			"file",
+			"item",
+			"otherlevel"
+		]
+	},
+	otherLevel: { type: "string" },
+	title: nonEmptyStringSchema,
+	referenceCode: { type: "string" },
+	repository: { type: "string" },
+	dates: {
+		type: "array",
+		items: dateSchema
+	},
+	extent: { type: "string" },
+	creator: { type: "string" },
+	creatorStatus: {
+		type: "string",
+		enum: [
+			"known",
+			"unknown",
+			"not_applicable"
+		]
+	},
+	abstract: { type: "string" },
+	scopeContent: { type: "string" },
+	arrangement: { type: "string" },
+	accessRestriction: { type: "string" },
+	useRestriction: { type: "string" },
+	language: { type: "string" },
+	biographicalHistory: { type: "string" },
+	custodialHistory: { type: "string" },
+	acquisitionInformation: { type: "string" },
+	appraisal: { type: "string" },
+	processingInformation: { type: "string" },
+	relatedMaterial: { type: "string" },
+	separatedMaterial: { type: "string" },
+	preferredCitation: { type: "string" },
+	notes: {
+		type: "array",
+		items: nonEmptyStringSchema
+	},
+	accessPoints: {
+		type: "array",
+		items: accessPointSchema
+	},
+	targets: {
+		type: "array",
+		items: targetRefSchema
+	},
+	provenance: provenanceSchema,
+	subItems: {
+		type: "array",
+		items: { $ref: "#/$defs/node" }
+	},
+	extensions: extensionsSchema
+};
+function buildArchiveDescriptionJsonSchema() {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: ARCHIVE_DESCRIPTION_SCHEMA_ID,
+		title: ARCHIVE_DESCRIPTION_SCHEMA_TITLE,
+		type: "object",
+		required: [
+			"schema",
+			"recordId",
+			"title",
+			"description",
+			"provenance"
+		],
+		properties: {
+			schema: { const: ARCHIVE_DESCRIPTION_SCHEMA },
+			recordId: nonEmptyStringSchema,
+			title: nonEmptyStringSchema,
+			maintenanceStatus: {
+				type: "string",
+				enum: [
+					"new",
+					"revised",
+					"deleted",
+					"derived",
+					"unknown"
+				]
+			},
+			language: { type: "string" },
+			agencyName: { type: "string" },
+			description: { allOf: [{ $ref: "#/$defs/node" }, {
+				type: "object",
+				properties: { level: { const: "collection" } }
+			}] },
+			provenance: provenanceSchema,
+			sourceRecords: {
+				type: "array",
+				items: sourceRecordSchema
+			},
+			extensions: extensionsSchema
+		},
+		$defs: { node: {
+			type: "object",
+			required: [
+				"id",
+				"level",
+				"title"
+			],
+			properties: nodeProperties,
+			allOf: [{
+				if: {
+					properties: { level: { const: "otherlevel" } },
+					required: ["level"]
+				},
+				then: {
+					required: ["otherLevel"],
+					properties: { otherLevel: nonEmptyStringSchema }
+				}
+			}],
+			additionalProperties: false
+		} },
+		additionalProperties: false
+	};
+}
+const archiveDescriptionJsonSchema = buildArchiveDescriptionJsonSchema();
+const ARCHIVE_DESCRIPTION_SCHEMA_REVISION = contentHash(canonicalJson(archiveDescriptionJsonSchema));
+
+//#endregion
+export { ARCHIVE_DESCRIPTION_EAD3_PROJECTION_ID, ARCHIVE_DESCRIPTION_FORMAT_ID, ARCHIVE_DESCRIPTION_SCHEMA, ARCHIVE_DESCRIPTION_SCHEMA_ID, ARCHIVE_DESCRIPTION_SCHEMA_REVISION, ARCHIVE_DESCRIPTION_SCHEMA_TITLE, ARCHIVE_DESCRIPTION_SCHEMA_VERSION, DACS_PROFILE_ID, archiveDescriptionAdapter, archiveDescriptionFromEad3, archiveDescriptionJsonSchema, archiveDescriptionToEad3, buildArchiveDescriptionJsonSchema, canonicalJson, contentHash, parseArchiveDescriptionJson, serializeArchiveDescriptionJson, validateArchiveDescription, validateDacsArchiveDescription };
+//# sourceMappingURL=index.js.map