textopt 0.0.0

package/dist/bootstrap-search/index.mjs

@@ -0,0 +1,307 @@
+import { a as requireMeasuredMean, d as createMemoryCache, i as measuredMean, l as runFingerprint, n as costExhausted, o as createDeadline, p as createBudget, r as createEvaluator, s as assertResumable, t as BudgetExhausted, u as componentNames } from "../evaluation-BV0nSZVx.mjs";
+import { n as formatDemos, t as bootstrapDemos } from "../demos-Degx6UmP.mjs";
+import { t as createSeededRng } from "../rng-Dtc5eZ_W.mjs";
+//#region src/bootstrap-search/optimize.ts
+const DEFAULT_CANDIDATES = 16;
+const DEFAULT_MAX_DEMOS = 4;
+const DEFAULT_MIN_DEMOS = 1;
+const DEFAULT_MAX_LABELED_DEMOS = 16;
+/**
+* Bootstrapped few-shot search: harvest demonstrations from rollouts the metric
+* already rewarded, and pick the set that scores best.
+*
+* DSPy's `BootstrapFewShotWithRandomSearch`, which is what the literature
+* usually means by "random search" over prompts. It is the only optimizer here
+* that calls no model to write text: every candidate is assembled from outputs
+* the system itself produced, so the search costs rollouts and nothing else.
+* That makes it the right first thing to try — it is cheap, it needs no
+* frontier model, and on tasks where the instruction is already adequate and
+* the format is not, it is often the whole win.
+*
+* The fixed candidates come first and in DSPy's order: zero-shot (seed -3),
+* labels-only when gold outputs exist (seed -2), and one unshuffled harvest at
+* full size (seed -1). Shuffled harvests of random size follow. Keeping
+* zero-shot in the running is not a formality — demonstrations can hurt, and a
+* search that cannot return "no demos" has no baseline to report against.
+*
+* One deviation, deliberate: DSPy bootstraps each predictor separately from the
+* traces of one pass. This library's adapter runs the whole system, so a
+* harvest is a set of end-to-end rollouts and every demo component is given the
+* same block. For per-module demos, use `createPipelineAdapter` with GEPA,
+* which sees each module's own inputs and outputs.
+*/
+var BootstrapSearchOptimizer = class {
+	#config;
+	constructor(config = {}) {
+		this.#config = config;
+	}
+	optimize(task) {
+		return run({
+			config: this.#config,
+			task
+		});
+	}
+};
+async function run(args) {
+	const { config, task } = args;
+	const { candidates: shuffledHarvests = DEFAULT_CANDIDATES, maxDemos = DEFAULT_MAX_DEMOS, minDemos = DEFAULT_MIN_DEMOS, maxLabeledDemos = DEFAULT_MAX_LABELED_DEMOS, demoMinScore, stopAtScore, seed = 0, trackBestOutputs = false, checkpointCache = true } = config;
+	const { seedCandidate, trainingSet, validationSet = trainingSet, testSet, adapter, demoComponents, renderDemo, goldOutput, maxMetricCalls, cache, cacheNamespace, retry, maxCostUsd, maxWallClockMs, instanceId = defaultInstanceId, onEvent, onCheckpoint, resumeFrom, signal } = task;
+	const deadline = createDeadline({ maxWallClockMs });
+	const components = componentNames(seedCandidate);
+	if (trainingSet.length === 0) throw new Error("optimize requires a non-empty trainingSet");
+	if (validationSet.length === 0) throw new Error("optimize requires a non-empty validationSet");
+	if (demoComponents.length === 0) throw new Error("optimize requires at least one demoComponent: this search has nothing to put demonstrations in otherwise");
+	if (testSet !== void 0 && testSet.length === 0) throw new Error("optimize requires a non-empty testSet when one is given; omit it to skip held-out evaluation");
+	const validationIds = validationSet.map((datum, index) => instanceId({
+		datum,
+		index
+	}));
+	const testIds = testSet?.map((datum, index) => instanceId({
+		datum,
+		index
+	})) ?? [];
+	const fingerprint = runFingerprint({
+		seedCandidate,
+		trainingIds: trainingSet.map((datum, index) => instanceId({
+			datum,
+			index
+		})),
+		validationIds,
+		seed,
+		...cacheNamespace === void 0 ? {} : { cacheNamespace }
+	});
+	assertResumable({
+		fingerprint,
+		...resumeFrom === void 0 ? {} : { snapshot: resumeFrom }
+	});
+	const rng = createSeededRng(seed, resumeFrom?.rngState);
+	const budget = createBudget({
+		maxMetricCalls,
+		spent: resumeFrom?.metricCalls ?? 0
+	});
+	const evaluationCache = cache === false ? void 0 : cache ?? createMemoryCache();
+	const evaluator = createEvaluator({
+		adapter,
+		budget,
+		...retry === void 0 ? {} : { retry },
+		...cacheNamespace === void 0 ? {} : { cacheNamespace },
+		...evaluationCache === void 0 ? {} : { cache: evaluationCache },
+		trackOutputs: trackBestOutputs,
+		cacheHits: resumeFrom?.cacheHits ?? 0,
+		...signal === void 0 ? {} : { signal },
+		onEvaluation: (event) => onEvent?.({
+			type: "evaluation",
+			...event
+		})
+	});
+	evaluator.restore(resumeFrom?.cache ?? []);
+	const evaluated = [...resumeFrom?.candidates ?? []];
+	let drawn = resumeFrom?.drawn ?? 0;
+	let bootstrapMetricCalls = resumeFrom?.bootstrapMetricCalls ?? 0;
+	let stopReason = "candidatesExhausted";
+	onEvent?.({
+		type: "start",
+		components,
+		validationSetSize: validationSet.length
+	});
+	async function sweep(candidate, phase) {
+		return evaluator.evaluate({
+			candidate,
+			batch: validationSet,
+			ids: validationIds,
+			split: "val",
+			phase,
+			candidateId: null,
+			iteration: evaluated.length
+		});
+	}
+	const seedScore = resumeFrom?.seedScore ?? requireMeasuredMean({
+		batch: await sweep(seedCandidate, "seed"),
+		phase: "seed"
+	});
+	let best = resumeFrom?.best ?? seedCandidate;
+	let bestScore = resumeFrom?.bestScore ?? seedScore;
+	let bestOutputs;
+	function takeSnapshot() {
+		const cached = checkpointCache ? evaluationCache?.entries?.() : void 0;
+		return {
+			version: 1,
+			fingerprint,
+			candidates: [...evaluated],
+			best,
+			bestScore,
+			seedScore,
+			drawn,
+			metricCalls: budget.spent(),
+			bootstrapMetricCalls,
+			cacheHits: evaluator.cacheHits(),
+			rngState: rng.state(),
+			...cached === void 0 ? {} : { cache: cached }
+		};
+	}
+	async function checkpoint() {
+		if (onCheckpoint === void 0) return;
+		await onCheckpoint(takeSnapshot());
+	}
+	const plan = candidatePlan({
+		shuffledHarvests,
+		labeled: goldOutput !== void 0
+	});
+	for (; drawn < plan.length; drawn += 1) {
+		if (signal?.aborted) {
+			stopReason = "aborted";
+			break;
+		}
+		if (costExhausted({
+			usage: evaluator.usage(),
+			maxCostUsd
+		})) {
+			stopReason = "costExhausted";
+			break;
+		}
+		if (deadline.exceeded()) {
+			stopReason = "deadlineReached";
+			break;
+		}
+		if (!budget.canAfford(validationSet.length + 1)) {
+			stopReason = "budgetExhausted";
+			break;
+		}
+		const source = plan[drawn];
+		const block = await buildBlock(source);
+		const candidate = withDemos(block);
+		let evaluation;
+		try {
+			evaluation = await sweep(candidate, "validation");
+		} catch (err) {
+			if (err instanceof BudgetExhausted) {
+				stopReason = "budgetExhausted";
+				break;
+			}
+			if (signal?.aborted) {
+				stopReason = "aborted";
+				break;
+			}
+			throw err;
+		}
+		const score = measuredMean(evaluation);
+		if (score === void 0) continue;
+		const accepted = score > bestScore;
+		evaluated.push({
+			candidate,
+			source,
+			demos: countDemos(block),
+			score
+		});
+		onEvent?.({
+			type: "candidate",
+			index: evaluated.length - 1,
+			source,
+			demos: countDemos(block),
+			score,
+			accepted
+		});
+		if (accepted) {
+			best = candidate;
+			bestScore = score;
+			bestOutputs = evaluation.outputs;
+		}
+		await checkpoint();
+		if (stopAtScore !== void 0 && score >= stopAtScore) {
+			stopReason = "scoreReached";
+			drawn += 1;
+			break;
+		}
+	}
+	if (signal?.aborted) stopReason = "aborted";
+	const testScore = testSet === void 0 ? void 0 : measuredMean(await evaluator.evaluate({
+		candidate: best,
+		batch: testSet,
+		ids: testIds,
+		split: "test",
+		phase: "test",
+		candidateId: null,
+		iteration: evaluated.length,
+		charge: false
+	}));
+	onEvent?.({
+		type: "finish",
+		reason: stopReason,
+		bestScore,
+		metricCalls: budget.spent(),
+		...testScore === void 0 ? {} : { testScore }
+	});
+	return {
+		bestCandidate: best,
+		bestScore,
+		usage: evaluator.usage(),
+		seedScore,
+		candidates: evaluated,
+		bootstrapMetricCalls,
+		cacheHits: evaluator.cacheHits(),
+		metricCalls: budget.spent(),
+		snapshot: takeSnapshot(),
+		...trackBestOutputs && bestOutputs !== void 0 ? { bestOutputs } : {},
+		...testScore === void 0 ? {} : {
+			testScore,
+			testMetricCalls: testSet?.length ?? 0
+		},
+		stopReason
+	};
+	function withDemos(block) {
+		const candidate = { ...seedCandidate };
+		for (const name of demoComponents) candidate[name] = block;
+		return candidate;
+	}
+	async function buildBlock(source) {
+		if (source === "zeroShot") return "";
+		if (source === "labeled") return labeledBlock();
+		const requested = source === "unshuffled" ? maxDemos : minDemos + rng.nextInt(Math.max(1, maxDemos - minDemos + 1));
+		const affordable = Math.min(trainingSet.length, budget.remaining() - validationSet.length);
+		if (affordable < 1) return "";
+		const harvest = await bootstrapDemos({
+			adapter,
+			candidate: seedCandidate,
+			trainingSet,
+			...demoMinScore === void 0 ? {} : { minScore: demoMinScore },
+			maxDemos: requested,
+			maxMetricCalls: affordable,
+			...source === "unshuffled" ? {} : { rng },
+			...renderDemo === void 0 ? {} : { renderDemo },
+			...signal === void 0 ? {} : { signal }
+		});
+		bootstrapMetricCalls += harvest.metricCalls;
+		budget.reserve(harvest.metricCalls);
+		return harvest.block;
+	}
+	function labeledBlock() {
+		const labelled = trainingSet.map((datum) => ({
+			input: datum,
+			output: goldOutput?.(datum)
+		})).filter((demo) => demo.output !== void 0).slice(0, maxLabeledDemos);
+		return formatDemos(labelled, renderDemo === void 0 ? {} : { render: renderDemo });
+	}
+}
+/**
+* The order candidates are tried in, following DSPy's special seeds: zero-shot
+* first, then labels-only, then one unshuffled full-size harvest, then the
+* shuffled ones. Cheapest and most reliable first, so a run cut short by its
+* budget still has the baseline it needs to report against.
+*/
+function candidatePlan(args) {
+	const { shuffledHarvests, labeled } = args;
+	return [
+		"zeroShot",
+		...labeled ? ["labeled"] : [],
+		"unshuffled",
+		...Array.from({ length: shuffledHarvests }, () => "bootstrapped")
+	];
+}
+function countDemos(block) {
+	return block.split("<demo>").length - 1;
+}
+function defaultInstanceId(args) {
+	return String(args.index);
+}
+//#endregion
+export { BootstrapSearchOptimizer };

