pi-mega-compact 0.20.18 → 0.20.20

package/src/vector-cortex/controller/_adaptive-fixture.ts

@@ -0,0 +1,230 @@
+/**
+ * controller/_adaptive-fixture.ts — VC8B conformance fixture I/O + host builders.
+ *
+ * Reads conformance fixtures from the v2 `adaptive-policy/` domain, decodes
+ * them into the REAL production types (`PolicyInput`, `M7Host`) and feeds
+ * them verbatim into `evaluatePolicy` / `evaluateShadow` / `migratePressureV2`.
+ *
+ * No mocks, no stubs, no parallel "test shape": the decoded objects ARE the
+ * production types and drive the production functions directly.
+ * Mirrors `_diagnostics-fixture.ts` (VC7C) and `_economics-fixture.ts` (VC7B).
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { PolicyInput } from "./types.js";
+import type {
+  M7Host,
+  PressureV1Row,
+  PressureV2Row,
+} from "../migrations/pressure-v2-types.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+function repoRoot(from: string): string {
+  let dir = from;
+  for (let i = 0; i < 8; i++) {
+    if (existsSync(join(dir, "conformance", "vector-cortex"))) return dir;
+    const next = dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  throw new Error("conformance corpus not found above " + from);
+}
+
+const V2 = join(repoRoot(here), "conformance", "vector-cortex", "v2");
+const DIR = join(V2, "adaptive-policy");
+
+/** Read + parse one conformance fixture by ID from adaptive-policy/. */
+export function adaptiveFixture(id: string): Record<string, unknown> {
+  const raw = readFileSync(join(DIR, `${id}.json`), "utf8");
+  return JSON.parse(raw);
+}
+
+/** Run `fn` with MEGACOMPACT_VC8B set to `value`, restoring the prior value after. */
+export function withVc8bFlag<T>(value: string, fn: () => T): T {
+  const prior = process.env.MEGACOMPACT_VC8B;
+  process.env.MEGACOMPACT_VC8B = value;
+  try {
+    return fn();
+  } finally {
+    if (prior === undefined) delete process.env.MEGACOMPACT_VC8B;
+    else process.env.MEGACOMPACT_VC8B = prior;
+  }
+}
+
+// ── Policy decision fixtures (POL-001..025 + POL-CLAMP-001) ──────────────────
+
+interface PolFxInput {
+  decisionId: string;
+  sessionId: string;
+  pressure: string;
+  requestedBudget: number;
+  bounds: { minBudget: number; maxBudget: number };
+  ts: string;
+  alternateRequestedBudget?: number;
+}
+
+interface PolFxExpected {
+  ok: boolean;
+  action?: string;
+  budget?: number;
+  pressure?: string;
+  reason?: string;
+  code?: string;
+  alternateBudget?: number;
+  alternateReason?: string;
+}
+
+export interface PolFx {
+  id: string;
+  assertion: string;
+  input: PolFxInput;
+  expected: PolFxExpected;
+}
+
+/** Read a policy-decision fixture as a typed PolFx. */
+export function polFx(id: string): PolFx {
+  return adaptiveFixture(id) as unknown as PolFx;
+}
+
+/** Decode the fixture's JSON input into the production PolicyInput. */
+export function toPolicyInput(fx: PolFx): PolicyInput {
+  return {
+    decisionId: fx.input.decisionId,
+    sessionId: fx.input.sessionId,
+    pressure: fx.input.pressure,
+    requestedBudget: fx.input.requestedBudget,
+    bounds: {
+      minBudget: fx.input.bounds.minBudget,
+      maxBudget: fx.input.bounds.maxBudget,
+    },
+    ts: fx.input.ts,
+  };
+}
+
+// ── Shadow fixtures (POL-SHADOW-002) ────────────────────────────────────────
+
+interface ShadowFxInput {
+  inputs: readonly PolFxInput[];
+  promptBytes: string;
+}
+
+interface ShadowFxExpected {
+  ok: boolean;
+  evaluated?: number;
+  clamped?: number;
+  rejected?: number;
+  liveMutations?: number;
+  promptUnchanged?: boolean;
+}
+
+export interface ShadowFx {
+  id: string;
+  assertion: string;
+  input: ShadowFxInput;
+  expected: ShadowFxExpected;
+}
+
+/** Read a policy-shadow fixture as a typed ShadowFx. */
+export function shadowFx(id: string): ShadowFx {
+  return adaptiveFixture(id) as unknown as ShadowFx;
+}
+
+/** Decode shadow input rows into production PolicyInput[]. */
+export function toShadowInputs(fx: ShadowFx): readonly PolicyInput[] {
+  return fx.input.inputs.map((i) => ({
+    decisionId: i.decisionId,
+    sessionId: i.sessionId,
+    pressure: i.pressure,
+    requestedBudget: i.requestedBudget,
+    bounds: {
+      minBudget: i.bounds.minBudget,
+      maxBudget: i.bounds.maxBudget,
+    },
+    ts: i.ts,
+  }));
+}
+
+// ── M7 pressure-v2 fixtures (M7-001..015 + M7-PRESSURE-003) ─────────────────
+
+interface M7FxInput {
+  scenario: string;
+  v1Rows: readonly {
+    sessionId: string;
+    label: string;
+    effectiveSeq: number;
+    ts: string;
+  }[];
+  injectedRow?: {
+    sessionId: string;
+    label: string;
+    effectiveSeq: number;
+    ts: string;
+  };
+  activeVersion?: number;
+}
+
+interface M7FxExpected {
+  ok: boolean;
+  codes?: string[];
+  code?: string;
+  activeVersionAfter?: number;
+  rowCount?: number;
+}
+
+export interface M7Fx {
+  id: string;
+  assertion: string;
+  input: M7FxInput;
+  expected: M7FxExpected;
+}
+
+/** Read an M7 fixture as a typed M7Fx. */
+export function m7Fx(id: string): M7Fx {
+  return adaptiveFixture(id) as unknown as M7Fx;
+}
+
+/** Build an in-memory M7Host from the fixture input. */
+export function toM7Host(
+  fx: M7Fx,
+): M7Host & { activeVersionAfter: number; readonly v2RowCount: number } {
+  const v1Rows: PressureV1Row[] = fx.input.v1Rows.map((r) => ({
+    sessionId: r.sessionId,
+    label: r.label,
+    effectiveSeq: r.effectiveSeq,
+    ts: r.ts,
+  }));
+  // For inject-after-copy, the injected row carries a non-canonical label.
+  // migratePressureV2 calls m7Copy first, which throws M7_PRESSURE_UNKNOWN for
+  // the bad label — the result is the same: ok:false, pointer on v1.
+  if (fx.input.injectedRow) {
+    v1Rows.push({
+      sessionId: fx.input.injectedRow.sessionId,
+      label: fx.input.injectedRow.label,
+      effectiveSeq: fx.input.injectedRow.effectiveSeq,
+      ts: fx.input.injectedRow.ts,
+    });
+  }
+  const v2Rows: PressureV2Row[] = [];
+  let activeVersion = fx.input.activeVersion ?? 1;
+
+  const host: M7Host & { activeVersionAfter: number; readonly v2RowCount: number } = {
+    v1Rows: () => v1Rows,
+    existingV2: () => v2Rows,
+    putV2: (rows) => v2Rows.push(...rows),
+    activeVersion: () => activeVersion,
+    switchToV2: () => {
+      activeVersion = 2;
+    },
+    get activeVersionAfter() {
+      return activeVersion;
+    },
+    get v2RowCount() {
+      return v2Rows.length;
+    },
+  };
+  return host;
+}

