@agent-custody/state 0.1.8 → 0.2.0

package/dist/ledger.js

@@ -1,4 +1,4 @@
-// The fact ledger: an append-only JSONL log of events about what an agent believes.
+// The fact ledger: an append-only log of events about what an agent believes, in a JSONL file, SQLite, or Postgres.
 // Bitemporal. Valid time is when a fact was true in the world; transaction time is when the ledger learned of it.
 // Nothing is ever edited in place. Correcting a belief is a new event, so "what did the agent believe at T" is always answerable.
 import { randomUUID } from "node:crypto";
@@ -6,19 +6,19 @@ import { createHash, createHmac } from "node:crypto";
 import { openStore } from "./storage.js";
 const RANK = { claimed: 0, attested: 1, verified: 2 };
 export class Ledger {
-    events;
     store;
     now;
     forgetKey;
     /**
-     * `location` is a path: JSONL by default, SQLite when it ends in .sqlite or .db; or pass a store.
-     * forgetKey: a secret kept outside the store; with it, forgotten values leave an HMAC rather than a plain hash.
+     * `location` is a path (JSONL by default, SQLite when it ends in .sqlite or .db) or a postgres:// URL; or pass a
+     * store. The ledger holds no events itself: every question is a query to the store, so a shared store means a
+     * shared ledger. forgetKey: a secret kept outside the store; with it, forgotten values leave an HMAC rather than a
+     * plain hash.
      */
     constructor(location, opts = {}) {
         this.store = typeof location === "string" ? openStore(location) : location;
         this.now = opts.now ?? (() => new Date());
         this.forgetKey = opts.forgetKey ? Buffer.from(opts.forgetKey) : null;
-        this.events = this.store.load();
     }
     /** Where the events live, for reports. */
     get location() {
@@ -26,31 +26,35 @@ export class Ledger {
     }
     /** Every event in order, for export. */
     export() {
-        return [...this.events];
+        return this.store.events();
     }
     close() {
-        this.store.close();
+        return this.store.close();
     }
-    get size() {
-        return this.events.length;
+    count() {
+        return this.store.count();
+    }
+    /** Every space with at least one fact. */
+    spaces() {
+        return this.store.spaces();
     }
     /** The checks assert makes, without appending. For callers that must do something irreversible before the append. */
-    validateAssert(input) {
+    async validateAssert(input) {
         const validFrom = input.validFrom ?? this.now().toISOString();
         if (input.supersedes !== undefined) {
-            const prior = this.factById(input.supersedes);
+            const prior = await this.factById(input.supersedes);
             if (!prior)
                 throw new Error(`cannot supersede unknown fact ${input.supersedes}`);
             if (prior.fact.validTo !== null)
                 throw new Error(`fact ${input.supersedes} is already superseded`);
-            if (this.retractedAt(input.supersedes))
+            if (await this.retractedAt(input.supersedes))
                 throw new Error(`fact ${input.supersedes} is retracted`);
             if (validFrom < prior.fact.validFrom)
                 throw new Error(`replacement cannot start before the fact it supersedes`);
         }
     }
-    assert(input) {
-        this.validateAssert(input);
+    async assert(input) {
+        await this.validateAssert(input);
         const txTime = this.now().toISOString();
         const validFrom = input.validFrom ?? txTime;
         const event = {
@@ -73,13 +77,13 @@ export class Ledger {
             },
             supersedes: input.supersedes ?? null,
         };
-        this.append(event);
+        await this.store.append(event);
         return event;
     }
-    retract(input) {
-        if (!this.factById(input.factId))
+    async retract(input) {
+        if (!(await this.factById(input.factId)))
             throw new Error(`cannot retract unknown fact ${input.factId}`);
-        if (this.retractedAt(input.factId))
+        if (await this.retractedAt(input.factId))
             throw new Error(`fact ${input.factId} is already retracted`);
         const event = {
             eventId: randomUUID(),
@@ -90,95 +94,106 @@ export class Ledger {
             reason: input.reason,
             source: input.source ?? { receiptId: null },
         };
-        this.append(event);
+        await this.store.append(event);
         return event;
     }
-    confirm(input) {
-        const prior = this.factById(input.factId);
+    async confirm(input) {
+        const prior = await this.factById(input.factId);
         if (!prior)
             throw new Error(`cannot confirm unknown fact ${input.factId}`);
-        if (this.retractedAt(input.factId))
+        if (await this.retractedAt(input.factId))
             throw new Error(`fact ${input.factId} is retracted`);
-        if (prior.fact.provenance !== "claimed" || this.confirmedAt(input.factId))
+        if (prior.fact.provenance !== "claimed" || (await this.confirmedAt(input.factId)))
             throw new Error(`fact ${input.factId} is already attested`);
         const event = { eventId: randomUUID(), kind: "confirm", txTime: this.now().toISOString(), factId: input.factId, actor: input.actor, source: input.source ?? { receiptId: null } };
-        this.append(event);
+        await this.store.append(event);
         return event;
     }
-    /**
-     * Erases a fact's value from the ledger file, keeping its digest, and stops believing it. The file is rewritten in
-     * place, which is the one thing an append-only ledger must do for a deletion demand. Everything else about the fact
-     * stays: who wrote it, when, from which receipt, and now who erased it and why.
-     */
     /** Whether a legal hold currently stands on the fact. */
-    held(factId) {
+    async held(factId) {
         let held = false;
-        for (const e of this.events)
+        for (const e of await this.store.eventsFor(factId))
             if ((e.kind === "hold" || e.kind === "release") && e.factId === factId)
                 held = e.kind === "hold";
         return held;
     }
-    hold(input) {
-        const prior = this.factById(input.factId);
+    async hold(input) {
+        const prior = await this.factById(input.factId);
         if (!prior)
             throw new Error(`cannot hold unknown fact ${input.factId}`);
         if (prior.fact.forgotten)
             throw new Error(`fact ${input.factId} is already forgotten`);
-        if (this.held(input.factId))
+        if (await this.held(input.factId))
             throw new Error(`fact ${input.factId} is already on hold`);
         const event = { eventId: randomUUID(), kind: "hold", txTime: this.now().toISOString(), factId: input.factId, actor: input.actor, reason: input.reason, source: input.source ?? { receiptId: null } };
-        this.append(event);
+        await this.store.append(event);
         return event;
     }
-    release(input) {
-        if (!this.held(input.factId))
+    async release(input) {
+        if (!(await this.held(input.factId)))
             throw new Error(`fact ${input.factId} is not on hold`);
         const event = { eventId: randomUUID(), kind: "release", txTime: this.now().toISOString(), factId: input.factId, actor: input.actor, reason: input.reason, source: input.source ?? { receiptId: null } };
-        this.append(event);
+        await this.store.append(event);
         return event;
     }
+    /** The facts the ledger learned of before an instant, in one space or all, that have not been forgotten: what a retention sweep decides about. */
+    async learnedBefore(before, space) {
+        const events = await this.store.eventsAbout({ txBefore: before, ...(space === undefined ? {} : { space }) });
+        return events.filter((e) => e.kind === "assert" && e.txTime < before && (space === undefined || e.fact.space === space) && !e.fact.forgotten).map((e) => ({ ...e.fact }));
+    }
     /** Retention: forgets every fact the ledger learned of before the cutoff, in one space or all, skipping held and already-forgotten facts. Returns what it forgot and what it skipped. */
-    sweep(input) {
+    async sweep(input) {
         const forgotten = [];
         const held = [];
-        const targets = this.events.filter((e) => e.kind === "assert" && e.txTime < input.before && (input.space === undefined || e.fact.space === input.space) && !e.fact.forgotten);
-        for (const e of targets) {
-            if (this.held(e.fact.factId)) {
-                held.push(e.fact.factId);
+        for (const f of await this.learnedBefore(input.before, input.space)) {
+            if (await this.held(f.factId)) {
+                held.push(f.factId);
                 continue;
             }
-            forgotten.push(this.forget({ factId: e.fact.factId, actor: input.actor, reason: input.reason, ...(input.source ? { source: input.source } : {}), ...(input.keepDigest === undefined ? {} : { keepDigest: input.keepDigest }) }));
+            forgotten.push(await this.forget({ factId: f.factId, actor: input.actor, reason: input.reason, ...(input.source ? { source: input.source } : {}), ...(input.keepDigest === undefined ? {} : { keepDigest: input.keepDigest }), compact: false }));
         }
+        if (forgotten.length > 0)
+            await this.store.compact();
         return { forgotten, held };
     }
-    forget(input) {
-        const prior = this.factById(input.factId);
+    /**
+     * Erases a fact's value from the store itself, keeping its digest, and stops believing it. The store rewrites the
+     * event in place, which is the one thing an append-only ledger must do for a deletion demand. Everything else about
+     * the fact stays: who wrote it, when, from which receipt, and now who erased it and why. With compact false the
+     * store's reclaim step is left to the caller, for a batch of forgets followed by one compact().
+     */
+    async forget(input) {
+        const prior = await this.factById(input.factId);
         if (!prior)
             throw new Error(`cannot forget unknown fact ${input.factId}`);
         if (prior.fact.forgotten)
             throw new Error(`fact ${input.factId} is already forgotten`);
-        if (this.held(input.factId))
+        if (await this.held(input.factId))
             throw new Error(`fact ${input.factId} is on legal hold; release it first`);
         const txTime = this.now().toISOString();
         const text = canonical(prior.fact.value);
         const digestKind = input.keepDigest === false ? "none" : this.forgetKey ? "hmac-sha256" : "sha256";
         const valueDigest = digestKind === "none" ? null : digestKind === "hmac-sha256" ? createHmac("sha256", this.forgetKey).update(text).digest("hex") : createHash("sha256").update(text).digest("hex");
-        for (const e of this.events) {
+        for (const e of await this.store.eventsFor(input.factId)) {
             if (e.kind === "assert" && e.fact.factId === input.factId) {
-                e.fact.value = null;
-                e.fact.forgotten = { valueDigest, digestKind, at: txTime };
-                this.store.replaceAssert(e);
+                await this.store.replaceAssert({ ...e, fact: { ...e.fact, value: null, forgotten: { valueDigest, digestKind, at: txTime } } });
             }
         }
         const event = { eventId: randomUUID(), kind: "forget", txTime, factId: input.factId, actor: input.actor, reason: input.reason, source: input.source ?? { receiptId: null }, valueDigest, digestKind };
-        this.append(event);
+        await this.store.append(event);
+        if (input.compact !== false)
+            await this.store.compact();
         return event;
     }
+    /** Reclaims whatever the store may still hold of erased values; forget and sweep do this themselves unless told not to. */
+    compact() {
+        return this.store.compact();
+    }
     /** The facts believed at a moment. Valid time answers "was it true then"; transaction time answers "did the ledger know it then". */
-    asOf(q = {}) {
+    async asOf(q = {}) {
         const validAt = q.validAt ?? this.now().toISOString();
         const txAt = q.txAt ?? this.now().toISOString();
-        const known = this.events.filter((e) => e.txTime <= txAt);
+        const known = await this.store.eventsAbout({ txAtMost: txAt, ...(q.space === undefined ? {} : { space: q.space }), ...(q.subject === undefined ? {} : { subject: q.subject }), ...(q.predicate === undefined ? {} : { predicate: q.predicate }) });
         const retracted = new Set(known.filter((e) => e.kind === "retract" || e.kind === "forget").map((e) => e.factId));
         const confirmed = new Set(known.filter((e) => e.kind === "confirm").map((e) => e.factId));
         const facts = new Map();
@@ -198,41 +213,43 @@ export class Ledger {
             (q.predicate === undefined || f.predicate === q.predicate) &&
             (q.include === undefined || q.include === "all" || RANK[f.provenance] >= RANK[q.include]));
     }
+    /** One fact by id, whatever its state, with supersession applied; undefined when the ledger never held it. */
+    async get(factId) {
+        return (await this.factById(factId))?.fact;
+    }
     /** Every fact ever asserted, with supersession applied and retracted ones included, for audits that must see everything. */
-    facts() {
+    async facts() {
+        const events = await this.store.events();
+        const retracted = new Set(events.filter((e) => e.kind === "retract" || e.kind === "forget").map((e) => e.factId));
         const out = new Map();
-        for (const e of this.events) {
+        for (const e of events) {
             if (e.kind !== "assert")
                 continue;
             out.set(e.fact.factId, { ...e.fact });
-            if (e.supersedes && out.has(e.supersedes) && !this.retractedAt(e.fact.factId))
+            if (e.supersedes && out.has(e.supersedes) && !retracted.has(e.fact.factId))
                 out.get(e.supersedes).validTo = e.fact.validFrom;
         }
         return [...out.values()];
     }
     /** Every event that touched a fact, oldest first: its assert, the assert that superseded it, its confirmation, its retraction. */
     history(factId) {
-        return this.events.filter((e) => (e.kind === "assert" ? e.fact.factId === factId || e.supersedes === factId : e.factId === factId));
+        return this.store.eventsFor(factId);
     }
-    confirmedAt(factId) {
-        return this.events.some((e) => e.kind === "confirm" && e.factId === factId);
+    async confirmedAt(factId) {
+        return (await this.store.eventsFor(factId)).some((e) => e.kind === "confirm" && e.factId === factId);
     }
-    factById(factId) {
+    async factById(factId) {
         let found;
-        for (const e of this.events) {
+        for (const e of await this.store.eventsFor(factId)) {
             if (e.kind === "assert" && e.fact.factId === factId)
                 found = { ...e, fact: { ...e.fact } };
-            else if (e.kind === "assert" && e.supersedes === factId && found && !this.retractedAt(e.fact.factId))
+            else if (e.kind === "assert" && e.supersedes === factId && found && !(await this.retractedAt(e.fact.factId)))
                 found.fact.validTo = e.fact.validFrom;
         }
         return found;
     }
-    retractedAt(factId) {
-        return this.events.some((e) => (e.kind === "retract" || e.kind === "forget") && e.factId === factId);
-    }
-    append(event) {
-        this.store.append(event);
-        this.events.push(event);
+    async retractedAt(factId) {
+        return (await this.store.eventsFor(factId)).some((e) => (e.kind === "retract" || e.kind === "forget") && e.factId === factId);
     }
 }
 /** Canonical JSON: sorted keys, no whitespace, undefined dropped. The same encoding the receipts package uses. */

package/dist/pack.d.ts

@@ -0,0 +1,49 @@
+import { type Envelope, type KeyPair, type PublicKeyRef, type ReceiptBundle } from "@agent-custody/receipts";
+import { type BlastRadius } from "./blast.ts";
+import type { Fact, Ledger, LedgerEvent } from "./ledger.ts";
+export declare const PACK_TYPE = "https://agent-custody.dev/custody-pack/v0.1";
+export interface CustodyPack {
+    version: "0.1";
+    generatedAt: string;
+    factId: string;
+    fact: Fact | null;
+    /** every event that touched the fact, oldest first */
+    history: LedgerEvent[];
+    /** every receipt referenced by the history or the blast radius, by id, as the full verifiable bundle */
+    receipts: Record<string, ReceiptBundle>;
+    /** receipt ids the history or blast radius cited but no bundle was found for */
+    missingReceipts: string[];
+    blast: BlastRadius;
+    /** the forget event and what the forget receipt recorded, when the fact was forgotten */
+    forget: {
+        event: LedgerEvent;
+        receiptId: string | null;
+        verification: Record<string, string> | null;
+        removedFrom: string[] | null;
+    } | null;
+    /** hold and release events, in order */
+    holds: LedgerEvent[];
+}
+export declare function buildPack(ledger: Ledger, receiptsDir: string, factId: string): Promise<CustodyPack>;
+export declare function signPack(pack: CustodyPack, key: KeyPair): Envelope;
+export interface PackCheck {
+    name: string;
+    ok: boolean;
+    detail?: string;
+}
+export interface PackVerification {
+    ok: boolean;
+    checks: PackCheck[];
+    pack: CustodyPack | null;
+}
+/**
+ * Verifies the pack's own signature and digest, then every receipt inside it against the gateway's keys when given,
+ * that every event's source receipt is present, and that the forget receipt's result names this fact.
+ */
+export declare function verifyPack(envelope: Envelope, packKeys: PublicKeyRef[], receiptKeys?: {
+    issuerKeys: PublicKeyRef[];
+    principalKeys?: PublicKeyRef[];
+    logKeys?: PublicKeyRef[];
+    upstreamKeys?: PublicKeyRef[];
+}): PackVerification;
+export declare function formatPack(p: CustodyPack): string;

package/dist/pack.js

@@ -0,0 +1,148 @@
+// The custody pack: everything about one fact as a single artefact a reviewer can verify. Its history with the
+// receipt that produced each event, its blast radius with every downstream receipt, its forget certificate and what
+// the stores answered, all inside one signed statement. Hand it to counsel, an auditor, or the person who asked for
+// the deletion; they need the signing key and the gateway's key, and nothing from you.
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { digestOf, dsseSign, dsseVerify, verifyBundle } from "@agent-custody/receipts";
+import { blastRadius, loadReceipts } from "./blast.js";
+export const PACK_TYPE = "https://agent-custody.dev/custody-pack/v0.1";
+function loadBundles(dir) {
+    const out = new Map();
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        try {
+            const bundle = JSON.parse(readFileSync(join(dir, f), "utf8"));
+            const st = JSON.parse(Buffer.from(bundle.envelope.payload, "base64").toString());
+            if (st.predicate?.receiptId)
+                out.set(st.predicate.receiptId, bundle);
+        }
+        catch {
+            // not a bundle; skip
+        }
+    }
+    return out;
+}
+function receiptResult(bundle) {
+    try {
+        const st = JSON.parse(Buffer.from(bundle.envelope.payload, "base64").toString());
+        const text = st.predicate?.execution?.result?.content?.find((c) => c.type === "text")?.text;
+        if (!text)
+            return null;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    catch {
+        return null; // a damaged bundle; the receipt check reports it
+    }
+}
+export async function buildPack(ledger, receiptsDir, factId) {
+    const bundles = loadBundles(receiptsDir);
+    const history = await ledger.history(factId);
+    const blast = await blastRadius(ledger, loadReceipts(receiptsDir), factId);
+    const wanted = new Set();
+    for (const e of history) {
+        const src = e.kind === "assert" ? e.fact.source.receiptId : e.source.receiptId;
+        if (src)
+            wanted.add(src);
+    }
+    for (const r of blast.receipts)
+        wanted.add(r.receiptId);
+    for (const f of blast.derivedFacts)
+        if (f.source.receiptId)
+            wanted.add(f.source.receiptId);
+    const receipts = {};
+    const missingReceipts = [];
+    for (const id of [...wanted].sort()) {
+        const b = bundles.get(id);
+        if (b)
+            receipts[id] = b;
+        else
+            missingReceipts.push(id);
+    }
+    const forgetEvent = history.find((e) => e.kind === "forget");
+    let forget = null;
+    if (forgetEvent && forgetEvent.kind === "forget") {
+        const rid = forgetEvent.source.receiptId;
+        const result = rid && receipts[rid] ? receiptResult(receipts[rid]) : null;
+        forget = { event: forgetEvent, receiptId: rid, verification: result?.verification ?? null, removedFrom: result?.removedFrom ?? null };
+    }
+    return {
+        version: "0.1",
+        generatedAt: new Date().toISOString(),
+        factId,
+        fact: blast.fact,
+        history,
+        receipts,
+        missingReceipts,
+        blast,
+        forget,
+        holds: history.filter((e) => e.kind === "hold" || e.kind === "release"),
+    };
+}
+export function signPack(pack, key) {
+    const statement = { _type: "https://in-toto.io/Statement/v1", subject: [{ name: `custody-pack:${pack.factId}`, digest: { sha256: digestOf(pack) } }], predicateType: PACK_TYPE, predicate: pack };
+    return dsseSign("application/vnd.in-toto+json", statement, key);
+}
+/**
+ * Verifies the pack's own signature and digest, then every receipt inside it against the gateway's keys when given,
+ * that every event's source receipt is present, and that the forget receipt's result names this fact.
+ */
+export function verifyPack(envelope, packKeys, receiptKeys) {
+    const checks = [];
+    const add = (name, ok, detail) => {
+        checks.push(detail === undefined ? { name, ok } : { name, ok, detail });
+        return ok;
+    };
+    const v = dsseVerify(envelope, packKeys);
+    if (!v.ok) {
+        add("pack signature", false, v.error);
+        return { ok: false, checks, pack: null };
+    }
+    add("pack signature", true, `keyid ${v.keyid.slice(0, 12)}`);
+    const st = v.payload;
+    if (!add("pack type", st.predicateType === PACK_TYPE && !!st.predicate))
+        return { ok: false, checks, pack: null };
+    const pack = st.predicate;
+    add("pack digest", st.subject?.[0]?.digest?.sha256 === digestOf(pack));
+    add("no receipts missing", pack.missingReceipts.length === 0, pack.missingReceipts.length ? `${pack.missingReceipts.length} cited receipt(s) absent` : undefined);
+    for (const e of pack.history) {
+        const src = e.kind === "assert" ? e.fact.source.receiptId : e.source.receiptId;
+        if (src)
+            add(`${e.kind} event cites a receipt in the pack`, src in pack.receipts, src.slice(0, 8));
+    }
+    if (receiptKeys) {
+        for (const [id, bundle] of Object.entries(pack.receipts)) {
+            const r = verifyBundle(bundle, { issuerKeys: receiptKeys.issuerKeys, principalKeys: receiptKeys.principalKeys ?? [], ...(receiptKeys.logKeys ? { logKeys: receiptKeys.logKeys } : {}), ...(receiptKeys.upstreamKeys ? { upstreamKeys: receiptKeys.upstreamKeys } : {}) });
+            add(`receipt ${id.slice(0, 8)} verifies`, r.ok, r.ok ? undefined : r.checks.filter((c) => !c.ok).map((c) => c.name).join(", "));
+            if (r.ok && r.statement && r.statement.predicate.receiptId !== id)
+                add(`receipt ${id.slice(0, 8)} is the receipt it claims to be`, false);
+        }
+    }
+    else {
+        add("receipts checked against the gateway's keys", false, "no issuer key given; pass --issuer-key to check the receipts inside the pack");
+    }
+    if (pack.forget) {
+        const bundle = pack.forget.receiptId ? pack.receipts[pack.forget.receiptId] : undefined;
+        const result = bundle ? receiptResult(bundle) : null;
+        add("forget receipt names this fact and records the erasure", !!result && result.factId === pack.factId && result.erasedFromLedger === true, bundle ? undefined : "forget receipt not in the pack");
+    }
+    return { ok: checks.every((c) => c.ok), checks, pack };
+}
+export function formatPack(p) {
+    const lines = [];
+    lines.push(p.fact ? `fact ${p.factId}: ${p.fact.subject} ${p.fact.predicate}${p.fact.forgotten ? " = (erased)" : ` = ${JSON.stringify(p.fact.value)}`} (space ${p.fact.space}, by ${p.fact.actor}, ${p.fact.provenance})` : `fact ${p.factId}: not in this ledger`);
+    lines.push(`history: ${p.history.map((e) => e.kind).join(" → ")}`);
+    lines.push(`receipts in pack: ${Object.keys(p.receipts).length}${p.missingReceipts.length ? `, missing ${p.missingReceipts.length}` : ""}`);
+    if (p.holds.length)
+        lines.push(`holds: ${p.holds.map((e) => (e.kind === "hold" || e.kind === "release" ? `${e.kind} by ${e.actor} (${e.reason})` : e.kind)).join("; ")}`);
+    if (p.forget)
+        lines.push(`forgotten at ${p.forget.event.txTime} by ${p.forget.event.actor}; receipt ${p.forget.receiptId?.slice(0, 8) ?? "none"}; stores: ${p.forget.verification ? Object.entries(p.forget.verification).map(([k, v]) => `${k}=${v}`).join(", ") : "none"}`);
+    lines.push(`blast radius: ${p.blast.receipts.length} later call(s), ${p.blast.derivedFacts.length} derived belief(s), ${p.blast.stillBelieved.length} still believed`);
+    return lines.join("\n");
+}

package/dist/server.d.ts

@@ -21,6 +21,11 @@ export interface MemoryServerOptions {
     identity?: KeyPair;
     /** Retention windows by space pattern, ISO 8601 durations: { "org": "P365D", "team:*": "P90D" }. memory.sweep without `before` uses them. */
     retention?: Record<string, string>;
+    /** After a removal, how many times to ask a store's search whether the value is gone, and the first wait between asks (doubling). Default 3 and 200 ms. */
+    verify?: {
+        attempts?: number;
+        delayMs?: number;
+    };
 }
 /** Parses the ISO 8601 duration subset retention needs: P<n>W, P<n>D, PT<n>H, and combinations of D and H. */
 export declare function durationMs(iso: string): number;