@adcp/sdk 14.0.0-rc.37 → 14.0.0-rc.39

package/dist/lib/reporting/source/inline.js

@@ -18,16 +18,21 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var inline_exports = {};
 __export(inline_exports, {
+  INLINE_REPORTING_AVAILABILITY_EVIDENCE_VERSION_V1: () => INLINE_REPORTING_AVAILABILITY_EVIDENCE_VERSION_V1,
   InlineReportingSourceError: () => InlineReportingSourceError,
   ReportingSourceNotReadyError: () => ReportingSourceNotReadyError,
-  createInlineReportingSourceExecutor: () => createInlineReportingSourceExecutor
+  createInlineReportingSourceExecutor: () => createInlineReportingSourceExecutor,
+  createInlineReportingSourceExecutorForTestsV1: () => createInlineReportingSourceExecutorForTestsV1,
+  inlineStagingCapacitiesForTestsV1: () => inlineStagingCapacitiesForTestsV1
 });
 module.exports = __toCommonJS(inline_exports);
 var import_node_crypto = require("node:crypto");
+var import_zod = require("zod");
 var import_builder = require('./builder.js');
 var import_conformance = require('./conformance.js');
 var import_manifest = require('./manifest.js');
 var import_source = require('./source.js');
+const INLINE_REPORTING_AVAILABILITY_EVIDENCE_VERSION_V1 = "1.0";
 class ReportingSourceNotReadyError extends Error {
   constructor(message = "Reporting data is not ready") {
     super(message);
@@ -50,7 +55,87 @@ const INLINE_MAX_OBJECT_BYTES_V1 = 64 * 1024 * 1024;
 const INLINE_MAX_TOTAL_OBJECT_BYTES_V1 = 256 * 1024 * 1024;
 const INLINE_MAX_SCOPE_OBJECT_BYTES_V1 = 32 * 1024 * 1024;
 const INLINE_MAX_ROWS_V1 = 1e5;
-function createInlineReportingSourceExecutor(deliveryFetch, offeringInput) {
+const INLINE_SHIPPED_CAPACITIES_V1 = {
+  object: INLINE_MAX_OBJECT_BYTES_V1,
+  total: INLINE_MAX_TOTAL_OBJECT_BYTES_V1,
+  scope: INLINE_MAX_SCOPE_OBJECT_BYTES_V1,
+  executions: INLINE_MAX_EXECUTIONS_V1,
+  scopeExecutions: INLINE_MAX_EXECUTIONS_PER_SCOPE_V1
+};
+function tightenInlineStagingCapacities(override) {
+  const tighten = (shipped, value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? Math.min(shipped, value) : shipped;
+  return {
+    object: tighten(INLINE_MAX_OBJECT_BYTES_V1, override.object),
+    total: tighten(INLINE_MAX_TOTAL_OBJECT_BYTES_V1, override.total),
+    scope: tighten(INLINE_MAX_SCOPE_OBJECT_BYTES_V1, override.scope),
+    executions: tighten(INLINE_MAX_EXECUTIONS_V1, override.executions),
+    scopeExecutions: tighten(INLINE_MAX_EXECUTIONS_PER_SCOPE_V1, override.scopeExecutions)
+  };
+}
+const INLINE_MAX_VALIDATION_WORK_UNITS_V1 = 5e6;
+const INLINE_MAX_VALIDATION_SCAN_BYTES_V1 = INLINE_MAX_OBJECT_BYTES_V1;
+const INLINE_MAX_VALIDATION_RETAINED_BYTES_V1 = INLINE_MAX_OBJECT_BYTES_V1;
+const INLINE_RETAINED_BYTES_PER_ROW_V1 = 48;
+const INLINE_RETAINED_BYTES_PER_CLAIM_V1 = 9;
+const INLINE_MAX_STATUS_CHARS_V1 = 32;
+const INLINE_NO_CLAIMS_OFFSET_V1 = -1;
+const INLINE_MAX_EVIDENCE_OBJECT_KEYS_V1 = 16;
+const INLINE_MAX_EVIDENCE_FIELD_CHARS_V1 = 1024;
+const INLINE_EVIDENCE_ENVELOPE_KEYS_V1 = ["version", "cells"];
+const INLINE_EVIDENCE_CELL_KEYS_V1 = ["constituent_id", "metric", "status", "reason", "data_through"];
+const INLINE_UNAVAILABLE_ROW_STATUSES_V1 = [
+  "failed",
+  "reporting_delayed",
+  "not_ready",
+  "pending",
+  "unavailable",
+  "error"
+];
+const INLINE_UNAVAILABLE_CELL_STATUSES_V1 = ["unsupported", "delayed", "missing"];
+const INLINE_MAX_PROTOTYPE_CHAIN_DEPTH_V1 = 64;
+const INLINE_MAX_DECIMAL_EXPONENT_V1 = 400;
+const InlineReportingMetricEvidenceV1Schema = import_zod.z.discriminatedUnion("status", [
+  import_zod.z.strictObject({
+    constituent_id: import_manifest.ReportingExternalIdV1Schema,
+    metric: import_source.ReportingMetricOrDimensionNameV1Schema,
+    status: import_zod.z.enum(["present", "explicit_zero"]),
+    data_through: import_zod.z.string().trim().min(1).max(64),
+    reason: import_zod.z.never().optional()
+  }),
+  import_zod.z.strictObject({
+    constituent_id: import_manifest.ReportingExternalIdV1Schema,
+    metric: import_source.ReportingMetricOrDimensionNameV1Schema,
+    status: import_zod.z.enum(["unsupported", "delayed", "partial", "stale", "missing"]),
+    reason: import_manifest.ReportingEvidenceReasonV1Schema,
+    data_through: import_zod.z.string().trim().min(1).max(64).optional()
+  })
+]);
+const InlineReportingAvailabilityEvidenceV1Schema = import_zod.z.strictObject({
+  version: import_zod.z.literal(INLINE_REPORTING_AVAILABILITY_EVIDENCE_VERSION_V1),
+  cells: import_zod.z.array(InlineReportingMetricEvidenceV1Schema).min(1).max(import_manifest.SOURCE_BATCH_MANIFEST_MAX_METRIC_AVAILABILITY_V1)
+});
+function createInlineReportingSourceExecutor(deliveryFetch, offeringInput, executorOptions = {}) {
+  return createInlineExecutorWithCapacities(
+    deliveryFetch,
+    offeringInput,
+    executorOptions,
+    INLINE_SHIPPED_CAPACITIES_V1
+  );
+}
+function createInlineReportingSourceExecutorForTestsV1(deliveryFetch, offeringInput, executorOptions, capacities, observer) {
+  return createInlineExecutorWithCapacities(
+    deliveryFetch,
+    offeringInput,
+    executorOptions,
+    tightenInlineStagingCapacities(capacities),
+    observer
+  );
+}
+function inlineStagingCapacitiesForTestsV1(capacities) {
+  return tightenInlineStagingCapacities(capacities);
+}
+function createInlineExecutorWithCapacities(deliveryFetch, offeringInput, executorOptions, capacities, observer) {
+  const evictSettled = executorOptions.replayRetention?.evictSettled === true;
   const parsedOffering = import_source.ReportingSourceOfferingV1Schema.parse(offeringInput);
   if (!parsedOffering.sourceExecution.manifestLevels.includes("basic")) {
     throw new TypeError("Inline reporting requires a basic manifest offering");
@@ -143,17 +228,39 @@ function createInlineReportingSourceExecutor(deliveryFetch, offeringInput) {
         if (existing.requestFingerprint !== requestFingerprint) {
           return failure("INTEGRITY_FAILED", "terminal", "sourceExecutionKey was reused with a different request");
         }
+        existing.reservation = void 0;
         return awaitInlineExecution(existing, context.signal, request.deadline.deadlineAt);
       }
-      if (executions.size >= INLINE_MAX_EXECUTIONS_V1) {
-        return failure("QUOTA_EXHAUSTED", "terminal", "Inline reporting replay capacity is exhausted");
-      }
-      if ([...executions.values()].filter((candidate) => candidate.scopeKey === scopeKey).length >= INLINE_MAX_EXECUTIONS_PER_SCOPE_V1) {
-        return failure("QUOTA_EXHAUSTED", "terminal", "Inline reporting scope replay capacity is exhausted");
+      const scopeCount = [...executions.values()].filter((candidate) => candidate.scopeKey === scopeKey).length;
+      const exhaustedGlobally = executions.size >= capacities.executions;
+      const exhaustedForScope = scopeCount >= capacities.scopeExecutions;
+      if ((exhaustedGlobally || exhaustedForScope) && !evictSettled) {
+        return failure(
+          "QUOTA_EXHAUSTED",
+          "terminal",
+          `Inline reporting ${exhaustedGlobally ? "replay" : "scope replay"} capacity is exhausted; supply a durable executor or an explicit replayRetention policy for long-lived feeds`
+        );
       }
       if (activeExecutions >= INLINE_MAX_CONCURRENT_EXECUTIONS_V1) {
         return failure("RATE_LIMITED", "retryable", "Inline reporting concurrency capacity is exhausted");
       }
+      const reclaimer = evictSettled ? createAdmissionReclaimer(executions, storage) : void 0;
+      if (exhaustedGlobally && reclaimer?.plan(scopeKey, false) === void 0) {
+        reclaimer?.release();
+        return failure(
+          "QUOTA_EXHAUSTED",
+          "terminal",
+          "Inline reporting replay capacity is exhausted; supply a durable executor or an explicit replayRetention policy for long-lived feeds"
+        );
+      }
+      if (scopeCount - (reclaimer?.plannedInScope(scopeKey) ?? 0) >= capacities.scopeExecutions && reclaimer?.plan(scopeKey, true) === void 0) {
+        reclaimer?.release();
+        return failure(
+          "QUOTA_EXHAUSTED",
+          "terminal",
+          "Inline reporting scope replay capacity is exhausted; supply a durable executor or an explicit replayRetention policy for long-lived feeds"
+        );
+      }
       activeExecutions += 1;
       const controller = new AbortController();
       const pending = Promise.resolve().then(
@@ -167,7 +274,10 @@ function createInlineReportingSourceExecutor(deliveryFetch, offeringInput) {
           controller.signal,
           storage,
           key,
-          scopeKey
+          scopeKey,
+          capacities,
+          reclaimer,
+          observer
         )
       ).then((result) => ({ requestFingerprint, result })).catch(() => ({
         requestFingerprint,
@@ -175,6 +285,7 @@ function createInlineReportingSourceExecutor(deliveryFetch, offeringInput) {
       })).finally(() => {
         activeExecutions -= 1;
         entry.pending = false;
+        reclaimer?.release();
       });
       const entry = {
         scopeKey,
@@ -206,13 +317,17 @@ function createInlineReportingSourceExecutor(deliveryFetch, offeringInput) {
   };
   return executor;
 }
-async function executeAndSeal(deliveryFetch, offering, format, request, deliveryDates, deadlineAt, signal, storage, executionNamespace, scopeKey) {
+async function executeAndSeal(deliveryFetch, offering, format, request, deliveryDates, deadlineAt, signal, storage, executionNamespace, scopeKey, capacities, reclaimer, observer) {
   let fetched;
   try {
     fetched = await deliveryFetch(
       {
         account: structuredClone(request.account),
         media_buy_ids: [...request.coverage.mediaBuyIds],
+        constituents: request.coverage.constituents.map((constituent) => ({
+          constituent_id: constituent.constituentId,
+          media_buy_id: constituent.mediaBuyId
+        })),
         start_date: deliveryDates.start,
         end_date: deliveryDates.end,
         source_read_cutoff_at: request.period.sourceReadCutoffAt,
@@ -246,70 +361,209 @@ async function executeAndSeal(deliveryFetch, offering, format, request, delivery
   if (fetched === null) {
     return failure("NOT_READY", "retryable", "Reporting data is not ready");
   }
-  const responseStatus = !isRows(fetched) ? fetched.status?.toLowerCase() : void 0;
+  const fetchedRecord = !isRows(fetched) ? fetched : void 0;
+  let rawStatus;
+  try {
+    rawStatus = fetchedRecord?.status;
+  } catch {
+    return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned an unreadable response");
+  }
+  if (rawStatus !== void 0 && typeof rawStatus !== "string") {
+    return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch reported an unreadable status");
+  }
+  const responseStatus = boundedLowerCaseStatus(rawStatus);
   if (["failed", "error", "canceled", "cancelled", "rejected"].includes(responseStatus ?? "")) {
     return failure("SOURCE_TRANSIENT", "retryable", "Inline delivery fetch reported failure");
   }
   if (responseStatus === "unavailable") {
     return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch reported unavailable data");
   }
-  if (!isRows(fetched) && (["working", "submitted", "input_required", "deferred", "reporting_delayed", "not_ready", "pending"].includes(
-    responseStatus ?? ""
-  ) || request.publicationClass === "AUTHORITATIVE" && fetched.is_final === false)) {
-    return failure("NOT_READY", "retryable", "Reporting data is not ready");
-  }
-  if (request.publicationClass === "AUTHORITATIVE" && (isRows(fetched) || fetched.is_final !== true && !["final", "adjusted"].includes(fetched.notification_type ?? ""))) {
-    return failure("NOT_READY", "retryable", "Authoritative inline reporting requires source finality evidence");
+  const readResponseField = createResponseFieldReader(fetchedRecord);
+  const scalarFailure = (() => {
+    try {
+      if (!isRows(fetched) && (["working", "submitted", "input_required", "deferred", "reporting_delayed", "not_ready", "pending"].includes(
+        responseStatus ?? ""
+      ) || request.publicationClass === "AUTHORITATIVE" && readResponseField("is_final") === false)) {
+        return failure("NOT_READY", "retryable", "Reporting data is not ready");
+      }
+      if (request.publicationClass === "AUTHORITATIVE" && (isRows(fetched) || readResponseField("is_final") !== true && !["final", "adjusted"].includes(asStringOrUndefined(readResponseField("notification_type")) ?? ""))) {
+        return failure("NOT_READY", "retryable", "Authoritative inline reporting requires source finality evidence");
+      }
+      if (!isRows(fetched) && (Boolean(readResponseField("partial_data")) || looseCount(readResponseField("unavailable_count")) > 0 || looseCount(lengthOfUnknown(readResponseField("errors"))) > 0)) {
+        return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch returned partial data");
+      }
+      const pagination = readResponseField("pagination");
+      if (!isRows(fetched) && fetchedRecord !== void 0 && pagination !== void 0) {
+        const paginationRecord = asRowRecord(pagination);
+        if (paginationRecord?.has_more !== false || Boolean(paginationRecord?.next_cursor)) {
+          return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch returned unfinished pagination");
+        }
+      }
+      return void 0;
+    } catch {
+      return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned an unreadable response");
+    }
+  })();
+  if (scalarFailure) return scalarFailure;
+  let reportingRowsInput;
+  let mediaBuyDeliveriesInput;
+  try {
+    reportingRowsInput = fetchedRecord ? fetchedRecord.reporting_rows : void 0;
+    mediaBuyDeliveriesInput = fetchedRecord ? fetchedRecord.media_buy_deliveries : void 0;
+  } catch {
+    return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned an invalid row collection");
   }
-  if (!isRows(fetched) && (fetched.partial_data || (fetched.unavailable_count ?? 0) > 0 || (fetched.errors?.length ?? 0) > 0)) {
-    return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch returned partial data");
+  const availabilityEvidenceSlot = fetchedRecord ? resolveOwnDataSlot(fetchedRecord, "availability_evidence") : { kind: "absent" };
+  if (reportingRowsInput !== void 0 && !Array.isArray(reportingRowsInput) || mediaBuyDeliveriesInput !== void 0 && !Array.isArray(mediaBuyDeliveriesInput)) {
+    return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned an invalid row collection");
   }
-  if (!isRows(fetched) && fetched.pagination !== void 0 && (fetched.pagination.has_more !== false || Boolean(fetched.pagination.next_cursor))) {
-    return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch returned unfinished pagination");
+  const reportingRows = reportingRowsInput;
+  const mediaBuyDeliveries = mediaBuyDeliveriesInput;
+  const reportingRowsLength = boundedCollectionLength(reportingRows);
+  const mediaBuyDeliveriesLength = boundedCollectionLength(mediaBuyDeliveries);
+  const sourceDeclaredLength = isRows(fetched) ? boundedCollectionLength(fetched) : reportingRows !== void 0 ? reportingRowsLength : mediaBuyDeliveriesLength;
+  if (reportingRowsLength === void 0 || mediaBuyDeliveriesLength === void 0 || sourceDeclaredLength === void 0) {
+    return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned an invalid row collection");
   }
-  if (!isRows(fetched) && fetched.reporting_rows === void 0 && fetched.media_buy_deliveries === void 0) {
+  if (!isRows(fetched) && reportingRows === void 0 && mediaBuyDeliveries === void 0) {
     return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch omitted its row collection");
   }
-  if (!isRows(fetched) && (!fetched.reporting_period || !deliveryPeriodBoundaryMatches(fetched.reporting_period.start, deliveryDates.start, request.period.start) || !deliveryPeriodBoundaryMatches(fetched.reporting_period.end, deliveryDates.end, request.period.end))) {
+  let responsePeriod;
+  let responseCurrency;
+  try {
+    const period = asRowRecord(readResponseField("reporting_period"));
+    const periodStart = period?.start;
+    const periodEnd = period?.end;
+    responsePeriod = {
+      present: period !== void 0 && periodStart !== void 0 && periodEnd !== void 0,
+      start: periodStart,
+      end: periodEnd
+    };
+    responseCurrency = readResponseField("currency");
+  } catch {
+    return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned an unreadable response");
+  }
+  if (!isRows(fetched) && (!responsePeriod.present || !deliveryPeriodBoundaryMatches(responsePeriod.start, deliveryDates.start, request.period.start) || !deliveryPeriodBoundaryMatches(responsePeriod.end, deliveryDates.end, request.period.end))) {
     return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch did not prove the requested half-open period");
   }
-  if (!isRows(fetched) && fetched.currency !== void 0 && fetched.currency !== request.sourceSettings.currency) {
+  if (!isRows(fetched) && responseCurrency !== void 0 && responseCurrency !== request.sourceSettings.currency) {
     return failure(
       "INTEGRITY_FAILED",
       "terminal",
       "Inline delivery currency does not match the frozen source settings"
     );
   }
-  if (!isRows(fetched) && ((fetched.reporting_rows?.length ?? 0) > INLINE_MAX_ROWS_V1 || (fetched.media_buy_deliveries?.length ?? 0) > INLINE_MAX_ROWS_V1 || (fetched.reporting_rows?.length ?? 0) + (fetched.media_buy_deliveries?.length ?? 0) > INLINE_MAX_ROWS_V1)) {
+  if (!isRows(fetched) && (reportingRowsLength > INLINE_MAX_ROWS_V1 || mediaBuyDeliveriesLength > INLINE_MAX_ROWS_V1 || reportingRowsLength + mediaBuyDeliveriesLength > INLINE_MAX_ROWS_V1)) {
     return failure("QUOTA_EXHAUSTED", "terminal", "Inline delivery fetch exceeded the row limit");
   }
-  if (!isRows(fetched) && fetched.reporting_rows !== void 0 && fetched.media_buy_deliveries !== void 0 && fetched.reporting_rows.length === 0 !== (fetched.media_buy_deliveries.length === 0)) {
+  if (!isRows(fetched) && reportingRows !== void 0 && mediaBuyDeliveries !== void 0 && reportingRowsLength === 0 !== (mediaBuyDeliveriesLength === 0)) {
     return failure("INTEGRITY_FAILED", "terminal", "Inline delivery row collections disagree about zero delivery");
   }
-  const sourceRows = isRows(fetched) ? [...fetched] : fetched.reporting_rows !== void 0 ? [...fetched.reporting_rows] : [...fetched.media_buy_deliveries ?? []];
-  if (sourceRows.length > INLINE_MAX_ROWS_V1) {
+  const sourceCollection = isRows(fetched) ? fetched : reportingRows ?? mediaBuyDeliveries ?? [];
+  const auxiliaryDeclaredLength = !isRows(fetched) && reportingRows !== void 0 ? mediaBuyDeliveriesLength : 0;
+  if (sourceDeclaredLength > INLINE_MAX_ROWS_V1 || auxiliaryDeclaredLength > INLINE_MAX_ROWS_V1) {
     return failure("QUOTA_EXHAUSTED", "terminal", "Inline delivery fetch exceeded the row limit");
   }
-  const evidenceRows = isRows(fetched) ? sourceRows : [...fetched.reporting_rows ?? [], ...fetched.media_buy_deliveries ?? []];
-  if (evidenceRows.some((row) => rowIsUnavailable(row))) {
-    return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch returned an unavailable row");
+  const sourceRowInputs = captureRowCollection(sourceCollection, sourceDeclaredLength);
+  const auxiliaryRowInputs = auxiliaryDeclaredLength > 0 ? captureRowCollection(mediaBuyDeliveries ?? [], auxiliaryDeclaredLength) : [];
+  let availabilityEvidence;
+  if (!isRows(fetched) && availabilityEvidenceSlot.kind === "unreadable") {
+    return failure("INTEGRITY_FAILED", "terminal", "Inline delivery availability evidence is invalid");
   }
-  if (sourceRows.length > 0) {
-    const admittedMediaBuyIds = new Set(
-      request.coverage.constituents.flatMap((constituent) => constituent.mediaBuyId ? [constituent.mediaBuyId] : [])
-    );
-    if (evidenceRows.some((row) => !admittedMediaBuyIds.has(rowMediaBuyId(row) ?? ""))) {
-      return failure("INTEGRITY_FAILED", "terminal", "Inline delivery fetch returned an out-of-scope row");
+  if (!isRows(fetched) && availabilityEvidenceSlot.kind === "data") {
+    try {
+      availabilityEvidence = parseInlineAvailabilityEvidence(
+        availabilityEvidenceSlot.value,
+        request
+      );
+    } catch {
+      return failure("INTEGRITY_FAILED", "terminal", "Inline delivery availability evidence is invalid");
     }
-    if (evidenceRows.some((row) => rowCurrency(row) !== void 0 && rowCurrency(row) !== request.sourceSettings.currency)) {
+  }
+  const captureLayout = captureLayoutFor(request);
+  const claimBearingRowCount = sourceRowInputs.length + (availabilityEvidenceSlot.kind === "data" ? auxiliaryRowInputs.length : 0);
+  if (workUnitsExceedCap(
+    claimBearingRowCount,
+    1 + request.requestedMetrics.length + request.requestedDimensions.length,
+    INLINE_MAX_VALIDATION_WORK_UNITS_V1
+  ) || workUnitsExceedCap(
+    claimBearingRowCount,
+    INLINE_RETAINED_BYTES_PER_ROW_V1 + captureLayout.fields.length * INLINE_RETAINED_BYTES_PER_CLAIM_V1,
+    INLINE_MAX_VALIDATION_RETAINED_BYTES_V1
+  )) {
+    return failure("QUOTA_EXHAUSTED", "terminal", "Inline availability verification exceeded the work budget");
+  }
+  const strictClaims = availabilityEvidence !== void 0;
+  let scanBudget = INLINE_MAX_VALIDATION_SCAN_BYTES_V1;
+  const chargeScan = (units) => {
+    if (units > scanBudget) throw new InlineWorkBudgetExhaustedError();
+    scanBudget -= units;
+  };
+  const sourceReserved = [];
+  const auxiliaryReserved = [];
+  for (const [rows2, captured] of [
+    [sourceRowInputs, sourceReserved],
+    [auxiliaryRowInputs, auxiliaryReserved]
+  ]) {
+    for (const row of rows2) {
+      const reserved = beginRowReserved(row);
+      captured.push(reserved);
+      if (reserved !== void 0 && (rowStatusIsUnavailable(reserved) || rowDeclaresPartialData(reserved))) {
+        return failure("PARTIAL_RESULT", "retryable", "Inline delivery fetch returned an unavailable row");
+      }
+    }
+  }
+  for (const reserved of [...sourceReserved, ...auxiliaryReserved]) {
+    if (reserved === void 0) continue;
+    readRowCurrency(reserved);
+    if (typeof reserved.currency === "string" && reserved.currency !== request.sourceSettings.currency) {
       return failure("INTEGRITY_FAILED", "terminal", "Inline delivery row currency does not match source settings");
     }
+  }
+  let sourceSnapshots;
+  let auxiliarySnapshots;
+  try {
+    const claimRowCount = sourceReserved.length + (strictClaims ? auxiliaryReserved.length : 0);
+    const store = createClaimStore(captureLayout, claimRowCount);
+    sourceSnapshots = sourceReserved.map(
+      (reserved, index) => captureRowSnapshot(reserved, store, index, strictClaims, chargeScan)
+    );
+    auxiliarySnapshots = auxiliaryReserved.map(
+      (reserved, index) => strictClaims ? captureRowSnapshot(reserved, store, sourceReserved.length + index, strictClaims, chargeScan) : captureRowIdentityOnly(reserved, store)
+    );
+  } catch (error) {
+    if (error instanceof InlineWorkBudgetExhaustedError) {
+      return failure("QUOTA_EXHAUSTED", "terminal", "Inline availability verification exceeded the scan budget");
+    }
+    return failure("INTEGRITY_FAILED", "terminal", "Inline delivery row contains invalid evidence values");
+  }
+  const allSnapshots = [...sourceSnapshots, ...auxiliarySnapshots];
+  if (validationWorkExceedsCap(
+    sourceSnapshots,
+    auxiliarySnapshots,
+    request,
+    availabilityEvidence !== void 0,
+    INLINE_MAX_VALIDATION_WORK_UNITS_V1
+  )) {
+    return failure("QUOTA_EXHAUSTED", "terminal", "Inline availability verification exceeded the work budget");
+  }
+  const admittedMediaBuyIds = new Set(
+    request.coverage.constituents.flatMap((constituent) => constituent.mediaBuyId ? [constituent.mediaBuyId] : [])
+  );
+  const sourceSnapshotsByMediaBuyId = groupSnapshotsByMediaBuyId(sourceSnapshots, admittedMediaBuyIds);
+  const auxiliarySnapshotsByMediaBuyId = groupSnapshotsByMediaBuyId(auxiliarySnapshots, admittedMediaBuyIds);
+  if (sourceSnapshots.length > 0) {
+    if (allSnapshots.some((snapshot) => !admittedMediaBuyIds.has(snapshot?.mediaBuyId ?? ""))) {
+      return failure("INTEGRITY_FAILED", "terminal", "Inline delivery fetch returned an out-of-scope row");
+    }
     if (request.coverage.constituents.some((constituent) => {
       if (constituent.constituentKind !== "media_buy" || !constituent.mediaBuyId) return true;
-      const constituentRows = sourceRows.filter((row) => rowMediaBuyId(row) === constituent.mediaBuyId);
-      return constituentRows.length === 0 || constituentRows.some(
-        (row) => request.requestedMetrics.some((metric) => !rowHasField(row, metric)) || request.requestedDimensions.some((dimension) => !rowHasDimension(row, dimension))
-      );
+      const constituentRows = sourceSnapshotsByMediaBuyId.get(constituent.mediaBuyId) ?? NO_SNAPSHOTS;
+      return constituentRows.some(
+        (snapshot) => request.requestedDimensions.some((dimension) => !snapshotHasDimension(snapshot, dimension))
+      ) || availabilityEvidence === void 0 && (constituentRows.length === 0 || constituentRows.some(
+        (snapshot) => request.requestedMetrics.some((metric) => snapshotFieldValue(snapshot, metric) === void 0)
+      ));
     })) {
       return failure(
         "PARTIAL_RESULT",
@@ -318,37 +572,35 @@ async function executeAndSeal(deliveryFetch, offering, format, request, delivery
       );
     }
   }
-  const remainingCapacity = Math.min(
-    INLINE_MAX_OBJECT_BYTES_V1,
-    INLINE_MAX_TOTAL_OBJECT_BYTES_V1 - storage.totalBytes,
-    INLINE_MAX_SCOPE_OBJECT_BYTES_V1 - (storage.scopeBytes.get(scopeKey) ?? 0)
-  );
-  let projectionBudget = remainingCapacity;
-  let rows;
-  try {
-    rows = sourceRows.map(
-      (row) => projectEvidenceRow(row, request, (upperBound) => {
-        if (upperBound > projectionBudget) throw new RangeError("Inline projection capacity exhausted");
-        projectionBudget -= upperBound;
-      })
+  if (availabilityEvidence !== void 0) {
+    const rowEvidenceFailure = validateSnapshotsAgainstAvailabilityEvidence(
+      sourceSnapshotsByMediaBuyId,
+      auxiliarySnapshotsByMediaBuyId,
+      request,
+      availabilityEvidence.cells
     );
-  } catch (error) {
-    if (error instanceof RangeError) {
-      return failure("STAGING_FAILED", "terminal", "Inline delivery evidence exceeds the bounded replay capacity");
+    if (rowEvidenceFailure === "partial") {
+      return failure("PARTIAL_RESULT", "retryable", "Inline delivery rows do not prove every metric marked present");
+    }
+    if (rowEvidenceFailure === "integrity") {
+      return failure("INTEGRITY_FAILED", "terminal", "Inline delivery rows contradict availability evidence");
     }
-    return failure("INTEGRITY_FAILED", "terminal", "Inline delivery row contains invalid evidence values");
   }
   const readsPartialPeriod = Date.parse(request.period.sourceReadCutoffAt) < Date.parse(request.period.end);
-  if (readsPartialPeriod && (isRows(fetched) || fetched.data_through === void 0 || fetched.observed_at === void 0)) {
+  if (readsPartialPeriod && (isRows(fetched) || readResponseField("data_through") === void 0 || readResponseField("observed_at") === void 0)) {
     return failure(
       "PARTIAL_RESULT",
       "retryable",
       "Inline delivery fetch did not provide temporal evidence for the source read cutoff"
     );
   }
-  const observedAt = isRows(fetched) ? request.period.sourceReadCutoffAt : normalizeDeliveryInstant(fetched.observed_at ?? request.period.sourceReadCutoffAt, deliveryDates, request.period);
+  const observedAt = isRows(fetched) ? request.period.sourceReadCutoffAt : normalizeDeliveryInstant(
+    readResponseField("observed_at") ?? request.period.sourceReadCutoffAt,
+    deliveryDates,
+    request.period
+  );
   const defaultDataThrough = request.publicationClass === "AUTHORITATIVE" ? request.period.end : Date.parse(request.period.sourceReadCutoffAt) < Date.parse(request.period.end) ? request.period.sourceReadCutoffAt : request.period.end;
-  const dataThrough = isRows(fetched) ? defaultDataThrough : normalizeDeliveryInstant(fetched.data_through ?? defaultDataThrough, deliveryDates, request.period);
+  const dataThrough = isRows(fetched) ? defaultDataThrough : normalizeDeliveryInstant(readResponseField("data_through") ?? defaultDataThrough, deliveryDates, request.period);
   const acquiredAt = (/* @__PURE__ */ new Date()).toISOString();
   const startMs = Date.parse(request.period.start);
   const endMs = Date.parse(request.period.end);
@@ -359,15 +611,110 @@ async function executeAndSeal(deliveryFetch, offering, format, request, delivery
   if (request.publicationClass === "AUTHORITATIVE" && dataThroughMs < endMs) {
     return failure("NOT_READY", "retryable", "Authoritative inline reporting has not reached period end");
   }
-  if (![dataThroughMs, observedMs].every(Number.isFinite) || dataThroughMs < startMs || dataThroughMs > endMs || dataThroughMs > cutoffMs || dataThroughMs > observedMs || observedMs > acquiredMs || rows.length > 0 && dataThroughMs <= startMs) {
+  if (![dataThroughMs, observedMs].every(Number.isFinite) || dataThroughMs < startMs || dataThroughMs > endMs || dataThroughMs > cutoffMs || dataThroughMs > observedMs || observedMs > acquiredMs || sourceSnapshots.length > 0 && dataThroughMs <= startMs) {
     return failure("SOURCE_PERMANENT", "terminal", "Inline delivery fetch returned invalid temporal evidence");
   }
-  let bytes;
-  try {
-    bytes = encodeRows(rows, format.mediaType, remainingCapacity);
-  } catch {
-    return failure("STAGING_FAILED", "terminal", "Inline delivery evidence exceeds the bounded replay capacity");
+  const declaredMetrics = new Map(offering.metrics.map((metric) => [metric.name, metric]));
+  const constituentIdsWithRows = new Set(
+    request.coverage.constituents.filter((constituent) => constituent.mediaBuyId && sourceSnapshotsByMediaBuyId.has(constituent.mediaBuyId)).map((constituent) => constituent.constituentId)
+  );
+  let projectedAvailability;
+  if (availabilityEvidence) {
+    try {
+      projectedAvailability = projectInlineAvailabilityEvidence(
+        availabilityEvidence.cells,
+        request,
+        declaredMetrics,
+        deliveryDates,
+        dataThrough,
+        sourceSnapshots.length,
+        constituentIdsWithRows
+      );
+    } catch {
+      return failure("INTEGRITY_FAILED", "terminal", "Inline delivery availability evidence is contradictory");
+    }
+  } else {
+    projectedAvailability = projectLegacyAvailability(request, declaredMetrics, dataThrough, sourceSnapshots.length);
+  }
+  if (request.coverage.expected === "full" && projectedAvailability.coverageStatus !== "full") {
+    return failure("PARTIAL_RESULT", "retryable", "Inline delivery evidence does not satisfy full requested coverage");
+  }
+  if (request.publicationClass === "AUTHORITATIVE" && projectedAvailability.metricAvailability.some(
+    (cell) => !["present", "explicit_zero"].includes(cell.status) || Date.parse(cell.dataThrough ?? "") !== endMs
+  )) {
+    return failure("PARTIAL_RESULT", "retryable", "Authoritative inline reporting has incomplete metric evidence");
+  }
+  const reservedBytes = reclaimer?.grantReservedBytes(scopeKey) ?? { global: 0, scope: 0 };
+  let plannedGlobalCredit = reservedBytes.global;
+  let plannedScopeCredit = reservedBytes.scope;
+  const globalRoom = () => capacities.total - storage.totalBytes + plannedGlobalCredit;
+  const scopeRoom = () => capacities.scope - (storage.scopeBytes.get(scopeKey) ?? 0) + plannedScopeCredit;
+  const capacity = () => Math.min(capacities.object, globalRoom(), scopeRoom());
+  const planMoreCapacity = () => {
+    for (; ; ) {
+      const freed = reclaimer?.plan(scopeKey, scopeRoom() <= globalRoom(), true);
+      if (freed === void 0) return false;
+      if (freed.bytes <= 0) continue;
+      plannedGlobalCredit += freed.bytes;
+      if (freed.sameScope) plannedScopeCredit += freed.bytes;
+      return true;
+    }
+  };
+  const growCapacity = (available) => {
+    observer?.onCapacityRequest?.();
+    if (!planMoreCapacity()) return void 0;
+    const grown = capacity();
+    return grown > available ? grown : void 0;
+  };
+  let remainingCapacity = capacity();
+  let projectionBudget = remainingCapacity;
+  let rows;
+  while (rows === void 0) {
+    projectionBudget = remainingCapacity;
+    try {
+      rows = sourceSnapshots.map(
+        (snapshot) => projectSnapshotRow(
+          snapshot,
+          request,
+          (upperBound) => {
+            if (upperBound > projectionBudget) throw new RangeError("Inline projection capacity exhausted");
+            projectionBudget -= upperBound;
+          },
+          {
+            allowMissingMetrics: true,
+            allowMissingDimensions: true,
+            strictMetricClaims: availabilityEvidence !== void 0,
+            includeDimensions: true
+          }
+        )
+      );
+    } catch (error) {
+      if (!(error instanceof RangeError)) {
+        return failure("INTEGRITY_FAILED", "terminal", "Inline delivery row contains invalid evidence values");
+      }
+      const grown = growCapacity(remainingCapacity);
+      if (grown === void 0) {
+        return failure("STAGING_FAILED", "terminal", "Inline delivery evidence exceeds the bounded replay capacity");
+      }
+      remainingCapacity = grown;
+    }
   }
+  let encoded;
+  while (encoded === void 0) {
+    try {
+      encoded = encodeRows(rows, format.mediaType, remainingCapacity);
+    } catch (error) {
+      if (!(error instanceof RangeError)) {
+        return failure("INTEGRITY_FAILED", "terminal", "Inline delivery row contains invalid evidence values");
+      }
+      const grown = growCapacity(remainingCapacity);
+      if (grown === void 0) {
+        return failure("STAGING_FAILED", "terminal", "Inline delivery evidence exceeds the bounded replay capacity");
+      }
+      remainingCapacity = grown;
+    }
+  }
+  const bytes = encoded;
   const objectDigest = digest(bytes);
   const objectRef = `inline-${executionNamespace.slice(0, 32)}`;
   const generation = `sha256-${objectDigest}`;
@@ -381,25 +728,423 @@ async function executeAndSeal(deliveryFetch, offering, format, request, delivery
     byteCount: bytes.byteLength,
     rowCount: rows.length
   };
-  const explicitZero = rows.length === 0;
+  let built;
+  try {
+    built = (0, import_builder.buildReportingSourceManifestV1)({
+      level: "basic",
+      request,
+      stagedCommitRef: `inline-manifest-${executionNamespace.slice(0, 32)}`,
+      objects: [object],
+      completeness: {
+        terminal: true,
+        rowsComplete: true,
+        requestedGroupsComplete: true
+      },
+      controlTotals: [],
+      metricAvailability: projectedAvailability.metricAvailability,
+      coverage: {
+        status: projectedAvailability.coverageStatus,
+        constituents: projectedAvailability.coverageConstituents
+      },
+      observedAt,
+      dataThrough,
+      finalityEvidence: {
+        owner: "adapter",
+        basis: request.publicationClass === "PROVISIONAL_SNAPSHOT" ? "provisional_observation" : "source_declared",
+        observedAt,
+        ...request.publicationClass === "AUTHORITATIVE" ? { evidenceRef: "get_media_buy_delivery.is_final" } : {}
+      },
+      explicitZero: projectedAvailability.explicitZero,
+      acquiredAt,
+      ...rows.length === 0 ? {} : { eventTimeRange: { start: request.period.start, end: dataThrough } },
+      warnings: []
+    });
+  } catch (error) {
+    if (!availabilityEvidence) throw error;
+    if (error instanceof import_manifest.SourceBatchContractError && error.code === "SOURCE_MANIFEST_TOO_LARGE") {
+      return failure("QUOTA_EXHAUSTED", "terminal", "Inline reporting manifest exceeded the bounded size limit");
+    }
+    return failure("INTEGRITY_FAILED", "terminal", "Inline delivery availability evidence is contradictory");
+  }
+  if (Date.parse(deadlineAt) <= Date.now()) {
+    return failure("DEADLINE_EXCEEDED", "retryable", "Inline reporting execution deadline elapsed");
+  }
+  if (reclaimer !== void 0 && !reclaimer.commit(scopeKey)) {
+    return failure(
+      "STAGING_FAILED",
+      "terminal",
+      "Inline reporting could not reacquire the capacity a revoked reservation had promised"
+    );
+  }
+  storage.objects.set(objectRef, { request: structuredClone(request), generation, bytes: Uint8Array.from(bytes) });
+  storage.totalBytes += bytes.byteLength;
+  storage.scopeBytes.set(scopeKey, (storage.scopeBytes.get(scopeKey) ?? 0) + bytes.byteLength);
+  return {
+    ok: true,
+    response: (0, import_source.completedReportingSourceResponseV1)({ request, manifest: built.reference }),
+    manifestBytes: built.manifestBytes
+  };
+}
+function parseInlineAvailabilityEvidence(input, request) {
+  if (typeof input !== "object" || input === null) throw new TypeError("Availability evidence is not an envelope");
+  const envelope = snapshotOwnDataObject(input, INLINE_EVIDENCE_ENVELOPE_KEYS_V1);
+  const inputCells = envelope.cells;
+  const cellCount = Array.isArray(inputCells) ? boundedCollectionLength(inputCells) : void 0;
+  if (cellCount === void 0) throw new TypeError("Availability evidence cells are not a bounded array");
+  if (cellCount > import_manifest.SOURCE_BATCH_MANIFEST_MAX_METRIC_AVAILABILITY_V1) {
+    throw new TypeError("Availability evidence exceeds the cell limit");
+  }
+  const cellSnapshot = new Array(cellCount);
+  for (let index = 0; index < cellCount; index += 1) {
+    const cell = inputCells[index];
+    if (typeof cell !== "object" || cell === null || Array.isArray(cell)) {
+      throw new TypeError("Availability evidence cell is not an object");
+    }
+    cellSnapshot[index] = snapshotOwnDataObject(cell, INLINE_EVIDENCE_CELL_KEYS_V1);
+  }
+  const parsed = InlineReportingAvailabilityEvidenceV1Schema.parse({ ...envelope, cells: cellSnapshot });
+  const expected = new Set(
+    request.coverage.constituents.flatMap(
+      (constituent) => request.requestedMetrics.map((metric) => availabilityCellKey(constituent.constituentId, metric))
+    )
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const cell of parsed.cells) {
+    const key = availabilityCellKey(cell.constituent_id, cell.metric);
+    if (!expected.has(key) || seen.has(key)) throw new TypeError("Availability cell is duplicate or out of scope");
+    seen.add(key);
+  }
+  if (seen.size !== expected.size) throw new TypeError("Availability evidence must cover the requested matrix");
+  const cellsByKey = new Map(parsed.cells.map((cell) => [availabilityCellKey(cell.constituent_id, cell.metric), cell]));
+  return {
+    ...parsed,
+    cells: request.coverage.constituents.flatMap(
+      (constituent) => request.requestedMetrics.map((metric) => {
+        const cell = cellsByKey.get(availabilityCellKey(constituent.constituentId, metric));
+        if (!cell) throw new TypeError("Availability evidence must cover the requested matrix");
+        return cell;
+      })
+    )
+  };
+}
+const NO_SNAPSHOTS = [];
+class InlineWorkBudgetExhaustedError extends Error {
+}
+const UNCLAIMED_V1 = { claimed: false };
+function captureLayoutFor(request) {
+  const fields = [];
+  const indexOf = /* @__PURE__ */ new Map();
+  const reservedFields = /* @__PURE__ */ new Set();
+  const requestedAsMetric = new Set(request.requestedMetrics);
+  for (const field of [...request.requestedMetrics, ...request.requestedDimensions]) {
+    if (indexOf.has(field)) continue;
+    if (field === "media_buy_id" && !requestedAsMetric.has(field)) continue;
+    indexOf.set(field, fields.length);
+    fields.push(field);
+    if (INLINE_RESERVED_ROW_FIELDS_V1.includes(field)) reservedFields.add(field);
+  }
+  return { fields, indexOf, reservedFields };
+}
+const CLAIM_DIRECT_CLAIMED_V1 = 1 << 0;
+const CLAIM_NESTED_CLAIMED_V1 = 1 << 1;
+const CLAIM_DIRECT_VALID_V1 = 1 << 2;
+const CLAIM_NESTED_VALID_V1 = 1 << 3;
+const CLAIM_VALUE_IS_ZERO_V1 = 1 << 4;
+const CLAIM_CLAIM_IS_ZERO_V1 = 1 << 5;
+const CLAIM_DISAGREE_V1 = 1 << 6;
+const INLINE_RESERVED_ROW_FIELDS_V1 = ["media_buy_id", "currency", "status", "partial_data", "totals"];
+function beginRowReserved(row) {
+  const record = asRowRecord(row);
+  if (!record) return void 0;
+  return { record, status: ownDataValue(record, "status") };
+}
+function rowStatusIsUnavailable(reserved) {
+  const status = boundedLowerCaseStatus(reserved.status);
+  return status !== void 0 && INLINE_UNAVAILABLE_ROW_STATUSES_V1.includes(status);
+}
+function rowDeclaresPartialData(reserved) {
+  reserved.partialData = ownDataValue(reserved.record, "partial_data");
+  return reserved.partialData === true;
+}
+function readRowCurrency(reserved) {
+  reserved.currency = ownDataValue(reserved.record, "currency");
+}
+function readRowIdentity(reserved) {
+  reserved.mediaBuyId = ownDataValue(reserved.record, "media_buy_id");
+}
+function reservedFieldValue(reserved, field) {
+  switch (field) {
+    case "media_buy_id":
+      return reserved.mediaBuyId;
+    case "currency":
+      return reserved.currency;
+    case "status":
+      return reserved.status;
+    case "partial_data":
+      return reserved.partialData;
+    default:
+      return reserved.totals;
+  }
+}
+function createClaimStore(layout, rowCount) {
+  const width = layout.fields.length;
+  return {
+    layout,
+    values: new Array(rowCount * width),
+    flags: new Uint8Array(rowCount * width)
+  };
+}
+function fieldSlotOf(snapshot, field) {
+  return snapshot.store.layout.indexOf.get(field) ?? -1;
+}
+function slotValue(snapshot, slot) {
+  return slot < 0 || snapshot.offset < 0 ? void 0 : snapshot.store.values[snapshot.offset + slot];
+}
+function slotFlags(snapshot, slot) {
+  return slot < 0 || snapshot.offset < 0 ? 0 : snapshot.store.flags[snapshot.offset + slot] ?? 0;
+}
+function snapshotFieldValue(snapshot, field) {
+  return slotValue(snapshot, fieldSlotOf(snapshot, field));
+}
+function captureRowSnapshot(reserved, store, rowIndex, strictClaims, chargeScan) {
+  if (!reserved) return void 0;
+  readRowIdentity(reserved);
+  const { record } = reserved;
+  const layout = store.layout;
+  const offset = rowIndex * layout.fields.length;
+  let totalsObserved = false;
+  let totalsRecord;
+  let totalsAliasesRow = false;
+  const observeTotals = () => {
+    if (!totalsObserved) {
+      totalsObserved = true;
+      reserved.totals = ownDataValue(record, "totals");
+      totalsRecord = typeof reserved.totals === "object" && reserved.totals !== null ? reserved.totals : void 0;
+      totalsAliasesRow = totalsRecord === record;
+    }
+    return reserved.totals;
+  };
+  for (let slot = 0; slot < layout.fields.length; slot += 1) {
+    const field = layout.fields[slot];
+    const direct = layout.reservedFields.has(field) ? claimOfValue(field === "totals" ? observeTotals() : reservedFieldValue(reserved, field)) : ownDataClaim(record, field);
+    const measurePasses = strictClaims ? 2 : 1;
+    chargeScan(measureScanWidth(direct.value) * measurePasses);
+    const measuredDirect = measureClaim(direct.value, strictClaims);
+    let nested = UNCLAIMED_V1;
+    let measuredNested = UNMEASURED_CLAIM_V1;
+    if (strictClaims || !measuredDirect.valid) {
+      observeTotals();
+      if (totalsRecord !== void 0) {
+        if (totalsAliasesRow) {
+          nested = direct;
+          measuredNested = measuredDirect;
+        } else {
+          nested = ownDataClaim(totalsRecord, field);
+          chargeScan(measureScanWidth(nested.value) * measurePasses);
+          measuredNested = measureClaim(nested.value, strictClaims);
+        }
+      }
+    }
+    const resolved = measuredDirect.valid ? measuredDirect : measuredNested.valid ? measuredNested : void 0;
+    const claimed = direct.claimed ? measuredDirect : measuredNested;
+    let bits = 0;
+    if (direct.claimed) bits |= CLAIM_DIRECT_CLAIMED_V1;
+    if (nested.claimed) bits |= CLAIM_NESTED_CLAIMED_V1;
+    if (measuredDirect.valid) bits |= CLAIM_DIRECT_VALID_V1;
+    if (measuredNested.valid) bits |= CLAIM_NESTED_VALID_V1;
+    if (resolved?.isZero === true) bits |= CLAIM_VALUE_IS_ZERO_V1;
+    if (claimed.valid && claimed.isZero) bits |= CLAIM_CLAIM_IS_ZERO_V1;
+    if (strictClaims && direct.claimed && nested.claimed && measuredDirect.valid && measuredNested.valid && !Object.is(direct.value, nested.value)) {
+      chargeScan(canonicalScanWidth(direct.value) + canonicalScanWidth(nested.value));
+      const canonicalDirect = canonicalDecimalEvidence(measuredDirect.value);
+      const canonicalNested = canonicalDecimalEvidence(measuredNested.value);
+      if (canonicalDirect === void 0 || canonicalDirect !== canonicalNested) bits |= CLAIM_DISAGREE_V1;
+    }
+    store.values[offset + slot] = resolved?.value;
+    store.flags[offset + slot] = bits;
+  }
+  return {
+    store,
+    offset,
+    mediaBuyId: typeof reserved.mediaBuyId === "string" ? reserved.mediaBuyId : void 0
+  };
+}
+function captureRowIdentityOnly(reserved, store) {
+  if (!reserved) return void 0;
+  reserved.mediaBuyId = ownDataValue(reserved.record, "media_buy_id");
+  return {
+    store,
+    offset: INLINE_NO_CLAIMS_OFFSET_V1,
+    mediaBuyId: typeof reserved.mediaBuyId === "string" ? reserved.mediaBuyId : void 0
+  };
+}
+function claimOfValue(value) {
+  return value === void 0 ? UNCLAIMED_V1 : { claimed: true, value };
+}
+function asRowRecord(row) {
+  return typeof row !== "object" || row === null || Array.isArray(row) ? void 0 : row;
+}
+function boundedLowerCaseStatus(status) {
+  return typeof status === "string" && status.length <= INLINE_MAX_STATUS_CHARS_V1 ? status.toLowerCase() : void 0;
+}
+const UNMEASURED_CLAIM_V1 = { value: void 0, valid: false, isZero: false };
+function measureClaim(value, strictClaims) {
+  if (!isEvidenceValue(value)) return UNMEASURED_CLAIM_V1;
+  return { value, valid: true, isZero: strictClaims ? isZeroEvidenceValue(value) : false };
+}
+function measureScanWidth(value) {
+  return typeof value === "string" ? value.length + 1 : 1;
+}
+function canonicalScanWidth(value) {
+  if (typeof value === "string") return value.length + 1;
+  if (typeof value !== "number") return 1;
+  return numericScanUnits(value);
+}
+function numericScanUnits(value) {
+  const printed = String(value);
+  const exponent = /[eE]([+-]?\d+)$/.exec(printed);
+  return printed.length + (exponent ? Math.abs(Number(exponent[1])) : 0) + 1;
+}
+function workUnitsExceedCap(count, unitsEach, cap) {
+  return unitsEach > 0 && count > Math.floor(cap / unitsEach);
+}
+function validationWorkExceedsCap(sourceSnapshots, auxiliarySnapshots, request, includeAuxiliary, cap) {
+  const unitsPerVisit = request.requestedMetrics.length + request.requestedDimensions.length;
+  if (unitsPerVisit === 0) return false;
+  const perConstituentCap = Math.floor(cap / unitsPerVisit);
+  const sourceCounts = countSnapshotsByMediaBuyId(sourceSnapshots);
+  const auxiliaryCounts = includeAuxiliary ? countSnapshotsByMediaBuyId(auxiliarySnapshots) : void 0;
+  let work = 0;
+  for (const constituent of request.coverage.constituents) {
+    if (!constituent.mediaBuyId) continue;
+    const visits = (sourceCounts.get(constituent.mediaBuyId) ?? 0) + (auxiliaryCounts?.get(constituent.mediaBuyId) ?? 0);
+    if (visits > perConstituentCap) return true;
+    work += visits * unitsPerVisit;
+    if (work > cap) return true;
+  }
+  return false;
+}
+function countSnapshotsByMediaBuyId(snapshots) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    if (snapshot?.mediaBuyId === void 0) continue;
+    counts.set(snapshot.mediaBuyId, (counts.get(snapshot.mediaBuyId) ?? 0) + 1);
+  }
+  return counts;
+}
+function groupSnapshotsByMediaBuyId(snapshots, admittedMediaBuyIds) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    if (!snapshot) continue;
+    const mediaBuyId = snapshot.mediaBuyId;
+    if (mediaBuyId === void 0 || !admittedMediaBuyIds.has(mediaBuyId)) continue;
+    const existing = grouped.get(mediaBuyId);
+    if (existing) existing.push(snapshot);
+    else grouped.set(mediaBuyId, [snapshot]);
+  }
+  return grouped;
+}
+function snapshotHasDimension(snapshot, dimension) {
+  return dimension === "media_buy_id" ? snapshot.mediaBuyId !== void 0 : snapshotFieldValue(snapshot, dimension) !== void 0;
+}
+function validateSnapshotsAgainstAvailabilityEvidence(sourceSnapshotsByMediaBuyId, auxiliarySnapshotsByMediaBuyId, request, cells) {
+  const cellsByConstituent = /* @__PURE__ */ new Map();
+  for (const constituent of request.coverage.constituents) cellsByConstituent.set(constituent.constituentId, []);
+  for (const cell of cells) cellsByConstituent.get(cell.constituent_id)?.push(cell);
+  let integrity = false;
+  for (const constituent of request.coverage.constituents) {
+    const sourceRows = constituent.mediaBuyId ? sourceSnapshotsByMediaBuyId.get(constituent.mediaBuyId) ?? NO_SNAPSHOTS : NO_SNAPSHOTS;
+    const auxiliaryRows = constituent.mediaBuyId ? auxiliarySnapshotsByMediaBuyId.get(constituent.mediaBuyId) ?? NO_SNAPSHOTS : NO_SNAPSHOTS;
+    for (const cell of cellsByConstituent.get(constituent.constituentId) ?? []) {
+      if (cell.status === "present" && sourceRows.length === 0) return "partial";
+      for (const snapshot of sourceRows) {
+        const verdict = cellVerdictForSnapshot(cell, snapshot, true);
+        if (verdict === "partial") return "partial";
+        if (verdict === "integrity") integrity = true;
+      }
+      for (const snapshot of auxiliaryRows) {
+        const verdict = cellVerdictForSnapshot(cell, snapshot, false);
+        if (verdict === "partial") return "partial";
+        if (verdict === "integrity") integrity = true;
+      }
+    }
+  }
+  return integrity ? "integrity" : void 0;
+}
+function cellVerdictForSnapshot(cell, snapshot, isSourceRow) {
+  const slot = fieldSlotOf(snapshot, cell.metric);
+  const flags = slotFlags(snapshot, slot);
+  if (isSourceRow) {
+    if (cell.status === "present" && slotValue(snapshot, slot) === void 0) return "partial";
+    if (cell.status === "explicit_zero" && (flags & CLAIM_VALUE_IS_ZERO_V1) === 0) return "integrity";
+  }
+  const directClaimed = (flags & CLAIM_DIRECT_CLAIMED_V1) !== 0;
+  const nestedClaimed = (flags & CLAIM_NESTED_CLAIMED_V1) !== 0;
+  const directValid = (flags & CLAIM_DIRECT_VALID_V1) !== 0;
+  const nestedValid = (flags & CLAIM_NESTED_VALID_V1) !== 0;
+  if (directClaimed && !directValid || nestedClaimed && !nestedValid) return "integrity";
+  const claimValid = directClaimed ? directValid : nestedValid;
+  if ((flags & CLAIM_DISAGREE_V1) !== 0) return "integrity";
+  if (!claimValid) return void 0;
+  if (cell.status === "explicit_zero" && (flags & CLAIM_CLAIM_IS_ZERO_V1) === 0) return "integrity";
+  return INLINE_UNAVAILABLE_CELL_STATUSES_V1.includes(cell.status) ? "integrity" : void 0;
+}
+function projectInlineAvailabilityEvidence(cells, request, declaredMetrics, deliveryDates, manifestDataThrough, rowCount, constituentIdsWithRows) {
+  const startMs = Date.parse(request.period.start);
+  const manifestDataThroughMs = Date.parse(manifestDataThrough);
+  const metricAvailability = cells.map((cell) => {
+    const metric = declaredMetrics.get(cell.metric);
+    if (!metric) throw new TypeError(`Offering does not declare ${cell.metric}`);
+    const dataThrough = cell.data_through ? normalizeDeliveryInstant(cell.data_through, deliveryDates, request.period) : void 0;
+    const dataThroughMs = dataThrough === void 0 ? void 0 : Date.parse(dataThrough);
+    if (dataThroughMs !== void 0 && (!Number.isFinite(dataThroughMs) || dataThroughMs < startMs || dataThroughMs > manifestDataThroughMs || ["present", "explicit_zero"].includes(cell.status) && constituentIdsWithRows.has(cell.constituent_id) && dataThroughMs === startMs)) {
+      throw new TypeError("Availability dataThrough exceeds the manifest window");
+    }
+    return {
+      constituentId: cell.constituent_id,
+      metric: cell.metric,
+      semanticContractId: metric.semanticContractId,
+      semanticContractVersion: metric.semanticContractVersion,
+      semanticContractSha256: metric.semanticContractSha256,
+      status: cell.status,
+      ...dataThrough ? { dataThrough } : {},
+      ...cell.reason ? { reason: cell.reason } : {}
+    };
+  });
+  const coverageConstituents = request.coverage.constituents.map((constituent) => {
+    const constituentCells = metricAvailability.filter((cell) => cell.constituentId === constituent.constituentId);
+    const status = rollUpInlineConstituentStatus(constituentCells.map((cell) => cell.status));
+    const dataThrough = earliestDataThrough(constituentCells);
+    const reason = constituentCells.find((cell) => cell.reason)?.reason;
+    if (!["present", "explicit_zero"].includes(status) && !reason) {
+      throw new TypeError("Unavailable constituent roll-up requires supplied evidence");
+    }
+    return {
+      ...constituent,
+      status,
+      ...dataThrough ? { dataThrough } : {},
+      ...reason && !["present", "explicit_zero"].includes(status) ? { reason } : {}
+    };
+  });
+  const allCellsExplicitZero = metricAvailability.every((cell) => cell.status === "explicit_zero");
+  if (rowCount === 0 && metricAvailability.some((cell) => ["present", "explicit_zero"].includes(cell.status)) && !allCellsExplicitZero) {
+    throw new TypeError("Zero-row evidence has contradictory available cells");
+  }
+  const fullyCovered = coverageConstituents.filter(
+    (constituent) => ["present", "explicit_zero"].includes(constituent.status)
+  ).length;
+  const someCoverage = fullyCovered > 0 || coverageConstituents.some((constituent) => constituent.status === "partial");
+  return {
+    metricAvailability,
+    coverageConstituents,
+    coverageStatus: fullyCovered === coverageConstituents.length ? "full" : someCoverage ? "partial" : "none",
+    explicitZero: rowCount === 0 && allCellsExplicitZero
+  };
+}
+function projectLegacyAvailability(request, declaredMetrics, dataThrough, rowCount) {
+  const explicitZero = rowCount === 0;
   const status = explicitZero ? "explicit_zero" : "present";
-  const coverageConstituents = request.coverage.constituents.map((constituent) => ({
-    ...constituent,
-    status,
-    dataThrough
-  }));
-  const declaredMetrics = new Map(offering.metrics.map((metric) => [metric.name, metric]));
-  const built = (0, import_builder.buildReportingSourceManifestV1)({
-    level: "basic",
-    request,
-    stagedCommitRef: `inline-manifest-${executionNamespace.slice(0, 32)}`,
-    objects: [object],
-    completeness: {
-      terminal: true,
-      rowsComplete: true,
-      requestedGroupsComplete: true
-    },
-    controlTotals: [],
+  return {
     metricAvailability: request.coverage.constituents.flatMap(
       (constituent) => request.requestedMetrics.map((metricName) => {
         const metric = declaredMetrics.get(metricName);
@@ -415,35 +1160,34 @@ async function executeAndSeal(deliveryFetch, offering, format, request, delivery
         };
       })
     ),
-    coverage: {
-      status: "full",
-      constituents: coverageConstituents
-    },
-    observedAt,
-    dataThrough,
-    finalityEvidence: {
-      owner: "adapter",
-      basis: request.publicationClass === "PROVISIONAL_SNAPSHOT" ? "provisional_observation" : "source_declared",
-      observedAt,
-      ...request.publicationClass === "AUTHORITATIVE" ? { evidenceRef: "get_media_buy_delivery.is_final" } : {}
-    },
-    explicitZero,
-    acquiredAt,
-    ...explicitZero ? {} : { eventTimeRange: { start: request.period.start, end: dataThrough } },
-    warnings: []
-  });
-  if (Date.parse(deadlineAt) <= Date.now()) {
-    return failure("DEADLINE_EXCEEDED", "retryable", "Inline reporting execution deadline elapsed");
-  }
-  storage.objects.set(objectRef, { request: structuredClone(request), generation, bytes: Uint8Array.from(bytes) });
-  storage.totalBytes += bytes.byteLength;
-  storage.scopeBytes.set(scopeKey, (storage.scopeBytes.get(scopeKey) ?? 0) + bytes.byteLength);
-  return {
-    ok: true,
-    response: (0, import_source.completedReportingSourceResponseV1)({ request, manifest: built.reference }),
-    manifestBytes: built.manifestBytes
+    coverageConstituents: request.coverage.constituents.map((constituent) => ({
+      ...constituent,
+      status,
+      dataThrough
+    })),
+    coverageStatus: "full",
+    explicitZero
   };
 }
+function rollUpInlineConstituentStatus(statuses) {
+  if (statuses.every((status) => status === "explicit_zero")) return "explicit_zero";
+  if (statuses.every((status) => status === "present" || status === "explicit_zero")) return "present";
+  if (statuses.every((status) => status === "unsupported")) return "unsupported";
+  if (statuses.every((status) => status === "missing")) return "missing";
+  if (statuses.every((status) => ["unsupported", "delayed", "missing"].includes(status))) return "delayed";
+  if (statuses.every((status) => ["unsupported", "delayed", "stale", "missing"].includes(status))) return "stale";
+  return "partial";
+}
+function earliestDataThrough(cells) {
+  return cells.reduce((earliest, cell) => {
+    if (!cell.dataThrough) return earliest;
+    if (!earliest || Date.parse(cell.dataThrough) < Date.parse(earliest)) return cell.dataThrough;
+    return earliest;
+  }, void 0);
+}
+function availabilityCellKey(constituentId, metric) {
+  return `${constituentId}\0${metric}`;
+}
 function encodeRows(rows, mediaType, maxBytes) {
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new RangeError("Inline staging capacity exhausted");
   const chunks = [];
@@ -549,29 +1293,50 @@ async function awaitInlineExecution(entry, signal, deadlineAt) {
     if (releaseWaiter) entry.waiters -= 1;
   }
 }
-function rowMediaBuyId(row) {
-  if (typeof row !== "object" || row === null) return void 0;
-  const value = ownDataValue(row, "media_buy_id");
-  return typeof value === "string" ? value : void 0;
+function isEvidenceValue(value) {
+  return typeof value === "number" && Number.isFinite(value) || typeof value === "string" && value.length > 0 && Buffer.byteLength(value, "utf8") <= INLINE_MAX_OBJECT_BYTES_V1;
 }
-function rowHasField(row, field) {
-  return rowFieldValue(row, field) !== void 0;
+function canonicalDecimalEvidence(value) {
+  let raw;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return void 0;
+    raw = plainDecimalNumberEvidence(value);
+  } else {
+    raw = value.trim();
+  }
+  const parts = /^(-?)(\d+)(?:\.(\d+))?$/.exec(raw);
+  if (!parts) return void 0;
+  const integer = trimLeadingZeroDigits(parts[2] ?? "");
+  const fraction = trimTrailingZeroDigits(parts[3] ?? "");
+  const magnitude = fraction ? `${integer}.${fraction}` : integer;
+  return magnitude === "0" ? "0" : `${parts[1] ?? ""}${magnitude}`;
 }
-function rowFieldValue(row, field) {
-  if (typeof row !== "object" || row === null) return void 0;
-  const record = row;
-  const direct = ownDataValue(record, field);
-  if (isEvidenceValue(direct)) return direct;
-  const totals = ownDataValue(record, "totals");
-  if (typeof totals !== "object" || totals === null) return void 0;
-  const nested = ownDataValue(totals, field);
-  return isEvidenceValue(nested) ? nested : void 0;
+const ZERO_CHAR_CODE = 48;
+function trimLeadingZeroDigits(digits) {
+  let start = 0;
+  while (start + 1 < digits.length && digits.charCodeAt(start) === ZERO_CHAR_CODE) start += 1;
+  return digits.slice(start);
 }
-function isEvidenceValue(value) {
-  return typeof value === "number" && Number.isFinite(value) || typeof value === "string" && value.length > 0 && Buffer.byteLength(value, "utf8") <= INLINE_MAX_OBJECT_BYTES_V1;
+function trimTrailingZeroDigits(digits) {
+  let end = digits.length;
+  while (end > 0 && digits.charCodeAt(end - 1) === ZERO_CHAR_CODE) end -= 1;
+  return digits.slice(0, end);
+}
+function plainDecimalNumberEvidence(value) {
+  const raw = String(value);
+  const parts = /^(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(raw);
+  if (!parts) return raw;
+  const exponent = Number(parts[4]);
+  if (!Number.isInteger(exponent) || Math.abs(exponent) > INLINE_MAX_DECIMAL_EXPONENT_V1) return raw;
+  const sign = parts[1] ?? "";
+  const digits = `${parts[2] ?? ""}${parts[3] ?? ""}`;
+  const pointIndex = (parts[2] ?? "").length + exponent;
+  if (pointIndex <= 0) return `${sign}0.${"0".repeat(-pointIndex)}${digits}`;
+  if (pointIndex >= digits.length) return `${sign}${digits}${"0".repeat(pointIndex - digits.length)}`;
+  return `${sign}${digits.slice(0, pointIndex)}.${digits.slice(pointIndex)}`;
 }
-function rowHasDimension(row, dimension) {
-  return dimension === "media_buy_id" ? rowMediaBuyId(row) !== void 0 : rowHasField(row, dimension);
+function isZeroEvidenceValue(value) {
+  return typeof value === "number" ? value === 0 : /^\s*-?0+(?:\.0+)?\s*$/.test(value);
 }
 function isRows(value) {
   return Array.isArray(value);
@@ -580,41 +1345,122 @@ function ownDataValue(record, field) {
   const descriptor = Object.getOwnPropertyDescriptor(record, field);
   return descriptor && "value" in descriptor ? descriptor.value : void 0;
 }
-function rowCurrency(row) {
-  if (typeof row !== "object" || row === null) return void 0;
-  const value = ownDataValue(row, "currency");
+function ownDataClaim(record, field) {
+  const descriptor = Object.getOwnPropertyDescriptor(record, field);
+  return descriptor && "value" in descriptor && descriptor.value !== void 0 ? { claimed: true, value: descriptor.value } : { claimed: false };
+}
+function snapshotOwnDataObject(record, allowedKeys) {
+  const keys = Reflect.ownKeys(record);
+  if (keys.length > INLINE_MAX_EVIDENCE_OBJECT_KEYS_V1) {
+    throw new TypeError("Availability evidence object declares too many keys");
+  }
+  for (const key of keys) {
+    if (typeof key !== "string" || !allowedKeys.includes(key)) {
+      throw new TypeError("Availability evidence object declares an unknown key");
+    }
+  }
+  const snapshot = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    if (!descriptor || !("value" in descriptor)) throw new TypeError("Availability evidence field is not readable");
+    if (typeof descriptor.value === "string" && descriptor.value.length > INLINE_MAX_EVIDENCE_FIELD_CHARS_V1) {
+      throw new TypeError("Availability evidence field exceeds its bounded length");
+    }
+    snapshot[key] = descriptor.value;
+  }
+  return snapshot;
+}
+function createResponseFieldReader(record) {
+  const observed = /* @__PURE__ */ new Map();
+  return (field) => {
+    if (observed.has(field)) return observed.get(field);
+    const value = record?.[field];
+    observed.set(field, value);
+    return value;
+  };
+}
+function asStringOrUndefined(value) {
   return typeof value === "string" ? value : void 0;
 }
-function rowIsUnavailable(row) {
-  if (typeof row !== "object" || row === null) return false;
-  const record = row;
-  const status = ownDataValue(record, "status");
-  return typeof status === "string" && ["failed", "reporting_delayed", "not_ready", "pending", "unavailable", "error"].includes(status.toLowerCase()) || ownDataValue(record, "partial_data") === true;
-}
-function projectEvidenceRow(row, request, consumeBudget) {
-  if (typeof row !== "object" || row === null || Array.isArray(row)) throw new TypeError("Invalid row");
-  const record = row;
-  const projected = { media_buy_id: rowMediaBuyId(row) };
-  for (const dimension of request.requestedDimensions) {
-    if (dimension === "media_buy_id") continue;
-    const value = rowFieldValue(record, dimension);
-    if (!isEvidenceValue(value)) throw new TypeError("Invalid dimension evidence");
-    consumeBudget(jsonEvidenceUpperBound(value));
-    projected[dimension] = value;
+function looseCount(value) {
+  return value ?? 0;
+}
+function lengthOfUnknown(value) {
+  return value?.length;
+}
+function boundedCollectionLength(rows) {
+  if (rows === void 0) return 0;
+  const declared = rows.length;
+  return typeof declared === "number" && Number.isSafeInteger(declared) && declared >= 0 ? declared : void 0;
+}
+function captureRowCollection(rows, declaredLength) {
+  const captured = new Array(declaredLength);
+  for (let index = 0; index < declaredLength; index += 1) captured[index] = rows[index];
+  return captured;
+}
+function resolveOwnDataSlot(record, field) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = record;
+  for (let depth = 0; current !== null; depth += 1) {
+    if (depth >= INLINE_MAX_PROTOTYPE_CHAIN_DEPTH_V1 || visited.has(current)) return { kind: "unreadable" };
+    visited.add(current);
+    let descriptor;
+    let prototype = null;
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(current, field);
+      if (!descriptor) prototype = Object.getPrototypeOf(current);
+    } catch {
+      return { kind: "unreadable" };
+    }
+    if (descriptor) {
+      if (!("value" in descriptor)) return { kind: "unreadable" };
+      if (descriptor.value === void 0) return { kind: "absent" };
+      return current === record ? { kind: "data", value: descriptor.value } : { kind: "unreadable" };
+    }
+    current = prototype;
+  }
+  return { kind: "absent" };
+}
+function projectSnapshotRow(snapshot, request, consumeBudget, options) {
+  if (!snapshot) throw new TypeError("Invalid row");
+  const projected = { media_buy_id: snapshot.mediaBuyId };
+  if (options.includeDimensions) {
+    for (const dimension of request.requestedDimensions) {
+      if (dimension === "media_buy_id") continue;
+      const value = snapshotFieldValue(snapshot, dimension);
+      if (value === void 0) {
+        if (options.allowMissingDimensions) continue;
+        throw new TypeError("Invalid dimension evidence");
+      }
+      consumeBudget(jsonEvidenceUpperBound(value));
+      projected[dimension] = value;
+    }
   }
-  const totals = ownDataValue(record, "totals");
   const projectedTotals = {};
   for (const metric of request.requestedMetrics) {
-    const direct = ownDataValue(record, metric);
-    if (isEvidenceValue(direct)) {
-      consumeBudget(jsonEvidenceUpperBound(direct));
-      projected[metric] = direct;
-      continue;
+    const slot = fieldSlotOf(snapshot, metric);
+    const flags = slotFlags(snapshot, slot);
+    const directClaimed = (flags & CLAIM_DIRECT_CLAIMED_V1) !== 0;
+    const directValid = (flags & CLAIM_DIRECT_VALID_V1) !== 0;
+    const value = slotValue(snapshot, slot);
+    let directValue = false;
+    if (options.strictMetricClaims) {
+      if (directClaimed && !directValid) throw new TypeError("Invalid metric evidence");
+      if ((flags & CLAIM_NESTED_CLAIMED_V1) !== 0 && (flags & CLAIM_NESTED_VALID_V1) === 0) {
+        throw new TypeError("Invalid metric evidence");
+      }
+      if ((flags & CLAIM_DISAGREE_V1) !== 0) throw new TypeError("Contradictory metric evidence");
+      directValue = directClaimed;
+    } else {
+      directValue = directValid;
+    }
+    if (value === void 0) {
+      if (options.allowMissingMetrics) continue;
+      throw new TypeError("Invalid metric evidence");
     }
-    const total = typeof totals === "object" && totals !== null ? ownDataValue(totals, metric) : void 0;
-    if (!isEvidenceValue(total)) throw new TypeError("Invalid metric evidence");
-    consumeBudget(jsonEvidenceUpperBound(total));
-    projectedTotals[metric] = total;
+    consumeBudget(jsonEvidenceUpperBound(value));
+    if (directValue) projected[metric] = value;
+    else projectedTotals[metric] = value;
   }
   if (Object.keys(projectedTotals).length > 0) projected.totals = projectedTotals;
   return projected;
@@ -625,6 +1471,154 @@ function inlineDeliveryDates(request) {
   if (start !== request.period.sourceLocalDate) throw new RangeError("sourceLocalDate does not match period start");
   return { start, end };
 }
+function stagedObjectRef(executionKey) {
+  return `inline-${executionKey.slice(0, 32)}`;
+}
+function stagedBytesOf(storage, executionKey) {
+  return storage.objects.get(stagedObjectRef(executionKey))?.bytes.byteLength ?? 0;
+}
+function planReclaim(executions, excluded, scopeKey) {
+  for (const [key, entry] of executions) {
+    if (entry.pending || entry.waiters > 0 || entry.reservation !== void 0) continue;
+    if (scopeKey !== void 0 && entry.scopeKey !== scopeKey) continue;
+    if (excluded.includes(key)) continue;
+    return key;
+  }
+  return void 0;
+}
+function commitReclaim(executions, storage, key) {
+  const entry = executions.get(key);
+  if (!entry) return;
+  executions.delete(key);
+  const objectRef = stagedObjectRef(key);
+  const stored = storage.objects.get(objectRef);
+  if (!stored) return;
+  storage.objects.delete(objectRef);
+  storage.totalBytes -= stored.bytes.byteLength;
+  const remaining = (storage.scopeBytes.get(entry.scopeKey) ?? 0) - stored.bytes.byteLength;
+  if (remaining > 0) storage.scopeBytes.set(entry.scopeKey, remaining);
+  else storage.scopeBytes.delete(entry.scopeKey);
+}
+function createAdmissionReclaimer(executions, storage) {
+  const planned = [];
+  const token = {};
+  const owns = (key) => executions.get(key)?.reservation === token;
+  let settled = false;
+  return {
+    plan(scopeKey, scopeOnly, credit = false) {
+      const victim = planReclaim(
+        executions,
+        planned.map((entry2) => entry2.key),
+        scopeOnly ? scopeKey : void 0
+      );
+      if (victim === void 0) return void 0;
+      const entry = executions.get(victim);
+      if (entry) entry.reservation = token;
+      const sameScope = entry?.scopeKey === scopeKey;
+      const bytes = stagedBytesOf(storage, victim);
+      planned.push({
+        key: victim,
+        sameScope,
+        grantedGlobal: credit ? bytes : 0,
+        grantedScope: credit && sameScope ? bytes : 0
+      });
+      return { bytes, sameScope };
+    },
+    plannedInScope(scopeKey) {
+      return planned.filter((entry) => owns(entry.key) && executions.get(entry.key)?.scopeKey === scopeKey).length;
+    },
+    grantReservedBytes(scopeKey) {
+      let global = 0;
+      let scope = 0;
+      for (const victim of planned) {
+        if (!owns(victim.key)) {
+          victim.grantedGlobal = 0;
+          victim.grantedScope = 0;
+          continue;
+        }
+        const bytes = stagedBytesOf(storage, victim.key);
+        const sameScope = executions.get(victim.key)?.scopeKey === scopeKey;
+        victim.grantedGlobal = bytes;
+        victim.grantedScope = sameScope ? bytes : 0;
+        global += bytes;
+        if (sameScope) scope += bytes;
+      }
+      return { global, scope };
+    },
+    commit(scopeKey) {
+      if (settled) return true;
+      const owned = [];
+      const spared = [];
+      for (const victim of planned) {
+        const entry = executions.get(victim.key);
+        if (entry === void 0) {
+          spared.push(victim);
+          continue;
+        }
+        if (entry.reservation !== token || entry.pending || entry.waiters > 0) spared.push(victim);
+        else owned.push(victim.key);
+      }
+      let owedCount = 0;
+      let owedScopeCount = 0;
+      let owedGlobalBytes = 0;
+      let owedScopeBytes = 0;
+      for (const victim of spared) {
+        owedCount += 1;
+        owedGlobalBytes += victim.grantedGlobal;
+        if (victim.sameScope) {
+          owedScopeCount += 1;
+          owedScopeBytes += victim.grantedScope;
+        }
+      }
+      const excluded = planned.map((victim) => victim.key);
+      const replacements = [];
+      const bound = executions.size;
+      for (let attempt = 0; attempt < bound; attempt += 1) {
+        if (owedCount <= 0 && owedScopeCount <= 0 && owedGlobalBytes <= 0 && owedScopeBytes <= 0) break;
+        const needScope = owedScopeCount > 0 || owedScopeBytes > 0;
+        const candidate = planReclaim(executions, [...excluded, ...replacements], needScope ? scopeKey : void 0);
+        if (candidate === void 0) {
+          if (needScope) break;
+          break;
+        }
+        replacements.push(candidate);
+        const bytes = stagedBytesOf(storage, candidate);
+        owedCount -= 1;
+        owedGlobalBytes -= bytes;
+        if (executions.get(candidate)?.scopeKey === scopeKey) {
+          owedScopeCount -= 1;
+          owedScopeBytes -= bytes;
+        }
+      }
+      settled = true;
+      if (owedCount > 0 || owedScopeCount > 0 || owedGlobalBytes > 0 || owedScopeBytes > 0) {
+        for (const key of owned) {
+          const entry = executions.get(key);
+          if (entry?.reservation === token) entry.reservation = void 0;
+        }
+        planned.length = 0;
+        return false;
+      }
+      for (const key of owned) {
+        const entry = executions.get(key);
+        if (entry?.reservation === token) entry.reservation = void 0;
+        commitReclaim(executions, storage, key);
+      }
+      for (const key of replacements) commitReclaim(executions, storage, key);
+      planned.length = 0;
+      return true;
+    },
+    release() {
+      if (settled) return;
+      settled = true;
+      for (const victim of planned) {
+        const entry = executions.get(victim.key);
+        if (entry?.reservation === token) entry.reservation = void 0;
+      }
+      planned.length = 0;
+    }
+  };
+}
 function sourceLocalMidnightDate(instant, timeZone) {
   const date = new Date(instant);
   const parts = Object.fromEntries(
@@ -645,12 +1639,13 @@ function sourceLocalMidnightDate(instant, timeZone) {
   return `${parts.year}-${parts.month}-${parts.day}`;
 }
 function deliveryPeriodBoundaryMatches(actual, wireDate, instant) {
+  if (typeof actual !== "string") return false;
   return actual === wireDate || Date.parse(actual) === Date.parse(instant);
 }
 function normalizeDeliveryInstant(value, deliveryDates, period) {
   if (value === deliveryDates.start) return period.start;
   if (value === deliveryDates.end) return period.end;
-  return value;
+  return typeof value === "string" ? value : String(value);
 }
 function scheduleDeadline(deadlineAt, expire) {
   let timer;
@@ -675,7 +1670,10 @@ function jsonEvidenceUpperBound(value) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  INLINE_REPORTING_AVAILABILITY_EVIDENCE_VERSION_V1,
   InlineReportingSourceError,
   ReportingSourceNotReadyError,
-  createInlineReportingSourceExecutor
+  createInlineReportingSourceExecutor,
+  createInlineReportingSourceExecutorForTestsV1,
+  inlineStagingCapacitiesForTestsV1
 });