package/src/vector-cortex/controller/policy-emit.ts

@@ -0,0 +1,82 @@
+/**
+ * controller/policy-emit.ts — VC8B reporter seam (FLAG-GATED).
+ *
+ * Mirrors the VC8A outcomes-emit pattern: a thin `safe()` wrapper around an
+ * optional injected `emit`, and the two event names the sprint spec requires:
+ *   - `vector_cortex_shadow_decision_recorded` — a shadow decision was produced.
+ *   - `vector_cortex_policy_action_rejected`   — an input was refused by policy.
+ *
+ * FLAG SEMANTICS. The policy/shadow/M7 arithmetic STILL RUNS regardless of
+ * `MEGACOMPACT_VC8B`. The flag gates ONLY this reporting + dashboard seam:
+ * flag-off is byte-identical to the predecessor (VC8A).
+ *
+ * PAYLOAD DISCIPLINE. These events carry only ids, the finite action, the
+ * numeric budget, and machine codes — never prompt bytes, response text, or
+ * free-text.
+ *
+ * PREVENT-PI-004: no network. PREVENT-011: no `any` type.
+ */
+
+import { VC8B_ENABLED } from "../../config/vector-cortex.js";
+import type { PolicyAction, PolicyReason, PressureLevel } from "./types.js";
+
+/** The two structured events the VC8B reporter emits. */
+export type PolicyEventName =
+  | "vector_cortex_shadow_decision_recorded"
+  | "vector_cortex_policy_action_rejected";
+
+/** Optional emit fn injected by the runtime; tests pass `undefined`. */
+export type PolicyEmit = (name: string, payload: unknown) => void;
+
+/** Run `fn` only when an emit exists; a reporting failure is never fatal. */
+function safe(emit: PolicyEmit | undefined, fn: (emit: PolicyEmit) => void): void {
+  if (emit === undefined) return;
+  try {
+    fn(emit);
+  } catch {
+    // Non-fatal: a reporting failure must never break the agent loop.
+  }
+}
+
+/** Report a shadow decision that was recorded. Gated by the flag. */
+export function reportShadowDecisionRecorded(
+  emit: PolicyEmit | undefined,
+  decision: {
+    readonly decisionId: string;
+    readonly sessionId: string;
+    readonly action: PolicyAction;
+    readonly budget: number;
+    readonly pressure: PressureLevel;
+    readonly reason: PolicyReason;
+  },
+): void {
+  if (!VC8B_ENABLED()) return;
+  safe(emit, (e) =>
+    e("vector_cortex_shadow_decision_recorded", {
+      ts: undefined,
+      event: "vector_cortex_shadow_decision_recorded",
+      decisionId: decision.decisionId,
+      sessionId: decision.sessionId,
+      action: decision.action,
+      budget: decision.budget,
+      pressure: decision.pressure,
+      reason: decision.reason,
+    }),
+  );
+}
+
+/** Report a policy action rejected by validation. Gated by the flag. */
+export function reportPolicyActionRejected(
+  emit: PolicyEmit | undefined,
+  rejection: { readonly decisionId: string; readonly code: string },
+): void {
+  if (!VC8B_ENABLED()) return;
+  safe(emit, (e) =>
+    e("vector_cortex_policy_action_rejected", {
+      ts: undefined,
+      event: "vector_cortex_policy_action_rejected",
+      decisionId: rejection.decisionId,
+      code: rejection.code,
+    }),
+  );
+}

