keri-ts 1.0.0 → 2.0.1

package/esm/keri/npm/src/app/group-members.js

@@ -1,37 +0,0 @@
-import { ValidationError } from "../core/errors.js";
-/** True when the selected habitat is a local group habitat. */
-export function isLocalGroupHab(hby, hab) {
-    return !!hab.pre && !!hby.db.getHab(hab.pre)?.mid;
-}
-/** Return the local member habitat for a persisted group identifier. */
-export function localGroupMember(hby, groupPre) {
-    const record = hby.db.getHab(groupPre);
-    const member = record?.mid ? hby.habs.get(record.mid) : null;
-    if (!member) {
-        throw new ValidationError(`Group ${groupPre} is missing local member metadata.`);
-    }
-    return member;
-}
-/** Return current group signing member AIDs in signing-index order. */
-export function groupSigningMembers(hby, groupPre) {
-    const stored = hby.ks.getSmids(groupPre).map((tuple) => tuple[0].qb64);
-    if (stored.length > 0) {
-        return stored;
-    }
-    const record = hby.db.getHab(groupPre);
-    return record?.smids ?? [];
-}
-/** Return the first locally available habitat from `members`, if any. */
-export function findLocalGroupMember(hby, members) {
-    for (const member of members) {
-        const hab = hby.habs.get(member);
-        if (hab) {
-            return hab;
-        }
-    }
-    return null;
-}
-/** Return unique non-empty member AIDs while preserving first-seen order. */
-export function uniqueMembers(members) {
-    return [...new Set(members.filter((member) => member.length > 0))];
-}

package/esm/keri/npm/src/app/httping.js

@@ -1,162 +0,0 @@
-import { call, resource } from "effection";
-import { defaultRuntimeServices } from "./runtime-services.js";
-/**
- * Fetch one HTTP response under Effection cancellation control.
- *
- * This is the shared request-lifecycle seam:
- * - create one local `AbortController`
- * - keep the request and response body owned through enclosing scope exit
- * - abort and join late fetch completion when the enclosing operation is canceled
- * - consume each response inside a finite `call`/`scoped` operation in continuous workers
- * - hand the caller both the `Response` and the controller when body policy
- *   needs later abort access, such as mailbox SSE long-poll reads
- */
-export function* fetchResponseHandle(url, init = {}, options = {}) {
-    const { services = defaultRuntimeServices } = options;
-    const handle = yield* fetchResponseHandleInternal(url, init, { services });
-    if (!handle) {
-        throw new Error("HTTP response handle unexpectedly resolved to null.");
-    }
-    return handle;
-}
-/**
- * Fetch one HTTP response handle with an abort-to-null policy.
- *
- * This is for callers such as mailbox polling that treat request timeout as a
- * normal "no response yet" outcome instead of as an exception.
- */
-export function* fetchResponseHandleOrNull(url, init = {}, options = {}) {
-    const { timeoutMs, services = defaultRuntimeServices } = options;
-    return yield* fetchResponseHandleInternal(url, init, {
-        timeoutMs,
-        nullOnAbort: true,
-        services,
-    });
-}
-/**
- * Close one response body under Effection control.
- *
- * Callers should use this instead of open-coding `body.cancel()` so response
- * cleanup policy stays consistent across mailbox, OOBI, auth, and exchange
- * flows.
- */
-export function* closeResponseBody(response) {
-    if (!response.body) {
-        return;
-    }
-    yield* call(function* () {
-        let pending;
-        yield* resource(function* (provide) {
-            try {
-                yield* provide();
-            }
-            finally {
-                // Register before starting cleanup; cancellation joins it and preserves later failure.
-                if (pending)
-                    yield* call(() => pending);
-            }
-        });
-        pending = response.body.cancel();
-        yield* call(() => pending);
-    });
-}
-/** Own fetch completion and the returned body until the enclosing request scope closes. */
-function* fetchResponseHandleInternal(url, init, options = {}) {
-    const { timeoutMs, nullOnAbort = false, services = defaultRuntimeServices, } = options;
-    return yield* resource(function* (provide) {
-        // The response body remains owned after headers settle and until this resource's scope exits.
-        const controller = new AbortController();
-        // Forward the caller's signal into the actual request/body owner, preserving its reason.
-        const upstream = init.signal;
-        const cancel = () => controller.abort(upstream.reason);
-        upstream?.addEventListener("abort", cancel, { once: true });
-        let timedOut = false;
-        let timeoutId;
-        /** A header timeout ends when fetch settles; body limits belong to its consumer. */
-        const clearTimer = () => {
-            if (timeoutId !== undefined)
-                services.clock.clearTimeout(timeoutId);
-        };
-        try {
-            if (upstream?.aborted)
-                cancel();
-            controller.signal.throwIfAborted();
-            if (timeoutMs !== undefined) {
-                timeoutId = services.clock.setTimeout(() => {
-                    // A later deadline must not reclassify an earlier external cancellation as a timeout.
-                    if (!controller.signal.aborted) {
-                        timedOut = true;
-                        controller.abort();
-                    }
-                }, timeoutMs);
-            }
-            let response;
-            try {
-                const owner = yield* ownHttpResponse(() => services.http.fetch(url, { ...init, signal: controller.signal }), controller);
-                response = yield* owner.response();
-            }
-            catch (error) {
-                if (nullOnAbort && timedOut && error === controller.signal.reason) {
-                    clearTimer();
-                    yield* provide(null);
-                    return;
-                }
-                throw error;
-            }
-            clearTimer();
-            yield* provide({ response, controller });
-        }
-        finally {
-            upstream?.removeEventListener("abort", cancel);
-            clearTimer();
-        }
-    });
-}
-/** Own one pending fetch and its returned body; protocol callers own request construction and upload policy. */
-export function ownHttpResponse(fetch, controller) {
-    return resource(function* (provide) {
-        let pending;
-        let deliveredFailure;
-        try {
-            pending = fetch();
-            yield* provide({
-                *response() {
-                    try {
-                        return yield* call(() => pending);
-                    }
-                    catch (error) {
-                        deliveredFailure = { error };
-                        throw error;
-                    }
-                },
-            });
-        }
-        finally {
-            controller.abort();
-            if (pending) {
-                yield* call(async () => {
-                    // A fetch completing during cancellation still transfers its response to this owner.
-                    let response;
-                    try {
-                        response = await pending;
-                    }
-                    catch (error) {
-                        // Consume only this controller's abort or the identical failure already propagated.
-                        if (error === controller.signal.reason || (deliveredFailure && error === deliveredFailure.error))
-                            return;
-                        throw error;
-                    }
-                    if (response.body && !response.body.locked) {
-                        try {
-                            await response.body.cancel();
-                        }
-                        catch (error) {
-                            if (error !== controller.signal.reason)
-                                throw error;
-                        }
-                    }
-                });
-            }
-        }
-    });
-}

