@randomplay/data 0.0.4 → 0.1.0

package/dist/index.mjs

@@ -84,6 +84,18 @@ function buildSourceDocument(descriptor, options) {
 	if (options.licenseNote !== void 0) candidate.licenseNote = options.licenseNote;
 	return sourceDocumentSchema.parse(candidate);
 }
+function buildSourceDocumentFromRegistryEntry(descriptor, registryEntry, options) {
+	if (registryEntry.sourceId !== descriptor.id) throw new Error(`source registry entry ${registryEntry.sourceId} does not match descriptor ${descriptor.id}`);
+	if (!registryEntry.contentHash.startsWith("sha256:")) throw new Error(`${registryEntry.sourceId}: source registry contentHash must be sha256-prefixed`);
+	if (registryEntry.liveVersionRef === "manifest.zzz.live" && !registryEntry.approvedLiveVersions?.includes(registryEntry.configuredLiveVersion)) throw new Error(`${registryEntry.sourceId}: approvedLiveVersions must include configuredLiveVersion`);
+	const sourceDocumentOptions = {
+		...options,
+		sourceVersion: registryEntry.configuredLiveVersion
+	};
+	if (registryEntry.fetchedAt !== void 0) sourceDocumentOptions.fetchedAt = registryEntry.fetchedAt;
+	if (descriptor.fileNameHint !== void 0) sourceDocumentOptions.fileName = descriptor.fileNameHint;
+	return buildSourceDocument(descriptor, sourceDocumentOptions);
+}
 function buildSourceRef(descriptor, options = {}) {
 	const candidate = { sourceId: descriptor.id };
 	if (options.sourceVersion !== void 0) candidate.sourceVersion = options.sourceVersion;
@@ -91,9 +103,901 @@ function buildSourceRef(descriptor, options = {}) {
 	if (options.dataPath !== void 0) candidate.dataPath = options.dataPath;
 	return sourceRefSchema.parse(candidate);
 }
+function buildSourceRefForParsedRecord(batch, record) {
+	if (record.sourceAnchor === void 0 || record.sourceAnchor.length === 0) throw new Error(`${record.id}: sourceAnchor is required for SourceRef emission`);
+	if (record.dataPath === void 0 || record.dataPath.length === 0) throw new Error(`${record.id}: dataPath is required for SourceRef emission`);
+	return sourceRefSchema.parse({
+		sourceId: batch.sourceId,
+		sourceVersion: batch.sourceVersion,
+		sourceAnchor: record.sourceAnchor,
+		dataPath: record.dataPath
+	});
+}
+function buildSourceRefsForParsedBatch(batch) {
+	return batch.records.map((record) => buildSourceRefForParsedRecord(batch, record));
+}
+//#endregion
+//#region src/nanoka.ts
+const NANOKA_SOURCE_ID = "nanoka-zzz";
+const NANOKA_PARSER_VERSION = "nanoka-source-v0.1.0";
+function assertNanokaSnapshotManifest(manifest) {
+	if (manifest.schemaVersion !== "nanoka-fetch-manifest-v1") throw new Error("Unexpected nanoka snapshot schemaVersion");
+	if (manifest.sourceId !== "nanoka-zzz") throw new Error(`Unexpected nanoka sourceId: ${manifest.sourceId}`);
+	if (manifest.parserVersion !== "nanoka-source-v0.1.0") throw new Error(`Unexpected nanoka parserVersion: ${manifest.parserVersion}`);
+	if (manifest.formalLivePolicy.liveVersionRef !== "manifest.zzz.live") throw new Error("nanoka snapshot must be tied to manifest.zzz.live");
+	if (manifest.snapshotId !== manifest.formalLivePolicy.configuredLiveVersion) throw new Error("nanoka snapshotId must match configuredLiveVersion");
+	assertNanokaUrlPolicy(manifest);
+	const assetIds = manifest.assets.map((asset) => asset.id);
+	if (new Set(assetIds).size !== assetIds.length) throw new Error("nanoka snapshot asset ids must be unique");
+	if (!assetIds.includes("manifest")) throw new Error("nanoka snapshot must retain manifest.json");
+	if (!assetIds.includes("boss-index")) throw new Error("nanoka snapshot must retain boss.json index");
+	for (const asset of manifest.assets) {
+		if (asset.sourceVersion !== manifest.snapshotId) throw new Error(`${asset.id}: sourceVersion must match snapshotId`);
+		assertNanokaAssetUrlAllowed(manifest, asset);
+		if (asset.entityType === "sourceManifest" && asset.approvedForCleanedOutput) throw new Error("source manifest gates must not be marked cleaned-output evidence");
+	}
+}
+function assertNanokaUrlPolicy(manifest) {
+	if (manifest.urlPolicy.manifestUrl !== "https://static.nanoka.cc/manifest.json") throw new Error("nanoka urlPolicy manifestUrl must point to static.nanoka.cc manifest.json");
+	if (!manifest.urlPolicy.approvedIndexUrls.includes(`https://static.nanoka.cc/zzz/${manifest.snapshotId}/boss.json`)) throw new Error("nanoka urlPolicy must approve the live boss index");
+	for (const forbiddenIndexName of [
+		"beta",
+		"preview",
+		"leak",
+		"datamine"
+	]) if (!manifest.urlPolicy.forbiddenIndexNames.includes(forbiddenIndexName)) throw new Error(`nanoka urlPolicy must forbid ${forbiddenIndexName}.json indexes`);
+}
+function assertNanokaAssetUrlAllowed(manifest, asset) {
+	let url;
+	try {
+		url = new URL(asset.url);
+	} catch {
+		throw new Error(`${asset.id}: invalid nanoka asset URL`);
+	}
+	if (url.origin !== "https://static.nanoka.cc") throw new Error(`${asset.id}: asset URL is not allowed by nanoka urlPolicy`);
+	if (asset.entityType === "sourceManifest") {
+		if (asset.url !== manifest.urlPolicy.manifestUrl) throw new Error(`${asset.id}: asset URL is not allowed by nanoka urlPolicy`);
+		return;
+	}
+	for (const forbiddenIndexName of manifest.urlPolicy.forbiddenIndexNames) if (url.pathname === `/zzz/${manifest.snapshotId}/${forbiddenIndexName}.json`) throw new Error(`${asset.id}: forbidden nanoka route in snapshot`);
+	const fileName = url.pathname.split("/").at(-1);
+	if (fileName !== void 0 && manifest.urlPolicy.forbiddenIndexNames.includes(fileName.replace(/\.json$/, ""))) throw new Error(`${asset.id}: forbidden nanoka route in snapshot`);
+	if (asset.entityType === "bossIndex") {
+		if (!manifest.urlPolicy.approvedIndexUrls.includes(asset.url)) throw new Error(`${asset.id}: asset URL is not allowed by nanoka urlPolicy`);
+		return;
+	}
+	if (!new RegExp(`^/zzz/${escapeRegExp(manifest.snapshotId)}/(?:zh|en|ja|ko)/(?:character|bangboo|monster|weapon|equipment|boss)/\\d+\\.json$`).test(url.pathname)) throw new Error(`${asset.id}: asset URL is not allowed by nanoka urlPolicy`);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function nanokaSnapshotRecords(manifest) {
+	assertNanokaSnapshotManifest(manifest);
+	return manifest.assets.map((asset) => ({
+		id: asset.id,
+		sourceAnchor: asset.url,
+		dataPath: asset.localPath,
+		raw: {
+			entityType: asset.entityType,
+			entityId: asset.entityId,
+			language: asset.language,
+			sha256: asset.sha256,
+			approvedForCleanedOutput: asset.approvedForCleanedOutput,
+			evidenceUse: asset.evidenceUse
+		}
+	}));
+}
+function createNanokaSnapshotAdapter(options) {
+	assertNanokaSnapshotManifest(options.manifest);
+	return {
+		sourceId: NANOKA_SOURCE_ID,
+		async fetch(context) {
+			return {
+				sourceId: NANOKA_SOURCE_ID,
+				sourceVersion: options.manifest.snapshotId,
+				fetchedAt: context.now,
+				payload: options.manifest,
+				fileName: `data/source/raw/nanoka/zzz/${options.manifest.snapshotId}/fetch-manifest.json`,
+				contentType: "application/json"
+			};
+		},
+		async parse(raw) {
+			if (raw.sourceId !== "nanoka-zzz") throw new Error(`nanoka adapter raw sourceId mismatch: ${raw.sourceId}`);
+			if (raw.sourceVersion !== raw.payload.snapshotId) throw new Error("nanoka adapter raw sourceVersion must match payload snapshotId");
+			assertNanokaSnapshotManifest(raw.payload);
+			return {
+				sourceId: NANOKA_SOURCE_ID,
+				sourceVersion: raw.sourceVersion,
+				formalDataReady: false,
+				records: nanokaSnapshotRecords(raw.payload),
+				notes: ["Nanoka snapshot adapter is source-gate only in this slice.", "Formal cleaned data promotion waits for Phase 2 normalization and semantic mapping."]
+			};
+		}
+	};
+}
+//#endregion
+//#region src/nanoka-bangboo-element.ts
+const attributeLabelMap = {
+	火: "fire",
+	电: "electric",
+	冰: "ice",
+	物理: "physical",
+	以太: "ether",
+	烈霜: "frost",
+	玄墨: "auricInk"
+};
+const damageAttributePattern = /造成[^。]*?(<color=[^>]+>(火|电|冰|物理|以太|烈霜|玄墨)属性伤害<\/color>)/g;
+function deriveNanokaBangbooElement(source, options) {
+	const sourceBangbooId = requiredFinite$3(source.id, "id");
+	if (sourceBangbooId !== options.bangbooId) throw new Error(`nanoka Bangboo element id mismatch: source id ${sourceBangbooId} does not match requested Bangboo ${options.bangbooId}`);
+	const skills = requiredObject$2(source.skill, "skill");
+	const evidence = [];
+	for (const skillKey of Object.keys(skills).sort()) {
+		const levels = requiredObject$2(skills[skillKey]?.level, `skill.${skillKey}.level`);
+		for (const levelKey of sortedNumericKeys$1(levels, `skill.${skillKey}.level`)) {
+			const level = levels[levelKey];
+			const desc = requiredString$3(level.desc, `skill.${skillKey}.level.${levelKey}.desc`);
+			const sourceName = requiredString$3(level.name, `skill.${skillKey}.level.${levelKey}.name`);
+			for (const match of desc.matchAll(damageAttributePattern)) {
+				const matchedText = match[1];
+				const rawLabel = match[2];
+				if (matchedText === void 0 || rawLabel === void 0) continue;
+				evidence.push({
+					skillKey,
+					level: Number(levelKey),
+					sourceName,
+					rawLabel,
+					attribute: mapAttributeLabel(rawLabel, `skill.${skillKey}.level.${levelKey}.desc`),
+					matchedText,
+					sourcePath: `/skill/${skillKey}/level/${levelKey}/desc`
+				});
+			}
+		}
+	}
+	if (evidence.length === 0) throw new Error("Missing nanoka Bangboo element damage text in skill descriptions");
+	const attributes = new Set(evidence.map((item) => item.attribute));
+	if (attributes.size !== 1) throw new Error(`Conflicting nanoka Bangboo element evidence: ${[...attributes].join(", ")}`);
+	return {
+		sourceVersion: options.sourceVersion,
+		bangbooId: options.bangbooId,
+		attribute: evidence[0].attribute,
+		evidence,
+		runtimeCutoverReady: false
+	};
+}
+function mapAttributeLabel(value, path) {
+	const attribute = attributeLabelMap[value];
+	if (attribute === void 0) throw new Error(`Unmapped nanoka Bangboo element label ${value} at ${path}`);
+	return attribute;
+}
+function sortedNumericKeys$1(value, path) {
+	const keys = Object.keys(value);
+	if (keys.length === 0) throw new Error(`Missing nanoka Bangboo level entries ${path}`);
+	for (const key of keys) if (!/^\d+$/.test(key)) throw new Error(`Invalid numeric key ${path}.${key}`);
+	return keys.sort((left, right) => Number(left) - Number(right));
+}
+function requiredObject$2(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Missing object nanoka Bangboo element field ${path}`);
+	return value;
+}
+function requiredString$3(value, path) {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Missing text nanoka Bangboo element field ${path}`);
+	return value;
+}
+function requiredFinite$3(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Missing numeric nanoka Bangboo element field ${path}`);
+	return value;
+}
+//#endregion
+//#region src/nanoka-da.ts
+const weaknessCodeMap = {
+	"200": "physical",
+	"201": "fire",
+	"202": "ice",
+	"203": "electric",
+	"204": "wind",
+	"205": "ether"
+};
+function deriveNanokaDeadlyAssaultPeriod(index, detail, options) {
+	const periodId = String(detail.id);
+	const indexEntry = index[periodId];
+	if (indexEntry === void 0) throw new Error(`Missing Deadly Assault period ${periodId} from nanoka boss index`);
+	const beginAt = normalizeNanokaChinaDate(detail.begin_time, "begin_time");
+	const endAt = normalizeNanokaChinaDate(detail.end_time, "end_time");
+	const configuredLiveSnapshotDate = parseDate(options.configuredLiveSnapshotDate, "configuredLiveSnapshotDate");
+	if (Date.parse(beginAt) > configuredLiveSnapshotDate.getTime()) throw new Error(`Deadly Assault period ${periodId} begins after configured live snapshot date`);
+	if (normalizeNanokaChinaDate(indexEntry.begin, "index.begin") !== beginAt) throw new Error(`Deadly Assault period ${periodId} begin_time does not match boss index`);
+	if (normalizeNanokaChinaDate(indexEntry.end, "index.end") !== endAt) throw new Error(`Deadly Assault period ${periodId} end_time does not match boss index`);
+	return {
+		id: periodId,
+		title: requiredString$2(detail.name, "name"),
+		sourceVersion: options.sourceVersion,
+		beginAt,
+		endAt,
+		zones: sortedEntries(detail.zone).map(([zoneId, zone]) => normalizeZone(zoneId, zone)),
+		bossAdjustments: sortedEntries(detail.boss_adjust).map(([id, adjustment]) => normalizeBossAdjustment(id, adjustment)),
+		runtimeCutoverReady: false
+	};
+}
+function normalizeZone(zoneId, zone) {
+	return {
+		zoneId,
+		stageNumber: requiredFinite$2(zone.stage_num, `zone.${zoneId}.stage_num`),
+		name: requiredString$2(zone.name, `zone.${zoneId}.name`),
+		monsterLevel: requiredFinite$2(zone.monster_level, `zone.${zoneId}.monster_level`),
+		goalType: requiredFinite$2(zone.goal_type, `zone.${zoneId}.goal_type`),
+		rankGoals: {
+			s: requiredFinite$2(zone.s_rank_goal, `zone.${zoneId}.s_rank_goal`),
+			a: requiredFinite$2(zone.a_rank_goal, `zone.${zoneId}.a_rank_goal`),
+			b: requiredFinite$2(zone.b_rank_goal, `zone.${zoneId}.b_rank_goal`)
+		},
+		layerBuffs: sortedEntries(zone.layer_buff).map(([id, buff]) => normalizeBuff(id, buff)),
+		selectableBuffs: sortedEntries(zone.selectable_buff).map(([id, buff]) => normalizeBuff(id, buff)),
+		rooms: sortedEntries(zone.layer_room).map(([roomId, room]) => ({
+			roomId,
+			waves: requiredFinite$2(room.waves_num, `zone.${zoneId}.layer_room.${roomId}.waves_num`),
+			monsters: sortedEntries(room.monster_list).map(([slotId, monster]) => normalizeMonster(slotId, monster, room.monster_weakness))
+		}))
+	};
+}
+function normalizeBuff(id, buff) {
+	return {
+		id,
+		title: buff.title ?? "",
+		description: requiredString$2(buff.desc, `buff.${id}.desc`)
+	};
+}
+function normalizeMonster(slotId, monster, weakness) {
+	return {
+		slotId,
+		monsterId: requiredFinite$2(monster.id, `monster.${slotId}.id`),
+		name: requiredString$2(monster.name, `monster.${slotId}.name`),
+		elementProfile: monster.element,
+		weaknessAttributes: Object.keys(weakness).map((code) => weaknessCodeMap[code]).filter((attribute) => attribute !== void 0),
+		stats: {
+			hp: requiredFinite$2(monster.stats.hp, `monster.${slotId}.stats.hp`),
+			attack: requiredFinite$2(monster.stats.attack, `monster.${slotId}.stats.attack`),
+			defense: requiredFinite$2(monster.stats.defence, `monster.${slotId}.stats.defence`),
+			daze: requiredFinite$2(monster.stats.stun, `monster.${slotId}.stats.stun`),
+			anomalyBuildupResistance: requiredFinite$2(monster.stats.attribute_infliction, `monster.${slotId}.stats.attribute_infliction`)
+		}
+	};
+}
+function normalizeBossAdjustment(id, adjustment) {
+	return {
+		id,
+		hpAdjustmentRaw: requiredFinite$2(adjustment.hp, `boss_adjust.${id}.hp`),
+		attackAdjustmentRaw: requiredFinite$2(adjustment.atk, `boss_adjust.${id}.atk`),
+		operationScorePoints: requiredFinite$2(adjustment.points, `boss_adjust.${id}.points`)
+	};
+}
+function normalizeNanokaChinaDate(value, path) {
+	const match = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})$/.exec(value);
+	if (match === null) throw new Error(`Invalid nanoka date ${path}`);
+	return `${match[1]}T${match[2]}+08:00`;
+}
+function parseDate(value, path) {
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) throw new Error(`Invalid date ${path}`);
+	return date;
+}
+function requiredString$2(value, path) {
+	if (typeof value !== "string") throw new Error(`Missing nanoka Deadly Assault text field ${path}`);
+	return value;
+}
+function requiredFinite$2(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Missing numeric nanoka Deadly Assault field ${path}`);
+	return value;
+}
+function sortedEntries(record) {
+	return Object.entries(record).sort(([left], [right]) => left.localeCompare(right, "en", { numeric: true }));
+}
+//#endregion
+//#region src/nanoka-enemy.ts
+const enemyAttributes = new Set([
+	"physical",
+	"fire",
+	"ice",
+	"electric",
+	"ether",
+	"wind"
+]);
+function deriveNanokaEnemyVariantMapping(detail, spec) {
+	if (detail.id !== spec.detailId) throw new Error(`${spec.cleanedEnemyId}: nanoka monster detail id mismatch`);
+	if (requiredFinite$1(detail.monster_id, `${spec.cleanedEnemyId}.monster_id`) !== spec.monsterInfoId) throw new Error(`${spec.cleanedEnemyId}: nanoka monster_info id mismatch`);
+	const info = detail.monster_info?.[String(spec.monsterInfoId)];
+	if (info === void 0) throw new Error(`${spec.cleanedEnemyId}: missing monster_info.${spec.monsterInfoId}`);
+	const name = requiredString$1(detail.name, `${spec.cleanedEnemyId}.name`);
+	if (name !== spec.expectedName) throw new Error(`${spec.cleanedEnemyId}: nanoka monster name mismatch`);
+	const codeName = requiredString$1(info.code_name, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.code_name`);
+	if (codeName !== spec.expectedCodeName) throw new Error(`${spec.cleanedEnemyId}: nanoka monster_info code_name mismatch`);
+	const tags = requiredStringArray(info.tag, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.tag`);
+	for (const tag of spec.requiredTags) if (!tags.includes(tag)) throw new Error(`${spec.cleanedEnemyId}: missing required monster_info tag ${tag}`);
+	const stats = requiredObject$1(info.stats, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats`);
+	return {
+		cleanedEnemyId: spec.cleanedEnemyId,
+		sourceVersion: spec.sourceVersion,
+		nanokaDetailId: detail.id,
+		nanokaMonsterInfoId: spec.monsterInfoId,
+		nanokaName: name,
+		nanokaCodeName: codeName,
+		nanokaGroupId: requiredFinite$1(detail.group_id, `${spec.cleanedEnemyId}.group_id`),
+		infoType: requiredString$1(info.type, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.type`),
+		tags,
+		goldenAnchors: [...spec.goldenAnchors],
+		variantSelectionRule: "detail.monster_id -> monster_info[monster_id]",
+		statsRaw: {
+			hp: requiredFinite$1(stats.hp, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats.hp`),
+			attack: requiredFinite$1(stats.attack, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats.attack`),
+			defense: requiredFinite$1(stats.defence, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats.defence`),
+			daze: requiredFinite$1(stats.stun, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats.stun`),
+			autoRecoverRate: requiredFinite$1(stats.auto_recover_rate, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats.auto_recover_rate`),
+			baseBuildupRatio: requiredFinite$1(stats.base_buildup_ratio, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.stats.base_buildup_ratio`)
+		},
+		elementProfile: normalizeElementProfile(info.element, `${spec.cleanedEnemyId}.monster_info.${spec.monsterInfoId}.element`),
+		runtimeCutoverReady: false
+	};
+}
+function deriveNanokaEnemyVariantMappings(details, specs) {
+	const detailsById = new Map(details.map((detail) => [detail.id, detail]));
+	return specs.map((spec) => {
+		const detail = detailsById.get(spec.detailId);
+		if (detail === void 0) throw new Error(`${spec.cleanedEnemyId}: missing nanoka monster detail ${spec.detailId}`);
+		return deriveNanokaEnemyVariantMapping(detail, spec);
+	});
+}
+function normalizeElementProfile(value, path) {
+	const record = requiredObject$1(value, path);
+	const result = {};
+	for (const [key, raw] of Object.entries(record)) {
+		if (!enemyAttributes.has(key)) continue;
+		result[key] = requiredFinite$1(raw, `${path}.${key}`);
+	}
+	return result;
+}
+function requiredObject$1(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Missing object nanoka enemy field ${path}`);
+	return value;
+}
+function requiredString$1(value, path) {
+	if (typeof value !== "string") throw new Error(`Missing nanoka enemy text field ${path}`);
+	return value;
+}
+function requiredStringArray(value, path) {
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new Error(`Missing nanoka enemy string array field ${path}`);
+	return value;
+}
+function requiredFinite$1(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Missing numeric nanoka enemy field ${path}`);
+	return value;
+}
+//#endregion
+//#region src/nanoka-panel.ts
+function deriveNanokaPanelValue(source, rule, options = {}) {
+	const promotionPhase = options.promotionPhase ?? "6";
+	const level = options.level ?? 60;
+	const phase = source.level[promotionPhase];
+	if (phase === void 0) throw new Error(`Missing nanoka level phase ${promotionPhase}`);
+	const base = requiredNumber$1(source.stats[rule.baseKey], `stats.${rule.baseKey}`);
+	const promotion = requiredNumber$1(phase[rule.levelKey], `level.${promotionPhase}.${rule.levelKey}`);
+	const growth = rule.growthKey === void 0 ? 0 : requiredNumber$1(source.stats[rule.growthKey], `stats.${rule.growthKey}`) * (level - 1) / 1e4;
+	return base + promotion + growth;
+}
+function requiredNumber$1(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Missing numeric nanoka panel field ${path}`);
+	return value;
+}
+//#endregion
+//#region src/nanoka-patch-history.ts
+function deriveNanokaSnapshotDiffHistory(inputs, options) {
+	assertApprovedSnapshotDiffInputs(inputs, options);
+	const inputsByVersion = new Map(inputs.map((input) => [input.sourceVersion, input]));
+	const orderedInputs = options.approvedLiveVersions.map((version) => inputsByVersion.get(version)).filter((input) => input !== void 0);
+	const comparedPairs = [];
+	for (let index = 1; index < orderedInputs.length; index += 1) {
+		const from = orderedInputs[index - 1];
+		const to = orderedInputs[index];
+		comparedPairs.push({
+			fromVersion: from.sourceVersion,
+			toVersion: to.sourceVersion,
+			fromContentHash: from.contentHash,
+			toContentHash: to.contentHash,
+			changes: diffNumericLeaves(from.records, to.records)
+		});
+	}
+	return {
+		schemaVersion: "nanoka-snapshot-diff-history/v0.1",
+		sourceId: options.sourceId,
+		generatedAt: options.generatedAt,
+		diffKind: "snapshot-derived-numeric-diff",
+		...options.latestResearchVersion === void 0 ? {} : { latestResearchVersion: options.latestResearchVersion },
+		approvedLiveVersions: [...options.approvedLiveVersions],
+		comparedPairs,
+		officialPatchNoteText: {
+			status: "not-found",
+			decision: "D-20 R4.a"
+		},
+		runtimeCutoverReady: false
+	};
+}
+function assertApprovedSnapshotDiffInputs(inputs, options) {
+	const approved = new Set(options.approvedLiveVersions);
+	for (const input of inputs) {
+		if (!approved.has(input.sourceVersion)) throw new Error(`snapshot-diff input ${input.sourceVersion} is not in approvedLiveVersions`);
+		if (input.sourceVersion === options.latestResearchVersion) throw new Error(`snapshot-diff input ${input.sourceVersion} is latest research-only`);
+		if (!/^sha256:[a-f0-9]{64}$/.test(input.contentHash)) throw new Error(`snapshot-diff input ${input.sourceVersion} must include sha256 contentHash`);
+	}
+}
+function diffNumericLeaves(from, to) {
+	const fromLeaves = numericLeaves(from);
+	const toLeaves = numericLeaves(to);
+	const paths = [...new Set([...fromLeaves.keys(), ...toLeaves.keys()])].sort((left, right) => left.localeCompare(right, "en", { numeric: true }));
+	const changes = [];
+	for (const path of paths) {
+		const before = fromLeaves.get(path);
+		const after = toLeaves.get(path);
+		if (before === void 0 && after !== void 0) changes.push({
+			kind: "new",
+			path,
+			after
+		});
+		else if (before !== void 0 && after === void 0) changes.push({
+			kind: "missing",
+			path,
+			before
+		});
+		else if (before !== void 0 && after !== void 0 && before !== after) changes.push({
+			kind: "changed",
+			path,
+			before,
+			after
+		});
+	}
+	return changes;
+}
+function numericLeaves(value, path = "") {
+	const leaves = /* @__PURE__ */ new Map();
+	collectNumericLeaves(value, path, leaves);
+	return leaves;
+}
+function collectNumericLeaves(value, path, leaves) {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		leaves.set(path || "/", value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => collectNumericLeaves(item, `${path}/${index}`, leaves));
+		return;
+	}
+	if (typeof value === "object" && value !== null) for (const [key, item] of Object.entries(value)) collectNumericLeaves(item, `${path}/${escapeJsonPointer(key)}`, leaves);
+}
+function escapeJsonPointer(value) {
+	return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+//#endregion
+//#region src/nanoka-promotion-extra.ts
+const promotionExtraPropRules = {
+	11101: {
+		canonicalField: "maxHp",
+		unitRule: "raw"
+	},
+	12101: {
+		canonicalField: "attack",
+		unitRule: "raw"
+	},
+	20101: {
+		canonicalField: "critRate",
+		unitRule: "basis-points-to-ratio"
+	}
+};
+function deriveNanokaPromotionExtraStats(source, options) {
+	const sourceAgentId = requiredFinite(source.id, "id");
+	if (sourceAgentId !== options.agentId) throw new Error(`nanoka promotion extra agent id mismatch: source id ${sourceAgentId} does not match requested agent ${options.agentId}`);
+	const extraLevels = requiredObject(source.extra_level, "extra_level");
+	const stats = [];
+	for (const phaseKey of sortedNumericKeys(extraLevels, "extra_level")) {
+		const phaseRaw = extraLevels[phaseKey];
+		const phase = Number(phaseKey);
+		const maxLevel = requiredFinite(phaseRaw.max_level, `extra_level.${phaseKey}.max_level`);
+		const extras = requiredObject(phaseRaw.extra, `extra_level.${phaseKey}.extra`);
+		for (const propKey of sortedNumericKeys(extras, `extra_level.${phaseKey}.extra`)) {
+			const rawStat = extras[propKey];
+			const prop = requiredFinite(rawStat.prop, `extra_level.${phaseKey}.extra.${propKey}.prop`);
+			if (prop !== Number(propKey)) throw new Error(`extra_level.${phaseKey}.extra.${propKey}: prop id mismatch`);
+			const rule = promotionExtraPropRules[prop];
+			if (rule === void 0) throw new Error(`extra_level.${phaseKey}.extra.${propKey}: unmapped promotion extra prop ${prop}`);
+			const rawValue = requiredFinite(rawStat.value, `extra_level.${phaseKey}.extra.${propKey}.value`);
+			stats.push({
+				phase,
+				maxLevel,
+				prop,
+				canonicalField: rule.canonicalField,
+				sourceName: requiredString(rawStat.name, `extra_level.${phaseKey}.extra.${propKey}.name`),
+				rawValue,
+				normalizedValue: normalizePromotionExtraValue(rawValue, rule.unitRule),
+				unitRule: rule.unitRule,
+				sourcePath: `/extra_level/${phaseKey}/extra/${propKey}`
+			});
+		}
+	}
+	return {
+		sourceVersion: options.sourceVersion,
+		agentId: options.agentId,
+		stats,
+		runtimeCutoverReady: false
+	};
+}
+function normalizePromotionExtraValue(value, unitRule) {
+	if (unitRule === "basis-points-to-ratio") return value / 1e4;
+	return value;
+}
+function sortedNumericKeys(value, path) {
+	const keys = Object.keys(value);
+	if (keys.length === 0) throw new Error(`Missing nanoka promotion extra entries ${path}`);
+	for (const key of keys) if (!/^\d+$/.test(key)) throw new Error(`Invalid numeric key ${path}.${key}`);
+	return keys.sort((left, right) => Number(left) - Number(right));
+}
+function requiredObject(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Missing object nanoka promotion extra field ${path}`);
+	return value;
+}
+function requiredString(value, path) {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Missing text nanoka promotion extra field ${path}`);
+	return value;
+}
+function requiredFinite(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Missing numeric nanoka promotion extra field ${path}`);
+	return value;
+}
+//#endregion
+//#region src/nanoka-resource.ts
+const nanokaResourceUnitRules = {
+	maxAdrenaline: "stats.rp_max",
+	automaticAdrenalineAccumulation: "stats.rp_recover / 100",
+	resonanceRecovery: "fever_recovery / 1000",
+	resonanceRecoveryGrowth: "fever_recovery_growth / 1000",
+	adrenalineRecovery: "rp_recovery / 10000",
+	adrenalineRecoveryGrowth: "rp_recovery_growth / 10000"
+};
+function deriveNanokaAdrenalinePanel(source) {
+	return {
+		maxAdrenaline: requiredNumber(source.stats.rp_max, "stats.rp_max"),
+		automaticAdrenalineAccumulation: requiredNumber(source.stats.rp_recover, "stats.rp_recover") / 100
+	};
+}
+function deriveNanokaSkillResourceRecovery(param) {
+	return {
+		resonanceRecovery: requiredNumber(param.fever_recovery, "fever_recovery") / 1e3,
+		resonanceRecoveryGrowth: requiredNumber(param.fever_recovery_growth, "fever_recovery_growth") / 1e3,
+		adrenalineRecovery: requiredNumber(param.rp_recovery, "rp_recovery") / 1e4,
+		adrenalineRecoveryGrowth: requiredNumber(param.rp_recovery_growth, "rp_recovery_growth") / 1e4
+	};
+}
+function requiredNumber(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Missing numeric nanoka resource field ${path}`);
+	return value;
+}
+//#endregion
+//#region cleaned/runtime/game-data.json
+var game_data_default = {
+	kind: "gameData",
+	schemaVersion: "cleaned-game-data-artifact/v0.1",
+	dataVersion: "fairy-v0.1.0-nanoka-runtime",
+	generatedAt: "2026-05-15T18:46:10+08:00",
+	sourceManifestPath: "data/source/source-manifest.json",
+	runtimeCutoverReady: true,
+	runtimeSourcePolicy: {
+		"primarySourceId": "nanoka-zzz",
+		"configuredLiveVersion": "2.8",
+		"deprecatedRuntimeSourceIds": [
+			"lo-user-excel",
+			"mihoyo-zzz-critical-assault",
+			"buhflipexplode-zzz-da",
+			"nanoka-zzz-boss-manual-2026-05-07"
+		],
+		"archivedSourcesRuntimeAllowed": false,
+		"phase3ExitSyncId": "phase3-sync-002-g27-g28"
+	},
+	data: {
+		"schemaVersion": "fairy-game-data-v0.1.0",
+		"gameVersion": "ZZZ-2.8",
+		"dataVersion": "0.1.0",
+		"sourceVersion": "nanoka-zzz@2.8",
+		"generatedAt": "2026-05-15T18:46:10+08:00",
+		"sources": [{
+			"id": "nanoka-zzz",
+			"kind": "thirdPartySite",
+			"url": "https://static.nanoka.cc/manifest.json",
+			"gameVersion": "ZZZ-2.8",
+			"sourceVersion": "2.8",
+			"fetchedAt": "2026-05-15T17:15:00+08:00",
+			"parsedAt": "2026-05-15T18:46:10+08:00",
+			"parserVersion": "nanoka-runtime-cutover-v0.1.0",
+			"licenseNote": "Runtime cleaned data uses lo-user-approved nanoka live 2.8 evidence; archived Excel/D-17/D-12 sources are retained for audit only."
+		}],
+		"agents": { "1371": {
+			"id": "1371",
+			"label": {
+				"zh": "仪玄",
+				"en": "Yixuan"
+			},
+			"source": {
+				"sourceId": "nanoka-zzz",
+				"sourceVersion": "2.8",
+				"sourceAnchor": "data/source/raw/nanoka/zzz/2.8/zh/character/1371.json",
+				"dataPath": "/"
+			},
+			"attribute": "auricInk",
+			"agentSpecialty": "rupture",
+			"baseStatsByLevel": { "60": {
+				"maxHp": 7953.8621,
+				"attack": 872.5748,
+				"defense": 441.1145,
+				"impact": 93,
+				"critRate": .05,
+				"critDamage": .5,
+				"anomalyMastery": 92,
+				"anomalyProficiency": 90,
+				"sheerForce": 795.38621
+			} },
+			"skillIds": ["1371001"],
+			"sourceAliases": [
+				"仪玄",
+				"Yixuan",
+				"Yixuan"
+			]
+		} },
+		"skills": { "1371001": {
+			"id": "1371001",
+			"agentId": "1371",
+			"label": {
+				"zh": "普通攻击：霄云劲（一段）",
+				"en": "Basic Attack: Xiao Yun Jin (Hit 1)"
+			},
+			"source": {
+				"sourceId": "nanoka-zzz",
+				"sourceVersion": "2.8",
+				"sourceAnchor": "data/source/raw/nanoka/zzz/2.8/zh/character/1371.json",
+				"dataPath": "/skill/basic/description/4/param/0/param/1371001"
+			},
+			"tags": ["basic"],
+			"attribute": "auricInk",
+			"segments": [{
+				"id": "1371001-hit-1",
+				"levelKey": "1",
+				"multiplierByLevel": { "1": .458 },
+				"dazeMultiplierByLevel": { "1": .286 },
+				"resonanceRecoveryByLevel": { "1": 71.5 },
+				"adrenalineRecoveryByLevel": { "1": .52 },
+				"damageType": "regular",
+				"hitCount": 1,
+				"defaultTags": ["basic"],
+				"source": {
+					"sourceId": "nanoka-zzz",
+					"sourceVersion": "2.8",
+					"sourceAnchor": "data/source/raw/nanoka/zzz/2.8/zh/character/1371.json",
+					"dataPath": "/skill/basic/description/4/param/0/param/1371001"
+				}
+			}]
+		} },
+		"bangboos": { "54008": {
+			"id": "54008",
+			"label": {
+				"zh": "插头布",
+				"en": "Plugboo"
+			},
+			"source": {
+				"sourceId": "nanoka-zzz",
+				"sourceVersion": "2.8",
+				"sourceAnchor": "data/source/raw/nanoka/zzz/2.8/zh/bangboo/54008.json",
+				"dataPath": "/"
+			},
+			"baseStatsByLevel": { "60": {
+				"maxHp": 4210.2983,
+				"attack": 8057.0996,
+				"defense": 723.8011,
+				"impact": 99,
+				"critRate": .05,
+				"critDamage": .5,
+				"anomalyMastery": 132
+			} },
+			"skillIds": ["5400801"],
+			"sourceAliases": [
+				"插头布",
+				"Plugboo",
+				"Plugboo"
+			]
+		} },
+		"bangbooSkills": { "5400801": {
+			"id": "5400801",
+			"bangbooId": "54008",
+			"label": {
+				"zh": "电流狙击",
+				"en": "Electric Current Snipe"
+			},
+			"source": {
+				"sourceId": "nanoka-zzz",
+				"sourceVersion": "2.8",
+				"sourceAnchor": "data/source/raw/nanoka/zzz/2.8/zh/bangboo/54008.json",
+				"dataPath": "/skill_prop/5400801"
+			},
+			"tags": ["special"],
+			"segments": [{
+				"id": "5400801-hit",
+				"levelKey": "1",
+				"multiplierByLevel": { "1": 5.12 },
+				"dazeMultiplierByLevel": { "1": 1.87 },
+				"damageType": "regular",
+				"hitCount": 1,
+				"defaultTags": ["special"],
+				"source": {
+					"sourceId": "nanoka-zzz",
+					"sourceVersion": "2.8",
+					"sourceAnchor": "data/source/raw/nanoka/zzz/2.8/zh/bangboo/54008.json",
+					"dataPath": "/skill_prop/5400801"
+				}
+			}]
+		} },
+		"wEngines": {},
+		"driveDiscs": {},
+		"enemies": {},
+		"resonium": {},
+		"modifiers": {},
+		"rules": {
+			"runtimePrimarySourceId": "nanoka-zzz",
+			"configuredLiveVersion": "2.8",
+			"runtimeCutoverReady": true,
+			"archivedRuntimeSourcesAllowed": false,
+			"driveDiscSlotAndSubstatTables": "out-of-scope:user-provided-snapshot-final-panel",
+			"implementationOwnedFormulaBoundary": ["rules.disorderFormula", "rules.disorderDazeLevelZone"]
+		},
+		"aliases": {
+			"fields": {
+				"defence": "defense",
+				"rp": "adrenaline",
+				"fever": "resonance"
+			},
+			"enumValues": {
+				"element_type.205": "auricInk",
+				"specialty.rupture": "rupture"
+			},
+			"sourceTerms": {
+				"玄墨": "auricInk",
+				"闪能": "adrenaline",
+				"喧响值": "resonance",
+				"电属性伤害": "electric"
+			}
+		}
+	}
+};
+//#endregion
+//#region src/runtime-policy.ts
+const NANOKA_RUNTIME_SOURCE_ID = "nanoka-zzz";
+const NANOKA_RUNTIME_SOURCE_VERSION = "2.8";
+const NANOKA_RUNTIME_DATA_VERSION = "fairy-v0.1.0-nanoka-runtime";
+const ARCHIVED_RUNTIME_SOURCE_IDS = [
+	"lo-user-excel",
+	"mihoyo-zzz-critical-assault",
+	"buhflipexplode-zzz-da",
+	"nanoka-zzz-boss-manual-2026-05-07"
+];
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSourceRefCandidate(value) {
+	return isObject(value) && typeof value.sourceId === "string";
+}
+function collectSourceRefs(value, refs = []) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectSourceRefs(item, refs);
+		return refs;
+	}
+	if (!isObject(value)) return refs;
+	if (isSourceRefCandidate(value)) {
+		const ref = { sourceId: value.sourceId };
+		if (typeof value.sourceVersion === "string") ref.sourceVersion = value.sourceVersion;
+		if (typeof value.sourceAnchor === "string") ref.sourceAnchor = value.sourceAnchor;
+		if (typeof value.dataPath === "string") ref.dataPath = value.dataPath;
+		refs.push(ref);
+	}
+	for (const item of Object.values(value)) collectSourceRefs(item, refs);
+	return refs;
+}
+function assert(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function assertNanokaRuntimeGameDataArtifact(artifact) {
+	assert(isObject(artifact), "runtime game data artifact must be an object");
+	assert(artifact.kind === "gameData", "runtime artifact kind must be gameData");
+	assert(artifact.dataVersion === NANOKA_RUNTIME_DATA_VERSION, "runtime artifact dataVersion drifted");
+	assert(artifact.runtimeCutoverReady === true, "runtimeCutoverReady must be true after Phase 4 cutover");
+	const policy = artifact.runtimeSourcePolicy;
+	assert(isObject(policy), "runtimeSourcePolicy is required");
+	assert(policy.primarySourceId === NANOKA_RUNTIME_SOURCE_ID, "runtime primary source must be nanoka-zzz");
+	assert(policy.configuredLiveVersion === "2.8", "runtime sourceVersion must use configured live version");
+	assert(policy.archivedSourcesRuntimeAllowed === false, "archived sources must not be allowed at runtime");
+	assert(policy.phase3ExitSyncId === "phase3-sync-002-g27-g28", "runtime cutover must cite Phase 3 exit sync");
+	assert(JSON.stringify(policy.deprecatedRuntimeSourceIds) === JSON.stringify(ARCHIVED_RUNTIME_SOURCE_IDS), "deprecated runtime source id list drifted");
+	const data = parseGameData(artifact.data);
+	assert(data.sourceVersion === `${NANOKA_RUNTIME_SOURCE_ID}@2.8`, "runtime GameData sourceVersion must be nanoka-zzz@2.8");
+	assert(data.sources.length === 1, "runtime GameData must expose exactly one runtime source document");
+	assert(data.sources[0]?.id === NANOKA_RUNTIME_SOURCE_ID, "runtime GameData source document must be nanoka-zzz");
+	assert(data.sources[0]?.sourceVersion === "2.8", "runtime GameData source document must use configured live version");
+	const archivedSources = new Set(ARCHIVED_RUNTIME_SOURCE_IDS);
+	for (const ref of collectSourceRefs(data)) {
+		assert(!archivedSources.has(ref.sourceId), `runtime GameData must not reference archived source ${ref.sourceId}`);
+		assert(ref.sourceId === NANOKA_RUNTIME_SOURCE_ID, `runtime GameData must not reference non-nanoka source ${ref.sourceId}`);
+		assert(ref.sourceVersion === "2.8", `${ref.sourceAnchor ?? ref.sourceId}: runtime source refs must use configured live version`);
+	}
+}
+//#endregion
+//#region src/runtime.ts
+const nanokaRuntimeGameDataArtifact = game_data_default;
+function getNanokaRuntimeGameData() {
+	assertNanokaRuntimeGameDataArtifact(nanokaRuntimeGameDataArtifact);
+	return nanokaRuntimeGameDataArtifact.data;
+}
+function getNanokaRuntimeSourcePolicy() {
+	assertNanokaRuntimeGameDataArtifact(nanokaRuntimeGameDataArtifact);
+	return nanokaRuntimeGameDataArtifact.runtimeSourcePolicy;
+}
 //#endregion
 //#region src/sources.ts
 const dataSourceDescriptors = [
+	{
+		id: "nanoka-zzz",
+		kind: "thirdPartySite",
+		label: "nanoka ZZZ static JSON",
+		url: "https://static.nanoka.cc/manifest.json",
+		status: "readyForAdapter",
+		formalDataReady: false,
+		parserTargets: [
+			"agent and Bangboo base panel raw fields",
+			"skill parameter tables",
+			"Deadly Assault period / zone / buff / boss detail raw fields",
+			"Adrenaline and Resonance recovery raw fields",
+			"enemy monster_info variant mapping raw fields",
+			"Phase 3 Nicole/Yanagi/Penguinboo/Sharkboo candidate coverage",
+			"approved-live snapshot diff inputs"
+		],
+		sourceVersionStrategy: "Resolve manifest.zzz.live, retain the configured live snapshot, and treat manifest.zzz.latest as research/drift only unless lo-user approves a version upgrade.",
+		discoveredAssets: [
+			"data/source/raw/nanoka/zzz/2.8/fetch-manifest.json",
+			"data/source/raw/nanoka/zzz/2.8/manifest.json",
+			"data/source/raw/nanoka/zzz/2.8/boss.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/character/1021.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/character/1371.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/character/1031.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/character/1221.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/boss/69036.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/30000.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/30004.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/200141.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/200014.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/200034.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/30033.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/monster/300211.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/bangboo/53001.json",
+			"data/source/raw/nanoka/zzz/2.8/zh/bangboo/54001.json"
+		],
+		fetchPolicy: {
+			mode: "httpGet",
+			maxRequestsPerMinute: 30,
+			cacheRequired: true,
+			conditionalRequestsPreferred: true,
+			requiresUserAgent: true
+		},
+		compliance: {
+			robotsTxt: "notChecked",
+			termsStatus: "requiresHumanReview",
+			redistribution: "cleanedDataOnly",
+			notes: [
+				"D-20 R1/R6 locks nanoka as the exclusive source for source-backed cleaned data.",
+				"Release artifacts default to manifest.zzz.live; latest/pre-release snapshots are research-only unless lo-user approves a version upgrade.",
+				"Phase 2 raw snapshot retention is for source-gate and adapter-skeleton verification only; runtime cutover waits for normalization, semantic mapping, and QA drift audit."
+			]
+		}
+	},
 	{
 		id: "lo-user-excel",
 		kind: "excel",
@@ -224,4 +1128,4 @@ function getDataSourceDescriptor(id) {
 	return descriptor;
 }
 //#endregion
-export { DATA_SOURCE_SKELETON_PARSER_VERSION, assertDiscoveryOnlyGameData, buildSourceDocument, buildSourceRef, createDiscoveryOnlyAdapter, createEmptyGameData, dataSourceDescriptors, getDataSourceDescriptor };
+export { ARCHIVED_RUNTIME_SOURCE_IDS, DATA_SOURCE_SKELETON_PARSER_VERSION, NANOKA_PARSER_VERSION, NANOKA_RUNTIME_DATA_VERSION, NANOKA_RUNTIME_SOURCE_ID, NANOKA_RUNTIME_SOURCE_VERSION, NANOKA_SOURCE_ID, assertApprovedSnapshotDiffInputs, assertDiscoveryOnlyGameData, assertNanokaRuntimeGameDataArtifact, assertNanokaSnapshotManifest, buildSourceDocument, buildSourceDocumentFromRegistryEntry, buildSourceRef, buildSourceRefForParsedRecord, buildSourceRefsForParsedBatch, createDiscoveryOnlyAdapter, createEmptyGameData, createNanokaSnapshotAdapter, dataSourceDescriptors, deriveNanokaAdrenalinePanel, deriveNanokaBangbooElement, deriveNanokaDeadlyAssaultPeriod, deriveNanokaEnemyVariantMapping, deriveNanokaEnemyVariantMappings, deriveNanokaPanelValue, deriveNanokaPromotionExtraStats, deriveNanokaSkillResourceRecovery, deriveNanokaSnapshotDiffHistory, diffNumericLeaves, getDataSourceDescriptor, getNanokaRuntimeGameData, getNanokaRuntimeSourcePolicy, nanokaResourceUnitRules, nanokaRuntimeGameDataArtifact, nanokaSnapshotRecords };