keri-ts 1.0.0 → 2.0.0

package/esm/keri/npm/src/app/{ipexing.js → ipex/ipexing.js}

@@ -1,4 +1,5 @@
-import { exchange, isIpexVerb } from "../core/protocol-exchanging.js";
+import { ValidationError } from "../../core/errors.js";
+import { exchange, isIpexVerb } from "../../core/exchange/protocol-exchanging.js";
 import { IpexV2Handler } from "./ipex-v2.js";
 /** KERIpy IPEX route constants. */
 export const IPEX_APPLY_ROUTE = "/ipex/apply";
@@ -191,6 +192,62 @@ function requiredSaid(serder, label) {
 function rawMessage(message) {
     return message instanceof Uint8Array ? message : message.raw;
 }
+/** Validate known signed response parties and the existing legacy predecessor graph. */
+export function validateIpexReply(prior, verb, sender, recipient) {
+    if (!(PREVIOUS_IPEX_ROUTES.get(verb) ?? []).some(route => prior.route === `/ipex/${route}`)) {
+        throw new ValidationError("Prior IPEX exchange is missing or has the wrong route.");
+    }
+    const intended = ipexRecipient(prior);
+    if (prior.pre !== recipient || (intended && intended !== sender)) {
+        throw new ValidationError("IPEX response parties do not match the accepted prior exchange.");
+    }
+}
+/**
+ * Preflight a proposed legacy conversation before a member adds a signature.
+ * Missing accepted predecessors stay pending; malformed routes, changed parties
+ * and replacement responses fail. This does not admit an EXN or change its indexes.
+ */
+export function ipexConversationReady(db, exn) {
+    const verb = ipexVerbForRoute(exn.route ?? "");
+    if (!verb || !exn.pre || exn.pvrsn.major !== 1)
+        throw new ValidationError("Unsupported IPEX conversation profile.");
+    const said = priorSaid(exn);
+    if (!said) {
+        if (!STARTABLE_WITHOUT_PRIOR.has(verb))
+            throw new ValidationError("IPEX response requires its predecessor.");
+        if (!ipexRecipient(exn))
+            throw new ValidationError("IPEX proposal is missing its recipient.");
+        return true;
+    }
+    const prior = db.exns.get([said]);
+    if (!prior)
+        return false;
+    const recipient = ipexRecipient(exn, prior);
+    if (!recipient)
+        throw new ValidationError("IPEX proposal is missing its recipient.");
+    validateIpexReply(prior, verb, exn.pre, recipient);
+    const response = db.erpy.get([said]);
+    if (response && response.qb64 !== exn.said) {
+        throw new ValidationError("Prior IPEX exchange already has another accepted response.");
+    }
+    return true;
+}
+/**
+ * Resolve signed recipient data, or the sender of an accepted linked predecessor.
+ * Legacy admit/agree/spurn builders omit an explicit recipient. Callers loading
+ * a predecessor must supply it from accepted storage; this helper does not admit it.
+ */
+export function ipexRecipient(exn, prior) {
+    const rp = exn.ked?.rp;
+    if (typeof rp === "string" && rp.length > 0)
+        return rp;
+    const attrs = exn.ked?.a;
+    if (isRecord(attrs) && typeof attrs.i === "string" && attrs.i.length > 0)
+        return attrs.i;
+    if (prior?.said && priorSaid(exn) === prior.said)
+        return prior.pre || null;
+    return null;
+}
 function priorSaid(serder) {
     const prior = serder.ked?.p;
     return typeof prior === "string" ? prior : "";

package/esm/keri/npm/src/app/mailbox/forward-handler.js

@@ -0,0 +1,228 @@
+/** Authenticated /fwd intake: validate provider authority before storing reconstructed child bytes. */
+import { collectPayload, concatBytes, Counter, Diger, nestedPayload, parsePather, SerderACDC, SerderKERI, Vrsn_2_0, } from "cesr-ts";
+import { Roles } from "../../core/roles.js";
+import { abortable } from "../runtime/abortable.js";
+/**
+ * Accepted `/fwd` route handler that stores embedded payloads in mailbox topics.
+ *
+ * This is the `keri-ts` mailbox-storage analogue to KERIpy's `ForwardHandler`.
+ *
+ * Authorization rule:
+ * - the request-scoped mailbox AID passed with this message must currently be
+ *   authorized for the addressed recipient
+ */
+export class ForwardHandler {
+    /**
+     * Bind mailbox publication without acquiring a store.
+     *
+     * @param mailboxDirector Borrowed provider owner that publishes accepted forwarded payloads.
+     */
+    constructor(mailboxDirector) {
+        /** Instance route identity used by exchange dispatch. */
+        Object.defineProperty(this, "resource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ForwardHandler.resource
+        });
+        /** This route binds a single v2 child body; recipient processors authenticate its evidence. */
+        Object.defineProperty(this, "acceptsNests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        /** Borrowed provider publication/correlation owner. */
+        Object.defineProperty(this, "mailboxDirector", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.mailboxDirector = mailboxDirector;
+    }
+    /**
+     * Verify that the embedded exchange has the mailbox modifiers and one
+     * extractable forwarded payload.
+     *
+     * @param args Signed forwarding exchange, attachment evidence and optional nested frames; children retain their own authentication requirements.
+     * @returns Whether required modifiers and one bound forwarded payload are structurally valid.
+     */
+    verify(args) {
+        const modifiers = args.serder.ked?.q;
+        if (typeof modifiers?.pre !== "string" || typeof modifiers?.topic !== "string")
+            return false;
+        if (args.serder.pvrsn.major < 2) {
+            return !args.nests?.length && extractForwardedMessage(args.serder, args.attachments) !== null;
+        }
+        if (args.nests?.length !== 1)
+            return false;
+        const signed = args.serder.a?.evt;
+        const child = args.nests[0].body;
+        if (typeof signed !== "string" || !(child instanceof SerderKERI || child instanceof SerderACDC))
+            return false;
+        try {
+            return child.verify() && new Diger({ qb64: signed }).verify(child.raw);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Store one forwarded payload when the receiving host is allowed to act as
+     * the recipient's async correspondence store.
+     *
+     * Accepted host shapes:
+     * - explicit mailbox provider authorized in `ends.`
+     * - recipient witness host from the accepted KEL witness set
+     * - recipient agent host authorized in `ends.`
+     *
+     * Controller endpoints stay excluded here because they are direct
+     * correspondence destinations, not store-and-forward hosts.
+     *
+     * @param args Accepted exchange with borrowed attachments/children and receiving mailboxAid provenance.
+     * @returns An operation for v2 child serialization, or synchronous completion/no-op for legacy or unauthorized input.
+     */
+    handle(args) {
+        const modifiers = args.serder.ked?.q;
+        const recipient = typeof modifiers?.pre === "string" ? modifiers.pre : null;
+        const topic = typeof modifiers?.topic === "string" ? modifiers.topic : null;
+        const child = args.serder.pvrsn.major >= 2 ? args.nests?.[0] : undefined;
+        const forwarded = child ? null : extractForwardedMessage(args.serder, args.attachments);
+        const mailboxAid = args.mailboxAid;
+        if (!recipient || !topic || (!child && !forwarded)) {
+            return;
+        }
+        if (!this.canStoreRecipient(recipient, mailboxAid))
+            return;
+        if (child) {
+            // Mailbox LMDB accepts a finite row; collect one child, never the whole exchange stream.
+            return abortable(async (signal) => {
+                const wire = await collectPayload(nestedPayload(child, Vrsn_2_0), signal);
+                signal.throwIfAborted();
+                if (this.canStoreRecipient(recipient, mailboxAid))
+                    this.mailboxDirector.publish(recipient, topic, wire);
+            });
+        }
+        this.mailboxDirector.publish(recipient, topic, forwarded);
+    }
+    /** Re-read accepted authority in the same synchronous turn as provider publication. */
+    canStoreRecipient(recipient, mailboxAid) {
+        const hby = this.mailboxDirector.hby;
+        const kever = hby.db.getKever(recipient);
+        if (!kever)
+            return false;
+        if (mailboxAid)
+            return hostCanStoreForwardRecipient(hby, recipient, kever, mailboxAid);
+        return hasLocalStoreForwardHost(hby, recipient, kever);
+    }
+}
+/** Registered exchange route for store-forward messages. */
+Object.defineProperty(ForwardHandler, "resource", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "/fwd"
+});
+/**
+ * Check recipient-specific store-forward authority without treating a controller endpoint as a mailbox.
+ *
+ * @param hby Borrowed local habitat collection and accepted-state database.
+ * @param recipient Final recipient AID.
+ * @param recipientKever Accepted recipient state supplying its current witness cohort.
+ * @param hostAid Receiving endpoint AID whose witness/mailbox/agent authority is checked.
+ * @returns True when current accepted witness or endpoint-role state authorizes a local store-forward host.
+ */
+function hostCanStoreForwardRecipient(hby, recipient, recipientKever, hostAid) {
+    // A local host may store forwarded traffic only when it is an authorized
+    // witness/mailbox/agent for the recipient. This keeps mailbox storage from
+    // becoming a generic unauthenticated relay.
+    if (recipientKever.wits.includes(hostAid)) {
+        return true;
+    }
+    for (const role of [Roles.mailbox, Roles.agent]) {
+        const end = hby.db.ends.get([recipient, role, hostAid]);
+        if (end?.allowed || end?.enabled) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check recipient-specific store-forward authority without treating a controller endpoint as a mailbox.
+ *
+ * @param hby Borrowed local habitat collection and accepted-state database.
+ * @param recipient Final recipient AID.
+ * @param recipientKever Accepted recipient state supplying its current witness cohort.
+ * @returns True when current accepted witness or endpoint-role state authorizes a local store-forward host.
+ */
+function hasLocalStoreForwardHost(hby, recipient, recipientKever) {
+    // Check all local prefixes because a multi-role runtime can host a mailbox
+    // AID that is distinct from the controller currently processing the EXN.
+    for (const hostAid of hby.db.prefixes) {
+        if (hostCanStoreForwardRecipient(hby, recipient, recipientKever, hostAid)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Reconstruct legacy forwarded wire without assigning outer attachments to the child.
+ *
+ * @param serder Legacy forwarding exchange containing an e.evt body.
+ * @param attachments Pathed attachments; only /e/evt material belongs to the embedded message.
+ * @returns Reconstructed child wire, or null without an embedded event.
+ */
+function extractForwardedMessage(serder, attachments) {
+    const embeds = serder.ked?.e;
+    const evt = embeds?.evt;
+    if (!evt || typeof evt !== "object" || Array.isArray(evt)) {
+        return null;
+    }
+    // Rebuild the embedded event from SAD plus only the attachment material
+    // pathed to `/e/evt`; other pathed groups belong to the outer `/fwd` message.
+    const embedded = embeddedSerderRaw(evt);
+    const messageParts = [embedded];
+    for (const attachment of attachments) {
+        const atc = forwardedAttachmentForPath(attachment.raw, "/e/evt");
+        if (atc) {
+            messageParts.push(atc);
+        }
+    }
+    return concatBytes(...messageParts);
+}
+/**
+ * Serialize one legacy embedded body according to its declared protocol.
+ *
+ * @param sad Embedded self-addressing data; version prefix selects ACDC versus KERI serialization.
+ * @returns Serialized embedded body bytes; caller owns attachment reconstruction.
+ */
+function embeddedSerderRaw(sad) {
+    const version = typeof sad.v === "string" ? sad.v : "";
+    if (version.startsWith("ACDC")) {
+        return new SerderACDC({ sad, verify: false }).raw;
+    }
+    return new SerderKERI({ sad }).raw;
+}
+/**
+ * Extract the forwarded attachment bytes for the embedded `/e/evt` path.
+ *
+ * Forwarded attachment groups can carry multiple pathed attachments, so the
+ * path filter keeps mailbox reconstruction focused on the embedded event.
+ *
+ * @param raw One qualified pathed attachment group in text-domain bytes.
+ * @param path Exact embedded SAD path to match.
+ * @returns Attachment bytes after the matching pather, or null for a different/empty group.
+ */
+function forwardedAttachmentForPath(raw, path) {
+    if (raw.length === 0) {
+        return null;
+    }
+    const counter = new Counter({ qb64b: raw });
+    const offset = counter.fullSize;
+    const pather = parsePather(raw.slice(offset), "txt");
+    if (pather.path !== path) {
+        return null;
+    }
+    return raw.slice(offset + pather.fullSize);
+}

package/esm/keri/npm/src/app/{mailbox-director.js → mailbox/mailbox-director.js}

@@ -1,5 +1,5 @@
-import { Deck } from "../core/deck.js";
-import { ValidationError } from "../core/errors.js";
+import { Deck } from "../../core/deck.js";
+import { ValidationError } from "../../core/errors.js";
 import { mailboxQueryTopics, mailboxTopicKey, updateMailboxRemoteCursor } from "./mailboxing.js";
 /** Shared encoder for SSE mailbox stream framing. */
 const textEncoder = new TextEncoder();
@@ -25,13 +25,27 @@ const STREAM_CHUNK_BYTES = 65536;
  *   `MailboxIterable`
  */
 export class MailboxDirector {
+    /**
+     * Compose provider publication and request-owned stream tracking.
+     * Absent mailboxer disables storage/serving; correlation and topic registration
+     * remain available. A new query Deck is created only when none is supplied.
+     *
+     * @param hby Borrowed local identities and accepted-state stores.
+     * @param options Optional borrowed mailbox store, exclusive query-cue Deck and initial topics; no store is opened.
+     */
     constructor(hby, { mailboxer, queryCues, topics = [], } = {}) {
+        /**
+         * Borrowed local identities and accepted-state stores.
+         */
         Object.defineProperty(this, "hby", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Borrowed provider mailbox store, or null when this host cannot serve stored messages.
+         */
         Object.defineProperty(this, "mailboxer", {
             enumerable: true,
             configurable: true,
@@ -45,18 +59,27 @@ export class MailboxDirector {
             writable: true,
             value: void 0
         });
+        /**
+         * Registered protocol topics, copied from construction input and extended by registerTopic.
+         */
         Object.defineProperty(this, "topics", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Live response finalizers joined before the provider store can close.
+         */
         Object.defineProperty(this, "streamCleanups", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Set()
         });
+        /**
+         * Terminal stream/correlation admission state.
+         */
         Object.defineProperty(this, "closed", {
             enumerable: true,
             configurable: true,
@@ -68,17 +91,21 @@ export class MailboxDirector {
         this.queryCues = queryCues ?? new Deck();
         this.topics = new Set(topics);
     }
-    /** Return true when provider-side mailbox storage is available. */
-    hasMailboxStore() {
-        return this.mailboxer !== null;
-    }
-    /** Register one mailbox topic this runtime should poll/stream. */
+    /**
+     * Register one mailbox topic this runtime should poll/stream.
+     *
+     * @param topic Protocol mailbox topic; leading slash is normalized where required.
+     */
     registerTopic(topic) {
         if (topic.length > 0) {
             this.topics.add(topic);
         }
     }
-    /** Snapshot the currently configured mailbox topic set. */
+    /**
+     * Snapshot the currently configured mailbox topic set.
+     *
+     * @returns Independent array snapshot of the configured topic set.
+     */
     registeredTopics() {
         return [...this.topics];
     }
@@ -99,7 +126,14 @@ export class MailboxDirector {
         if (failures.length)
             throw new AggregateError(failures, "Mailbox stream cleanup failed");
     }
-    /** Validate exact cursor ordinals before copying the caller's query positions. */
+    /**
+     * Validate exact cursor ordinals before copying the caller's query positions.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param topics Topic-to-next-wanted ordinal map; each value must be a nonnegative safe integer.
+     * @returns A copied cursor map owned by this response.
+     * @throws RangeError for malformed prefix/map/ordinals.
+     */
     cursor(pre, topics) {
         if (typeof pre !== "string" || !topics || typeof topics !== "object" || Array.isArray(topics)) {
             throw new RangeError("Invalid mailbox topic metadata");
@@ -113,7 +147,11 @@ export class MailboxDirector {
         }
         return { ...topics };
     }
-    /** Queue a query cue for correlation with its mailbox response. */
+    /**
+     * Queue a query cue for correlation with its mailbox response.
+     *
+     * @param cue Authorized stream request produced by protocol processing; the director owns later correlation consumption.
+     */
     retainQueryCue(cue) {
         if (this.closed)
             throw new Error("Mailbox query correlation is closed");
@@ -124,13 +162,24 @@ export class MailboxDirector {
      * `pre/topic`.
      *
      * The returned index is the newly assigned mailbox event id for that topic.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param topic Protocol mailbox topic; leading slash is normalized where required.
+     * @param msg Complete already-authorized wire message to persist under this recipient/topic.
+     * @returns Assigned mailbox index; persistence is not remote consumption.
      */
     publish(pre, topic, msg) {
         const idx = this.lastIndex(pre, topic) + 1;
         this.requireMailboxer().storeMsg(mailboxTopicKey(pre, topic), msg);
         return idx;
     }
-    /** Return the latest stored publication index for one topic, or `-1`. */
+    /**
+     * Return the latest stored publication index for one topic, or `-1`.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param topic Protocol mailbox topic; leading slash is normalized where required.
+     * @returns Latest stored insertion ordinal, or -1 for an empty topic.
+     */
     lastIndex(pre, topic) {
         const count = this.requireMailboxer().tpcs.cntOn(mailboxTopicKey(pre, topic));
         return count > 0 ? count - 1 : -1;
@@ -140,6 +189,11 @@ export class MailboxDirector {
      *
      * The returned index is the mailbox event id that should be reflected in the
      * SSE `id:` field for the emitted message.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param topic Protocol mailbox topic; leading slash is normalized where required.
+     * @param from Inclusive insertion ordinal; default zero.
+     * @returns Synchronous iterator of ordinal/message pairs in storage order.
      */
     *topicIter(pre, topic, from = 0) {
         for (const [idx, , msg] of this.requireMailboxer().cloneTopicIter(mailboxTopicKey(pre, topic), from)) {
@@ -154,13 +208,26 @@ export class MailboxDirector {
      * - emit one initial `retry:` hint
      * - stream ordered mailbox payloads as `id/event/data`
      * - close once the idle window expires without new mailbox traffic
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param topicCursor Next wanted insertion ordinal for each requested topic; copied before streaming.
+     * @param options SSE retry hint, local polling interval, optional idle expiry and initial hint selection.
+     * @returns Demand-driven response tracked until EOF, cancellation or director close.
      */
     streamMailbox(pre, topicCursor, options = {}) {
         if (this.closed)
             throw new Error("Mailbox stream is closed");
         return this.mailboxStream(pre, this.cursor(pre, topicCursor), options, true);
     }
-    /** Own one demand-driven mailbox reader; query responses join their nested reader themselves. */
+    /**
+     * Own one demand-driven mailbox reader; query responses join their nested reader themselves.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param cursors Response-owned next-wanted ordinals, advanced as rows are framed.
+     * @param options Millisecond retry/poll/idle settings; null idle timeout keeps the response open.
+     * @param tracked Track direct responses here; nested query responses are joined by their outer owner.
+     * @returns SSE bytes in 64 KiB chunks; database iterators close before awaiting HTTP demand.
+     */
     mailboxStream(pre, cursors, { retryMs = 5000, pollIntervalMs = 50, idleTimeoutMs = 2000, emitRetryHeader = true, }, tracked) {
         for (const value of [retryMs, pollIntervalMs, idleTimeoutMs]) {
             if (value !== null && (!Number.isSafeInteger(value) || value < 0)) {
@@ -189,9 +256,11 @@ export class MailboxDirector {
             wake?.();
             parts = [];
         };
+        /** Remove this direct stream from shutdown tracking after its pending pull settles. */
         const finish = () => {
             this.streamCleanups.delete(close);
         };
+        /** Wake and join the pending pull once before forgetting this response owner. */
         const cleanup = () => {
             stop();
             return closing ??= Promise.resolve(pending).finally(finish);
@@ -205,6 +274,11 @@ export class MailboxDirector {
             return cleanup();
         };
         const readable = new ReadableStream({
+            /**
+             * Bind the Web stream controller before response demand begins.
+             *
+             * @param controller Web response controller retained for later pulls/shutdown.
+             */
             start(controller) {
                 stream = controller;
             },
@@ -298,6 +372,10 @@ export class MailboxDirector {
      * This mirrors KERIpy `QryRpyMailboxIterable` ownership closely: the HTTP
      * route does not guess mailbox topics itself; it waits for mailbox query
      * correlation to tell it what to stream.
+     *
+     * @param said Query SAID used to locate an already-authorized stream cue; correlation alone is not authorization.
+     * @param options Retry hint and query-cue polling interval in milliseconds; defaults 5000 and 50.
+     * @returns Request-owned SSE response that waits for its cue then proxies an unbounded mailbox reader.
      */
     streamQueryResponse(said, { retryMs = 5000, pollIntervalMs = 50 } = {}) {
         if (this.closed)
@@ -363,6 +441,9 @@ export class MailboxDirector {
             return completed;
         };
         const readable = new ReadableStream({
+            /** Bind this nested response controller before the first pull.
+             * @param controller Web response controller used by pull and shutdown.
+             */
             start(controller) {
                 stream = controller;
             },
@@ -433,11 +514,22 @@ export class MailboxDirector {
      *
      * Stored cursor rows track the last seen index, while the wire query asks for
      * the next wanted index.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param witness Remote mailbox/witness endpoint AID, not the local signer.
+     * @returns Next-wanted ordinals (last consumed + 1, or zero) for registered topics.
      */
     remoteQueryCursor(pre, witness) {
         return mailboxQueryTopics(this.hby, pre, witness, this.topics);
     }
-    /** Persist one consumed remote mailbox index for one `(pre, witness, topic)`. */
+    /**
+     * Persist one consumed remote mailbox index for one `(pre, witness, topic)`.
+     *
+     * @param pre AID whose mailbox or accepted state is addressed.
+     * @param witness Remote endpoint AID.
+     * @param topic Protocol mailbox topic; leading slash is normalized where required.
+     * @param idx Last successfully consumed insertion ordinal, not the next requested ordinal.
+     */
     updateRemoteCursor(pre, witness, topic, idx) {
         updateMailboxRemoteCursor(this.hby, pre, witness, topic, idx);
     }
@@ -447,6 +539,9 @@ export class MailboxDirector {
      *
      * This keeps query correlation observable without consuming cues that later
      * host work still needs.
+     *
+     * @param said Exact query SAID whose stream request is sought.
+     * @returns Whether a matching request exists.
      */
     hasQueryCue(said) {
         for (const cue of this.queryCues) {
@@ -455,7 +550,12 @@ export class MailboxDirector {
         }
         return false;
     }
-    /** Select the first matching owner without re-admission or changing preceding cue order. */
+    /**
+     * Select the first matching owner without re-admission or changing preceding cue order.
+     *
+     * @param said Exact query SAID whose stream request is sought.
+     * @returns Removed matching cue, or null; other cues retain their order.
+     */
     takeQueryCue(said) {
         let preceding = 0;
         for (const cue of this.queryCues) {
@@ -472,7 +572,12 @@ export class MailboxDirector {
         }
         return null;
     }
-    /** Require provider mailbox storage for publication or mailbox serving. */
+    /**
+     * Require provider mailbox storage for publication or mailbox serving.
+     *
+     * @returns Borrowed provider store.
+     * @throws ValidationError when storage is absent.
+     */
     requireMailboxer() {
         if (!this.mailboxer) {
             throw new ValidationError("Provider mailbox storage is unavailable for this runtime.");