@rotifer/playground 0.28.0 → 0.30.0

package/dist/utils/fitness-formula.d.ts

@@ -7,10 +7,17 @@
  * sit in the denominator and a slower, costlier gene scores lower. The
  * implementation does not divide by raw values — an unbounded denominator
  * drives F(g) to zero for any gene with a realistic latency, which is what
- * ADR-215 P1 set out to avoid. It normalizes each into a (0, 1] score first:
+ * ADR-215 P1 set out to avoid. It normalizes each into a (0, 1] score first,
+ * against a reference scale (ADR-318 D2):
  *
- *   L_score    = 1 / (1 + avg_latency_ms / LATENCY_SCALE_MS)
- *   Cost_score = 1 / (1 + avg_cost / RESOURCE_SCALE_UNITS)
+ *   L_score    = 1 / (1 + avg_latency_ms / L_ref)
+ *   Cost_score = 1 / (1 + avg_cost / Cost_ref)
+ *
+ * L_ref / Cost_ref are the current-season median of the gene's own domain and
+ * fidelity, computed by the registry (`get_fitness_reference`); a gene exactly
+ * at its peers' median scores 1/2 on each. While the season has too few
+ * measured genes, or the registry cannot be reached, the fixed constants below
+ * stand in (FALLBACK_REFERENCE).
  *
  * Those scores are already *inverted* — lower latency means a score nearer 1 —
  * so they belong in the numerator. Dividing by them, as this code did until
@@ -19,18 +26,19 @@
  * tests in `tests/unit/fitness-formula.test.ts` hold the direction.
  */
 /**
- * Latency at which L_score halves. `[N]` — provisional, uncalibrated.
+ * Fallback L_ref: latency at which L_score halves when no season median is
+ * available. `[N]` — provisional, uncalibrated.
  *
- * ADR-318 D2 replaces both constants with `L_ref` / `Cost_ref` — the season
- * median for the gene's own domain and fidelity, which is what makes F(g)
- * dimensionless and comparable across bindings — and marks their values `[N]`
- * pending ABM / measured calibration under RFC-001 §0. That reference scale
- * needs a season-median pipeline that does not exist yet (v0.9.3 #6); these two
- * fixed constants are the stand-ins until it does.
+ * ADR-318 D2 defines `L_ref` / `Cost_ref` as the season median for the gene's
+ * own domain and fidelity, which is what makes F(g) dimensionless and
+ * comparable across bindings. The registry computes it (v0.9.3 #6); these two
+ * fixed constants are used only while that median does not exist for a group
+ * — too few measured genes this season — or cannot be fetched.
  */
 export declare const LATENCY_SCALE_MS = 1000;
 /**
- * Resource cost (fuel units) at which Cost_score halves. `[N]` — provisional.
+ * Fallback Cost_ref: resource cost (fuel units) at which Cost_score halves
+ * when no season median is available. `[N]` — provisional.
  *
  * Badly out of scale, and known to be: ADR-318 recorded both constants as
  * guesses, and measured 7.7e9 fuel on a leaderboard gene from its reported
@@ -46,6 +54,55 @@ export declare const LATENCY_SCALE_MS = 1000;
  * protocol-parameter change under RFC-001 §0, not a code cleanup.
  */
 export declare const RESOURCE_SCALE_UNITS = 10000;