package/src/vector-cortex/migrations/pressure-v2-ops.ts

@@ -0,0 +1,204 @@
+/**
+ * pressure-v2-ops.ts — M7 migration operational logic (copy/validate/switch).
+ *
+ * Extracted from pressure-v2.ts to keep the parent file under the 300-line
+ * soft limit (soft-as-hard gate). Pure logic over an injected M7Host;
+ * deterministic + testable; no console. PREVENT-002/011/PI-004 honored.
+ *
+ * WHY THE LABEL CHECK RE-READS THE HOST AT SWITCH TIME. The sprint's failure
+ * injection is explicit: kill the process after the copy phase, insert an
+ * unknown legacy pressure row, then resume — and the resumed run must return
+ * M7_PRESSURE_UNKNOWN and KEEP THE OLD POINTER. If the switch trusted the
+ * verdict of an earlier verify call, the injected row would be invisible and
+ * the pointer would flip over a store that still holds an uncanonical label.
+ * So `m7Switch` re-reads `v1Rows`/`existingV2`/`activeVersion` and re-validates
+ * against that live state. Validation is a precondition; the switch is the only
+ * place that proves the hazard is absent *right now*.
+ */
+
+import { createHash } from "node:crypto";
+
+import { isPressureLevel } from "../controller/policy.js";
+import type {
+  M7Host,
+  M7MigrationCode,
+  M7ValidateResult,
+  PressureV1Row,
+  PressureV2Row,
+} from "./pressure-v2-types.js";
+import { M7_FAIL, PRESSURE_LEGACY_VERSION } from "./pressure-v2-types.js";
+
+/** Length-prefixed framing so the folded fields cannot alias. */
+function field(value: string): string {
+  return `${Buffer.byteLength(value, "utf8")}:${value}`;
+}
+
+/** Row identity is (session, effectiveSeq) — one pressure per sequence point. */
+const identity = (sessionId: string, effectiveSeq: number): string =>
+  `${sessionId}::${effectiveSeq}`;
+
+/** The authoritative v2 digest: SHA-256 over the length-prefixed fields. */
+export function derivePressureDigest(
+  sessionId: string,
+  level: string,
+  effectiveSeq: number,
+  ts: string,
+): string {
+  return createHash("sha256")
+    .update(
+      field("pressure-v2") +
+        field(sessionId) +
+        field(level) +
+        field(String(effectiveSeq)) +
+        field(ts),
+      "utf8",
+    )
+    .digest("hex");
+}
+
+/**
+ * Map ONE legacy row to its v2 form. ONLY the canonical five labels map;
+ * anything else throws `{ code: M7_PRESSURE_UNKNOWN }`. There is deliberately
+ * no fallback branch — a coerced label is a silently misclassified workload.
+ */
+export function mapPressureRow(v1: PressureV1Row): PressureV2Row {
+  if (!isPressureLevel(v1.label)) {
+    throw { code: M7_FAIL.PRESSURE_UNKNOWN };
+  }
+  return {
+    sessionId: v1.sessionId,
+    level: v1.label,
+    effectiveSeq: v1.effectiveSeq,
+    ts: v1.ts,
+    digest: derivePressureDigest(
+      v1.sessionId,
+      v1.label,
+      v1.effectiveSeq,
+      v1.ts,
+    ),
+  };
+}
+
+/** True when every legacy row carries a canonical label. */
+export function allLabelsCanonical(host: M7Host): boolean {
+  return host.v1Rows().every((r) => isPressureLevel(r.label));
+}
+
+/**
+ * COPY: resumable per (session, effectiveSeq). An interrupted run resumes
+ * without duplicate rows. An uncanonical label aborts the copy with
+ * M7_PRESSURE_UNKNOWN before anything is written.
+ */
+export function m7Copy(host: M7Host): {
+  readonly written: readonly PressureV2Row[];
+  readonly all: readonly PressureV2Row[];
+} {
+  const existing = new Map(
+    host.existingV2().map((r) => [identity(r.sessionId, r.effectiveSeq), r]),
+  );
+  const wanted: PressureV2Row[] = [];
+  for (const v1 of host.v1Rows()) {
+    // Throws M7_PRESSURE_UNKNOWN for a non-canonical label.
+    const fresh = mapPressureRow(v1);
+    const stored = existing.get(identity(v1.sessionId, v1.effectiveSeq));
+    if (stored !== undefined && stored.digest === fresh.digest) continue;
+    wanted.push(fresh);
+  }
+  if (wanted.length > 0) host.putV2(wanted);
+  return { written: wanted, all: [...host.existingV2()] };
+}
+
+function dedupe(codes: readonly M7MigrationCode[]): M7MigrationCode[] {
+  const out: M7MigrationCode[] = [];
+  for (const c of codes) if (!out.includes(c)) out.push(c);
+  return out;
+}
+
+/**
+ * VALIDATE: compare counts and digests between v1 and v2, and re-check every
+ * legacy label. Returns codes rather than throwing so a caller sees every
+ * problem at once.
+ */
+export function m7Verify(host: M7Host): M7ValidateResult {
+  const codes: M7MigrationCode[] = [];
+  const v1Rows = host.v1Rows();
+  const stored = host.existingV2();
+
+  // Label check first: an uncanonical legacy label invalidates the whole run.
+  for (const v1 of v1Rows) {
+    if (!isPressureLevel(v1.label)) codes.push(M7_FAIL.PRESSURE_UNKNOWN);
+  }
+
+  const counts = new Map<string, number>();
+  for (const r of stored) {
+    const id = identity(r.sessionId, r.effectiveSeq);
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+
+  const expected = new Set<string>();
+  for (const v1 of v1Rows) {
+    if (!isPressureLevel(v1.label)) continue;
+    const id = identity(v1.sessionId, v1.effectiveSeq);
+    expected.add(id);
+    const n = counts.get(id) ?? 0;
+    if (n === 0) codes.push(M7_FAIL.COPY_PARTIAL);
+    if (n > 1) codes.push(M7_FAIL.COUNT_MISMATCH);
+  }
+
+  // Every stored row must re-derive its own digest and correspond to a v1 row.
+  for (const r of stored) {
+    const fresh = derivePressureDigest(
+      r.sessionId,
+      r.level,
+      r.effectiveSeq,
+      r.ts,
+    );
+    if (r.digest !== fresh) codes.push(M7_FAIL.DIGEST_MISMATCH);
+    if (!expected.has(identity(r.sessionId, r.effectiveSeq))) {
+      codes.push(M7_FAIL.COUNT_MISMATCH);
+    }
+  }
+
+  return { ok: codes.length === 0, codes: dedupe(codes) };
+}
+
+/**
+ * SWITCH: atomically flip the active pointer to v2 — but ONLY after
+ * re-validating against freshly-read host state (see the module note on the
+ * post-copy failure injection). The pointer is left untouched on any failure.
+ */
+export function m7Switch(host: M7Host): M7ValidateResult {
+  if (host.activeVersion() !== PRESSURE_LEGACY_VERSION) {
+    return { ok: false, codes: [M7_FAIL.NOT_ON_LEGACY] };
+  }
+  // Re-read the live rows: an unknown label injected after the copy is caught
+  // here, and the old pointer survives.
+  if (!allLabelsCanonical(host)) {
+    return { ok: false, codes: [M7_FAIL.PRESSURE_UNKNOWN] };
+  }
+  const verify = m7Verify(host);
+  if (!verify.ok) return verify;
+  host.switchToV2();
+  return { ok: true, codes: [] };
+}
+
+/**
+ * Full M7 migration: copy, then validate + switch. An uncanonical label thrown
+ * during the copy is converted to a result code so the caller sees the same
+ * shape as a validation failure, and the pointer is left on legacy.
+ */
+export function migratePressureV2(host: M7Host): M7ValidateResult {
+  try {
+    m7Copy(host);
+  } catch (err) {
+    const code =
+      typeof err === "object" && err !== null && "code" in err
+        ? (err as { code: unknown }).code
+        : undefined;
+    if (code === M7_FAIL.PRESSURE_UNKNOWN) {
+      return { ok: false, codes: [M7_FAIL.PRESSURE_UNKNOWN] };
+    }
+    throw err;
+  }
+  return m7Switch(host);
+}

package/src/vector-cortex/migrations/pressure-v2-types.ts

@@ -0,0 +1,83 @@
+/**
+ * pressure-v2-types.ts — M7 pressure-v2 migration types.
+ *
+ * Extracted from pressure-v2.ts to keep the parent file under the 300-line
+ * soft limit (soft-as-hard gate). Pure type + constant definitions; no logic.
+ * PREVENT-002/011/PI-004 honored.
+ */
+
+/** The active-version value the v2 pointer is switched to. */
+export const PRESSURE_V2_VERSION = 2;
+/** The legacy (predecessor) active version. */
+export const PRESSURE_LEGACY_VERSION = 1;
+
+/** M7 failure codes. */
+export const M7_FAIL = {
+  /** A legacy row carries a label outside the canonical five levels. */
+  PRESSURE_UNKNOWN: "M7_PRESSURE_UNKNOWN",
+  /** Copied row count does not match the legacy row count. */
+  COUNT_MISMATCH: "M7_COUNT_MISMATCH",
+  /** A v2 row digest does not re-derive from its own declared fields. */
+  DIGEST_MISMATCH: "M7_DIGEST_MISMATCH",
+  /** A legacy row has no corresponding v2 row (interrupted copy). */
+  COPY_PARTIAL: "M7_COPY_PARTIAL",
+  /** The active pointer is not on v1; switching would regress or no-op. */
+  NOT_ON_LEGACY: "M7_NOT_ON_LEGACY",
+} as const;
+export type M7MigrationCode = (typeof M7_FAIL)[keyof typeof M7_FAIL];
+
+/**
+ * Registered M7 conformance IDs (M7-001..015). The acceptance test reads these
+ * rows from the v2 `adaptive-policy/` domain and asserts each returns its
+ * manifest bytes or exactly its listed failure code. Mirrors M5_IDS / M6_IDS.
+ */
+export const M7_IDS: readonly string[] = Array.from(
+  { length: 15 },
+  (_v, i) => `M7-${String(i + 1).padStart(3, "0")}`,
+);
+
+/** Named M7 rows surfaced by the conformance corpus. */
+export const M7_NAMED_IDS = ["M7-PRESSURE-003"] as const;
+
+/**
+ * A predecessor (v1) pressure row. `label` is UNTRUSTED: the whole point of
+ * the migration is that a legacy store may hold labels outside the canonical
+ * five, and those must reject rather than be coerced.
+ */
+export interface PressureV1Row {
+  readonly sessionId: string;
+  readonly label: string;
+  readonly effectiveSeq: number;
+  readonly ts: string;
+}
+
+/** A v2 pressure row: canonical level + a digest over its own fields. */
+export interface PressureV2Row {
+  readonly sessionId: string;
+  /** One of the canonical five levels — validated, never coerced. */
+  readonly level: string;
+  readonly effectiveSeq: number;
+  readonly ts: string;
+  /** SHA-256 over the length-prefixed canonical fields. */
+  readonly digest: string;
+}
+
+/** The host the migration reads from / writes to (capability-shaped). */
+export interface M7Host {
+  /** Every predecessor row being migrated. */
+  readonly v1Rows: () => readonly PressureV1Row[];
+  /** Persisted v2 rows already written (for resume). */
+  readonly existingV2: () => readonly PressureV2Row[];
+  /** Idempotent write of v2 rows (never mutates v1 rows). */
+  readonly putV2: (rows: readonly PressureV2Row[]) => void;
+  /** The currently ACTIVE version (1 = legacy; only v1 -> v2 switching). */
+  readonly activeVersion: () => number;
+  /** Atomically flip the active pointer to v2. */
+  readonly switchToV2: () => void;
+}
+
+/** An M7 validation result. */
+export interface M7ValidateResult {
+  readonly ok: boolean;
+  readonly codes: readonly M7MigrationCode[];
+}

package/src/vector-cortex/migrations/pressure-v2.ts

@@ -0,0 +1,59 @@
+/**
+ * vector-cortex/migrations/pressure-v2.ts — M7 pressure-v2 migration
+ * (COPY + VALIDATE + SWITCH).
+ *
+ * Delegate-shell: types + constants live in pressure-v2-types.ts and the
+ * operational logic (copy/verify/switch/label mapping) lives in
+ * pressure-v2-ops.ts. This file re-exports the public surface so callers import
+ * from a single module. Split to keep under the 300-line soft limit
+ * (soft-as-hard gate).
+ *
+ * M7 canonicalizes the context-pressure label. The predecessor stored whatever
+ * label a producer happened to write; v2 admits EXACTLY five — `low`, `medium`,
+ * `high`, `ultra`, `mega` — and rejects everything else as
+ * `M7_PRESSURE_UNKNOWN`. The rejection is the feature: coercing an unrecognized
+ * legacy label onto the nearest level would silently reclassify a workload, and
+ * the direction of that error is unknowable from the label alone.
+ *
+ * Like M4/M5/M6 it follows the copy/validate/switch contract:
+ *
+ *   - copy:     resumable per (session, effectiveSeq) — an interrupted run
+ *               resumes without duplicate rows or active-pointer drift.
+ *   - validate: every v1 row has exactly one v2 row, every v2 digest re-derives
+ *               from its own declared fields, and every legacy label is
+ *               canonical.
+ *   - switch:   ATOMICALLY flip the active pointer via `host.switchToV2()`, but
+ *               only after RE-READING host state and re-validating. The sprint's
+ *               failure injection kills the process after the copy and then
+ *               inserts an unknown legacy pressure; the resumed run must return
+ *               `M7_PRESSURE_UNKNOWN` and KEEP THE OLD POINTER. A migration that
+ *               trusts a stale verification is a migration that corrupts on
+ *               restart.
+ *
+ * PREVENT-002/011/PI-004 honored.
+ */
+
+export {
+  PRESSURE_V2_VERSION,
+  PRESSURE_LEGACY_VERSION,
+  M7_FAIL,
+  M7_IDS,
+  M7_NAMED_IDS,
+} from "./pressure-v2-types.js";
+export type {
+  M7MigrationCode,
+  PressureV1Row,
+  PressureV2Row,
+  M7Host,
+  M7ValidateResult,
+} from "./pressure-v2-types.js";
+
+export {
+  derivePressureDigest,
+  mapPressureRow,
+  allLabelsCanonical,
+  m7Copy,
+  m7Verify,
+  m7Switch,
+  migratePressureV2,
+} from "./pressure-v2-ops.js";