package/dist/cache-CuSo0NJ8.d.cts

@@ -0,0 +1,24 @@
+//#region src/cache.d.ts
+/**
+ * What the cache stores per (candidate, instance): the metric the frontier is
+ * built from, plus the per-objective breakdown when the adapter reports one.
+ * Both come from the same rollout, so caching the score without the objectives
+ * would force a re-run to recover them.
+ */
+interface CachedScore {
+  score: number;
+  objectiveScores?: Record<string, number>;
+}
+interface EvaluationCache {
+  get(key: string): CachedScore | undefined;
+  set(key: string, cached: CachedScore): void;
+  /** Entries for checkpointing. Omit on caches that are already durable. */
+  entries?(): [string, CachedScore][];
+}
+declare function createMemoryCache(args?: {
+  maxEntries?: number;
+  /** Entries from a previous run's checkpoint. */
+  entries?: readonly [string, CachedScore][];
+}): EvaluationCache;
+//#endregion
+export { EvaluationCache as n, createMemoryCache as r, CachedScore as t };

package/dist/cache-CuSo0NJ8.d.mts

@@ -0,0 +1,24 @@
+//#region src/cache.d.ts
+/**
+ * What the cache stores per (candidate, instance): the metric the frontier is
+ * built from, plus the per-objective breakdown when the adapter reports one.
+ * Both come from the same rollout, so caching the score without the objectives
+ * would force a re-run to recover them.
+ */
+interface CachedScore {
+  score: number;
+  objectiveScores?: Record<string, number>;
+}
+interface EvaluationCache {
+  get(key: string): CachedScore | undefined;
+  set(key: string, cached: CachedScore): void;
+  /** Entries for checkpointing. Omit on caches that are already durable. */
+  entries?(): [string, CachedScore][];
+}
+declare function createMemoryCache(args?: {
+  maxEntries?: number;
+  /** Entries from a previous run's checkpoint. */
+  entries?: readonly [string, CachedScore][];
+}): EvaluationCache;
+//#endregion
+export { EvaluationCache as n, createMemoryCache as r, CachedScore as t };