+/** The scale the two efficiency terms are measured against (ADR-318 D2). */
+export interface ReferenceScale {
+    /** L_ref, in milliseconds. */
+    latencyMs: number;
+    /** Cost_ref, in fuel units. */
+    resourceCost: number;
+}
+/** The fixed constants, used whenever no season median is available. */
+export declare const FALLBACK_REFERENCE: Readonly<ReferenceScale>;
+/** Both values finite and positive; anything else would divide by zero or flip a sign. */
+export declare function isUsableReference(reference: ReferenceScale): boolean;
+/** One row of `get_fitness_reference`: the season median for a (domain, fidelity) group. */
+export interface SeasonReferenceRow {
+    l_ref_ms: number;
+    cost_ref: number;
+    sample_genes: number;
+    season_number: number;
+}
+/**
+ * `code` on the error a reference fetcher throws when the registry has no
+ * `get_fitness_reference` (HTTP 404): a registry from before the migration,
+ * whose arena_entries has no reference columns either. A code rather than an
+ * error class, so the check survives two copies of this module.
+ */
+export declare const REFERENCE_FUNCTION_MISSING = "REFERENCE_FUNCTION_MISSING";
+export interface ResolvedReference {
+    scale: ReferenceScale;
+    source: "season-median" | "fallback";
+    /**
+     * Whether a submission may record this reference in the row. False only
+     * when the registry said it has no `get_fitness_reference` (404): the
+     * columns ship in the same migration as the function, so that registry
+     * would reject them. Any other failure — a timeout, a 500 — still records
+     * the fallback with its constants: the upsert keeps columns it is not sent,
+     * so leaving them out would leave an older median on a row whose F(g) used
+     * the constants, and the row could no longer be recomputed on its own.
+     */
+    isRecordable: boolean;
+    /** Why the fallback was used; absent for a season median. */
+    reason?: string;
+    sampleGenes?: number;
+    seasonNumber?: number;
+}
+/**
+ * The reference scale for one gene's F(g): its group's season median when the
+ * registry has one, the fixed constants otherwise. Never throws — a missing
+ * median is a reason to fall back, not to fail the evaluation.
+ */
+export declare function resolveFitnessReference(domain: string, fidelity: string, fetchReference: (domain: string, fidelity: string) => Promise<SeasonReferenceRow | null>): Promise<ResolvedReference>;
 export interface FitnessInputs {
     /** S_r — fraction of evaluation runs that passed, in [0, 1]. */
     successRate: number;
@@ -74,15 +131,16 @@ export interface FitnessBreakdown {
     /** Cost_score — 1 at zero cost, falling monotonically as cost rises. */
     resourceEfficiency: number;
 }
-/** L_score: 1 at zero latency, strictly decreasing, never zero. */
-export declare function latencyScoreFor(avgLatencyMs: number): number;
-/** Cost_score: 1 at zero cost, strictly decreasing, never zero. */
-export declare function resourceEfficiencyFor(avgResourceCost: number): number;
+/** L_score: 1 at zero latency, 1/2 at L_ref, strictly decreasing, never zero. */
+export declare function latencyScoreFor(avgLatencyMs: number, latencyRefMs?: number): number;
+/** Cost_score: 1 at zero cost, 1/2 at Cost_ref, strictly decreasing, never zero. */
+export declare function resourceEfficiencyFor(avgResourceCost: number, costRef?: number): number;
 /**
- * F(g) from one batch of evaluation measurements.
+ * F(g) from one batch of evaluation measurements, against `reference` (the
+ * fixed constants when omitted, or when the given scale is not usable).
  *
  * Multiplicative throughout: a zero in any factor collapses the score, with no
  * mutual compensation between a gene's strengths and its weaknesses.
  */
-export declare function computeBaseFitness(inputs: FitnessInputs): FitnessBreakdown;
+export declare function computeBaseFitness(inputs: FitnessInputs, reference?: ReferenceScale): FitnessBreakdown;
 //# sourceMappingURL=fitness-formula.d.ts.map

package/dist/utils/fitness-formula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fitness-formula.d.ts","sourceRoot":"","sources":["../../src/utils/fitness-formula.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAE3C,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAU1E"}
+{"version":3,"file":"fitness-formula.d.ts","sourceRoot":"","sources":["../../src/utils/fitness-formula.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,OAAO,CAAC;AACrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAE3C,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,cAAc,CAGtD,CAAC;AAEH,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,cAAc,GAAG,OAAO,CAKpE;AAED,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,eAAe,GAAG,UAAU,CAAC;IACrC;;;;;;;;OAQG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,GACvF,OAAO,CAAC,iBAAiB,CAAC,CAuC5B;AAED,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,GAAE,MAAyB,GAAG,MAAM,CAErG;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,GAAE,MAA6B,GAAG,MAAM,CAE7G;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,cAAmC,GAC7C,gBAAgB,CAWlB"}

package/dist/utils/fitness-formula.js

@@ -8,10 +8,17 @@
  * sit in the denominator and a slower, costlier gene scores lower. The
  * implementation does not divide by raw values — an unbounded denominator
  * drives F(g) to zero for any gene with a realistic latency, which is what
- * ADR-215 P1 set out to avoid. It normalizes each into a (0, 1] score first:
+ * ADR-215 P1 set out to avoid. It normalizes each into a (0, 1] score first,
+ * against a reference scale (ADR-318 D2):
  *
- *   L_score    = 1 / (1 + avg_latency_ms / LATENCY_SCALE_MS)
- *   Cost_score = 1 / (1 + avg_cost / RESOURCE_SCALE_UNITS)
+ *   L_score    = 1 / (1 + avg_latency_ms / L_ref)
+ *   Cost_score = 1 / (1 + avg_cost / Cost_ref)
+ *
+ * L_ref / Cost_ref are the current-season median of the gene's own domain and
+ * fidelity, computed by the registry (`get_fitness_reference`); a gene exactly
+ * at its peers' median scores 1/2 on each. While the season has too few
+ * measured genes, or the registry cannot be reached, the fixed constants below
+ * stand in (FALLBACK_REFERENCE).
  *
  * Those scores are already *inverted* — lower latency means a score nearer 1 —
  * so they belong in the numerator. Dividing by them, as this code did until
@@ -20,23 +27,26 @@
  * tests in `tests/unit/fitness-formula.test.ts` hold the direction.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESOURCE_SCALE_UNITS = exports.LATENCY_SCALE_MS = void 0;
+exports.REFERENCE_FUNCTION_MISSING = exports.FALLBACK_REFERENCE = exports.RESOURCE_SCALE_UNITS = exports.LATENCY_SCALE_MS = void 0;
+exports.isUsableReference = isUsableReference;
+exports.resolveFitnessReference = resolveFitnessReference;
 exports.latencyScoreFor = latencyScoreFor;
 exports.resourceEfficiencyFor = resourceEfficiencyFor;
 exports.computeBaseFitness = computeBaseFitness;
 /**
- * Latency at which L_score halves. `[N]` — provisional, uncalibrated.
+ * Fallback L_ref: latency at which L_score halves when no season median is
+ * available. `[N]` — provisional, uncalibrated.
  *
- * ADR-318 D2 replaces both constants with `L_ref` / `Cost_ref` — the season
- * median for the gene's own domain and fidelity, which is what makes F(g)
- * dimensionless and comparable across bindings — and marks their values `[N]`
- * pending ABM / measured calibration under RFC-001 §0. That reference scale
- * needs a season-median pipeline that does not exist yet (v0.9.3 #6); these two
- * fixed constants are the stand-ins until it does.
+ * ADR-318 D2 defines `L_ref` / `Cost_ref` as the season median for the gene's
+ * own domain and fidelity, which is what makes F(g) dimensionless and
+ * comparable across bindings. The registry computes it (v0.9.3 #6); these two
+ * fixed constants are used only while that median does not exist for a group
+ * — too few measured genes this season — or cannot be fetched.
  */
 exports.LATENCY_SCALE_MS = 1000;
 /**
- * Resource cost (fuel units) at which Cost_score halves. `[N]` — provisional.
+ * Fallback Cost_ref: resource cost (fuel units) at which Cost_score halves
+ * when no season median is available. `[N]` — provisional.
  *
  * Badly out of scale, and known to be: ADR-318 recorded both constants as
  * guesses, and measured 7.7e9 fuel on a leaderboard gene from its reported
@@ -52,23 +62,88 @@ exports.LATENCY_SCALE_MS = 1000;
  * protocol-parameter change under RFC-001 §0, not a code cleanup.
  */
 exports.RESOURCE_SCALE_UNITS = 10_000;
-/** L_score: 1 at zero latency, strictly decreasing, never zero. */
-function latencyScoreFor(avgLatencyMs) {
-    return 1.0 / (1.0 + Math.max(avgLatencyMs, 0) / exports.LATENCY_SCALE_MS);
+/** The fixed constants, used whenever no season median is available. */
+exports.FALLBACK_REFERENCE = Object.freeze({
+    latencyMs: exports.LATENCY_SCALE_MS,
+    resourceCost: exports.RESOURCE_SCALE_UNITS,
+});
+/** Both values finite and positive; anything else would divide by zero or flip a sign. */
+function isUsableReference(reference) {
+    return (Number.isFinite(reference.latencyMs) && reference.latencyMs > 0 &&
+        Number.isFinite(reference.resourceCost) && reference.resourceCost > 0);
+}
+/**
+ * `code` on the error a reference fetcher throws when the registry has no
+ * `get_fitness_reference` (HTTP 404): a registry from before the migration,
+ * whose arena_entries has no reference columns either. A code rather than an
+ * error class, so the check survives two copies of this module.
+ */
+exports.REFERENCE_FUNCTION_MISSING = "REFERENCE_FUNCTION_MISSING";
+/**
+ * The reference scale for one gene's F(g): its group's season median when the
+ * registry has one, the fixed constants otherwise. Never throws — a missing
+ * median is a reason to fall back, not to fail the evaluation.
+ */
+async function resolveFitnessReference(domain, fidelity, fetchReference) {
+    let row;
+    try {
+        row = await fetchReference(domain, fidelity);
+    }
+    catch (err) {
+        const isFunctionMissing = err?.code === exports.REFERENCE_FUNCTION_MISSING;
+        return {
+            scale: { ...exports.FALLBACK_REFERENCE },
+            source: "fallback",
+            isRecordable: !isFunctionMissing,
+            reason: isFunctionMissing
+                ? "the registry has no season median yet (get_fitness_reference is not deployed)"
+                : `the registry's season median could not be read (${err.message})`,
+        };
+    }
+    if (row === null) {
+        return {
+            scale: { ...exports.FALLBACK_REFERENCE },
+            source: "fallback",
+            isRecordable: true,
+            reason: `too few measured ${domain} / ${fidelity} genes this season for a median`,
+        };
+    }
+    const scale = { latencyMs: Number(row.l_ref_ms), resourceCost: Number(row.cost_ref) };
+    if (!isUsableReference(scale)) {
+        return {
+            scale: { ...exports.FALLBACK_REFERENCE },
+            source: "fallback",
+            isRecordable: true,
+            reason: "the registry returned a median that is not a positive number",
+        };
+    }
+    return {
+        scale,
+        source: "season-median",
+        isRecordable: true,
+        sampleGenes: row.sample_genes,
+        seasonNumber: row.season_number,
+    };
+}
+/** L_score: 1 at zero latency, 1/2 at L_ref, strictly decreasing, never zero. */
+function latencyScoreFor(avgLatencyMs, latencyRefMs = exports.LATENCY_SCALE_MS) {
+    return 1.0 / (1.0 + Math.max(avgLatencyMs, 0) / latencyRefMs);
 }
-/** Cost_score: 1 at zero cost, strictly decreasing, never zero. */
-function resourceEfficiencyFor(avgResourceCost) {
-    return 1.0 / (1.0 + Math.max(avgResourceCost, 0) / exports.RESOURCE_SCALE_UNITS);
+/** Cost_score: 1 at zero cost, 1/2 at Cost_ref, strictly decreasing, never zero. */
+function resourceEfficiencyFor(avgResourceCost, costRef = exports.RESOURCE_SCALE_UNITS) {
+    return 1.0 / (1.0 + Math.max(avgResourceCost, 0) / costRef);
 }
 /**
- * F(g) from one batch of evaluation measurements.
+ * F(g) from one batch of evaluation measurements, against `reference` (the
+ * fixed constants when omitted, or when the given scale is not usable).
  *
  * Multiplicative throughout: a zero in any factor collapses the score, with no
  * mutual compensation between a gene's strengths and its weaknesses.
  */
-function computeBaseFitness(inputs) {
-    const latencyScore = latencyScoreFor(inputs.avgLatencyMs);
-    const resourceEfficiency = resourceEfficiencyFor(inputs.avgResourceCost);
+function computeBaseFitness(inputs, reference = exports.FALLBACK_REFERENCE) {
+    const scale = isUsableReference(reference) ? reference : exports.FALLBACK_REFERENCE;
+    const latencyScore = latencyScoreFor(inputs.avgLatencyMs, scale.latencyMs);
+    const resourceEfficiency = resourceEfficiencyFor(inputs.avgResourceCost, scale.resourceCost);
     const quality = inputs.successRate * Math.log1p(inputs.coverage) * (1 + inputs.robustness);
     // Multiplied, not divided: L_score and Cost_score are already inverted, so
     // multiplying by them is what makes slower and costlier score lower. No cap —

package/dist/utils/fitness-formula.js.map

@@ -1 +1 @@
-{"version":3,"file":"fitness-formula.js","sourceRoot":"","sources":["../../src/utils/fitness-formula.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AA8DH,0CAEC;AAGD,sDAEC;AAQD,gDAUC;AArFD;;;;;;;;;GASG;AACU,QAAA,gBAAgB,GAAG,IAAI,CAAC;AACrC;;;;;;;;;;;;;;;GAeG;AACU,QAAA,oBAAoB,GAAG,MAAM,CAAC;AAgC3C,mEAAmE;AACnE,SAAgB,eAAe,CAAC,YAAoB;IAClD,OAAO,GAAG,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,CAAC,GAAG,wBAAgB,CAAC,CAAC;AACpE,CAAC;AAED,mEAAmE;AACnE,SAAgB,qBAAqB,CAAC,eAAuB;IAC3D,OAAO,GAAG,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC,CAAC,GAAG,4BAAoB,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,MAAqB;IACtD,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAC1D,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IACzE,MAAM,OAAO,GACX,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAC7E,2EAA2E;IAC3E,8EAA8E;IAC9E,kDAAkD;IAClD,MAAM,KAAK,GAAG,OAAO,GAAG,YAAY,GAAG,kBAAkB,CAAC;IAC1D,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC;AACrD,CAAC"}
+{"version":3,"file":"fitness-formula.js","sourceRoot":"","sources":["../../src/utils/fitness-formula.ts"],"names":[],"mappings":"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"}

package/dist/utils/run-fuel-ladder.d.ts

@@ -10,9 +10,12 @@
  * A ladder keeps both properties we care about:
  *   - completion: a run that dies of fuel alone is retried with more, up to a
  *     hard cap, so "expensive" stops reading as "broken";
- *   - honesty: the fuel actually burned is what lands in resource_cost, and
- *     F(g)'s efficiency term already prices it — a Gene that needs 8e9 fuel
- *     pays for 8e9 fuel. Nothing here makes an expensive Gene look cheap.
+ *   - honesty: what lands in resource_cost is the fuel actually burned plus
+ *     any host-call surcharges (ADR-327 D4, billed on top, not drawn from the
+ *     budget), and F(g)'s efficiency term prices all of it — a Gene that
+ *     needs 8e9 fuel pays for 8e9 fuel. Nothing here makes an expensive Gene
+ *     look cheap. A rung's budget bounds guest computation only, so
+ *     resource_cost can exceed it; that is not a fuel-exhausted failure.
  *
  * The cap is finite on purpose: a Gene that exhausts the top rung records a
  * fuel-exhausted failure, because at some point "needs more fuel" is the

package/dist/utils/run-fuel-ladder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-fuel-ladder.d.ts","sourceRoot":"","sources":["../../src/utils/run-fuel-ladder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EAQxC,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,iBAAiB,GACjB,SAAS,GACT,OAAO,CAAC;AAEZ;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACtC,cAAc,GAAG,IAAI,CAWvB;AAED,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D"}
+{"version":3,"file":"run-fuel-ladder.d.ts","sourceRoot":"","sources":["../../src/utils/run-fuel-ladder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EAQxC,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,iBAAiB,GACjB,SAAS,GACT,OAAO,CAAC;AAEZ;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACtC,cAAc,GAAG,IAAI,CAWvB;AAED,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/utils/run-fuel-ladder.js

@@ -16,9 +16,12 @@ const sandbox_defaults_js_1 = require("./sandbox-defaults.js");
  * A ladder keeps both properties we care about:
  *   - completion: a run that dies of fuel alone is retried with more, up to a
  *     hard cap, so "expensive" stops reading as "broken";
- *   - honesty: the fuel actually burned is what lands in resource_cost, and
- *     F(g)'s efficiency term already prices it — a Gene that needs 8e9 fuel
- *     pays for 8e9 fuel. Nothing here makes an expensive Gene look cheap.
+ *   - honesty: what lands in resource_cost is the fuel actually burned plus
+ *     any host-call surcharges (ADR-327 D4, billed on top, not drawn from the
+ *     budget), and F(g)'s efficiency term prices all of it — a Gene that
+ *     needs 8e9 fuel pays for 8e9 fuel. Nothing here makes an expensive Gene
+ *     look cheap. A rung's budget bounds guest computation only, so
+ *     resource_cost can exceed it; that is not a fuel-exhausted failure.
  *
  * The cap is finite on purpose: a Gene that exhausts the top rung records a
  * fuel-exhausted failure, because at some point "needs more fuel" is the

package/dist/utils/run-fuel-ladder.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-fuel-ladder.js","sourceRoot":"","sources":["../../src/utils/run-fuel-ladder.ts"],"names":[],"mappings":";;;AA6CA,gDAaC;AAGD,gDAEC;AA/DD,+DAAoE;AAEpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACU,QAAA,WAAW,GAAsB;IAC5C,iDAA2B,CAAC,QAAQ,EAAE,+BAA+B;IACrE,aAAa;IACb,wEAAwE;IACxE,wEAAwE;IACxE,yEAAyE;IACzE,2EAA2E;IAC3E,cAAc;CACf,CAAC;AAQF;;;;;GAKG;AACH,SAAgB,kBAAkB,CAChC,YAAuC;IAEvC,IAAI,CAAC,YAAY;QAAE,OAAO,IAAI,CAAC;IAC/B,MAAM,GAAG,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;IACvC,IAAI,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC;QACxE,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IACD,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,iBAAiB,CAAC;IACrD,IAAI,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC5F,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,uDAAuD;AACvD,SAAgB,kBAAkB,CAAC,OAAe;IAChD,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,iDAA2B,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;AAC/E,CAAC"}
+{"version":3,"file":"run-fuel-ladder.js","sourceRoot":"","sources":["../../src/utils/run-fuel-ladder.ts"],"names":[],"mappings":";;;AAgDA,gDAaC;AAGD,gDAEC;AAlED,+DAAoE;AAEpE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,WAAW,GAAsB;IAC5C,iDAA2B,CAAC,QAAQ,EAAE,+BAA+B;IACrE,aAAa;IACb,wEAAwE;IACxE,wEAAwE;IACxE,yEAAyE;IACzE,2EAA2E;IAC3E,cAAc;CACf,CAAC;AAQF;;;;;GAKG;AACH,SAAgB,kBAAkB,CAChC,YAAuC;IAEvC,IAAI,CAAC,YAAY;QAAE,OAAO,IAAI,CAAC;IAC/B,MAAM,GAAG,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;IACvC,IAAI,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC;QACxE,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IACD,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,iBAAiB,CAAC;IACrD,IAAI,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC5F,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,uDAAuD;AACvD,SAAgB,kBAAkB,CAAC,OAAe;IAChD,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,iDAA2B,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;AAC/E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotifer/playground",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Rotifer Protocol Playground — local development environment for gene development, Arena competition, and protocol simulation",
   "license": "Apache-2.0",
   "author": "Rotifer Protocol Contributors",
@@ -92,10 +92,10 @@
   },
   "optionalDependencies": {
     "@rolldown/binding-linux-x64-gnu": "1.1.1",
-    "@rotifer/playground-darwin-arm64": "0.28.0",
-    "@rotifer/playground-darwin-x64": "0.28.0",
-    "@rotifer/playground-linux-x64-gnu": "0.28.0",
-    "@rotifer/playground-win32-x64-msvc": "0.28.0"
+    "@rotifer/playground-darwin-arm64": "0.30.0",
+    "@rotifer/playground-darwin-x64": "0.30.0",
+    "@rotifer/playground-linux-x64-gnu": "0.30.0",
+    "@rotifer/playground-win32-x64-msvc": "0.30.0"
   },
   "engines": {
     "node": ">=22.18.0"