@snoai/memory 0.0.0-stage → 1.0.0

package/dist/index-BsMap4It.d.ts

@@ -0,0 +1,650 @@
+import { c as RemConfig, d as RemEnableGateArtifact, g as RemOperationType, o as RemBuiltOperationType, u as RemDatabaseLike } from "./types-pVomjzqR.js";
+import { g as JournalEntry } from "./classifier-C96uH9OF.js";
+//#region src/engine/rem/adapter-a-conflict-adjudicator.d.ts
+type AdapterAVerdict = "replacement" | "keep" | "uncertain";
+interface AdapterAMemoryView {
+  text: string;
+  subject?: string | null;
+  kind: "profile" | "episodic" | "state";
+  validFrom: string;
+  assertedAt: string;
+  contentHash: string;
+}
+interface AdapterAMemoryRecord {
+  text: string;
+  subject?: string | null;
+  kind: string;
+  validFrom: number;
+  assertedAt: number;
+  contentHash: string;
+}
+interface OrderedAdapterAPair {
+  older: AdapterAMemoryView;
+  newer: AdapterAMemoryView;
+  candidateRole: "older" | "newer";
+}
+declare function adapterAViewFromRecord(record: AdapterAMemoryRecord): AdapterAMemoryView;
+declare function prospectiveProfileView(text: string, at: number): AdapterAMemoryView;
+declare function orderAdapterAPair(existing: AdapterAMemoryView, candidate: AdapterAMemoryView): OrderedAdapterAPair;
+declare function renderAdapterAPrompt(older: AdapterAMemoryView, newer: AdapterAMemoryView): string;
+declare function renderAdapterAChatPrompt(pair: Pick<OrderedAdapterAPair, "older" | "newer">): string;
+declare function parseAdapterAChatVerdict(raw: string): AdapterAVerdict;
+/**
+ * Whether a reply is a verdict at all: a bare verdict token, or a JSON object carrying one, read
+ * the way `parseAdapterAChatVerdict` reads it (a fenced object counts).
+ */
+declare function isAdapterAVerdictReply(value: string): boolean;
+declare function extractJsonFromResponse(text: string): string | null;
+//#endregion
+//#region src/engine/rem/operational-config.d.ts
+interface RemOperationalConfiguration {
+  profileId: string;
+  operations: {
+    "rem-update": boolean;
+    "rem-replace": boolean;
+    "rem-distill": boolean;
+    "rem-retire": boolean;
+  };
+  budgets: {
+    maxPairs: number;
+  };
+  retrieval: {
+    neighborLimit: number;
+    similarityThreshold: number;
+  };
+  coverage: {
+    accuracyFloor: number | null;
+  };
+  retries: {
+    liveContentionRetries: number;
+  };
+  facetPolicy: {
+    aggregationGrammar: string;
+    historyGrammar: string;
+  };
+  calibration: {
+    minimumPublishableScoreEffect: number | null;
+    minimumTargetCount: number | null;
+    minimumTargetPercent: number | null;
+  };
+  enableGateDigests: {
+    "p5-production-config": string;
+    "p6-monthly-non-regression": string;
+    "p7-detector-gate-verdict": string;
+    "population-routing": string;
+    "rem-update": string;
+    "rem-replace": string;
+    "p5-immutable-profile"?: string | undefined;
+  };
+}
+type RemConfigurationDecision = {
+  decision: "allow";
+  reasonCode: null;
+} | {
+  decision: "refuse";
+  reasonCode: string;
+};
+declare function parseRemOperationalConfiguration(input: unknown): RemOperationalConfiguration;
+declare function canonicalizeRemConfiguration(input: RemOperationalConfiguration): string;
+declare function deriveRemConfigurationSha256(input: RemOperationalConfiguration): string;
+declare function validateRemEnableGateDigestKeys(input: {
+  configuration: RemOperationalConfiguration;
+  p5ReadbackSource: "wrapper" | "immutable-profile";
+}): RemConfigurationDecision;
+declare function requireRemCoverageAccuracyFloor(input: {
+  configuration: RemOperationalConfiguration;
+}): RemConfigurationDecision;
+declare function requireRemOwnerDecisions(input: {
+  configuration: RemOperationalConfiguration;
+}): RemConfigurationDecision;
+declare function declareRemCalibrationThreshold(input: {
+  configuration: RemOperationalConfiguration;
+  derivationStatement?: string;
+}): RemConfigurationDecision;
+declare function validateRemGrammarChange(input: {
+  beforeConfigurationSha256: string;
+  before: RemOperationalConfiguration;
+  beforeCorpusSha256: string;
+  afterConfigurationSha256: string;
+  after: RemOperationalConfiguration;
+  abArtifact?: {
+    beforeConfigurationSha256: string;
+    afterConfigurationSha256: string;
+    corpusSha256: string;
+    metricDefinitions: readonly string[];
+    result: "pass" | "fail";
+  };
+}): RemConfigurationDecision;
+//#endregion
+//#region src/engine/rem/census.d.ts
+type Decision = {
+  decision: "allow";
+  reasonCode: null;
+} | {
+  decision: "refuse";
+  reasonCode: string;
+};
+declare function validateRemProspectiveIdentity(input: {
+  writeIdentitySha256: string;
+  candidateSetSha256: string;
+}): Decision;
+declare function deriveRemWriteIdentity(input: {
+  rowId: string;
+  text: string;
+  contentHash: string;
+  timestamp: number;
+}): string;
+declare function deriveRemReplayArtifactIdentity(input: {
+  corpusPath: string;
+  embedderPath: string;
+  toolPath: string;
+  configuration: RemOperationalConfiguration;
+  callerLabel?: string;
+}): {
+  replayIdentitySha256: string;
+  corpusSha256: string;
+  embedderSha256: string;
+  toolSha256: string;
+  configurationSha256: string;
+};
+declare function validateRemReplayIdentityTuple(input: {
+  corpusSha256: string;
+  embedderSha256: string;
+  configurationSha256: string;
+}): Decision;
+declare function classifyRemCensusLabel(input: {
+  label: string;
+  observations: Record<string, unknown>;
+}): string;
+declare function classifyAllRemCensusLabels(input: {
+  reachability: Record<string, unknown>;
+  contradiction: Record<string, unknown>;
+  coverageEligibility: Record<string, unknown>;
+}): Record<string, string>;
+declare function validateRemCensusOracleProvenance(input: {
+  authoredBy?: string;
+}): Decision;
+declare function validateRemCensusLabelTuple(input: {
+  reachability: string;
+  contradiction: string;
+  coverageEligibility: string;
+}): Decision;
+declare function readRetainedRemCensusArtifact(input: {
+  artifactPath: string;
+  generationId: string;
+}): Decision & {
+  artifactSha256?: string;
+};
+declare function produceRemCensusArtifact(input: {
+  producer: string;
+  outputPath: string;
+}): void;
+declare function validateRemCensusRouteCoverage(input: readonly {
+  route: string;
+}[]): Decision;
+declare function journalRemGenerationTransition(input: {
+  database: RemDatabaseLike;
+  outgoingGenerationId: string;
+  incomingGenerationId: string;
+}): Decision;
+interface BatchEvent {
+  calls?: number;
+  tokens?: number;
+  verdict?: string;
+  close?: number;
+  refusal?: string | null;
+}
+declare function summarizeRemBatchEvents(input: {
+  database: RemDatabaseLike;
+  batchId: string;
+  generationId?: string;
+  events: readonly BatchEvent[];
+}): void;
+declare function recordRemObservedVerdict(input: {
+  database: RemDatabaseLike;
+  pairId: string;
+  observed: string;
+}): void;
+declare function recordRemCandidateCapCounts(input: {
+  database: RemDatabaseLike;
+  generationId: string;
+  total: number;
+  cap: number;
+}): void;
+declare function reportRemSimilarityCalibration(input: {
+  retainedArtifactPath: string;
+  emittedPairIds: readonly string[];
+  targetPairIds: readonly string[];
+  rankedPairIds: readonly string[];
+  modelCallBudget: number;
+}): Record<string, unknown>;
+declare function validateRemCalibrationCrossCheck(input: {
+  independent: unknown;
+}): Decision;
+//#endregion
+//#region src/engine/rem/update-locale-resources.d.ts
+declare const REM_UPDATE_LOCALES: readonly ["en", "de", "es", "fr", "zh", "zh-Hant", "ja", "ko", "ru"];
+type RemUpdateLocale = (typeof REM_UPDATE_LOCALES)[number];
+interface RemUpdateLocaleResource {
+  valuePrefix: string;
+  listPrefix: string;
+  listSeparator: string;
+  spanSeparator: string;
+  anchorMode: "capitalized-sequence" | "explicit-script";
+}
+declare function getRemUpdateLocaleResource(locale: RemUpdateLocale): RemUpdateLocaleResource;
+//#endregion
+//#region src/engine/rem/update-rewrite.d.ts
+type RemUpdateTier = "list" | "prose";
+interface RemUpdateSpan {
+  start: number;
+  end: number;
+}
+interface RemUpdateReferenceUnit extends RemUpdateSpan {
+  id: string;
+  atomId: string;
+  kind: "clause" | "anchor" | "structured-member" | "structured-field";
+  value: string;
+  text: string;
+  sourceTextSha256: string;
+  startByte: number;
+  endByte: number;
+}
+declare function composeRemNegatedCurrent(input: {
+  topic: string;
+  priorRowId: string;
+  retractionText: string;
+}): {
+  shape: "negated-current";
+  topic: string;
+  assertions: Array<{
+    polarity: "negative";
+    provenance: string;
+  }>;
+  generatedRowId: string;
+  consumedRowIds: string[];
+};
+declare function enumerateRemUpdateMembers(source: string): string[];
+declare function buildRemUpdateReferenceSet(input: {
+  source: string;
+  tier: RemUpdateTier;
+  locale: RemUpdateLocale;
+  enumeratedMembers?: readonly string[];
+}): RemUpdateReferenceUnit[];
+//#endregion
+//#region src/engine/rem/coverage-contract.d.ts
+type RemCoverageAtom = Pick<RemUpdateReferenceUnit, "atomId" | "kind" | "sourceTextSha256" | "startByte" | "endByte" | "text">;
+type RemCoverageBuildResult = {
+  outcome: "accept";
+  atoms: RemCoverageAtom[];
+} | {
+  outcome: "refuse";
+  reason: "empty_reference_set" | "unsegmentable_reference_set";
+};
+declare function buildRemCoverageAtoms(input: {
+  source: string;
+  format: "structured" | "prose" | "flattened-clauses";
+}): RemCoverageBuildResult;
+interface RemClauseCoverageGateResult {
+  decision: "allow" | "refuse";
+  reason: string | null;
+  arms: Record<string, "pass" | "fail" | "owner-unset">;
+}
+declare function validateRemClauseCoverageArtifacts(input: {
+  accuracyFloor: number | null;
+  measuredAccuracy: number | null;
+  expectedGoldSetSha256: string;
+  measuredGoldSetSha256: string;
+  confidenceSatisfied: boolean;
+  declarationSequence: number;
+  firstScoredSequence: number;
+  measurementPresent: boolean;
+  artifactDigestMatches: boolean;
+}): Promise<RemClauseCoverageGateResult>;
+//#endregion
+//#region src/engine/rem/clause-splitter.d.ts
+interface RemExactClause {
+  value: string;
+  start: number;
+  end: number;
+  separatorAfter: string;
+}
+/**
+ * Produces the fixed, lossless clause list used by REM judgments. The text itself
+ * remains the authority: clause values are exact source slices and separators are retained.
+ */
+declare function splitExactClauses(text: string): RemExactClause[];
+//#endregion
+//#region src/engine/rem/enable-gate.d.ts
+declare class RemEnableGateError extends Error {
+  readonly code: string;
+  constructor(code: string);
+}
+interface LoadRemEnableGateInput {
+  stateDir: string;
+  jobType: RemBuiltOperationType;
+  implementationVersion: string;
+  corpusSha256: string;
+  baselineSha256: string;
+  artifactSha256: string;
+  now: string;
+}
+declare const REM_ENABLE_GATE_BINDINGS: {
+  readonly implementationVersion: "edge-rem-wave-20260806";
+  readonly corpusSha256: "67d1acbe4451cccc0199a9b670b2b8df17b79ba7c3d6d431b4e0e303d73869e2";
+  readonly baselineSha256: "87413c08883fddc81d479fe6dcb9d7a537ee156d2fb73716ab0603860caa64c1";
+};
+declare function loadRemEnableGate(input: LoadRemEnableGateInput): RemEnableGateArtifact;
+//#endregion
+//#region src/engine/rem/entry-governance.d.ts
+type RemEntryDecision = {
+  decision: "allow";
+  reasonCode: null;
+} | {
+  decision: "refuse";
+  reasonCode: string;
+};
+declare function recordNonRefusePairDecision(input: {
+  database: RemDatabaseLike;
+  attemptIdentity: string;
+  waveId: string;
+  operation: "rem-replace" | "rem-update";
+  decision: "allow" | "refuse";
+  source: "arbitration" | "coverage";
+  reason: string | null;
+  throughRefusePair: boolean;
+}): Promise<void>;
+declare function validateRemSubstantiveWaveEffects(input: {
+  database: RemDatabaseLike;
+  waveId: string;
+}): RemEntryDecision;
+declare function defineRemSafetyGuard<TInput, TResult>(_metadata: {
+  guardId: string;
+}, guard: (input: TInput) => TResult): (input: TInput) => TResult;
+declare function validateRemGuardCensus(input: {
+  manifestPath: string;
+  requiredGuardsPath: string;
+  sourceRoots: readonly string[];
+  productionRoots: readonly string[];
+}): RemEntryDecision;
+//#endregion
+//#region src/engine/rem/facet-policy.d.ts
+/**
+ * The facet a row carries — whether it is the current value or one that has been superseded.
+ *
+ * There is deliberately NO function here that reads the user's question and picks one. Whether a
+ * question needs a retired value is a question of meaning, and this repo's law is that keyword
+ * rules filter while models score. `resolveRemFacetPolicy` used to answer it from three regexes:
+ * measured 2026-08-19, that sent 372 of 540 real benchmark questions down the current-only path,
+ * and 6 of 8 plausible "what did I used to..." probes had their history hidden because only the
+ * literal phrase "used to" was listed. The option survives on `SearchOptions` for a caller that
+ * knows what it wants; nothing derives it from query text.
+ */
+type RemFacetPolicy = "current-only" | "include-history";
+//#endregion
+//#region src/engine/rem/facet-persistence.d.ts
+interface RemCurrentFacetChunk {
+  chunkId: string;
+  chunkIndex: number;
+  chunkText: string;
+  densePayload: string;
+  summary?: string | undefined;
+  startOffset: number;
+  endOffset: number;
+  tokenCount: number;
+  contentType: "conversation" | "prose" | "structured";
+  chunkingVersion: string;
+  embedderProvider: string;
+  embedderModel: string;
+  embedderDim: number;
+  vectorBytes: Uint8Array;
+}
+declare function writeRemTwoFacetTransaction(input: {
+  database: RemDatabaseLike;
+  memoryId: string;
+  current: string;
+  history: string;
+  currentChunks: readonly RemCurrentFacetChunk[];
+  timestamp?: string;
+  metadata?: string;
+  contentHash?: string;
+  reason?: string;
+  jobId: string;
+  jobType: RemOperationType;
+  /**
+   * The verified-write attempt this transaction belongs to. Supplied by the mutation executor,
+   * never by a caller, exactly as `jobId` and `jobType` are. The post-write content hash is
+   * stamped onto that attempt row INSIDE this transaction so a crash between commit and the
+   * attempt being closed still leaves the two agreeing; recovery then reads the stamp instead of
+   * comparing a text hash against a content hash, which can never match once REM update metadata
+   * is written.
+   */
+  attemptId?: string;
+}): Promise<{
+  contentHash: string;
+  recoveryHandle: string;
+}>;
+//#endregion
+//#region src/engine/rem/replace-clause-verdict.d.ts
+type ReplaceClauseVerdict = "replacement" | "keep" | "uncertain";
+interface ReplaceEligibleClause {
+  origin: "older" | "newer";
+  value: string;
+  start: number;
+  end: number;
+  separatorAfter: string;
+}
+interface UsableReplaceClauseVerdict {
+  parseState: "valid" | "invalid";
+  verdict: ReplaceClauseVerdict;
+  retiringClauseIndices: number[];
+}
+type ReplaceArbitration = {
+  outcome: "proceed";
+  retiringClauseIndices: number[];
+} | {
+  outcome: "no-action";
+} | {
+  outcome: "refused";
+  reason: "clause_keep" | "clause_parse_failed" | "clause_uncertain" | "empty_retiring_set";
+};
+declare function buildReplaceEligibleClauses(older: string, newer: string): ReplaceEligibleClause[];
+declare function renderReplaceClauseVerdictPrompt(clauses: readonly ReplaceEligibleClause[]): string;
+declare function parseReplaceClauseVerdict(response: unknown, clauses: readonly ReplaceEligibleClause[]): UsableReplaceClauseVerdict;
+declare function arbitrateReplaceVerdicts(pairVerdict: ReplaceClauseVerdict, clauseVerdict: UsableReplaceClauseVerdict): ReplaceArbitration;
+//#endregion
+//#region src/engine/rem/replace-coverage.d.ts
+type ReplaceCoverageClass = "current-fact" | "retired-fact" | "event-fact";
+type ReplaceCoverageStatus = "covered" | "uncovered" | "undetermined";
+interface ReplaceCoverageAtom {
+  clauseIndex: number;
+  class: ReplaceCoverageClass;
+  status: ReplaceCoverageStatus;
+}
+interface ReplaceCoverageObservation {
+  code: string;
+  detail?: string;
+}
+type ReplaceCoverageDecision = {
+  decision: "allow";
+  atoms: ReplaceCoverageAtom[];
+  observations?: ReplaceCoverageObservation[];
+  uncertifiedClauses?: string[];
+} | {
+  decision: "refuse";
+  reason: string;
+  detail?: string;
+  atoms: ReplaceCoverageAtom[];
+  observations?: ReplaceCoverageObservation[];
+};
+/** Why the surviving row would stop answering a counting question once the close lands. */
+type RemReplaceCarrierFault = "carrier_missing" | "carrier_inactive" | "carrier_superseded" | "carrier_not_on_current_facet" | "carrier_out_of_aggregation_scope";
+type RemReplaceCarrierState = {
+  retained: true;
+} | {
+  retained: false;
+  fault: RemReplaceCarrierFault;
+};
+/**
+ * 40-rem-replace-prd.md:566 defines retrievable as "still returned by the paths that ANSWER a
+ * counting question" AFTER the close. Whether the surviving row still carries the event is
+ * already decided upstream, by the coverage model that is shown both texts and whose per-atom
+ * `status` this file gates on. What only the store knows is whether that carrier itself is still
+ * on the aggregation path once this close lands — a row already parked, already closed by an
+ * earlier pair in the same batch, demoted to the history facet, or filtered out by the
+ * aggregation query's own scope and category predicates.
+ */
+interface RemReplaceCarrierPort {
+  carrierState(): Promise<RemReplaceCarrierState>;
+}
+declare function renderReplaceCoveragePrompt(input: {
+  older: string;
+  newer: string;
+  retiringClauseIndices: readonly number[];
+}): string;
+declare function parseReplaceCoverageAtoms(value: unknown): ReplaceCoverageAtom[] | undefined;
+declare function decideReplaceCoverage(input: {
+  older: string;
+  newer: string;
+  retiringClauseIndices: readonly number[];
+  atoms: readonly ReplaceCoverageAtom[];
+  carrier?: RemReplaceCarrierPort;
+  rawCandidateEvidence?: string;
+}): ReplaceCoverageDecision | Promise<ReplaceCoverageDecision>;
+//#endregion
+//#region src/engine/rem/row-hash.d.ts
+/**
+ * The one definition of a REM whole-row hash.
+ *
+ * A recovery record stores `expected_post_hash` before the write; the verified-write guard
+ * recomputes it after the write and refuses the mutation when the two disagree. Those two
+ * computations lived in different packages and drifted: this package hashed `SELECT *` while
+ * `rem-sqlite-adapter` hashed a projected row, so adding the `timezone` column to the projection
+ * made every text-version write refuse AFTER its transaction had already committed. One function,
+ * imported by both sides, is what stops that happening again.
+ *
+ * `REM_ROW_HASH_FIELDS` IS the hash — reordering it, adding to it, or removing from it changes
+ * every value this function produces. That is why it is versioned rather than edited in place.
+ */
+declare const REM_ROW_HASH_FIELDS: readonly ["id", "text", "category", "project_id", "importance", "timestamp", "timezone", "metadata", "content_hash", "fact_id", "derived_from", "consolidation_epoch_id", "confidence_source", "lane", "raw_candidate_json", "disposition_reason", "dispositioned_at_ms"];
+/**
+ * Stamped on every recovery record this build writes. Version 1 means "written before the field
+ * list was pinned", and a version-1 hash cannot be reproduced — the two producers of that era
+ * covered different columns. Readers must branch on the stored version rather than assume.
+ */
+declare const REM_ROW_HASH_VERSION = 2;
+/** Version 1 records predate the pinned field list and carry a hash nothing can recompute. */
+declare const REM_ROW_HASH_VERSION_LEGACY = 1;
+declare function hashRemMemoryRow(row: Record<string, unknown>): string;
+//#endregion
+//#region src/engine/rem/rem-update-judgment.d.ts
+type RemUpdateJudgmentRefusalReason = "model_response_invalid" | "no_retired_fact" | "no_surviving_remainder";
+type RemUpdateJudgmentDecision = {
+  outcome: "verify";
+  proposedCurrent: string;
+  retiredValues: string[];
+} | {
+  outcome: "refuse";
+  reason: RemUpdateJudgmentRefusalReason;
+};
+type RemUpdateVerificationDecision = {
+  outcome: "apply";
+} | {
+  outcome: "refuse";
+  reason: "model_response_invalid" | "proposal_not_faithful" | "retired_value_survives" | "surviving_fact_lost";
+};
+type RemClauseCarryDecision = {
+  outcome: "decided";
+  alreadyCurrent: boolean[];
+} | {
+  outcome: "refuse";
+  reason: "model_response_invalid";
+};
+declare function renderRemUpdateJudgmentPrompt(input: {
+  judgmentSkill: string;
+  source: string;
+  enumeratedMembers?: readonly string[];
+  supersedingText?: string;
+}): string;
+declare function renderRemUpdateRelationJudgmentPrompt(input: {
+  judgmentSkill: string;
+  rowText: string;
+  predecessorTexts: readonly string[];
+  successorTexts: readonly string[];
+}): string;
+declare function renderRemRetirementTargetPrompt(input: {
+  judgmentSkill: string;
+  nominatedRow: {
+    id: string;
+    text: string;
+  };
+  candidateRows: ReadonlyArray<{
+    id: string;
+    text: string;
+  }>;
+}): string;
+declare function renderRemUpdateVerificationPrompt(input: {
+  judgmentSkill: string;
+  source: string;
+  proposedCurrent: string;
+  retiredValues: readonly string[];
+  retractionText?: string;
+  supersedingText?: string;
+}): string;
+declare function renderRemClauseCarryPrompt(input: {
+  judgmentSkill: string;
+  survivorText: string;
+  clauses: readonly string[];
+}): string;
+declare function decideRemUpdateRelationFromReply(reply: string): {
+  outcome: "allow";
+  supersedesEverything: boolean;
+} | {
+  outcome: "refuse";
+  reason: "no_retired_fact" | "model_response_invalid";
+};
+declare function decideRemRetirementTargetFromReply(reply: string, offeredRowIds: ReadonlySet<string>): {
+  outcome: "allow";
+  targetRowIds: string[];
+} | {
+  outcome: "refuse";
+  reason: "model_response_invalid" | "row_id_not_offered";
+};
+declare function decideRemUpdateFromReply(reply: string): RemUpdateJudgmentDecision;
+declare function decideRemUpdateVerification(reply: string): RemUpdateVerificationDecision;
+declare function decideRemClauseCarry(reply: string, clauseCount: number): RemClauseCarryDecision;
+//#endregion
+//#region src/engine/rem/runner.d.ts
+interface RemJournalWriter {
+  appendJournal(jobId: string, jobType: RemOperationType, entry: JournalEntry): void | Promise<void>;
+}
+interface RemStage {
+  name: string;
+  run(): Promise<Partial<JournalEntry>> | Partial<JournalEntry>;
+}
+declare function runRemStages(input: {
+  repository: RemJournalWriter;
+  jobId: string;
+  jobType: RemOperationType;
+  config: RemConfig;
+  stages: readonly RemStage[];
+  onStageError?: (event: {
+    stage: string;
+    error: unknown;
+  }) => void;
+}): Promise<Record<string, "done" | "failed" | "disabled">>;
+//#endregion
+//#region src/engine/rem/schema.d.ts
+declare function installRemSchema(database: RemDatabaseLike): void;
+//#endregion
+//#region src/engine/rem/writer-census.d.ts
+interface RemDiscoveredWriter {
+  writer: string;
+}
+declare function discoverRemWritersFromCallGraph(input: {
+  entryPoints: readonly string[];
+}): {
+  writers: RemDiscoveredWriter[];
+};
+//#endregion
+export { REM_ENABLE_GATE_BINDINGS as $, orderAdapterAPair as $t, ReplaceCoverageDecision as A, validateRemCalibrationCrossCheck as At, arbitrateReplaceVerdicts as B, deriveRemConfigurationSha256 as Bt, REM_ROW_HASH_VERSION_LEGACY as C, journalRemGenerationTransition as Ct, RemReplaceCarrierState as D, recordRemObservedVerdict as Dt, RemReplaceCarrierPort as E, recordRemCandidateCapCounts as Et, renderReplaceCoveragePrompt as F, validateRemReplayIdentityTuple as Ft, writeRemTwoFacetTransaction as G, validateRemGrammarChange as Gt, parseReplaceClauseVerdict as H, requireRemCoverageAccuracyFloor as Ht, ReplaceArbitration as I, RemConfigurationDecision as It, defineRemSafetyGuard as J, AdapterAVerdict as Jt, RemFacetPolicy as K, AdapterAMemoryRecord as Kt, ReplaceClauseVerdict as L, RemOperationalConfiguration as Lt, ReplaceCoverageStatus as M, validateRemCensusOracleProvenance as Mt, decideReplaceCoverage as N, validateRemCensusRouteCoverage as Nt, ReplaceCoverageAtom as O, reportRemSimilarityCalibration as Ot, parseReplaceCoverageAtoms as P, validateRemProspectiveIdentity as Pt, LoadRemEnableGateInput as Q, isAdapterAVerdictReply as Qt, ReplaceEligibleClause as R, canonicalizeRemConfiguration as Rt, REM_ROW_HASH_VERSION as S, deriveRemWriteIdentity as St, RemReplaceCarrierFault as T, readRetainedRemCensusArtifact as Tt, renderReplaceClauseVerdictPrompt as U, requireRemOwnerDecisions as Ut, buildReplaceEligibleClauses as V, parseRemOperationalConfiguration as Vt, RemCurrentFacetChunk as W, validateRemEnableGateDigestKeys as Wt, validateRemGuardCensus as X, adapterAViewFromRecord as Xt, recordNonRefusePairDecision as Y, OrderedAdapterAPair as Yt, validateRemSubstantiveWaveEffects as Z, extractJsonFromResponse as Zt, renderRemRetirementTargetPrompt as _, RemUpdateLocaleResource as _t, RemStage as a, RemCoverageAtom as at, renderRemUpdateVerificationPrompt as b, classifyRemCensusLabel as bt, RemUpdateJudgmentDecision as c, validateRemClauseCoverageArtifacts as ct, decideRemClauseCarry as d, RemUpdateTier as dt, parseAdapterAChatVerdict as en, RemEnableGateError as et, decideRemRetirementTargetFromReply as f, buildRemUpdateReferenceSet as ft, renderRemClauseCarryPrompt as g, RemUpdateLocale as gt, decideRemUpdateVerification as h, REM_UPDATE_LOCALES as ht, RemJournalWriter as i, RemClauseCoverageGateResult as it, ReplaceCoverageObservation as j, validateRemCensusLabelTuple as jt, ReplaceCoverageClass as k, summarizeRemBatchEvents as kt, RemUpdateJudgmentRefusalReason as l, RemUpdateReferenceUnit as lt, decideRemUpdateRelationFromReply as m, enumerateRemUpdateMembers as mt, discoverRemWritersFromCallGraph as n, renderAdapterAChatPrompt as nn, RemExactClause as nt, runRemStages as o, RemCoverageBuildResult as ot, decideRemUpdateFromReply as p, composeRemNegatedCurrent as pt, RemEntryDecision as q, AdapterAMemoryView as qt, installRemSchema as r, renderAdapterAPrompt as rn, splitExactClauses as rt, RemClauseCarryDecision as s, buildRemCoverageAtoms as st, RemDiscoveredWriter as t, prospectiveProfileView as tn, loadRemEnableGate as tt, RemUpdateVerificationDecision as u, RemUpdateSpan as ut, renderRemUpdateJudgmentPrompt as v, getRemUpdateLocaleResource as vt, hashRemMemoryRow as w, produceRemCensusArtifact as wt, REM_ROW_HASH_FIELDS as x, deriveRemReplayArtifactIdentity as xt, renderRemUpdateRelationJudgmentPrompt as y, classifyAllRemCensusLabels as yt, UsableReplaceClauseVerdict as z, declareRemCalibrationThreshold as zt };