package/dist/concurrency-C-cFzWW2.cjs

@@ -0,0 +1,44 @@
+//#region src/concurrency.ts
+/**
+* Order-preserving concurrency-limited map. An optimization run's workload is
+* entirely IO bound, so adapters use this to fan out a batch across a bounded
+* number of in-flight model calls.
+*/
+async function mapWithConcurrency(args) {
+	const { items, limit, task, signal } = args;
+	if (items.length === 0) return [];
+	signal?.throwIfAborted();
+	const workerCount = Math.max(1, Math.min(Math.floor(limit), items.length));
+	const results = new Array(items.length);
+	let cursor = 0;
+	/**
+	* The first failure, kept rather than thrown so the workers that are already
+	* running settle before the caller gets control back. A rejection that left
+	* tasks running in the background would go on spending an optimizer's budget
+	* and writing its caches after the run it belonged to had ended.
+	*/
+	let failure;
+	async function worker() {
+		while (cursor < items.length && failure === void 0) {
+			const index = cursor;
+			cursor += 1;
+			try {
+				signal?.throwIfAborted();
+				results[index] = await task(items[index], index);
+			} catch (err) {
+				failure ??= { err };
+				return;
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	if (failure !== void 0) throw failure.err;
+	return results;
+}
+//#endregion
+Object.defineProperty(exports, "mapWithConcurrency", {
+	enumerable: true,
+	get: function() {
+		return mapWithConcurrency;
+	}
+});

package/dist/concurrency-D58PWeSk.mjs

@@ -0,0 +1,39 @@
+//#region src/concurrency.ts
+/**
+* Order-preserving concurrency-limited map. An optimization run's workload is
+* entirely IO bound, so adapters use this to fan out a batch across a bounded
+* number of in-flight model calls.
+*/
+async function mapWithConcurrency(args) {
+	const { items, limit, task, signal } = args;
+	if (items.length === 0) return [];
+	signal?.throwIfAborted();
+	const workerCount = Math.max(1, Math.min(Math.floor(limit), items.length));
+	const results = new Array(items.length);
+	let cursor = 0;
+	/**
+	* The first failure, kept rather than thrown so the workers that are already
+	* running settle before the caller gets control back. A rejection that left
+	* tasks running in the background would go on spending an optimizer's budget
+	* and writing its caches after the run it belonged to had ended.
+	*/
+	let failure;
+	async function worker() {
+		while (cursor < items.length && failure === void 0) {
+			const index = cursor;
+			cursor += 1;
+			try {
+				signal?.throwIfAborted();
+				results[index] = await task(items[index], index);
+			} catch (err) {
+				failure ??= { err };
+				return;
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	if (failure !== void 0) throw failure.err;
+	return results;
+}
+//#endregion
+export { mapWithConcurrency as t };

package/dist/demos-B0pVQjYC.d.mts

@@ -0,0 +1,88 @@
+import { n as Candidate, t as Adapter } from "./types-CWv4IQFF.mjs";
+import { t as Rng } from "./rng-BR5MOedA.mjs";
+//#region src/demos.d.ts
+/**
+ * One worked example: what went in, what a run of the system produced, and
+ * how that output scored. A demo is harvested, never written — its value is
+ * that the output is one the system actually produced and the metric actually
+ * rewarded.
+ */
+interface Demo<Datum = unknown, Output = unknown> {
+  input: Datum;
+  output: Output;
+  /** Present on harvested demos, absent on ones recovered from a block. */
+  score?: number;
+}
+type DemoRenderer<Datum = unknown, Output = unknown> = (args: {
+  demo: Demo<Datum, Output>;
+  index: number;
+}) => string;
+interface BootstrapResult<Datum, Output> {
+  demos: Demo<Datum, Output>[];
+  /** The demos as a candidate component, ready to seed a run with. */
+  block: string;
+  /** Rollouts this cost. Bootstrapping is cheap, not free. */
+  metricCalls: number;
+  attempted: number;
+}
+/**
+ * Harvest demonstrations by running a candidate over the training set and keeping
+ * the rollouts the metric rewarded.
+ *
+ * The cheapest signal in the whole library: a rollout that scored well is
+ * already paid for, and turning it into a few-shot block costs one pass over
+ * the data rather than a search. Instruction search and demonstrations pull on
+ * different parts of a model's behaviour — instructions on what to do,
+ * examples on what the output should look like — so a seed carrying both
+ * starts somewhere neither reaches alone.
+ */
+declare function bootstrapDemos<Datum, Trajectory, Output, K extends string = string>(args: {
+  adapter: Adapter<Datum, Trajectory, Output, K>;
+  /** The candidate to run. Usually the seed, sometimes a run's winner. */
+  candidate: Candidate<K>;
+  trainingSet: readonly Datum[];
+  /**
+   * Score a rollout must reach to be kept. Unset keeps every rollout the
+   * metric rewarded at all, which is what MIPROv2's bootstrapper does without
+   * a `metric_threshold`: it keeps a trace on any truthy score and only
+   * compares against a number once one is configured.
+   *
+   * Demanding a perfect score instead is the right call for a boolean metric
+   * and the wrong one for a graded metric, where it throws away every rollout
+   * that was most of the way there — which on a hard task is all of them.
+   */
+  minScore?: number;
+  /** Demos to collect before stopping. Default 4. */
+  maxDemos?: number;
+  /**
+   * Instances per rollout batch. Smaller batches stop closer to the moment
+   * enough demos exist, at the cost of less concurrency inside the adapter.
+   */
+  batchSize?: number;
+  /** Ceiling on rollouts. Defaults to one pass over the trainingSet. */
+  maxMetricCalls?: number;
+  /** Shuffles the trainingSet first, so demos are not all drawn from its head. */
+  rng?: Rng;
+  renderDemo?: DemoRenderer<Datum, Output>;
+  signal?: AbortSignal;
+}): Promise<BootstrapResult<Datum, Output>>;
+/**
+ * Render demos as the text a candidate component holds.
+ *
+ * Delimited rather than free-form so `parseDemos` can read them back: a demo
+ * component is edited over the course of a run, and a block that cannot be
+ * parsed can only be replaced wholesale, throwing away every example found
+ * before it.
+ */
+declare function formatDemos<Datum, Output>(demos: readonly Demo<Datum, Output>[], options?: {
+  render?: DemoRenderer<Datum, Output>;
+}): string;
+/**
+ * Recover the demos from a formatted block, ignoring anything written around
+ * them. Text a model rewrote and mangled yields the demos it left intact
+ * rather than throwing: a malformed example is worth less than the rest of the
+ * block, not more than it.
+ */
+declare function parseDemos(text: string): Demo[];
+//#endregion
+export { formatDemos as a, bootstrapDemos as i, Demo as n, parseDemos as o, DemoRenderer as r, BootstrapResult as t };

package/dist/demos-B9BJiNKz.cjs

@@ -0,0 +1,143 @@
+const require_evaluation = require("./evaluation-OZOp6TB7.cjs");
+//#region src/demos.ts
+const DEMO_OPEN = "<demo>";
+const DEMO_CLOSE = "</demo>";
+const DEMO_BLOCK = /<demo>\s*([\s\S]*?)\s*<\/demo>/g;
+const DEMO_PARTS = /<input>\s*([\s\S]*?)\s*<\/input>\s*<output>\s*([\s\S]*?)\s*<\/output>/;
+const DEFAULT_MAX_DEMOS = 4;
+/**
+* Harvest demonstrations by running a candidate over the training set and keeping
+* the rollouts the metric rewarded.
+*
+* The cheapest signal in the whole library: a rollout that scored well is
+* already paid for, and turning it into a few-shot block costs one pass over
+* the data rather than a search. Instruction search and demonstrations pull on
+* different parts of a model's behaviour — instructions on what to do,
+* examples on what the output should look like — so a seed carrying both
+* starts somewhere neither reaches alone.
+*/
+async function bootstrapDemos(args) {
+	const { adapter, candidate, trainingSet, minScore, maxDemos = DEFAULT_MAX_DEMOS, batchSize = maxDemos, maxMetricCalls = trainingSet.length, rng, renderDemo, signal } = args;
+	if (trainingSet.length === 0) throw new Error("bootstrapDemos requires a non-empty trainingSet");
+	const budget = require_evaluation.createBudget({ maxMetricCalls });
+	const evaluator = require_evaluation.createEvaluator({
+		adapter,
+		budget,
+		...signal === void 0 ? {} : { signal }
+	});
+	const order = rng === void 0 ? [...trainingSet] : rng.shuffle(trainingSet);
+	const demos = [];
+	let attempted = 0;
+	for (let start = 0; start < order.length; start += batchSize) {
+		if (demos.length >= maxDemos || signal?.aborted) break;
+		const batch = order.slice(start, start + Math.min(batchSize, budget.remaining()));
+		if (batch.length === 0) break;
+		const evaluation = await evaluator.evaluateTraced({
+			candidate,
+			batch,
+			split: "train",
+			phase: "seed",
+			candidateId: null,
+			iteration: 0
+		});
+		if (evaluation === null) break;
+		attempted += batch.length;
+		for (let index = 0; index < batch.length; index += 1) {
+			const score = evaluation.scores[index];
+			if (!(minScore === void 0 ? score > 0 : score >= minScore) || demos.length >= maxDemos) continue;
+			demos.push({
+				input: batch[index],
+				output: evaluation.outputs[index],
+				score
+			});
+		}
+	}
+	return {
+		demos,
+		block: formatDemos(demos, renderDemo === void 0 ? {} : { render: renderDemo }),
+		metricCalls: budget.spent(),
+		attempted
+	};
+}
+/**
+* Render demos as the text a candidate component holds.
+*
+* Delimited rather than free-form so `parseDemos` can read them back: a demo
+* component is edited over the course of a run, and a block that cannot be
+* parsed can only be replaced wholesale, throwing away every example found
+* before it.
+*/
+function formatDemos(demos, options = {}) {
+	const { render = renderDefault } = options;
+	if (demos.length === 0) return "";
+	return demos.map((demo, index) => `${DEMO_OPEN}\n${render({
+		demo,
+		index
+	})}\n${DEMO_CLOSE}`).join("\n");
+}
+/**
+* Recover the demos from a formatted block, ignoring anything written around
+* them. Text a model rewrote and mangled yields the demos it left intact
+* rather than throwing: a malformed example is worth less than the rest of the
+* block, not more than it.
+*/
+function parseDemos(text) {
+	const demos = [];
+	for (const match of text.matchAll(DEMO_BLOCK)) {
+		const parts = (match[1] ?? "").match(DEMO_PARTS);
+		if (parts === null) continue;
+		const input = parseValue(parts[1] ?? "");
+		const output = parseValue(parts[2] ?? "");
+		demos.push({
+			input,
+			output
+		});
+	}
+	return demos;
+}
+function renderDefault(args) {
+	const { demo } = args;
+	return [
+		"<input>",
+		serialize(demo.input),
+		"</input>",
+		"<output>",
+		serialize(demo.output),
+		"</output>"
+	].join("\n");
+}
+/** Strings stay as they are; anything else is shown as JSON. */
+function serialize(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value, null, 2) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function parseValue(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "bootstrapDemos", {
+	enumerable: true,
+	get: function() {
+		return bootstrapDemos;
+	}
+});
+Object.defineProperty(exports, "formatDemos", {
+	enumerable: true,
+	get: function() {
+		return formatDemos;
+	}
+});
+Object.defineProperty(exports, "parseDemos", {
+	enumerable: true,
+	get: function() {
+		return parseDemos;
+	}
+});