sealkeep 0.9.0 → 0.11.0

package/dist/src/index-publication-proof.js

@@ -0,0 +1,380 @@
+import { createHash } from "node:crypto";
+export const INDEX_PUBLICATION_DIGEST_ALGORITHM = "sha256";
+export const INDEX_PUBLICATION_MAX_POSTINGS_PER_TOKEN = 256;
+export class IndexPublicationProofError extends Error {
+    code = "INDEX_PUBLICATION_PROOF_INVALID";
+    constructor(message) {
+        super(message);
+        this.name = "IndexPublicationProofError";
+    }
+}
+const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const lexical = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+function invalid(message) {
+    throw new IndexPublicationProofError(message);
+}
+function record(value, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return invalid(`${label} must be an object`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        return invalid(`${label} must be a plain JSON object`);
+    }
+    if (Object.getOwnPropertySymbols(value).length !== 0) {
+        return invalid(`${label} must not contain symbol keys`);
+    }
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        if (descriptor.enumerable && !("value" in descriptor)) {
+            return invalid(`${label}.${key} must not be an accessor`);
+        }
+    }
+    return value;
+}
+/**
+ * A compact canonical JSON-value encoding used only inside the digest.
+ *
+ * It sorts every object recursively and rejects values JSON cannot preserve.
+ * Type tags retain distinctions such as string "1" versus number 1 and -0
+ * versus 0. Array holes are rejected instead of silently becoming null.
+ */
+function canonicalValue(value, ancestors = new Set()) {
+    if (value === null)
+        return "n";
+    if (typeof value === "string")
+        return `s${JSON.stringify(value)}`;
+    if (typeof value === "boolean")
+        return value ? "b1" : "b0";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return invalid("index metadata contains a non-finite number");
+        return `d${Object.is(value, -0) ? "-0" : JSON.stringify(value)}`;
+    }
+    if (Array.isArray(value)) {
+        if (ancestors.has(value))
+            return invalid("index metadata contains a cycle");
+        ancestors.add(value);
+        const entries = [];
+        for (let index = 0; index < value.length; index += 1) {
+            if (!own(value, index))
+                return invalid("index metadata contains a sparse array");
+            entries.push(canonicalValue(value[index], ancestors));
+        }
+        ancestors.delete(value);
+        return `a[${entries.join(",")}]`;
+    }
+    if (typeof value !== "object") {
+        return invalid(`index metadata contains unsupported ${typeof value}`);
+    }
+    const object = record(value, "index metadata");
+    if (ancestors.has(object))
+        return invalid("index metadata contains a cycle");
+    ancestors.add(object);
+    const encoded = Object.keys(object).sort(lexical).map((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (!descriptor || !("value" in descriptor))
+            return invalid(`index metadata.${key} must be a data property`);
+        return `${JSON.stringify(key)}:${canonicalValue(descriptor.value, ancestors)}`;
+    });
+    ancestors.delete(object);
+    return `o{${encoded.join(",")}}`;
+}
+/** Length framing makes adjacent values unambiguous without constructing a
+ * vault-sized intermediate string. */
+function frame(hash, label, value) {
+    hash.update(label, "utf8");
+    hash.update("\0", "utf8");
+    hash.update(String(Buffer.byteLength(value, "utf8")), "utf8");
+    hash.update(":", "utf8");
+    hash.update(value, "utf8");
+}
+function archiveReference(value) {
+    if (!value)
+        return invalid("an archive reference is empty");
+    // `@cN` is the existing posting delimiter. Current account ids and team
+    // shareRefs are UUIDs; reserving it prevents an ambiguous ownership proof.
+    if (value.includes("@"))
+        return invalid(`archive reference ${JSON.stringify(value)} contains the reserved @ delimiter`);
+    if (value === "__proto__")
+        return invalid("archive reference __proto__ is unsafe in a coverage map");
+    return value;
+}
+function postingOwner(posting, archiveRefs) {
+    if (!posting)
+        return invalid("an index posting is empty");
+    const delimiter = posting.indexOf("@");
+    const owner = delimiter === -1 ? posting : posting.slice(0, delimiter);
+    if (delimiter !== -1 && !/^@c(?:0|[1-9]\d*)$/.test(posting.slice(delimiter))) {
+        return invalid(`index posting ${JSON.stringify(posting)} does not use the archiveRef@cN format`);
+    }
+    if (!archiveRefs.has(owner)) {
+        return invalid(`index posting ${JSON.stringify(posting)} refers to an absent archive`);
+    }
+    return owner;
+}
+function archiveTime(meta) {
+    if (!meta)
+        return undefined;
+    for (const field of ["startedAt", "endedAt", "archivedAt"]) {
+        const value = meta[field];
+        if (value !== undefined && value !== null && typeof value !== "string") {
+            return invalid(`index metadata ${field} must be a string when present`);
+        }
+    }
+    // Match the serializer's nullish fallback exactly. In particular an explicit
+    // empty startedAt wins over endedAt and then behaves as an undated posting.
+    const value = meta.startedAt ?? meta.endedAt ?? meta.archivedAt;
+    return typeof value === "string" && value ? value : undefined;
+}
+/** Mirrors `serializedIndexRows`: timestamped postings are chronological,
+ * undated/tied postings retain their input order, then only the newest 256 are
+ * present in the actual encrypted JSONL generation. */
+function effectivePostings(entries, archiveRefs, metadata) {
+    const ordered = entries.map((value, position) => {
+        if (typeof value !== "string")
+            return invalid("every index posting must be a string");
+        const owner = postingOwner(value, archiveRefs);
+        const at = archiveTime(metadata.get(owner));
+        return { posting: value, owner, position, ...(at ? { at } : {}) };
+    }).sort((left, right) => {
+        if (left.at && right.at)
+            return left.at.localeCompare(right.at) || left.position - right.position;
+        if (left.at)
+            return 1;
+        if (right.at)
+            return -1;
+        return left.position - right.position;
+    });
+    return ordered.length > INDEX_PUBLICATION_MAX_POSTINGS_PER_TOKEN
+        ? ordered.slice(-INDEX_PUBLICATION_MAX_POSTINGS_PER_TOKEN)
+        : ordered;
+}
+/**
+ * Incremental coverage for the exact rows an index checkpoint emits.
+ *
+ * The writer should call `addArchive` from its archive-row loop, `addToken`
+ * with the already chronological/capped posting array used for that exact
+ * token row, `addMetadata` from its metadata-row loop, then `finish`. Construct
+ * it with the same positive extraction policy written in the JSONL header. This
+ * avoids cloning or traversing a 600 MB index a second time, and it cannot race
+ * indexing lanes because the proof consumes the same values as the JSONL row.
+ * Token rows must be supplied in lexical order by default; enforcing that
+ * keeps new coverage independent of object insertion order. The authenticated
+ * legacy-v3 reader may explicitly preserve wire order after independently
+ * proving uniqueness with bounded state. `finish` also returns exact posting
+ * counts: zero is valid catalog coverage for a delta base, but must not be used
+ * as proof that a requested/head archive is directly searchable.
+ */
+export class IndexPublicationCoverageBuilder {
+    #entries = new Map();
+    #archiveRefs = new Set();
+    #phase = "archives";
+    #lastToken = null;
+    #extractionPolicy;
+    #tokenOrder;
+    constructor(options) {
+        if (!Number.isSafeInteger(options?.extractionPolicy) || options.extractionPolicy < 1) {
+            invalid("the index extraction policy must be a positive integer");
+        }
+        if (options.tokenOrder !== undefined && options.tokenOrder !== "lexical" && options.tokenOrder !== "wire") {
+            invalid("the index token order must be lexical or wire");
+        }
+        this.#extractionPolicy = options.extractionPolicy;
+        this.#tokenOrder = options.tokenOrder ?? "lexical";
+    }
+    addArchive(refValue, row) {
+        if (this.#phase !== "archives")
+            return invalid("archive rows must precede token and metadata rows");
+        const ref = archiveReference(refValue);
+        if (this.#entries.has(ref))
+            return invalid(`duplicate archive row ${JSON.stringify(ref)}`);
+        if (!Array.isArray(row))
+            return invalid(`index archive row ${JSON.stringify(ref)} must be an array`);
+        for (let position = 0; position < row.length; position += 1) {
+            if (!own(row, position) || typeof row[position] !== "string") {
+                return invalid(`index archive row ${JSON.stringify(ref)} must contain only dense string fields`);
+            }
+        }
+        const hash = createHash(INDEX_PUBLICATION_DIGEST_ALGORITHM);
+        frame(hash, "domain", "sealkeep-index-publication-entry-v1");
+        frame(hash, "extraction-policy", String(this.#extractionPolicy));
+        frame(hash, "archive-ref", ref);
+        frame(hash, "archive-row", canonicalValue(row));
+        this.#archiveRefs.add(ref);
+        this.#entries.set(ref, { hash, postings: 0, metadataAdded: false });
+    }
+    /** Add one effective `t` row, after chronology and the 256-entry cap. */
+    addToken(token, postings) {
+        if (this.#phase === "metadata" || this.#phase === "finished") {
+            return invalid("token rows must precede metadata rows");
+        }
+        this.#phase = "tokens";
+        if (!token)
+            return invalid("an index token is empty");
+        if (this.#lastToken !== null) {
+            if (this.#lastToken === token)
+                return invalid("index token rows must be unique");
+            if (this.#tokenOrder === "lexical" && lexical(this.#lastToken, token) > 0) {
+                return invalid("index token rows must be unique and in lexical order");
+            }
+        }
+        this.#lastToken = token;
+        if (!Array.isArray(postings) || postings.length === 0) {
+            return invalid(`index token ${JSON.stringify(token)} must have at least one posting`);
+        }
+        if (postings.length > INDEX_PUBLICATION_MAX_POSTINGS_PER_TOKEN) {
+            return invalid(`index token ${JSON.stringify(token)} exceeds the effective publication cap`);
+        }
+        for (let position = 0; position < postings.length; position += 1) {
+            if (!own(postings, position))
+                return invalid(`index token ${JSON.stringify(token)} contains a sparse posting list`);
+            const posting = postings[position];
+            if (typeof posting !== "string")
+                return invalid("every index posting must be a string");
+            const owner = postingOwner(posting, this.#archiveRefs);
+            const entry = this.#entries.get(owner);
+            frame(entry.hash, "token", token);
+            frame(entry.hash, "posting", posting);
+            entry.postings += 1;
+        }
+    }
+    addMetadata(refValue, value) {
+        if (this.#phase === "finished")
+            return invalid("metadata cannot be added after coverage is finalized");
+        this.#phase = "metadata";
+        const ref = archiveReference(refValue);
+        const entry = this.#entries.get(ref);
+        if (!entry)
+            return invalid(`index metadata for ${JSON.stringify(ref)} has no archive row`);
+        if (entry.metadataAdded)
+            return invalid(`duplicate index metadata for ${JSON.stringify(ref)}`);
+        const metadata = record(value, `index.meta[${JSON.stringify(ref)}]`);
+        frame(entry.hash, "meta-presence", "present");
+        frame(entry.hash, "meta", canonicalValue(metadata));
+        entry.metadataAdded = true;
+    }
+    finish() {
+        if (this.#phase === "finished")
+            return invalid("index publication coverage was already finalized");
+        this.#phase = "finished";
+        const coverage = Object.create(null);
+        const effectivePostingCounts = Object.create(null);
+        for (const ref of [...this.#entries.keys()].sort(lexical)) {
+            const entry = this.#entries.get(ref);
+            if (!entry.metadataAdded)
+                frame(entry.hash, "meta-presence", "missing");
+            frame(entry.hash, "posting-count", String(entry.postings));
+            frame(entry.hash, "end", "entry");
+            coverage[ref] = entry.hash.digest("hex");
+            effectivePostingCounts[ref] = entry.postings;
+        }
+        return { coverage, effectivePostingCounts };
+    }
+}
+export function createIndexPublicationCoverageBuilder(options) {
+    return new IndexPublicationCoverageBuilder(options);
+}
+/**
+ * Produce the exact per-archive semantic coverage committed by a search-index
+ * generation.
+ *
+ * Each SHA-256 binds the extraction policy, archive reference, its complete
+ * archive row, matching metadata (missing and `{}` differ), and every
+ * token/posting occurrence that
+ * survives the real JSONL serializer's chronological 256-posting cap. Object
+ * key order never matters. Duplicate posting occurrences do matter. Orphan or
+ * malformed data throws, so damaged input can never become positive proof.
+ * Catalog-only delta bases remain in `coverage` with a posting count of zero;
+ * callers authorizing reclaim must demand a positive count for the logical
+ * session head and exact coverage for every base needed to restore it.
+ *
+ * Runtime is O(A log A + T log T + sum(P_t log P_t)): one traversal of the
+ * sorted archive/token maps and each sorted posting list, with O(A) hash state.
+ */
+export function buildIndexPublicationProof(index) {
+    const archives = record(index.archives, "index.archives");
+    const tokens = record(index.tokens, "index.tokens");
+    const meta = index.meta === undefined ? null : record(index.meta, "index.meta");
+    const refs = Object.keys(archives).sort(lexical).map(archiveReference);
+    const refSet = new Set(refs);
+    const metadata = new Map();
+    if (meta) {
+        for (const ref of Object.keys(meta).sort(lexical)) {
+            if (!refSet.has(ref))
+                return invalid(`index metadata for ${JSON.stringify(ref)} has no archive row`);
+            const value = record(meta[ref], `index.meta[${JSON.stringify(ref)}]`);
+            // Validate the whole value now, before any digest could be returned.
+            canonicalValue(value);
+            metadata.set(ref, value);
+        }
+    }
+    const builder = createIndexPublicationCoverageBuilder({ extractionPolicy: index.extractionPolicy });
+    for (const ref of refs) {
+        const row = archives[ref];
+        if (!Array.isArray(row))
+            return invalid(`index archive row ${JSON.stringify(ref)} must be an array`);
+        builder.addArchive(ref, row);
+    }
+    for (const token of Object.keys(tokens).sort(lexical)) {
+        if (!token)
+            return invalid("an index token is empty");
+        const entries = tokens[token];
+        if (!Array.isArray(entries) || entries.length === 0) {
+            return invalid(`index token ${JSON.stringify(token)} must have at least one posting`);
+        }
+        for (let position = 0; position < entries.length; position += 1) {
+            if (!own(entries, position))
+                return invalid(`index token ${JSON.stringify(token)} contains a sparse posting list`);
+        }
+        builder.addToken(token, effectivePostings(entries, refSet, metadata).map(({ posting }) => posting));
+    }
+    for (const ref of refs) {
+        const value = metadata.get(ref);
+        if (value)
+            builder.addMetadata(ref, value);
+    }
+    return builder.finish();
+}
+/** Convenience for publishers that only need the canonical CAS coverage map. */
+export function buildIndexPublicationCoverage(index) {
+    return buildIndexPublicationProof(index).coverage;
+}
+function validateCoverageMap(value) {
+    const source = record(value, "index publication coverage");
+    const result = Object.create(null);
+    for (const ref of Object.keys(source).sort(lexical)) {
+        archiveReference(ref);
+        const digest = source[ref];
+        if (typeof digest !== "string" || !/^[0-9a-f]{64}$/.test(digest)) {
+            return invalid(`coverage for ${JSON.stringify(ref)} is not a lowercase SHA-256 digest`);
+        }
+        result[ref] = digest;
+    }
+    return result;
+}
+/** Canonical, lexically sorted object JSON suitable for an opaque CAS field. */
+export function canonicalIndexPublicationCoverageJson(value) {
+    const coverage = validateCoverageMap(value);
+    return `{${Object.keys(coverage).sort(lexical).map((ref) => `${JSON.stringify(ref)}:${JSON.stringify(coverage[ref])}`).join(",")}}`;
+}
+/**
+ * Parse only the canonical representation produced above. Byte-for-byte
+ * reserialization rejects duplicate JSON keys as well as ambiguous whitespace
+ * or ordering, instead of letting JSON.parse silently keep a last value.
+ */
+export function parseIndexPublicationCoverageJson(raw) {
+    if (typeof raw !== "string")
+        return invalid("index publication coverage JSON must be a string");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return invalid("index publication coverage JSON is malformed");
+    }
+    const coverage = validateCoverageMap(parsed);
+    if (canonicalIndexPublicationCoverageJson(coverage) !== raw) {
+        return invalid("index publication coverage JSON is not canonical");
+    }
+    return coverage;
+}

package/dist/src/index-publication-state.d.ts

@@ -0,0 +1,149 @@
+declare const PUBLICATION_POLICY_VERSION: 1;
+export type AccountIndexPublicationScope = {
+    kind: "account";
+    vaultId: string;
+};
+export type TeamIndexPublicationScope = {
+    kind: "team";
+    spaceKey: string;
+    membershipVersion: number;
+};
+export type IndexPublicationScope = AccountIndexPublicationScope | TeamIndexPublicationScope;
+/** The exact archive entry which must be remotely discoverable. */
+export type IndexPublicationRequirement = {
+    archiveId: string;
+    archiveRef: string;
+    entryDigest: string;
+    scope: IndexPublicationScope;
+};
+/**
+ * A positive receipt returned only after the registry/object read-after-write
+ * checks have succeeded. The receipt is useful only for its exact requirement.
+ */
+export type IndexPublicationReceipt = {
+    requirementKey: string;
+    policyVersion: typeof PUBLICATION_POLICY_VERSION;
+    publisherId: string;
+    generationId: string;
+    registryReceiptId: string;
+    registryRevision: number;
+    objectRef: string;
+    ciphertextSha256: string;
+    ciphertextBytes: number;
+    committedAt: string;
+};
+export type IndexPublicationReceiptDetails = Omit<IndexPublicationReceipt, "requirementKey" | "policyVersion"> & Partial<Pick<IndexPublicationReceipt, "requirementKey" | "policyVersion">>;
+/** Optimistic token for one logical scope/archive obligation. */
+export type IndexPublicationRequirementHandle = {
+    logicalKey: string;
+    requirementKey: string;
+    ledgerGeneration: string;
+    requirementRevision: number;
+};
+export type UnsatisfiedIndexPublicationRequirement = IndexPublicationRequirementHandle & {
+    requirement: IndexPublicationRequirement;
+    requiredAt: string;
+};
+export type IndexPublicationRequirementStatus = IndexPublicationRequirementHandle & {
+    requirement: IndexPublicationRequirement;
+    requiredAt: string;
+    receipt: IndexPublicationReceipt | null;
+};
+export type IndexPublicationKeyMaterial = string | {
+    phrase: string;
+} | {
+    vaultId: string;
+} | {
+    key: Uint8Array;
+};
+export type IndexPublicationStateSnapshot = {
+    status: "ok";
+    generation: string;
+    revision: number;
+    requirements: number;
+    satisfied: number;
+};
+export type IndexPublicationStateRead = IndexPublicationStateSnapshot | {
+    status: "missing";
+} | {
+    status: "unreadable";
+    errorCode: string;
+};
+export type IndexPublicationReadOptions = {
+    /** Test seam for deterministic permission/I/O failure checks. */
+    readFile?: (path: string, encoding: "utf8") => Promise<string>;
+};
+export type IndexPublicationMutationOptions = IndexPublicationReadOptions & {
+    signal?: AbortSignal;
+    lockTimeoutMs?: number;
+    lockPollMs?: number;
+    now?: () => string;
+    uuid?: () => string;
+};
+export type RecordIndexPublicationRequirementOptions = IndexPublicationMutationOptions & {
+    /** `null` means create-only; a handle makes replacement a compare-and-set. */
+    expected?: IndexPublicationRequirementHandle | null;
+};
+export type RecordedIndexPublicationRequirement = {
+    requirement: IndexPublicationRequirement;
+    handle: IndexPublicationRequirementHandle;
+};
+export type IndexPublicationReceiptWrite = RecordedIndexPublicationRequirement & {
+    details: IndexPublicationReceiptDetails;
+};
+export declare class IndexPublicationStateError extends Error {
+    readonly code: "INDEX_PUBLICATION_STATE_CORRUPT" | "INDEX_PUBLICATION_STATE_UNREADABLE";
+    readonly cause?: unknown;
+    constructor(code: "INDEX_PUBLICATION_STATE_CORRUPT" | "INDEX_PUBLICATION_STATE_UNREADABLE", message: string, cause?: unknown);
+}
+export declare class IndexPublicationConflictError extends Error {
+    readonly code: "INDEX_PUBLICATION_STATE_CONFLICT";
+    constructor(message?: string);
+}
+export declare function indexPublicationStatePath(dataDir: string): string;
+export declare function indexPublicationRequirementKey(material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement): string;
+export declare function indexPublicationLogicalKey(material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement): string;
+export declare function readIndexPublicationState(dataDir: string, options?: IndexPublicationReadOptions): Promise<IndexPublicationStateRead>;
+/**
+ * Installs or refreshes one exact obligation. Repeating the same tuple is a
+ * true no-op; changing a tuple removes only that logical archive's receipt.
+ */
+export declare function recordIndexPublicationRequirement(dataDir: string, material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement, options?: RecordIndexPublicationRequirementOptions): Promise<IndexPublicationRequirementHandle>;
+/**
+ * Atomically installs a checkpoint's obligations with one lock acquisition and
+ * one fsync. Large vaults routinely contain thousands of sessions, so making
+ * each row its own durable transaction would turn indexing into minutes of
+ * avoidable disk latency. Duplicate logical slots are rejected because their
+ * order would otherwise decide which exact tuple survived.
+ */
+export declare function recordIndexPublicationRequirements(dataDir: string, material: IndexPublicationKeyMaterial, requirements: readonly IndexPublicationRequirement[], options?: IndexPublicationMutationOptions): Promise<RecordedIndexPublicationRequirement[]>;
+/**
+ * Records positive publication proof only while the exact requirement and its
+ * local generation/revision still match the writer's pre-publication handle.
+ */
+export declare function recordIndexPublicationReceipt(dataDir: string, material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement, expected: IndexPublicationRequirementHandle, details: IndexPublicationReceiptDetails, options?: IndexPublicationMutationOptions): Promise<boolean>;
+/** Installs all still-current receipts from one verified remote generation. */
+export declare function recordIndexPublicationReceipts(dataDir: string, material: IndexPublicationKeyMaterial, writes: readonly IndexPublicationReceiptWrite[], options?: IndexPublicationMutationOptions): Promise<{
+    recorded: number;
+    stale: number;
+}>;
+/** Missing, corrupt and unreadable state all deliberately return no proof. */
+export declare function getIndexPublicationReceipt(dataDir: string, material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement, options?: IndexPublicationReadOptions): Promise<IndexPublicationReceipt | null>;
+export declare function hasIndexPublicationReceipt(dataDir: string, material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement, options?: IndexPublicationReadOptions): Promise<boolean>;
+/**
+ * Lists only durable obligations which lack their exact positive receipt.
+ * Missing state has no recorded requirements. Corrupt/EACCES state throws so
+ * callers cannot mistake an I/O fault for an authoritative empty list.
+ */
+export declare function listUnsatisfiedIndexPublicationRequirements(dataDir: string, material: IndexPublicationKeyMaterial, options?: IndexPublicationReadOptions): Promise<UnsatisfiedIndexPublicationRequirement[]>;
+/**
+ * Lists every exact obligation together with its positive receipt, if any.
+ * Missing state is an empty non-authoritative list; corrupt or unreadable state
+ * throws so destructive callers cannot interpret an I/O failure as success.
+ */
+export declare function listIndexPublicationRequirements(dataDir: string, material: IndexPublicationKeyMaterial, options?: IndexPublicationReadOptions): Promise<IndexPublicationRequirementStatus[]>;
+/** Invalidates one exact receipt; there is intentionally no global clear. */
+export declare function invalidateIndexPublicationReceipt(dataDir: string, material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement, expected: IndexPublicationRequirementHandle, options?: IndexPublicationMutationOptions): Promise<boolean>;
+/** Removes one no-longer-applicable obligation using the same per-entry CAS. */
+export declare function removeIndexPublicationRequirement(dataDir: string, material: IndexPublicationKeyMaterial, requirement: IndexPublicationRequirement, expected: IndexPublicationRequirementHandle, options?: IndexPublicationMutationOptions): Promise<boolean>;
+export {};