@tangle-network/agent-eval 0.144.9 → 0.144.11

package/dist/{skillopt-optimization-method-Dtzp7QpP.js → skillopt-optimization-method-CQdVeM8k.js}

@@ -1,8 +1,9 @@
 import { c as ValidationError, i as JudgeError, t as AgentEvalError } from "./errors-D-LKuDhb.js";
 import { i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledger-DMFxsLKr.js";
 import { f as maximumChargeForLlmRequest, l as costReceiptFromLlm, m as stripFencedJson, u as costReceiptFromLlmError } from "./llm-client-DzvMUsS_.js";
+import { a as deepFreezeCanonicalJson } from "./usage-receipt-t7vAzCRQ.js";
 import { a as clamp01, o as combineAbortSignals, t as assertProposalFindings } from "./proposal-findings-2GIUo1et.js";
-import { C as isExternalTextCandidate, D as resolveExternalOptimizerProcessLimits, E as resolveExternalOptimizerCallbackLimits, O as safePathComponent, S as isCandidateText, T as removeCredentialEnvironment, b as assertJsonValue, d as closeExternalOptimizerResources, f as runWithCleanup, l as startExternalOptimizerCallback, n as createRunCostLedger, p as startExternalOptimizerModelProxy, r as fsCampaignStorage, t as acquireSingleRunLock, u as runExternalOptimizerProcess, w as isRecord, x as assertNoCredentialValues, y as assertExternalOptimizerModelBudget } from "./single-run-lock-BMQEv1wG.js";
+import { C as isExternalTextCandidate, D as resolveExternalOptimizerProcessLimits, E as resolveExternalOptimizerCallbackLimits, O as safePathComponent, S as isCandidateText, T as removeCredentialEnvironment, b as assertJsonValue, d as closeExternalOptimizerResources, f as runWithCleanup, i as fsCampaignStorage, n as startExternalOptimizerCallback, p as startExternalOptimizerModelProxy, r as createRunCostLedger, t as acquireSingleRunLock, u as runExternalOptimizerProcess, w as isRecord, x as assertNoCredentialValues, y as assertExternalOptimizerModelBudget } from "./single-run-lock-DFWHEB09.js";
 import { n as canonicalJson, r as contentHash } from "./verdict-cache-BCcOh0kF.js";
 import { p as mapConcurrent } from "./ledger-core-DXZIqu17.js";
 import { E as pairedBootstrap, H as weightedComposite, d as confidenceInterval } from "./statistics-ByxzSiOM.js";
@@ -1413,73 +1414,241 @@ function designedCellIds(scenarios, reps) {
 	return ids;
 }
 //#endregion
-//#region src/campaign/external-optimizer-run-budget.ts
-function externalOptimizerRunKey(input) {
-	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
-	if (typeof input.resumeEnabled !== "boolean") throw new Error("external optimizer resumeEnabled must be a boolean");
-	const compatible = externalOptimizerCompatibleRunKey(input.material);
-	return input.resumeEnabled ? compatible : `${compatible}-${input.attemptId}`;
-}
-function externalOptimizerCompatibleRunKey(material) {
-	return contentHash(material);
-}
-function openExternalOptimizerRunBudget(input) {
-	if (!input.runKey.trim() || input.runKey.trim() !== input.runKey) throw new Error("external optimizer runKey must be trimmed and non-empty");
-	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
-	if (!Number.isSafeInteger(input.maxEvaluations) || input.maxEvaluations <= 0) throw new Error("external optimizer maxEvaluations must be a positive safe integer");
-	const budgetDir = `${input.runDir}/budgets`;
-	const statePath = `${budgetDir}/${input.runKey}.jsonl`;
-	input.storage.ensureDir(budgetDir);
-	const runTags = Object.freeze({ optimizerRun: input.runKey });
-	const attemptTags = Object.freeze({
-		optimizerRun: input.runKey,
-		optimizerAttempt: input.attemptId
+//#region src/campaign/external-optimizer-observations.ts
+/**
+* Read and verify the exact callback observation artifact addressed by method provenance.
+*
+* The reader checks the raw SHA-256, canonical JSONL bytes, sequence, candidate
+* identities, and summary counts before it returns any candidate.
+* This proves that the bytes match the supplied summary. The caller remains
+* responsible for obtaining that summary from trusted provenance.
+*/
+function readExternalOptimizerObservationArtifact(input) {
+	const { summary } = input;
+	assertObservationSummary(summary);
+	const storage = input.storage ?? fsCampaignStorage();
+	const contents = storage.read(summary.path);
+	if (contents === void 0) {
+		const state = storage.exists(summary.path) ? "unreadable" : "missing";
+		throw new Error(`external optimizer observation artifact is ${state} at '${summary.path}'`);
+	}
+	const sha256 = `sha256:${createHash("sha256").update(contents).digest("hex")}`;
+	if (sha256 !== summary.sha256) throw new Error(`external optimizer observation artifact digest mismatch at '${summary.path}': expected ${summary.sha256}, got ${sha256}`);
+	if (contents.length > 0 && !contents.endsWith("\n")) throw new Error(`external optimizer observation artifact must end with a newline at '${summary.path}'`);
+	const observations = contents.length === 0 ? [] : parseObservationLines(contents, summary.path);
+	const candidates = [];
+	const proposed = /* @__PURE__ */ new Map();
+	const evaluationNumbers = /* @__PURE__ */ new Set();
+	let evaluations = 0;
+	let failedEvaluations = 0;
+	let refusals = 0;
+	for (const [index, observation] of observations.entries()) {
+		if (observation.sequence !== index + 1) throw new Error(`external optimizer observation artifact expected sequence ${index + 1}, got ${observation.sequence}`);
+		if (observation.kind === "proposal") {
+			assertCandidateIdentity(observation.candidate, observation.candidateHash, observation.sequence);
+			if (proposed.has(observation.candidateHash)) throw new Error(`external optimizer observation artifact repeats candidate ${observation.candidateHash}`);
+			const candidate = {
+				candidate: structuredClone(observation.candidate),
+				candidateHash: observation.candidateHash,
+				candidateDigest: `sha256:${observation.candidateHash}`,
+				proposalSequence: observation.sequence,
+				provenance: {
+					path: summary.path,
+					sha256: summary.sha256
+				}
+			};
+			proposed.set(observation.candidateHash, candidate);
+			candidates.push(candidate);
+			continue;
+		}
+		if (observation.kind === "evaluation") {
+			evaluations += 1;
+			if (evaluationNumbers.has(observation.evaluationNumber)) throw new Error(`external optimizer observation artifact repeats evaluation number ${observation.evaluationNumber}`);
+			evaluationNumbers.add(observation.evaluationNumber);
+			assertObservedCandidate(observation, proposed);
+			assertJsonValue(observation.response, "external optimizer evaluation response");
+			continue;
+		}
+		refusals += 1;
+		if (observation.reason !== "invalid-request" && observation.reason !== "evaluation-limit" && observation.reason !== "evaluation-failed") throw new Error(`external optimizer observation artifact has invalid refusal reason at sequence ${observation.sequence}`);
+		if (observation.reason === "evaluation-failed") failedEvaluations += 1;
+		const candidateFields = [observation.candidate, observation.candidateHash];
+		if (observation.reason !== "invalid-request" && candidateFields.some((value) => value === void 0)) throw new Error(`external optimizer observation artifact omits a refused candidate at sequence ${observation.sequence}`);
+		if (candidateFields.some((value) => value !== void 0)) {
+			if (candidateFields.some((value) => value === void 0)) throw new Error(`external optimizer observation artifact has incomplete candidate identity at sequence ${observation.sequence}`);
+			assertObservedCandidate(observation, proposed);
+		}
+	}
+	const acceptedEvaluations = evaluations + failedEvaluations;
+	for (const evaluationNumber of evaluationNumbers) if (evaluationNumber > acceptedEvaluations) throw new Error(`external optimizer observation artifact has out-of-range evaluation number ${evaluationNumber}`);
+	if (candidates.length !== summary.submittedCandidates || evaluations !== summary.evaluations || refusals !== summary.refusals) throw new Error(`external optimizer observation artifact counts disagree at '${summary.path}': expected ${summary.submittedCandidates}/${summary.evaluations}/${summary.refusals}, got ${candidates.length}/${evaluations}/${refusals}`);
+	return deepFreezeCanonicalJson({
+		summary: structuredClone(summary),
+		observations,
+		candidates
 	});
+}
+/** Append-only observation log for one external-optimizer attempt. */
+function openExternalOptimizerObservationLog(input) {
+	if (input.storage.read(input.path) !== void 0 || input.storage.exists(input.path)) throw new Error(`external optimizer observation log already exists at '${input.path}'`);
+	input.storage.write(input.path, "");
+	let revision = 0;
+	const counts = {
+		submittedCandidates: 0,
+		evaluations: 0,
+		refusals: 0
+	};
 	return {
-		runKey: input.runKey,
-		attemptId: input.attemptId,
-		runTags,
-		attemptTags,
-		acceptedEvaluations: () => readState(input.storage.read(statePath), input.maxEvaluations, statePath).accepted,
-		acceptEvaluation() {
-			for (let attempt = 0; attempt < 16; attempt += 1) {
-				const current = input.storage.read(statePath) ?? "";
-				const state = readState(current, input.maxEvaluations, statePath);
-				if (state.accepted >= input.maxEvaluations) return void 0;
-				if (!input.storage.append) throw new Error("external optimizer evaluation budgets require appendable storage");
-				const next = state.accepted + 1;
-				const event = `${JSON.stringify({
-					maxEvaluations: input.maxEvaluations,
-					accepted: next
-				})}\n`;
-				const expectedBytes = new TextEncoder().encode(current).byteLength;
-				if (input.storage.append(statePath, event, expectedBytes) !== void 0) return next;
-			}
-			throw new Error(`external optimizer evaluation counter for '${input.runKey}' was updated concurrently`);
+		observe(observation) {
+			const expectedSequence = counts.submittedCandidates + counts.evaluations + counts.refusals + 1;
+			if (observation.sequence !== expectedSequence) throw new Error(`external optimizer observation log expected sequence ${expectedSequence}, got ${observation.sequence}`);
+			const line = `${canonicalJson(observation)}\n`;
+			const next = input.storage.append(input.path, line, revision);
+			if (next === void 0) throw new Error(`external optimizer observation log changed concurrently at '${input.path}'`);
+			revision = next;
+			if (observation.kind === "proposal") counts.submittedCandidates += 1;
+			else if (observation.kind === "evaluation") counts.evaluations += 1;
+			else counts.refusals += 1;
+		},
+		summary() {
+			const contents = input.storage.read(input.path) ?? "";
+			const bytes = new TextEncoder().encode(contents);
+			if (bytes.byteLength !== revision) throw new Error(`external optimizer observation log revision changed at '${input.path}'`);
+			return {
+				scope: "callback-submitted-candidates",
+				path: input.path,
+				sha256: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+				...counts
+			};
 		}
 	};
 }
-function readState(text, maxEvaluations, statePath) {
-	if (text === void 0 || text === "") return {
-		maxEvaluations,
-		accepted: 0
-	};
-	let accepted = 0;
-	for (const line of text.split("\n")) {
-		if (!line) continue;
-		let value;
+function assertObservationSummary(summary) {
+	if (summary.scope !== "callback-submitted-candidates") throw new Error("external optimizer observation summary has an invalid scope");
+	if (typeof summary.path !== "string" || summary.path.trim().length === 0) throw new Error("external optimizer observation summary has an invalid path");
+	if (!/^sha256:[a-f0-9]{64}$/u.test(summary.sha256)) throw new Error("external optimizer observation summary has an invalid SHA-256");
+	for (const [field, value] of [
+		["submittedCandidates", summary.submittedCandidates],
+		["evaluations", summary.evaluations],
+		["refusals", summary.refusals]
+	]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`external optimizer observation summary ${field} must be a non-negative integer`);
+}
+function parseObservationLines(contents, path) {
+	return contents.slice(0, -1).split("\n").map((line, index) => {
+		let observation;
 		try {
-			value = JSON.parse(line);
+			observation = JSON.parse(line);
 		} catch (cause) {
-			throw new Error(`external optimizer evaluation state is invalid at '${statePath}'`, { cause });
+			throw new Error(`external optimizer observation artifact has invalid JSON at '${path}' line ${index + 1}`, { cause });
 		}
-		if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "accepted,maxEvaluations" || value.maxEvaluations !== maxEvaluations || value.accepted !== accepted + 1) throw new Error(`external optimizer evaluation state does not match at '${statePath}'`);
-		accepted += 1;
+		assertObservationShape(observation, index + 1);
+		if (canonicalJson(observation) !== line) throw new Error(`external optimizer observation artifact is not canonical at '${path}' line ${index + 1}`);
+		return observation;
+	});
+}
+function assertObservationShape(value, line) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`external optimizer observation artifact line ${line} must be an object`);
+	const observation = value;
+	if (!Number.isSafeInteger(observation.sequence) || Number(observation.sequence) <= 0) throw new Error(`external optimizer observation artifact line ${line} has an invalid sequence`);
+	if (observation.kind === "proposal") {
+		assertExactKeys$1(observation, [
+			"candidate",
+			"candidateHash",
+			"kind",
+			"sequence"
+		], line);
+		assertCandidateFields(observation, line);
+		return;
 	}
-	if (accepted > maxEvaluations) throw new Error(`external optimizer evaluation state exceeds its limit at '${statePath}'`);
+	if (observation.kind === "evaluation") {
+		assertExactKeys$1(observation, [
+			"candidate",
+			"candidateHash",
+			"evaluationNumber",
+			"exampleId",
+			"kind",
+			"response",
+			"sequence"
+		], line);
+		assertCandidateFields(observation, line);
+		if (typeof observation.exampleId !== "string") throw new Error(`external optimizer observation artifact line ${line} has an invalid exampleId`);
+		if (!Number.isSafeInteger(observation.evaluationNumber) || Number(observation.evaluationNumber) <= 0) throw new Error(`external optimizer observation artifact line ${line} has an invalid evaluationNumber`);
+		assertJsonValue(observation.response, `external optimizer observation artifact line ${line}`);
+		return;
+	}
+	if (observation.kind === "refusal") {
+		assertAllowedKeys(observation, [
+			"candidate",
+			"candidateHash",
+			"exampleId",
+			"kind",
+			"reason",
+			"sequence"
+		], line);
+		if (typeof observation.reason !== "string") throw new Error(`external optimizer observation artifact line ${line} has an invalid reason`);
+		if (observation.candidate !== void 0 || observation.candidateHash !== void 0) assertCandidateFields(observation, line);
+		if (observation.exampleId !== void 0 && typeof observation.exampleId !== "string") throw new Error(`external optimizer observation artifact line ${line} has an invalid exampleId`);
+		return;
+	}
+	throw new Error(`external optimizer observation artifact line ${line} has an invalid kind`);
+}
+function assertCandidateFields(observation, line) {
+	if (!isExternalTextCandidate(observation.candidate)) throw new Error(`external optimizer observation artifact line ${line} has an invalid candidate`);
+	if (typeof observation.candidateHash !== "string" || !/^[a-f0-9]{64}$/u.test(observation.candidateHash)) throw new Error(`external optimizer observation artifact line ${line} has an invalid candidateHash`);
+}
+function assertExactKeys$1(value, expected, line) {
+	assertAllowedKeys(value, expected, line);
+	for (const key of expected) if (!(key in value)) throw new Error(`external optimizer observation artifact line ${line} is missing ${key}`);
+}
+function assertAllowedKeys(value, allowed, line) {
+	const extras = Object.keys(value).filter((key) => !allowed.includes(key));
+	if (extras.length > 0) throw new Error(`external optimizer observation artifact line ${line} has unexpected field ${extras[0]}`);
+}
+function assertCandidateIdentity(candidate, candidateHash, sequence) {
+	if (candidateHash !== contentHash({
+		kind: "external-text-candidate",
+		candidate
+	})) throw new Error(`external optimizer observation artifact candidate hash mismatch at sequence ${sequence}`);
+}
+function assertObservedCandidate(observation, proposed) {
+	assertCandidateIdentity(observation.candidate, observation.candidateHash, observation.sequence);
+	const candidate = proposed.get(observation.candidateHash);
+	if (!candidate) throw new Error(`external optimizer observation artifact references an unproposed candidate at sequence ${observation.sequence}`);
+	if (!isDeepStrictEqual(observation.candidate, candidate.candidate)) throw new Error(`external optimizer observation artifact changes candidate bytes at sequence ${observation.sequence}`);
+}
+/** Append-only opaque Runtime execution records for one optimizer attempt. */
+function openExternalOptimizerExecutionLog(input) {
+	if (input.storage.read(input.path) !== void 0 || input.storage.exists(input.path)) throw new Error(`external optimizer execution log already exists at '${input.path}'`);
+	input.storage.write(input.path, "");
+	let revision = 0;
+	const counts = {
+		calls: 0,
+		succeeded: 0,
+		failed: 0
+	};
 	return {
-		maxEvaluations,
-		accepted
+		observe(observation) {
+			if (observation.sequence !== counts.calls + 1) throw new Error(`external optimizer execution log expected sequence ${counts.calls + 1}, got ${observation.sequence}`);
+			const line = `${canonicalJson(observation)}\n`;
+			const next = input.storage.append(input.path, line, revision);
+			if (next === void 0) throw new Error(`external optimizer execution log changed concurrently at '${input.path}'`);
+			revision = next;
+			counts.calls += 1;
+			if (observation.succeeded) counts.succeeded += 1;
+			else counts.failed += 1;
+		},
+		summary() {
+			const contents = input.storage.read(input.path) ?? "";
+			const bytes = new TextEncoder().encode(contents);
+			if (bytes.byteLength !== revision) throw new Error(`external optimizer execution log revision changed at '${input.path}'`);
+			if (counts.calls !== counts.succeeded + counts.failed) throw new Error(`external optimizer execution log counts disagree at '${input.path}'`);
+			return {
+				scope: "runtime-model-calls",
+				path: input.path,
+				sha256: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+				...counts
+			};
+		}
 	};
 }
 //#endregion
@@ -2830,6 +2999,76 @@ function deepFreeze$1(value) {
 	return value;
 }
 //#endregion
+//#region src/campaign/external-optimizer-run-budget.ts
+function externalOptimizerRunKey(input) {
+	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
+	if (typeof input.resumeEnabled !== "boolean") throw new Error("external optimizer resumeEnabled must be a boolean");
+	const compatible = externalOptimizerCompatibleRunKey(input.material);
+	return input.resumeEnabled ? compatible : `${compatible}-${input.attemptId}`;
+}
+function externalOptimizerCompatibleRunKey(material) {
+	return contentHash(material);
+}
+function openExternalOptimizerRunBudget(input) {
+	if (!input.runKey.trim() || input.runKey.trim() !== input.runKey) throw new Error("external optimizer runKey must be trimmed and non-empty");
+	if (!input.attemptId.trim() || input.attemptId.trim() !== input.attemptId) throw new Error("external optimizer attemptId must be trimmed and non-empty");
+	if (!Number.isSafeInteger(input.maxEvaluations) || input.maxEvaluations <= 0) throw new Error("external optimizer maxEvaluations must be a positive safe integer");
+	const budgetDir = `${input.runDir}/budgets`;
+	const statePath = `${budgetDir}/${input.runKey}.jsonl`;
+	input.storage.ensureDir(budgetDir);
+	const runTags = Object.freeze({ optimizerRun: input.runKey });
+	const attemptTags = Object.freeze({
+		optimizerRun: input.runKey,
+		optimizerAttempt: input.attemptId
+	});
+	return {
+		runKey: input.runKey,
+		attemptId: input.attemptId,
+		runTags,
+		attemptTags,
+		acceptedEvaluations: () => readState(input.storage.read(statePath), input.maxEvaluations, statePath).accepted,
+		acceptEvaluation() {
+			for (let attempt = 0; attempt < 16; attempt += 1) {
+				const current = input.storage.read(statePath) ?? "";
+				const state = readState(current, input.maxEvaluations, statePath);
+				if (state.accepted >= input.maxEvaluations) return void 0;
+				if (!input.storage.append) throw new Error("external optimizer evaluation budgets require appendable storage");
+				const next = state.accepted + 1;
+				const event = `${JSON.stringify({
+					maxEvaluations: input.maxEvaluations,
+					accepted: next
+				})}\n`;
+				const expectedBytes = new TextEncoder().encode(current).byteLength;
+				if (input.storage.append(statePath, event, expectedBytes) !== void 0) return next;
+			}
+			throw new Error(`external optimizer evaluation counter for '${input.runKey}' was updated concurrently`);
+		}
+	};
+}
+function readState(text, maxEvaluations, statePath) {
+	if (text === void 0 || text === "") return {
+		maxEvaluations,
+		accepted: 0
+	};
+	let accepted = 0;
+	for (const line of text.split("\n")) {
+		if (!line) continue;
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch (cause) {
+			throw new Error(`external optimizer evaluation state is invalid at '${statePath}'`, { cause });
+		}
+		if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "accepted,maxEvaluations" || value.maxEvaluations !== maxEvaluations || value.accepted !== accepted + 1) throw new Error(`external optimizer evaluation state does not match at '${statePath}'`);
+		accepted += 1;
+	}
+	if (accepted > maxEvaluations) throw new Error(`external optimizer evaluation state exceeds its limit at '${statePath}'`);
+	return {
+		maxEvaluations,
+		accepted
+	};
+}
+//#endregion
 //#region src/campaign/external-text-optimization-contract.ts
 const MAX_TIMER_DELAY_MS$3 = 2147483647;
 function assertExternalTextOptimizationConfig(config) {
@@ -2924,6 +3163,191 @@ function assertExternalCostAccounting(value, calls, name) {
 	if (accounting.kind !== "external" || typeof accounting.reason !== "string" || !accounting.reason.trim() || accounting.reason.trim() !== accounting.reason) throw new Error(`${name}: optimizer returned invalid costAccounting`);
 }
 //#endregion
+//#region src/campaign/gepa-candidate-population.ts
+/**
+* Read GEPA's exact candidate graph from the artifact addressed by method provenance.
+*
+* The reader checks the supplied digest, declared byte count, run identity,
+* candidate surfaces, parent graph, selection scores, and configured bounds.
+* This proves that the bytes match the supplied summary. The caller remains
+* responsible for obtaining that summary from trusted method provenance.
+*/
+function readGepaCandidatePopulationArtifact(input) {
+	assertGepaCandidatePopulationSummary(input.summary);
+	const scenarioIds = scenarioIdSet(input.summary.scenarioIds);
+	const storage = input.storage ?? fsCampaignStorage();
+	const contents = storage.read(input.summary.path);
+	if (contents === void 0) {
+		const state = storage.exists(input.summary.path) ? "unreadable" : "missing";
+		throw new Error(`GEPA candidate population artifact is ${state} at '${input.summary.path}'`);
+	}
+	const bytes = new TextEncoder().encode(contents).byteLength;
+	if (bytes !== input.summary.bytes) throw new Error(`GEPA candidate population byte count mismatch at '${input.summary.path}': expected ${input.summary.bytes}, got ${bytes}`);
+	if (BigInt(bytes) > maximumArtifactBytes(input.summary.maxCandidates, input.summary.maxCandidateChars, scenarioIds)) throw new Error(`GEPA candidate population exceeds its configured bounds at '${input.summary.path}'`);
+	const sha256 = `sha256:${createHash("sha256").update(contents).digest("hex")}`;
+	if (sha256 !== input.summary.sha256) throw new Error(`GEPA candidate population digest mismatch at '${input.summary.path}': expected ${input.summary.sha256}, got ${sha256}`);
+	let raw;
+	try {
+		raw = JSON.parse(contents);
+	} catch (cause) {
+		throw new Error(`GEPA candidate population is not JSON at '${input.summary.path}'`, { cause });
+	}
+	assertExactKeys(raw, [
+		"bestIndex",
+		"candidates",
+		"runId",
+		"schemaVersion",
+		"scope"
+	], "artifact");
+	if (raw.schemaVersion !== 1 || raw.scope !== "gepa-candidate-population") throw new Error("GEPA candidate population has an unsupported schema");
+	if (raw.runId !== input.summary.runId) throw new Error("GEPA candidate population run ID differs from its summary");
+	if (!Array.isArray(raw.candidates) || raw.candidates.length === 0) throw new Error("GEPA candidate population must contain candidates");
+	if (raw.candidates.length !== input.summary.candidates || raw.candidates.length > input.summary.maxCandidates) throw new Error("GEPA candidate population count differs from its summary or configured bound");
+	const bestIndex = raw.bestIndex;
+	if (typeof bestIndex !== "number" || !Number.isSafeInteger(bestIndex) || bestIndex < 0 || bestIndex >= raw.candidates.length || bestIndex !== input.summary.bestIndex) throw new Error("GEPA candidate population has an invalid best index");
+	const candidates = raw.candidates.map((candidate, index) => parseCandidate({
+		candidate,
+		index,
+		maxCandidateChars: input.summary.maxCandidateChars,
+		scenarioIds,
+		expectsComponents: input.summary.surfaceKind === "components"
+	}));
+	return deepFreezeCanonicalJson({
+		summary: structuredClone(input.summary),
+		runId: raw.runId,
+		bestIndex,
+		candidates
+	});
+}
+function assertGepaCandidatePopulationSummary(value) {
+	assertExactKeys(value, [
+		"bestIndex",
+		"bytes",
+		"candidates",
+		"maxCandidateChars",
+		"maxCandidates",
+		"path",
+		"runId",
+		"scenarioIds",
+		"scope",
+		"sha256",
+		"surfaceKind"
+	], "summary");
+	if (value.scope !== "gepa-candidate-population") throw new Error("GEPA candidate population summary has an invalid scope");
+	if (typeof value.path !== "string" || value.path.trim().length === 0) throw new Error("GEPA candidate population summary has an invalid path");
+	if (typeof value.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(value.sha256)) throw new Error("GEPA candidate population summary has an invalid SHA-256");
+	if (typeof value.runId !== "string" || value.runId.trim().length === 0) throw new Error("GEPA candidate population summary has an invalid run ID");
+	const bytes = value.bytes;
+	const candidates = value.candidates;
+	const maxCandidates = value.maxCandidates;
+	const maxCandidateChars = value.maxCandidateChars;
+	assertPositiveSafeInteger$2(bytes, "summary.bytes");
+	assertPositiveSafeInteger$2(candidates, "summary.candidates");
+	assertPositiveSafeInteger$2(maxCandidates, "summary.maxCandidates");
+	assertPositiveSafeInteger$2(maxCandidateChars, "summary.maxCandidateChars");
+	if (candidates > maxCandidates) throw new Error("GEPA candidate population summary exceeds its configured candidate bound");
+	scenarioIdSet(value.scenarioIds);
+	if (value.surfaceKind !== "text" && value.surfaceKind !== "components") throw new Error("GEPA candidate population summary has an invalid surface kind");
+	const bestIndex = value.bestIndex;
+	if (typeof bestIndex !== "number" || !Number.isSafeInteger(bestIndex) || bestIndex < 0 || bestIndex >= candidates) throw new Error("GEPA candidate population summary has an invalid best index");
+}
+function parseCandidate(input) {
+	const { candidate, index } = input;
+	assertExactKeys(candidate, [
+		"aggregateScore",
+		"candidate",
+		"discoveryEvaluationCount",
+		"index",
+		"parentIndices",
+		"selectionScores"
+	], `candidate ${index}`);
+	if (candidate.index !== index) throw new Error(`GEPA candidate population expected index ${index}`);
+	if (!isExternalTextCandidate(candidate.candidate) || input.expectsComponents !== (typeof candidate.candidate !== "string") || candidateChars(candidate.candidate) > input.maxCandidateChars) throw new Error(`GEPA candidate ${index} has an invalid surface`);
+	const parentIndices = parseParents(candidate.parentIndices, index);
+	const selectionScores = parseSelectionScores(candidate.selectionScores, input.scenarioIds, index);
+	const aggregateScore = parseAggregateScore(candidate.aggregateScore, selectionScores, index);
+	const discoveryEvaluationCount = candidate.discoveryEvaluationCount;
+	if (typeof discoveryEvaluationCount !== "number" || !Number.isSafeInteger(discoveryEvaluationCount) || discoveryEvaluationCount < 0) throw new Error(`GEPA candidate ${index} has an invalid discovery evaluation count`);
+	const candidateHash = contentHash({
+		kind: "external-text-candidate",
+		candidate: candidate.candidate
+	});
+	return {
+		index,
+		candidate: structuredClone(candidate.candidate),
+		candidateHash,
+		candidateDigest: `sha256:${candidateHash}`,
+		parentIndices,
+		aggregateScore,
+		selectionScores,
+		discoveryEvaluationCount
+	};
+}
+function parseParents(value, index) {
+	if (!Array.isArray(value) || value.length === 0) throw new Error(`GEPA candidate ${index} has invalid parents`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const parent of value) {
+		if (parent === null) {
+			if (index !== 0) throw new Error(`GEPA candidate ${index} has a null parent`);
+		} else if (!Number.isSafeInteger(parent) || parent < 0 || parent >= index) throw new Error(`GEPA candidate ${index} has an invalid parent index`);
+		if (seen.has(parent)) throw new Error(`GEPA candidate ${index} repeats a parent index`);
+		seen.add(parent);
+	}
+	if (index === 0 && (value.length !== 1 || value[0] !== null)) throw new Error("GEPA root candidate must have one null parent");
+	return [...value];
+}
+function parseSelectionScores(value, scenarioIds, candidateIndex) {
+	if (!Array.isArray(value)) throw new Error(`GEPA candidate ${candidateIndex} has invalid selection scores`);
+	const seen = /* @__PURE__ */ new Set();
+	let prior = "";
+	return value.map((row, index) => {
+		assertExactKeys(row, ["scenarioId", "score"], `candidate ${candidateIndex} score ${index}`);
+		if (typeof row.scenarioId !== "string" || !scenarioIds.has(row.scenarioId) || seen.has(row.scenarioId) || index > 0 && row.scenarioId <= prior) throw new Error(`GEPA candidate ${candidateIndex} has invalid selection score identity`);
+		if (typeof row.score !== "number" || !Number.isFinite(row.score)) throw new Error(`GEPA candidate ${candidateIndex} has an invalid selection score`);
+		seen.add(row.scenarioId);
+		prior = row.scenarioId;
+		return {
+			scenarioId: row.scenarioId,
+			score: row.score
+		};
+	});
+}
+function parseAggregateScore(value, scores, candidateIndex) {
+	if (scores.length === 0) {
+		if (value !== null) throw new Error(`GEPA candidate ${candidateIndex} has a score without selection evidence`);
+		return null;
+	}
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`GEPA candidate ${candidateIndex} has an invalid aggregate score`);
+	const mean = scores.reduce((total, row) => total + row.score, 0) / scores.length;
+	if (Math.abs(value - mean) > Math.max(1e-12, Math.abs(mean) * 1e-9)) throw new Error(`GEPA candidate ${candidateIndex} aggregate score differs from its selection scores`);
+	return value;
+}
+function candidateChars(candidate) {
+	return typeof candidate === "string" ? candidate.length : JSON.stringify(candidate).length;
+}
+function scenarioIdSet(values) {
+	if (!Array.isArray(values)) throw new Error("scenarioIds must be an array");
+	const result = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		if (typeof value !== "string" || value.length === 0 || result.has(value)) throw new Error("scenarioIds must contain unique non-empty strings");
+		result.add(value);
+	}
+	return result;
+}
+function maximumArtifactBytes(maxCandidates, maxCandidateChars, scenarioIds) {
+	const scenarioChars = [...scenarioIds].reduce((total, id) => total + id.length, 0);
+	const candidates = BigInt(maxCandidates);
+	return 8192n + candidates * (BigInt(maxCandidateChars) * 6n + BigInt(scenarioChars) * 6n + BigInt(scenarioIds.size) * 128n + candidates * 32n + 8192n);
+}
+function assertExactKeys(value, expected, label) {
+	if (!isRecord(value)) throw new Error(`GEPA candidate population ${label} must be an object`);
+	const actual = Object.keys(value).sort();
+	if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) throw new Error(`GEPA candidate population ${label} has unexpected fields`);
+}
+function assertPositiveSafeInteger$2(value, label) {
+	if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`GEPA candidate population ${label} must be a positive safe integer`);
+}
+//#endregion
 //#region src/campaign/presets/compare-optimization-methods.ts
 /**
 * Compare optimization methods on shared train, selection, and test data.
@@ -3178,6 +3602,14 @@ function assertOptimizationProvenance(methodName, value) {
 			"refusals"
 		]) if (!Number.isSafeInteger(value.observations[field]) || value.observations[field] < 0) fail(`observations.${field}`);
 	}
+	if (value.gepaCandidatePopulation !== void 0) {
+		try {
+			assertGepaCandidatePopulationSummary(value.gepaCandidatePopulation);
+		} catch {
+			fail("gepaCandidatePopulation");
+		}
+		if (value.gepaCandidatePopulation.runId !== value.runId) fail("gepaCandidatePopulation.runId");
+	}
 	if (value.modelExecutions !== void 0) {
 		if (value.modelExecutions.scope !== "runtime-model-calls" || typeof value.modelExecutions.path !== "string" || !value.modelExecutions.path.trim() || typeof value.modelExecutions.sha256 !== "string" || !/^sha256:[0-9a-f]{64}$/.test(value.modelExecutions.sha256)) fail("modelExecutions");
 		for (const field of [
@@ -4493,78 +4925,6 @@ function assertExternalOptimizerCompletionCount(upstream, requestAttempts, succe
 	if (upstream.requestAttempts !== void 0 && upstream.requestAttempts !== requestAttempts) throw new Error(`${name}: ${optimizer} reported ${upstream.requestAttempts} model attempts but the proxy received ${requestAttempts}`);
 }
 //#endregion
-//#region src/campaign/external-optimizer-observations.ts
-/** Append-only observation log for one external-optimizer attempt. */
-function openExternalOptimizerObservationLog(input) {
-	if (input.storage.read(input.path) !== void 0 || input.storage.exists(input.path)) throw new Error(`external optimizer observation log already exists at '${input.path}'`);
-	input.storage.write(input.path, "");
-	let revision = 0;
-	const counts = {
-		submittedCandidates: 0,
-		evaluations: 0,
-		refusals: 0
-	};
-	return {
-		observe(observation) {
-			const expectedSequence = counts.submittedCandidates + counts.evaluations + counts.refusals + 1;
-			if (observation.sequence !== expectedSequence) throw new Error(`external optimizer observation log expected sequence ${expectedSequence}, got ${observation.sequence}`);
-			const line = `${canonicalJson(observation)}\n`;
-			const next = input.storage.append(input.path, line, revision);
-			if (next === void 0) throw new Error(`external optimizer observation log changed concurrently at '${input.path}'`);
-			revision = next;
-			if (observation.kind === "proposal") counts.submittedCandidates += 1;
-			else if (observation.kind === "evaluation") counts.evaluations += 1;
-			else counts.refusals += 1;
-		},
-		summary() {
-			const contents = input.storage.read(input.path) ?? "";
-			const bytes = new TextEncoder().encode(contents);
-			if (bytes.byteLength !== revision) throw new Error(`external optimizer observation log revision changed at '${input.path}'`);
-			return {
-				scope: "callback-submitted-candidates",
-				path: input.path,
-				sha256: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
-				...counts
-			};
-		}
-	};
-}
-/** Append-only opaque Runtime execution records for one optimizer attempt. */
-function openExternalOptimizerExecutionLog(input) {
-	if (input.storage.read(input.path) !== void 0 || input.storage.exists(input.path)) throw new Error(`external optimizer execution log already exists at '${input.path}'`);
-	input.storage.write(input.path, "");
-	let revision = 0;
-	const counts = {
-		calls: 0,
-		succeeded: 0,
-		failed: 0
-	};
-	return {
-		observe(observation) {
-			if (observation.sequence !== counts.calls + 1) throw new Error(`external optimizer execution log expected sequence ${counts.calls + 1}, got ${observation.sequence}`);
-			const line = `${canonicalJson(observation)}\n`;
-			const next = input.storage.append(input.path, line, revision);
-			if (next === void 0) throw new Error(`external optimizer execution log changed concurrently at '${input.path}'`);
-			revision = next;
-			counts.calls += 1;
-			if (observation.succeeded) counts.succeeded += 1;
-			else counts.failed += 1;
-		},
-		summary() {
-			const contents = input.storage.read(input.path) ?? "";
-			const bytes = new TextEncoder().encode(contents);
-			if (bytes.byteLength !== revision) throw new Error(`external optimizer execution log revision changed at '${input.path}'`);
-			if (counts.calls !== counts.succeeded + counts.failed) throw new Error(`external optimizer execution log counts disagree at '${input.path}'`);
-			return {
-				scope: "runtime-model-calls",
-				path: input.path,
-				sha256: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
-				...counts
-			};
-		}
-	};
-}
-//#endregion
 //#region src/campaign/external-optimizer-run-config.ts
 function externalOptimizerRunnerIdentity(runner, module) {
 	return {
@@ -4827,7 +5187,7 @@ function addEvaluationLimit(total, increment) {
 }
 //#endregion
 //#region src/campaign/gepa-optimization-result.ts
-function assertGepaBridgeOutput(result, name, maxCandidateChars, recipeKind, maxEvaluations, expectsComponents) {
+function assertGepaBridgeOutput(result, name, maxCandidateChars, recipeKind, maxEvaluations, maxPopulationCandidates, scenarioIds, expectsComponents, requiresCandidatePopulation) {
 	if (result.recipeKind !== recipeKind) throw new Error(`${name}: GEPA bridge reported recipe '${String(result.recipeKind)}'`);
 	if (!isGepaCandidate(result.bestCandidate, maxCandidateChars) || expectsComponents !== (typeof result.bestCandidate !== "string")) throw new Error(`${name}: GEPA bridge returned an invalid candidate`);
 	if (!Number.isFinite(result.bestScore)) throw new Error(`${name}: GEPA bridge returned an invalid bestScore`);
@@ -4840,6 +5200,11 @@ function assertGepaBridgeOutput(result, name, maxCandidateChars, recipeKind, max
 	assertExternalOptimizerPackageSource(result.upstream, "gepa", name, "GEPA");
 	if (typeof result.runId !== "string" || result.runId.length === 0 || result.runId !== result.runId.trim()) throw new Error(`${name}: GEPA bridge returned an invalid runId`);
 	if (typeof result.resumed !== "boolean") throw new Error(`${name}: GEPA bridge returned an invalid resumed flag`);
+	if (result.candidatePopulation !== void 0) {
+		assertGepaCandidatePopulationSummary(result.candidatePopulation);
+		if (result.candidatePopulation.runId !== result.runId) throw new Error(`${name}: GEPA candidate population has a different run ID`);
+		if (result.candidatePopulation.maxCandidates !== maxPopulationCandidates || result.candidatePopulation.maxCandidateChars !== maxCandidateChars || result.candidatePopulation.surfaceKind !== (expectsComponents ? "components" : "text") || result.candidatePopulation.scenarioIds.length !== scenarioIds.length || result.candidatePopulation.scenarioIds.some((scenarioId, index) => scenarioId !== scenarioIds[index])) throw new Error(`${name}: GEPA candidate population differs from its configured bounds`);
+	} else if (requiresCandidatePopulation) throw new Error(`${name}: GEPA bridge omitted the official candidate population`);
 }
 function isGepaCandidate(value, maxChars) {
 	if (!isExternalTextCandidate(value)) return false;
@@ -4893,6 +5258,8 @@ function gepaOptimizationMethod(config) {
 			const trainSet = input.trainScenarios.map((scenario) => describeExternalScenario(scenario, "GEPA", maxEvidenceChars, config.describeScenario));
 			const selectionSet = input.selectionScenarios.map((scenario) => describeExternalScenario(scenario, "GEPA", maxEvidenceChars, config.describeScenario));
 			const evaluationLimit = gepaRecipeEvaluationLimit(config.recipe, input.selectionScenarios.length);
+			const maxPopulationCandidates = Math.min(Number.MAX_SAFE_INTEGER, evaluationLimit + 1);
+			const populationScenarioIds = (selectionSet.length > 0 ? selectionSet : trainSet).map((scenario) => scenario.id);
 			const runMaterial = {
 				optimizer: "gepa",
 				runtime: runtimeIdentity,
@@ -4908,6 +5275,7 @@ function gepaOptimizationMethod(config) {
 				trainSet,
 				selectionSet,
 				maxCandidateChars,
+				maxPopulationCandidates,
 				maxEvidenceChars,
 				evaluationCallbackLimits: resolveExternalOptimizerCallbackLimits(config.evaluationCallbackLimits),
 				optimizerModel: config.optimizer ? {
@@ -5021,6 +5389,7 @@ function gepaOptimizationMethod(config) {
 								trainSet,
 								selectionSet,
 								maxCandidateChars,
+								maxPopulationCandidates,
 								maxEvidenceChars,
 								outputDir,
 								...modelProxy && config.optimizer ? { modelProxy: {
@@ -5043,7 +5412,7 @@ function gepaOptimizationMethod(config) {
 				cleanup: closeResources
 			});
 			signal?.throwIfAborted();
-			assertGepaBridgeOutput(result, name, maxCandidateChars, config.recipe.kind, evaluationLimit, expectsComponents);
+			assertGepaBridgeOutput(result, name, maxCandidateChars, config.recipe.kind, evaluationLimit, maxPopulationCandidates, populationScenarioIds, expectsComponents, config.recipe.kind === "engine" && config.recipe.run.engine === "gepa");
 			assertExternalOptimizerRunBinding({
 				label: name,
 				runtime: runtimeIdentity,
@@ -5055,6 +5424,15 @@ function gepaOptimizationMethod(config) {
 				resumed: result.resumed
 			});
 			if (callback.evaluations() !== result.totalEvaluations) throw new Error(`${name}: GEPA reported ${result.totalEvaluations} evaluations but the callback received ${callback.evaluations()}`);
+			if (result.candidatePopulation) {
+				const population = readGepaCandidatePopulationArtifact({ summary: result.candidatePopulation });
+				const selected = population.candidates[population.bestIndex];
+				const selectedHash = contentHash({
+					kind: "external-text-candidate",
+					candidate: result.bestCandidate
+				});
+				if (selected?.candidateHash !== selectedHash) throw new Error(`${name}: GEPA candidate population identifies a different winner`);
+			}
 			const evaluationCost = costFromLedgerSummary(costLedger.summary({
 				phase: "gepa.external-evaluation",
 				tags: runBudget.runTags
@@ -5115,6 +5493,7 @@ function gepaOptimizationMethod(config) {
 					artifactDir: outputDir,
 					...tokenUsage ? { tokenUsage } : {},
 					observations: observationLog.summary(),
+					...result.candidatePopulation ? { gepaCandidatePopulation: result.candidatePopulation } : {},
 					...executionLog ? { modelExecutions: executionLog.summary() } : {}
 				}
 			};
@@ -6528,6 +6907,6 @@ function skillOptOptimizationMethod(config) {
 	};
 }
 //#endregion
-export { runReferenceEquivalenceJudge as $, componentSurfaceIdentityMaterial as A, planCampaignRun as B, combineComparisonCosts as C, assertCodeSurfaceIdentity as D, optimizationTokenUsageFromSummary as E, campaignMeanComposite as F, assertCampaignSplitIdentity as G, resolveRunDir as H, compareRankKeys as I, campaignSplitDigestFromIdentities as J, campaignScenarioIdentity as K, DEFAULT_MUTATION_PRIMITIVES as L, surfaceContentHash as M, surfaceHash as N, assertComponentSurface as O, campaignBreakdown as P, createReferenceEquivalenceJudge as Q, buildReflectionPrompt as R, assertOptimizationResult as S, costFromLedgerSummary as T, tangleTracesRoot as U, runCampaign as V, assertCampaignDesign as W, REFERENCE_EQUIVALENCE_INPUT_LIMITS as X, openAutoPr as Y, REFERENCE_EQUIVALENCE_JUDGE_VERSION as Z, heldOutGate as _, assertRealBackend as _t, emitLoopProvenance as a, Dataset as at, composeGate as b, JudgeParseError as bt, provenanceRecordPath as c, llmJudge as ct, runImprovementLoop as d, paretoFrontier as dt, DEFAULT_RED_TEAM_CORPUS as et, runOptimization as f, paretoFrontierWithCrowding as ft, gepaOptimizationMethod as g, assertRealAgentReceipts as gt, labelTrustRank as h, BackendIntegrityError as ht, canonicalDigest as i, toolNamesForRun as it, renderSurfaceDiff as j, codeSurfaceIdentityMaterial as k, provenanceSpansPath as l, crowdingDistance as lt, isProposedCandidate as m, recoverTruncatedJson as mt, buildLoopProvenanceRecord as n, redTeamReport as nt, loopProvenanceArgsFromResult as o, HoldoutLockedError as ot, runEval as p, scalarScore as pt, campaignSplitDigest as q, campaignMeasurementDigest as r, scoreRedTeamOutput as rt, loopProvenanceSpans as s, hashScenarios as st, skillOptOptimizationMethod as t, redTeamDataset as tt, verifyLoopProvenanceRecord as u, dominates as ut, defaultProductionGate as v, summarizeAgentReceiptIntegrity as vt, compareOptimizationMethods as w, externalTextOptimizationMethod as x, runCanaries as y, summarizeBackendIntegrity as yt, parseReflectionResponse as z };
+export { REFERENCE_EQUIVALENCE_INPUT_LIMITS as $, assertComponentSurface as A, buildReflectionPrompt as B, combineComparisonCosts as C, JudgeParseError as Ct, readGepaCandidatePopulationArtifact as D, optimizationTokenUsageFromSummary as E, surfaceHash as F, tangleTracesRoot as G, planCampaignRun as H, campaignBreakdown as I, assertCampaignSplitIdentity as J, readExternalOptimizerObservationArtifact as K, campaignMeanComposite as L, componentSurfaceIdentityMaterial as M, renderSurfaceDiff as N, decodeExternalTextCandidate as O, surfaceContentHash as P, openAutoPr as Q, compareRankKeys as R, assertOptimizationResult as S, summarizeBackendIntegrity as St, costFromLedgerSummary as T, runCampaign as U, parseReflectionResponse as V, resolveRunDir as W, campaignSplitDigest as X, campaignScenarioIdentity as Y, campaignSplitDigestFromIdentities as Z, heldOutGate as _, recoverTruncatedJson as _t, emitLoopProvenance as a, redTeamReport as at, composeGate as b, assertRealBackend as bt, provenanceRecordPath as c, Dataset as ct, runImprovementLoop as d, llmJudge as dt, REFERENCE_EQUIVALENCE_JUDGE_VERSION as et, runOptimization as f, crowdingDistance as ft, gepaOptimizationMethod as g, scalarScore as gt, labelTrustRank as h, paretoFrontierWithCrowding as ht, canonicalDigest as i, redTeamDataset as it, codeSurfaceIdentityMaterial as j, assertCodeSurfaceIdentity as k, provenanceSpansPath as l, HoldoutLockedError as lt, isProposedCandidate as m, paretoFrontier as mt, buildLoopProvenanceRecord as n, runReferenceEquivalenceJudge as nt, loopProvenanceArgsFromResult as o, scoreRedTeamOutput as ot, runEval as p, dominates as pt, assertCampaignDesign as q, campaignMeasurementDigest as r, DEFAULT_RED_TEAM_CORPUS as rt, loopProvenanceSpans as s, toolNamesForRun as st, skillOptOptimizationMethod as t, createReferenceEquivalenceJudge as tt, verifyLoopProvenanceRecord as u, hashScenarios as ut, defaultProductionGate as v, BackendIntegrityError as vt, compareOptimizationMethods as w, externalTextOptimizationMethod as x, summarizeAgentReceiptIntegrity as xt, runCanaries as y, assertRealAgentReceipts as yt, DEFAULT_MUTATION_PRIMITIVES as z };
 
-//# sourceMappingURL=skillopt-optimization-method-Dtzp7QpP.js.map
+//# sourceMappingURL=skillopt-optimization-method-CQdVeM8k.js.map