package/esm/keri/npm/src/app/ipex-graph.js

@@ -1,407 +0,0 @@
-/** Borrowed ACDC disclosure DAGs: structure, negotiated paths and edge semantics. */
-import { Compactor, makePather, Saider, SealEvent, SerderACDC } from "cesr-ts";
-import { validateSchema } from "../acdc/scheming.js";
-const sectionLabels = new Set(["d", "u", "o", "w"]);
-const groupLabels = new Set([...sectionLabels, "s"]);
-const nodeLabels = new Set(["d", "u", "n", "s", "o", "w"]);
-const nodeIlks = new Set([null, "acm", "ace", "act", "acg"]);
-const unaryOps = new Set(["I2I", "NI2I", "DI2I", "E1E", "NOT"]);
-/** SAD maps, including null-prototype maps, exclude scalar/array representations. */
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/** Required SAIDs must have valid digest-qualified CESR material. */
-function validSaid(value) {
-    if (typeof value !== "string")
-        return false;
-    try {
-        return new Saider({ qb64: value }).qb64 === value;
-    }
-    catch {
-        return false;
-    }
-}
-/** Python's empty section containers carry no disclosed edge semantics. */
-function present(value) {
-    return Array.isArray(value) ? value.length > 0 : record(value) ? Object.keys(value).length > 0 : Boolean(value);
-}
-/** Return disclosed edge blocks, with null distinguishing malformed from absent. */
-function blocks(value) {
-    if (!present(value))
-        return [];
-    if (record(value))
-        return [value];
-    return Array.isArray(value) && value.every(record) ? value : null;
-}
-/** Validate the frozen single-DAG disclosure triple grammar without parsing child bytes. */
-export function validDisclosurePlan(value) {
-    if (!Array.isArray(value))
-        return false;
-    for (const item of value) {
-        if (!Array.isArray(item) || item.length !== 3)
-            return false;
-        const [schema, path, fields] = item;
-        if (typeof schema !== "string" || typeof path !== "string")
-            return false;
-        if (path !== "/") {
-            if (!path.startsWith("/") || !path.endsWith("/"))
-                return false;
-            const parts = path.replace(/^\/+|\/+$/g, "").split("/");
-            if (parts.some((part) => !part) || parts.at(-1) !== "_")
-                return false;
-        }
-        if (!Array.isArray(fields))
-            return false;
-        if (fields.length === 1 && fields[0] === "")
-            continue;
-        for (const field of fields) {
-            if (typeof field !== "string" || !field || field.startsWith("/"))
-                return false;
-            try {
-                makePather(field, { relative: true });
-            }
-            catch {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/**
- * Index unique disclosed credential nodes and walk their reachable graph in BFS order.
- * Offers may omit far nodes; grants require every referenced node. Nested ownership
- * does not make these nodes independently accepted runtime messages.
- */
-export function walkIpexGraph(origin, nests, closed) {
-    const nodes = new Map();
-    for (const [index, frame] of nests.entries()) {
-        const body = frame.body;
-        if (!(body instanceof SerderACDC) || !body.verify() || !nodeIlks.has(body.ilk)
-            || !body.said || (index === 0 && body.said !== origin) || nodes.has(body.said))
-            return null;
-        // Descendants are not additional implicit evidence for this disclosed node.
-        if (frame.nests?.length)
-            return null;
-        nodes.set(body.said, frame);
-    }
-    if (!nodes.has(origin))
-        return null;
-    const seen = new Set();
-    const order = [];
-    const dependencies = new Map();
-    const queue = [origin];
-    for (let index = 0; index < queue.length; index++) {
-        const said = queue[index];
-        if (seen.has(said))
-            continue;
-        seen.add(said);
-        order.push(said);
-        const farNodes = new Set();
-        dependencies.set(said, farNodes);
-        const edges = blocks(nodes.get(said).body.sad.e);
-        if (!edges)
-            return null;
-        const groups = edges.map((edge) => ({ edge, nested: false }));
-        for (let g = 0; g < groups.length; g++) {
-            const { edge, nested } = groups[g];
-            if (Object.hasOwn(edge, "n")) {
-                if (Object.keys(edge).some((key) => !nodeLabels.has(key)) || !validSaid(edge.n))
-                    return null;
-                if (!nodes.has(edge.n)) {
-                    if (closed)
-                        return null;
-                }
-                else {
-                    farNodes.add(edge.n);
-                    if (!seen.has(edge.n))
-                        queue.push(edge.n);
-                }
-            }
-            else {
-                const labels = nested ? groupLabels : sectionLabels;
-                for (const [key, value] of Object.entries(edge)) {
-                    if (labels.has(key))
-                        continue;
-                    if (!record(value))
-                        return null;
-                    groups.push({ edge: value, nested: true });
-                }
-            }
-        }
-    }
-    if (seen.size !== nodes.size)
-        return null;
-    const parents = new Map();
-    for (const [near, children] of dependencies) {
-        for (const far of children) {
-            if (!parents.has(far))
-                parents.set(far, new Set());
-            parents.get(far).add(near);
-        }
-    }
-    const dependencyOrder = order.filter((said) => dependencies.get(said).size === 0);
-    for (let i = 0; i < dependencyOrder.length; i++) {
-        for (const near of parents.get(dependencyOrder[i]) ?? []) {
-            const children = dependencies.get(near);
-            children.delete(dependencyOrder[i]);
-            if (!children.size)
-                dependencyOrder.push(near);
-        }
-    }
-    return dependencyOrder.length === nodes.size ? { nodes, order, dependencyOrder } : null;
-}
-/** Compare SAD values structurally while retaining list order; map insertion order is not semantic here. */
-function equal(a, b) {
-    if (a === b)
-        return true;
-    if (Array.isArray(a) && Array.isArray(b))
-        return a.length === b.length && a.every((item, i) => equal(item, b[i]));
-    if (record(a) && record(b)) {
-        return Object.keys(a).length === Object.keys(b).length
-            && Object.entries(a).every(([key, value]) => Object.hasOwn(b, key) && equal(value, b[key]));
-    }
-    return false;
-}
-/** Require the plan to select every disclosed node in canonical breadth-first order. */
-export function verifyIpexDisclosure(plan, origin, graph) {
-    const selected = [];
-    for (const [schema, prefix, fields] of plan) {
-        let said = origin;
-        let node = graph.nodes.get(said);
-        if (!node)
-            return false;
-        let value = node.body.sad;
-        if (prefix !== "/") {
-            for (const part of prefix.replace(/^\/+|\/+$/g, "").split("/")) {
-                if (part === "_") {
-                    if (!record(value) || typeof value.n !== "string")
-                        return false;
-                    said = value.n;
-                    node = graph.nodes.get(said);
-                    if (!node)
-                        return false;
-                    value = node.body.sad;
-                }
-                else if (record(value) && Object.hasOwn(value, part))
-                    value = value[part];
-                else if (Array.isArray(value) && /^\d+$/.test(part) && Number(part) < value.length)
-                    value = value[Number(part)];
-                else
-                    return false;
-            }
-        }
-        selected.push(said);
-        const serder = node.body;
-        const nodeSchema = serder.schema;
-        if ((record(nodeSchema) ? nodeSchema.$id : nodeSchema) !== schema)
-            return false;
-        if (fields.length === 1 && fields[0] === "") {
-            for (const label of ["a", "e", "r"]) {
-                const section = serder.sad[label];
-                if (present(section) && !record(section))
-                    return false;
-            }
-            if (present(serder.sad.A) && !Array.isArray(serder.sad.A))
-                return false;
-            continue;
-        }
-        const sections = new Map();
-        for (const field of fields) {
-            try {
-                const pather = makePather(field, { relative: true });
-                pather.resolve(serder.sad);
-                const root = pather.rparts[0];
-                if (root !== undefined)
-                    sections.set(root, [...(sections.get(root) ?? []), field]);
-            }
-            catch {
-                return false;
-            }
-        }
-        for (const [root, paths] of sections) {
-            const section = serder.sad[root];
-            if (!record(section))
-                continue;
-            try {
-                const compactor = new Compactor({
-                    mad: structuredClone(section),
-                    makify: true,
-                    kind: serder.kind,
-                });
-                compactor.compact(paths, root);
-                const partial = compactor.partials?.[paths.join("|")];
-                if (!partial)
-                    return false;
-                const expected = partial.mad;
-                if (section.d === "" && expected.d)
-                    expected.d = "";
-                if (!equal(expected, section))
-                    return false;
-            }
-            catch {
-                return false;
-            }
-        }
-    }
-    return equal(selected, graph.order);
-}
-/** Walk approved inception relationships without modifying delegation hints or imposing a depth policy. */
-function delegatedIssuer(issuer, issuee, db) {
-    let pre = issuer;
-    while (pre !== issuee) {
-        if (!db.getKever(pre))
-            return { kind: "missingKel", pre };
-        const said = db.kels.getLast(pre, 0);
-        const inception = said ? db.getEvtSerder(pre, said) : null;
-        if (!inception)
-            return { kind: "missingKel", pre };
-        if (inception.ilk !== "dip" || !inception.delpre)
-            return false;
-        const delegator = inception.delpre;
-        if (!db.getKever(delegator))
-            return { kind: "missingKel", pre: delegator };
-        const parentSaid = db.kels.getLast(delegator, 0);
-        const parent = parentSaid ? db.getEvtSerder(delegator, parentSaid) : null;
-        if (!parent)
-            return { kind: "missingKel", pre: delegator };
-        if (parent.traits.includes("DND"))
-            return false;
-        let approved = false;
-        for (const event of db.getEvtPreIter(delegator)) {
-            // Only the DIP's ordinal-zero seal matters; unrelated application data stays opaque.
-            if (event.seals.some((seal) => SealEvent.isSad(seal) && seal.i === pre && seal.d === inception.said && /^0+$/.test(seal.s))) {
-                approved = true;
-                break;
-            }
-        }
-        if (!approved)
-            return { kind: "missingKel", pre: delegator };
-        // DIP prefixes commit their delegator: a valid chain cannot contain a hash cycle.
-        pre = delegator;
-    }
-    return true;
-}
-/** Identity policy is separate from edge shape and additional far-node schema validation. */
-function identityRelation(operators, near, far, db) {
-    if (operators.includes("E1E") && (!near.issuee || !far.issuee || near.issuee !== far.issuee))
-        return false;
-    // Preserve the reference E1E extension's entity-only path unless identity is explicit.
-    let relation = far.issuee && !operators.includes("E1E") ? "I2I" : "NI2I";
-    for (const operator of operators) {
-        if (operator === "I2I" || operator === "NI2I" || operator === "DI2I")
-            relation = operator;
-    }
-    if (relation === "NI2I")
-        return true;
-    if (!far.issuee || !near.issuer)
-        return false;
-    if (near.issuer === far.issuee)
-        return true;
-    return relation === "DI2I" ? delegatedIssuer(near.issuer, far.issuee, db) : false;
-}
-/** Check one declared edge relation and its schema pin after the graph's issuer proofs pass. */
-function leafRelation(group, near, graph, inheritedSchema, db, validities) {
-    if (Object.keys(group).some((key) => !nodeLabels.has(key)) || typeof group.n !== "string")
-        return null;
-    const far = graph.nodes.get(group.n)?.body;
-    if (!far)
-        return null;
-    const op = group.o;
-    const operators = op == null || op === ""
-        ? []
-        : typeof op === "string"
-            ? [op]
-            : Array.isArray(op) && op.every((item) => typeof item === "string")
-                ? op
-                : null;
-    if (!operators || operators.some((item) => !unaryOps.has(item)))
-        return null;
-    const identity = identityRelation(operators, near, far, db);
-    if (typeof identity === "object")
-        return identity;
-    const schema = Object.hasOwn(group, "s") ? group.s : inheritedSchema;
-    let schemaMatches = true;
-    if (schema != null) {
-        if (typeof schema !== "string" && !record(schema))
-            return null;
-        const result = validateSchema(far, db, schema);
-        if (result.kind === "missing")
-            return result;
-        if (result.kind === "invalid") {
-            if (result.subject === "schema")
-                return null;
-            schemaMatches = false;
-        }
-    }
-    const valid = validities.get(group.n);
-    if (valid === undefined)
-        return null;
-    return identity && schemaMatches && (operators.includes("NOT") ? !valid : valid);
-}
-/** Evaluate AND/OR edge groups; malformed members cannot be hidden by a passing sibling. */
-function groupRelation(group, near, graph, inheritedSchema, nested, db, validities) {
-    const op = group.o ?? "AND";
-    if (op !== "AND" && op !== "OR")
-        return null;
-    const labels = nested ? groupLabels : sectionLabels;
-    const schema = nested && Object.hasOwn(group, "s") ? group.s : inheritedSchema;
-    const results = [];
-    for (const [key, node] of Object.entries(group)) {
-        if (labels.has(key))
-            continue;
-        if (!record(node))
-            return null;
-        const result = Object.hasOwn(node, "n")
-            ? leafRelation(node, near, graph, schema, db, validities)
-            : groupRelation(node, near, graph, schema, true, db, validities);
-        if (result === null)
-            return null;
-        if (typeof result === "object")
-            return result;
-        results.push(result);
-    }
-    return !results.length ? null : op === "OR" ? results.some(Boolean) : results.every(Boolean);
-}
-/** Preserve malformed/dependency outcomes separately from a disproved node relationship. */
-function nodeRelations(near, graph, db, validities) {
-    const edges = blocks(near.sad.e);
-    if (!edges)
-        return null;
-    let valid = true;
-    for (const edge of edges) {
-        const matched = Object.hasOwn(edge, "n")
-            ? leafRelation(edge, near, graph, null, db, validities)
-            : groupRelation(edge, near, graph, null, false, db, validities);
-        if (matched === null || typeof matched === "object")
-            return matched;
-        valid &&= matched;
-    }
-    return valid;
-}
-/**
- * Evaluate authenticated far-node validity before its parents. The issuance profile
- * uses the receiver's accepted observer state at this validation: issued/revoked.
- * Unknown vocabularies, malformed input and dependencies are never negated. The
- * origin is a disclosed message, not wallet acceptance of its own issuance state.
- */
-export function verifyIpexRelations(graph, db, registrations) {
-    const validities = new Map();
-    const origin = graph.order[0];
-    for (const said of graph.dependencyOrder) {
-        const near = graph.nodes.get(said).body;
-        const matched = nodeRelations(near, graph, db, validities);
-        if (matched === null)
-            return false;
-        if (typeof matched === "object")
-            return matched;
-        let valid = matched;
-        if (said !== origin && near.regid) {
-            const state = registrations.get(said)?.state ?? null;
-            if (state !== "issued" && state !== "revoked")
-                return { kind: "unknownState", said, state };
-            valid &&= state === "issued";
-        }
-        validities.set(said, valid);
-    }
-    return validities.get(origin) ?? false;
-}