nenavi 0.0.0 → 0.1.0-alpha.2

package/dist/cjs/client.js

@@ -0,0 +1,918 @@
+"use strict";
+// The client, `Nenavi`, and its resource groups (sdks/CONTRACT.md, Operations).
+//
+// Each method describes one call: its HTTP method and path, where its fields go, and
+// whether the SDK may retry it by itself. Core in core.ts sends it.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nenavi = exports.NenaviMethods = exports.ReingestWithHelpers = exports.NodesWithHelpers = exports.EventsWithHelpers = exports.Learning = exports.LearningProfiles = exports.AnswerCitations = exports.Relevance = exports.Retrievals = exports.Quantities = exports.Assertions = exports.Extractions = exports.Materializations = exports.AliasProposals = exports.Claims = exports.Reingest = exports.Nodes = exports.Events = void 0;
+const errors_js_1 = require("./errors.js");
+const core_js_1 = require("./core.js");
+class Resource {
+    _core;
+    _raw;
+    constructor(core, raw) {
+        this._core = core;
+        this._raw = raw;
+    }
+    /** Build the call and send it; an error while building it rejects the promise too. */
+    _request(build) {
+        let call;
+        try {
+            call = build();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        return this._core.request(call, this._raw);
+    }
+}
+/**
+ * The states a helper keeps polling through. Any other state, one the service adds later
+ * included, is final and returned.
+ */
+const WORKING = new Set(['pending', 'running']);
+/** `GET /v1/events/{event_id}/extraction-status`, for the method and its helper. */
+function extractionStatusCall(eventId, options) {
+    return {
+        method: 'GET',
+        path: `/v1/events/${(0, core_js_1.pathParam)(eventId)}/extraction-status`,
+        retrySafe: true,
+        options,
+    };
+}
+/** `GET /v1/reingest/{run_id}`, for the method and its helper. */
+function reingestGetCall(runId, options) {
+    return { method: 'GET', path: `/v1/reingest/${(0, core_js_1.pathParam)(runId)}`, retrySafe: true, options };
+}
+/** A caller's `Idempotency-Key`, or null; an empty value counts as not given. */
+function callerKey(options) {
+    const key = (0, core_js_1.ownProperties)(options).idempotencyKey;
+    return key ? String(key) : null;
+}
+/** The `/v1/events` routes. */
+class Events extends Resource {
+    /** `GET /v1/events/{event_id}`: the stored event, as the JSON object it is. */
+    get(eventId, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/events/${(0, core_js_1.pathParam)(eventId)}`,
+            retrySafe: true,
+            options,
+        }));
+    }
+    /** `GET /v1/events/{event_id}/nodes`: the nodes derived from the event. */
+    nodes(eventId, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/events/${(0, core_js_1.pathParam)(eventId)}/nodes`,
+            retrySafe: true,
+            options,
+        }));
+    }
+    /** `GET /v1/events/{event_id}/processing-status`. */
+    processingStatus(eventId, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/events/${(0, core_js_1.pathParam)(eventId)}/processing-status`,
+            retrySafe: true,
+            options,
+        }));
+    }
+    /** `GET /v1/events/{event_id}/extraction`: the record, or its protected view. */
+    extraction(eventId, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/events/${(0, core_js_1.pathParam)(eventId)}/extraction`,
+            retrySafe: true,
+            options,
+        }));
+    }
+    /** `GET /v1/events/{event_id}/extraction-status`. */
+    extractionStatus(eventId, options) {
+        return this._request(() => extractionStatusCall(eventId, options));
+    }
+    /** `POST /v1/events/{event_id}/retry-extraction`. Not retried automatically. */
+    retryExtraction(eventId, params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: `/v1/events/${(0, core_js_1.pathParam)(eventId)}/retry-extraction`,
+            retrySafe: false,
+            query: params,
+            options,
+        }));
+    }
+}
+exports.Events = Events;
+/** The `/v1/nodes` routes. */
+class Nodes extends Resource {
+    /** `GET /v1/nodes/{node_id}`. */
+    get(nodeId, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}`,
+            retrySafe: true,
+            options,
+        }));
+    }
+    /** `GET /v1/nodes`: list nodes. */
+    list(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/nodes',
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /**
+     * `GET /v1/nodes/scan`: one page of nodes, in id order.
+     *
+     * While the page's `has_more` is true, pass its `next_cursor` as `after_id` to read the
+     * next page.
+     */
+    scan(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/nodes/scan',
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /** `GET /v1/nodes/{node_id}/provenance`: the provenance, or its protected view. */
+    provenance(nodeId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/provenance`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /** `PUT /v1/nodes/{node_id}/promote`. Not retried automatically. */
+    promote(nodeId, options) {
+        return this._request(() => ({
+            method: 'PUT',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/promote`,
+            retrySafe: false,
+            idempotencyKey: callerKey(options),
+            options,
+        }));
+    }
+    /** `PUT /v1/nodes/{node_id}/archive`. Not retried automatically. */
+    archive(nodeId, options) {
+        return this._request(() => ({
+            method: 'PUT',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/archive`,
+            retrySafe: false,
+            idempotencyKey: callerKey(options),
+            options,
+        }));
+    }
+    /**
+     * `PUT /v1/nodes/{node_id}/reinforce`. Not retried automatically.
+     *
+     * Sends a body only when `params` has a field.
+     */
+    reinforce(nodeId, params, options) {
+        const given = Object.values(params ?? {}).some((value) => value !== undefined);
+        return this._request(() => ({
+            method: 'PUT',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/reinforce`,
+            retrySafe: false,
+            body: given ? params : undefined,
+            idempotencyKey: callerKey(options),
+            options,
+        }));
+    }
+    /** `PUT /v1/nodes/{node_id}/condition`: record a conditional claim's state. Not retried automatically. */
+    evaluateCondition(nodeId, params, options) {
+        return this._request(() => ({
+            method: 'PUT',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/condition`,
+            retrySafe: false,
+            body: params ?? {},
+            idempotencyKey: callerKey(options),
+            options,
+        }));
+    }
+    /** `GET /v1/nodes/{node_id}/neighborhood`: the nodes within `max_hops` edges. */
+    neighborhood(nodeId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/neighborhood`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /** `GET /v1/nodes/{node_id}/chain`: the node's supersedence chain. */
+    chain(nodeId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/nodes/${(0, core_js_1.pathParam)(nodeId)}/chain`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+}
+exports.Nodes = Nodes;
+/** The `/v1/reingest` routes: re-derive one end user's stored memories. */
+class Reingest extends Resource {
+    /**
+     * `POST /v1/reingest` with `dry_run: true`: count and estimate a run.
+     *
+     * Always sends `dry_run: true`, so a preview never starts a run. Not retried
+     * automatically.
+     */
+    preview(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/reingest',
+            retrySafe: false,
+            body: { ...(0, core_js_1.ownProperties)(params), dry_run: true },
+            options,
+        }));
+    }
+    /**
+     * `POST /v1/reingest` with `dry_run: false`: start a background run.
+     *
+     * The service answers `202` with the run's `run_id`, or `200` with `run_id: null` when
+     * nothing needs re-deriving. Each memory the run takes counts as one ingest call. A run
+     * takes at most `limit` memories, so a `complete` run can leave some for later
+     * (`remaining` above 0): sending the same request again continues it. Not retried
+     * automatically; a `409` `reingest_running` throws `ConflictError`.
+     */
+    start(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/reingest',
+            retrySafe: false,
+            body: { ...(0, core_js_1.ownProperties)(params), dry_run: false },
+            options,
+        }));
+    }
+    /** `GET /v1/reingest/{run_id}`: the run's state, counts and usage. */
+    get(runId, options) {
+        return this._request(() => reingestGetCall(runId, options));
+    }
+}
+exports.Reingest = Reingest;
+/** The claim routes: supersedences and contradictions. Not retried automatically. */
+class Claims extends Resource {
+    /** `POST /v1/supersedences`: record that one claim replaces another. */
+    supersede(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/supersedences',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `POST /v1/contradictions`: mark two claims as contradicting each other. */
+    markContradiction(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/contradictions',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `POST /v1/contradictions/resolve`: resolve a contradiction in favor of one claim. */
+    resolveContradiction(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/contradictions/resolve',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.Claims = Claims;
+/** The `/v1/alias-proposals` routes: identity review. */
+class AliasProposals extends Resource {
+    /** `GET /v1/alias-proposals`: the alias proposals waiting for review. */
+    list(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/alias-proposals',
+            retrySafe: true,
+            query: params,
+            answer: 'array',
+            options,
+        }));
+    }
+    /** `POST /v1/alias-proposals/{proposal_operation_id}/review`. Not retried automatically. */
+    review(proposalOperationId, params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: `/v1/alias-proposals/${(0, core_js_1.pathParam)(proposalOperationId)}/review`,
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.AliasProposals = AliasProposals;
+/** The `/v1/materializations` routes. */
+class Materializations extends Resource {
+    /** `POST /v1/materializations/process`: run the due materializations. Not retried automatically. */
+    process(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/materializations/process',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.Materializations = Materializations;
+/** The `/v1/extractions` routes. */
+class Extractions extends Resource {
+    /** `POST /v1/extractions/process`: run the due extraction jobs. Not retried automatically. */
+    process(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/extractions/process',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.Extractions = Extractions;
+/** The `/v1/assertions` routes: exact queries over assertions. Not retried automatically. */
+class Assertions extends Resource {
+    /** `POST /v1/assertions/aggregate`. */
+    aggregate(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/assertions/aggregate',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `POST /v1/assertions/state`. */
+    state(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/assertions/state',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.Assertions = Assertions;
+/** The `/v1/quantities` routes: exact queries over quantities. Not retried automatically. */
+class Quantities extends Resource {
+    /** `POST /v1/quantities/aggregate`. */
+    aggregate(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/quantities/aggregate',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `POST /v1/quantities/aggregate-text`: plan and run an aggregation from a question. */
+    aggregateText(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/quantities/aggregate-text',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.Quantities = Quantities;
+/** The `/v1/retrievals` routes: retrieval receipts. */
+class Retrievals extends Resource {
+    /** `GET /v1/retrievals/{request_id}`: the receipt, or one of its protected views. */
+    get(requestId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/retrievals/${(0, core_js_1.pathParam)(requestId)}`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+}
+exports.Retrievals = Retrievals;
+/** The `/v1/relevance` routes: relevance feedback. */
+class Relevance extends Resource {
+    /** `POST /v1/relevance`: record feedback on a retrieved memory. Not retried automatically. */
+    record(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/relevance',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `GET /v1/relevance`: the recorded feedback. */
+    list(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/relevance',
+            retrySafe: true,
+            query: params,
+            answer: 'array',
+            options,
+        }));
+    }
+    /** `GET /v1/relevance/{feedback_id}`. */
+    get(feedbackId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/relevance/${(0, core_js_1.pathParam)(feedbackId)}`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+}
+exports.Relevance = Relevance;
+/** The `/v1/answer-citations` routes: which memories an answer cited. */
+class AnswerCitations extends Resource {
+    /** `POST /v1/answer-citations`: record an answer's citations. Not retried automatically. */
+    record(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/answer-citations',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `GET /v1/answer-citations`: the recorded citations, each a record or its protected view. */
+    list(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/answer-citations',
+            retrySafe: true,
+            query: params,
+            answer: 'array',
+            options,
+        }));
+    }
+    /** `GET /v1/answer-citations/{citation_id}`: the record, or its protected view. */
+    get(citationId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/answer-citations/${(0, core_js_1.pathParam)(citationId)}`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+}
+exports.AnswerCitations = AnswerCitations;
+/** The `/v1/learning/profiles` routes: ranking profiles. */
+class LearningProfiles extends Resource {
+    /** `GET /v1/learning/profiles`. */
+    list(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/learning/profiles',
+            retrySafe: true,
+            query: params,
+            answer: 'array',
+            options,
+        }));
+    }
+    /** `POST /v1/learning/profiles`: create a profile. Not retried automatically. */
+    create(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/learning/profiles',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `GET /v1/learning/profiles/{profile_id}`: the profile and its status. */
+    get(profileId, params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: `/v1/learning/profiles/${(0, core_js_1.pathParam)(profileId)}`,
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /** `GET /v1/learning/profiles/active`: the active profile, or null when none is. */
+    active(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/learning/profiles/active',
+            retrySafe: true,
+            query: params,
+            answer: 'nullable',
+            options,
+        }));
+    }
+    /** `GET /v1/learning/profiles/history`: the activation history. */
+    history(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/learning/profiles/history',
+            retrySafe: true,
+            query: params,
+            answer: 'array',
+            options,
+        }));
+    }
+    /** `POST /v1/learning/profiles/{profile_id}/activate`. Not retried automatically. */
+    activate(profileId, params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: `/v1/learning/profiles/${(0, core_js_1.pathParam)(profileId)}/activate`,
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `POST /v1/learning/profiles/deactivate`: null when no profile was active. Not retried automatically. */
+    deactivate(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/learning/profiles/deactivate',
+            retrySafe: false,
+            body: params ?? {},
+            answer: 'nullable',
+            options,
+        }));
+    }
+    /** `POST /v1/learning/profiles/rollback`. Not retried automatically. */
+    rollback(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/learning/profiles/rollback',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.LearningProfiles = LearningProfiles;
+/** The `/v1/learning` routes: offline evaluation and ranking profiles. */
+class Learning extends Resource {
+    profiles;
+    constructor(core, raw) {
+        super(core, raw);
+        this.profiles = new LearningProfiles(core, raw);
+    }
+    /** `POST /v1/learning/evaluate`. Not retried automatically. */
+    evaluate(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/learning/evaluate',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `POST /v1/learning/evaluate-full-retrieval`. Not retried automatically. */
+    evaluateFullRetrieval(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/learning/evaluate-full-retrieval',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.Learning = Learning;
+// The helpers (sdks/CONTRACT.md, Helpers) live on the parsed form only: the raw view has
+// every operation and no helpers. Each poll is an ordinary call, with its retries and errors.
+/** `client.events`: the event routes and `waitForExtraction()`. */
+class EventsWithHelpers extends Events {
+    /**
+     * Poll the event's extraction status until it is no longer `pending` or `running`.
+     *
+     * Polls `GET /v1/events/{event_id}/extraction-status` at once and then every
+     * `interval` milliseconds (2 000), and returns the first status that is not `pending`
+     * or `running`: `complete`, `failed` (returned, not thrown), or a status this SDK does
+     * not know yet. When `timeout` milliseconds (300 000) run out first, throws
+     * `WaitTimeoutError` with the last status as `lastStatus`; `timeout` is a deadline that
+     * also bounds each poll and its retries (see `HelperOptions`). Aborting `signal` stops
+     * the helper and any pending poll or retry. Each poll is an ordinary call, with the
+     * client's retries and errors, and counts against the key's request rate limit like any
+     * other call, so many waits at once can slow the key's other calls. A job can stay
+     * `pending` until the next batch flush; `extractions.process()` runs the due jobs.
+     */
+    async waitForExtraction(eventId, options) {
+        const { timeout = 300_000, interval = 2_000, signal = null } = (0, core_js_1.ownProperties)(options);
+        const core = this._core;
+        const deadline = (0, core_js_1.helperDeadline)(core.now(), timeout, interval);
+        let lastStatus = null;
+        for (;;) {
+            let status;
+            try {
+                status = await this._request(() => ({
+                    ...extractionStatusCall(eventId, { signal }),
+                    deadline,
+                }));
+            }
+            catch (error) {
+                // Only a poll the deadline stopped throws WaitTimeoutError; its own error is the cause.
+                if (!(error instanceof errors_js_1.WaitTimeoutError))
+                    throw error;
+                const last = lastStatus === null ? 'none' : JSON.stringify(lastStatus.status);
+                throw (0, core_js_1.withCause)(new errors_js_1.WaitTimeoutError(`The extraction did not finish within ${timeout} ms: ${error.message}. The last ` +
+                    `status read was ${last}.`, { lastStatus }), error.cause);
+            }
+            if (!WORKING.has(status.status))
+                return status;
+            lastStatus = status;
+            const wait = (0, core_js_1.helperWait)(core.now(), deadline, interval);
+            if (wait === null) {
+                throw new errors_js_1.WaitTimeoutError(`The extraction did not finish within ${timeout} ms; its last status was ` +
+                    `${JSON.stringify(status.status)}.`, { lastStatus: status });
+            }
+            await core.sleep(wait, signal);
+        }
+    }
+}
+exports.EventsWithHelpers = EventsWithHelpers;
+/** `client.nodes`: the node routes and `scanAll()`. */
+class NodesWithHelpers extends Nodes {
+    /**
+     * Yield every node `scan()` reaches, one page after another.
+     *
+     * While a page's `has_more` is true, sends its `next_cursor` as the next `after_id`,
+     * with the other parameters unchanged; `limit` is the page size. Each page is an
+     * ordinary `scan()` call with `options`, sent as soon as the previous page is read, and
+     * counts against the key's request rate limit: a large `limit` (up to 1 000) needs fewer
+     * pages. A page whose `has_more` is true without a new `next_cursor` throws
+     * `NenaviError`, so a scan never ends early without saying so.
+     *
+     * @example
+     * for await (const node of client.nodes.scanAll({ user_id: 'user-1', limit: 1000 })) {
+     *   console.log(node.id);
+     * }
+     */
+    async *scanAll(params, options) {
+        const given = (0, core_js_1.ownProperties)(params);
+        let cursor = given.after_id;
+        for (;;) {
+            const page = await this.scan({ ...given, after_id: cursor }, options);
+            for (const node of page.nodes ?? [])
+                yield node;
+            if (!page.has_more)
+                return;
+            if (page.next_cursor === undefined ||
+                page.next_cursor === null ||
+                String(page.next_cursor) === String(cursor)) {
+                // Following it would read the same page forever; stopping quietly would hide the
+                // nodes the scan did not reach.
+                throw new errors_js_1.NenaviError('The scan page says there are more nodes but gives no new next_cursor, so the ' +
+                    'scan cannot continue.');
+            }
+            cursor = page.next_cursor;
+        }
+    }
+}
+exports.NodesWithHelpers = NodesWithHelpers;
+/** `client.reingest`: the re-ingest routes and `run()`. */
+class ReingestWithHelpers extends Reingest {
+    /**
+     * Start a re-ingest run and poll it until its `state` is final.
+     *
+     * Sends `start()` (`dry_run: false`), then polls `get()` every `interval` milliseconds
+     * (5 000) and returns the first status whose `state` is not `pending` or `running`:
+     * `complete`, `failed` (returned, not thrown), or a state this SDK does not know yet.
+     * When nothing needs re-deriving, the service's `200` answer is returned as it is. A
+     * `409` `reingest_running` throws `ConflictError`. When `timeout` milliseconds
+     * (3 600 000) run out first, throws `WaitTimeoutError` with the last status as
+     * `lastStatus`; the run itself goes on. `timeout` is a deadline that also bounds each
+     * poll and its retries (see `HelperOptions`); it never prevents or cuts short the start,
+     * which has the client's own timeout. Aborting `signal` stops the helper and any pending
+     * poll, not the run. A poll that fails throws that call's error while the run goes on,
+     * with the last status read before it as `lastStatus`: its `run_id` lets the caller go
+     * on polling with `get()` instead of calling `run()` again, which throws `ConflictError`
+     * (`reingest_running`) until the run ends.
+     *
+     * A run takes at most `limit` memories, so a `complete` run can leave some for later
+     * (`remaining` above 0): calling `run()` again with the same parameters continues it.
+     */
+    async run(params, options) {
+        const { timeout = 3_600_000, interval = 5_000, signal = null } = (0, core_js_1.ownProperties)(options);
+        const core = this._core;
+        const deadline = (0, core_js_1.helperDeadline)(core.now(), timeout, interval);
+        let status = await this.start(params, { signal });
+        while (status.run_id !== null && status.run_id !== undefined && WORKING.has(status.state)) {
+            const wait = (0, core_js_1.helperWait)(core.now(), deadline, interval);
+            if (wait === null) {
+                throw new errors_js_1.WaitTimeoutError(`The re-ingest run ${status.run_id} did not finish within ${timeout} ms; its ` +
+                    `last state was ${JSON.stringify(status.state)}.`, { lastStatus: status });
+            }
+            await core.sleep(wait, signal);
+            const runId = status.run_id;
+            try {
+                status = await this._request(() => ({
+                    ...reingestGetCall(runId, { signal }),
+                    deadline,
+                }));
+            }
+            catch (error) {
+                // A poll the deadline stopped throws WaitTimeoutError; its own error is the cause.
+                if (error instanceof errors_js_1.WaitTimeoutError) {
+                    throw (0, core_js_1.withCause)(new errors_js_1.WaitTimeoutError(`The re-ingest run ${runId} did not finish within ${timeout} ms: ` +
+                        `${error.message}. Its last state was ${JSON.stringify(status.state)}.`, { lastStatus: status }), error.cause);
+                }
+                // The run goes on; without its id the caller could only call run() again, which
+                // the service refuses with 409 until the run ends. An abort keeps its own reason.
+                if (error instanceof errors_js_1.NenaviError && !signal?.aborted)
+                    error.lastStatus = status;
+                throw error;
+            }
+        }
+        return status;
+    }
+}
+exports.ReingestWithHelpers = ReingestWithHelpers;
+/** The operations, in the parsed form (`Nenavi`) or the raw form (`withRawResponse`). */
+class NenaviMethods extends Resource {
+    events;
+    nodes;
+    reingest;
+    claims;
+    aliasProposals;
+    materializations;
+    extractions;
+    assertions;
+    quantities;
+    retrievals;
+    relevance;
+    answerCitations;
+    learning;
+    constructor(core, raw) {
+        super(core, raw);
+        this.events = new Events(core, raw);
+        this.nodes = new Nodes(core, raw);
+        this.reingest = new Reingest(core, raw);
+        this.claims = new Claims(core, raw);
+        this.aliasProposals = new AliasProposals(core, raw);
+        this.materializations = new Materializations(core, raw);
+        this.extractions = new Extractions(core, raw);
+        this.assertions = new Assertions(core, raw);
+        this.quantities = new Quantities(core, raw);
+        this.retrievals = new Retrievals(core, raw);
+        this.relevance = new Relevance(core, raw);
+        this.answerCitations = new AnswerCitations(core, raw);
+        this.learning = new Learning(core, raw);
+    }
+    /** `GET /v1/health`. Sends no key, and works on a client built without one. */
+    health(options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/health',
+            retrySafe: true,
+            auth: false,
+            options,
+        }));
+    }
+    /** `GET /v1/usage`: this month's usage and the project's quota. */
+    usage(options) {
+        return this._request(() => ({ method: 'GET', path: '/v1/usage', retrySafe: true, options }));
+    }
+    /** `GET /v1/stats`: event and node counts. */
+    stats(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/stats',
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /**
+     * `POST /v1/store`: store one memory.
+     *
+     * Never retried automatically: a retry would store and extract the text again and count
+     * twice against the monthly limits.
+     */
+    store(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/store',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /**
+     * `POST /v1/ingest`: store a message and queue its extraction.
+     *
+     * Never retried automatically: a retry would store and extract the text again and count
+     * twice against the monthly limits.
+     */
+    ingest(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/ingest',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /**
+     * `POST /v1/ingest/fast`: store a batch of sources without waiting for extraction.
+     *
+     * Every call sends an `Idempotency-Key`: `options.idempotencyKey` when given, else a new
+     * random UUID. Retries of the call send the same key, so the service answers a retry
+     * with the first attempt's event ids instead of storing the batch again. To retry by
+     * hand after an error, pass the error's `idempotencyKey`. An aborted `signal` rejects
+     * with the signal's reason, which carries no key, so when you pass a `signal`, pass
+     * your own `idempotencyKey` too and reuse it to retry an aborted call.
+     */
+    ingestFast(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/ingest/fast',
+            retrySafe: true,
+            body: params ?? {},
+            idempotencyKey: callerKey(options) ?? crypto.randomUUID(),
+            options,
+        }));
+    }
+    /**
+     * `POST /v1/retrieve`: retrieve the memories that answer a query.
+     *
+     * Retrieved memory is untrusted input: stored text can carry instructions meant for the
+     * model that later reads it, so treat it as data, not instructions. Not retried
+     * automatically, because each call writes a retrieval receipt.
+     */
+    retrieve(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/retrieve',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+    /** `GET /v1/graph`: the user's nodes and edges. */
+    graph(params, options) {
+        return this._request(() => ({
+            method: 'GET',
+            path: '/v1/graph',
+            retrySafe: true,
+            query: params,
+            options,
+        }));
+    }
+    /** `POST /v1/organize`: run organizing jobs within a time budget. Not retried automatically. */
+    organize(params, options) {
+        return this._request(() => ({
+            method: 'POST',
+            path: '/v1/organize',
+            retrySafe: false,
+            body: params ?? {},
+            options,
+        }));
+    }
+}
+exports.NenaviMethods = NenaviMethods;
+/**
+ * Client for the Nenavi Cloud memory API, for server-side code.
+ *
+ * The key comes from `apiKey`, else `NENAVI_API_KEY`; the base URL from `baseURL`, else
+ * `NENAVI_BASE_URL`, else `https://api.prismemory.com`. A client built without a key can
+ * call only `health()`. Never ship the key to a browser.
+ *
+ * Retrieved memory is untrusted input: treat retrieved text as data, not instructions.
+ */
+class Nenavi extends NenaviMethods {
+    #raw;
+    constructor(options = {}) {
+        const core = new core_js_1.Core(options);
+        super(core, false);
+        this.events = new EventsWithHelpers(core, false);
+        this.nodes = new NodesWithHelpers(core, false);
+        this.reingest = new ReingestWithHelpers(core, false);
+    }
+    /** The base URL the client sends to. */
+    get baseURL() {
+        return this._core.baseURL;
+    }
+    /** The same methods, returning a RawResponse with the status, headers and request id. */
+    get withRawResponse() {
+        this.#raw ??= new NenaviMethods(this._core, true);
+        return this.#raw;
+    }
+}
+exports.Nenavi = Nenavi;