@looply/sdk 0.0.0-stage → 0.2.0

package/dist/client.js

@@ -0,0 +1,520 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LooplyClient = void 0;
+const errors_1 = require("./errors");
+/**
+ * A ceiling on every request.
+ *
+ * A call with no deadline is a spinner that never stops. Fifteen seconds is the
+ * app's existing choice and is kept so the two behave identically.
+ */
+const DEFAULT_TIMEOUT_MS = 15_000;
+class LooplyClient {
+    opts;
+    http;
+    constructor(opts) {
+        this.opts = opts;
+        const f = opts.fetch ?? globalThis.fetch;
+        if (typeof f !== 'function') {
+            throw new Error('no fetch is available; pass one in LooplyClientOptions.fetch');
+        }
+        this.http = f;
+    }
+    /* ──────────────────────────────────────────────────────────── projects ── */
+    /**
+     * ⚠️ THIS ROUTE ANSWERS A BARE ARRAY, NOT `{ projects }`.
+     *
+     * 🔴 THE FIRST DRAFT UNWRAPPED AN ENVELOPE THAT DOES NOT EXIST, and returned
+     * `undefined` typed as `ProjectView[]` — the cast asserted the envelope into
+     * being and TypeScript had nothing to object to. It was caught by
+     * `sdk-flagship.e2e.spec.ts`, which drives this client against a REAL server;
+     * a suite that mocked `fetch` would have returned whatever shape this method
+     * asked for and agreed with itself all the way to production.
+     */
+    async projects() {
+        return await this.request('GET', '/v1/projects');
+    }
+    /* ─────────────────────────────────────────────────────────────── goals ── */
+    /**
+     * Create a goal, at most once per key.
+     *
+     * 🔴 `clientRef` IS THE IDEMPOTENCY KEY AND IT IS REQUIRED. There is no
+     * DELETE for a goal, so a duplicate from a retried POST is permanent. Sending
+     * the same key with the SAME text returns the same goal; sending it with
+     * DIFFERENT text is a conflict, because the key was a promise about which
+     * request this is.
+     */
+    async createGoal(projectId, input) {
+        const r = await this.request('POST', `/v1/projects/${enc(projectId)}/goals`, input);
+        return r.goal;
+    }
+    async goal(projectId, goalId) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/goals/${enc(goalId)}`);
+        return r.goal;
+    }
+    async goals(projectId, state) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/goals`, undefined, { state });
+        return r.goals;
+    }
+    /* ───────────────────────────────────────────────────────────── sources ── */
+    /**
+     * Hand a document over, at most once per key AND at most once per content.
+     *
+     * A source is stored verbatim and content-addressed: the same bytes under a
+     * fresh `clientRef` answer with the source that already exists, and the same
+     * `clientRef` with different bytes is a conflict. What comes back is the
+     * stored record with its anchored statements — the extractor's answer, so a
+     * caller can see what Looply read before anything is built on it.
+     *
+     * ⚠️ `kind` is `markdown`, `text` or `pdf`. The text kinds send `content`;
+     * a `pdf` sends the `pages` of its text layer (as read on the machine that
+     * holds the file) and may carry the file's own sha256 as `originSha256`.
+     */
+    async createSource(projectId, input) {
+        const r = await this.request('POST', `/v1/projects/${enc(projectId)}/sources`, input);
+        return detailView(r);
+    }
+    /**
+     * Classify a source with the current classifier version, once.
+     *
+     * Idempotent per version: the rows that exist are answered as they are.
+     * What comes back says what each statement IS; nothing here says what the
+     * repository has done about it.
+     */
+    async classifySource(projectId, sourceId) {
+        const r = await this.request('POST', `/v1/projects/${enc(projectId)}/sources/${enc(sourceId)}/classify`);
+        return { classifications: r.classifications, classifierVersion: r.classifierVersion, created: r.created };
+    }
+    /**
+     * Record where each requirement of a source stands against the repository,
+     * as measured at one committed tree — once per (tree, reconciler version).
+     *
+     * The measurement is made where the project index lives (the machine that
+     * holds the repository; `looply source reconcile` is the usual caller) with
+     * `@looply/core`'s `reconcileStatements`; the server stores it verbatim and
+     * recomputes nothing. A second hand-over of the same tree answers the rows
+     * on record (`created: false`).
+     *
+     * 🔴 `implemented-and-evidenced` and `partial` are REFUSED here (400): a
+     * rule cannot put them on record. They are a person's attestation with
+     * evidence, which is a different act.
+     */
+    async reconcileSource(projectId, sourceId, input) {
+        const r = await this.request('POST', `/v1/projects/${enc(projectId)}/sources/${enc(sourceId)}/reconcile`, input);
+        return { dispositions: r.dispositions, treeSha: r.treeSha, reconcilerVersion: r.reconcilerVersion, created: r.created };
+    }
+    /**
+     * Say, as a person, that a requirement is implemented-and-evidenced or
+     * partial — with at least one evidence anchor, at the committed tree the
+     * evidence was read at.
+     *
+     * 🔴 THIS NEEDS A DEVICE TOKEN. A machine token is refused (403): the machine
+     * measures (`reconcileSource`), a person vouches. A measurement's values are
+     * refused here (400). The same person saying the same thing at the same tree
+     * is one act: a repeat answers the record with `created: false`.
+     */
+    async attestSource(projectId, sourceId, input) {
+        const r = await this.request('POST', `/v1/projects/${enc(projectId)}/sources/${enc(sourceId)}/attest`, input);
+        return { attestation: r.attestation, created: r.created };
+    }
+    /**
+     * What is covered and by whom: every requirement and constraint of a source
+     * with the goals that serve it, where it stands, what a person attested, and
+     * one word each. A read; nothing here is written by anyone.
+     */
+    async coverage(projectId, sourceId) {
+        return this.request('GET', `/v1/projects/${enc(projectId)}/sources/${enc(sourceId)}/coverage`);
+    }
+    /**
+     * Every session-control grant this project has issued, live and historical.
+     *
+     * 🔴 THE MACHINE READS THESE AND WRITES NONE OF THEM. `OWNER_CHARTER.md` §5
+     * F-14 is explicit that only the server may issue one — a machine that could
+     * mint its own would be granting itself authority over a session, which is
+     * the whole thing the grant exists to prevent. So there is a reader here and
+     * deliberately no `issueSessionGrant`: issuing is a person's act, from a
+     * person's device, against the route that stamps their principal onto it.
+     */
+    async sessionGrants(projectId) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/session-grants`);
+        return r.grants;
+    }
+    /**
+     * Record that a session acknowledged a grant, through the channel it came on.
+     *
+     * ⚠️ THE CHANNEL IS CLAIMED, NOT PROVED, AND THAT IS WHY IT IS RECORDED
+     * RATHER THAN TRUSTED. A session's adapter and a person's terminal can hold
+     * the same device token — the token says which DEVICE, never which program.
+     * So this writes down what arrived and `controlVerdict` in core refuses
+     * anything that is not `adapter`, which turns a person's attempt into a fact
+     * on the record instead of an inference nobody can check.
+     */
+    async acknowledgeSessionGrant(projectId, grantId, ack) {
+        const r = await this.request('POST', `/v1/projects/${enc(projectId)}/session-grants/${enc(grantId)}/acknowledge`, ack);
+        return r.grant;
+    }
+    /** A project's sources, newest first, without their content. */
+    async sources(projectId) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/sources`);
+        return r.sources;
+    }
+    /** One source, verbatim, with its anchored statements, their latest classifications and the most recent reconciliation. */
+    async source(projectId, sourceId) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/sources/${enc(sourceId)}`);
+        return detailView(r);
+    }
+    /**
+     * Ask Looply to work on a goal, once.
+     *
+     * 🔴 ONE EXPLICIT START ≤ ONE RUN, AND A LOST RESPONSE MUST NOT SPEND TWO.
+     * `clientRef` is what makes a retry safe: the same key names the same act of
+     * permission, so a repeat returns the command the first call created rather
+     * than authorising a second Start.
+     *
+     * ⚠️ IT IS REQUIRED HERE THOUGH THE SERVER TREATS IT AS OPTIONAL. The server
+     * has to accept keyless commands because the phone and the CLI have always
+     * sent none; an SDK written today has no such history and no reason to offer
+     * the unsafe shape. A caller who genuinely wants at-least-once can pass a
+     * fresh key each time — deliberately, rather than by omission.
+     *
+     * 🔴 THIS DEFECT WAS FOUND BY WRITING THIS METHOD. `POST /v1/commands` had no
+     * key at all, and the daemon derives a Start's request id from the COMMAND
+     * ID, so a retried enqueue was a second Start spending a second ordinal of a
+     * person's autonomy budget. Phase 15 added the key to the server.
+     */
+    async startGoal(projectId, goalId, input) {
+        /**
+         * ⚠️ THERE IS NO `/goals/:id/start` ROUTE, AND INVENTING ONE HERE WOULD BE
+         * THE DEFECT §77 NAMES: an SDK method with no real route behind it. Work is
+         * started by issuing a COMMAND, which is how the daemon learns of it — the
+         * app has done this since Phase 4 and the server's verb set is fixed.
+         *
+         * 🔴 NO `goalVersion` IS SENT, DELIBERATELY. The server stamps the version
+         * it just read and REFUSES a client-supplied one, so that a phone which has
+         * been asleep cannot authorise pursuit of wording nobody is looking at. The
+         * absence is the safety property, not an omission.
+         *
+         * Naming no items means "start this goal on the work it already owns".
+         */
+        const r = await this.request('POST', '/v1/commands', {
+            projectId,
+            kind: 'start-run',
+            payload: { goalId },
+            clientRef: input.clientRef,
+            ...(input.deliverBy === undefined ? {} : { deliverBy: input.deliverBy }),
+        });
+        return { commandId: r.id };
+    }
+    /**
+     * Authorise BOUNDED AUTONOMOUS PURSUIT of a goal: the machine plans, runs and
+     * re-plans on its own, up to the server's budget (Starts and lifetime), until
+     * the goal is met, a person is needed, or the budget runs out.
+     *
+     * 🔴 THIS, NOT `startGoal`, IS WHAT AN UNATTENDED CALLER WANTS. `startGoal` is
+     * ONE run: when it ends nothing says whether the goal was met. A pursuit ends
+     * with a verdict — `satisfied`, `human_required`, `budget_exhausted` — read by
+     * `autonomy()` and `goalEvidence()`, and on `satisfied` the machine's own
+     * delivery comes with it.
+     *
+     * The SERVER stamps the version, the budget and the expiry; the client names
+     * the goal and nothing else, so a caller cannot pin a budget it was not given.
+     * Idempotent on `clientRef`, which matters doubly here: authorising SPENDS the
+     * grant, so a lost response retried without the key would spend it twice.
+     */
+    async authorizeGoalAutonomy(projectId, goalId, input) {
+        const r = await this.request('POST', '/v1/commands', {
+            projectId,
+            kind: 'authorize-goal-autonomy',
+            payload: { goalId },
+            clientRef: input.clientRef,
+            ...(input.deliverBy === undefined ? {} : { deliverBy: input.deliverBy }),
+        });
+        return { commandId: r.id };
+    }
+    /**
+     * Is the machine that holds this project awake? A Start is delivered by the
+     * machine polling, so this is the first half of "will my Start run".
+     */
+    async presence(projectId) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/presence`);
+    }
+    /**
+     * What became of a command.
+     *
+     * `startGoal` returns an id and then goes quiet; this is the durable answer —
+     * started, terminally refused, and why.
+     *
+     * ⚠️ COMMAND TRUTH ONLY. `done` on a start-run means the Start reached its
+     * success boundary, NOT that the run finished or the goal was met. A caller
+     * wanting the whole picture composes this with `status()` and `events()`.
+     */
+    async commandStatus(projectId, commandId) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/commands/${enc(commandId)}`);
+        return r.command;
+    }
+    /** Amend or abandon a goal. `version` is the OCC token the read returned. */
+    async patchGoal(projectId, goalId, input) {
+        const r = await this.request('PATCH', `/v1/projects/${enc(projectId)}/goals/${enc(goalId)}`, input);
+        return r.goal;
+    }
+    /* ──────────────────────────────────────────────────────────────── work ── */
+    async items(projectId) {
+        const r = await this.request('GET', `/v1/projects/${enc(projectId)}/queue`);
+        return r.items;
+    }
+    /**
+     * The current run, as a projection.
+     *
+     * ⚠️ THERE IS NO `/runs` COLLECTION, so this SDK does not pretend to one. The
+     * server keeps a single latest-run projection per project — which is what the
+     * product actually shows — and run HISTORY lives in the event ledger, reached
+     * through `events()`.
+     */
+    async status(projectId) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/status`);
+    }
+    /* ─────────────────────────────────────────────────────────── keeper ── */
+    /**
+     * Ask the keeper about a project (DESIGN §9 read path).
+     *
+     * A POST that READS. The question travels in the body rather than a query
+     * string, because a sentence about somebody's codebase does not belong in an
+     * access log — and because the answer quotes item titles, commit shas and the
+     * implementer's own round notes, it needs the same grant `status()` does.
+     *
+     * ⚠️ NOTHING HERE ACTS. The keeper’s write path is deliberately not a second
+     * set of methods: an intent goes through the routes a person already uses —
+     * `command()`, `patchItem()`, answering a question — with `actor: keeper` on
+     * the record, so there is no privileged path for it to take.
+     */
+    async ask(projectId, question) {
+        return await this.request('POST', `/v1/projects/${enc(projectId)}/keeper/ask`, { question });
+    }
+    /* ─────────────────────────────────────────────────────────── approvals ── */
+    /**
+     * ⚠️ THE APPROVAL ROUTES ANSWER BARE VALUES, NOT ENVELOPES.
+     *
+     * The goal and queue routes DO wrap (`{ goals }`, `{ items }`) and these do
+     * not. There is no rule to infer here — it is simply how each controller was
+     * written — which is exactly why this client is checked against a running
+     * server rather than against a design document.
+     */
+    async approvals(projectId) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/approvals`);
+    }
+    async approval(projectId, approvalId) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/approvals/${enc(approvalId)}`);
+    }
+    /**
+     * Advise on a pending approval: approve or deny, and why.
+     *
+     * 🔴 THIS IS WHAT AN INTEGRATION CAN DO WITH AN APPROVAL, AND ALL IT CAN DO.
+     * Deciding is a person's authority (`decideApproval` needs an owner's device
+     * token); an integration that has reviewed the action in its own process says
+     * what it concluded here, and the owner is notified and decides with the
+     * advice in front of them. Pending only (a 409 otherwise); latest wins, so a
+     * retry is harmless.
+     */
+    async recommendApproval(projectId, approvalId, input) {
+        return await this.request('POST', `/v1/projects/${enc(projectId)}/approvals/${enc(approvalId)}/recommendation`, input);
+    }
+    /**
+     * Approve or deny one exact action.
+     *
+     * 🔴 A PERSON DOES THIS. A machine credential is refused by the server, and
+     * that refusal is the security content of the route rather than an
+     * inconvenience — the hazard is not the 403, it is somebody meeting it and
+     * widening the guard so a machine can authorise its own work.
+     *
+     * `version` is the approval's OCC token: deciding against a stale one is a
+     * conflict, not a silent overwrite, because the thing being approved may have
+     * expired or been revoked since it was read.
+     */
+    async decideApproval(projectId, approvalId, input) {
+        return await this.request('POST', `/v1/projects/${enc(projectId)}/approvals/${enc(approvalId)}/decision`, input);
+    }
+    /* ───────────────────────────────────────────────── governed execution ── */
+    async execution(projectId, executionId) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/executions/${enc(executionId)}`);
+    }
+    /**
+     * Tell Looply what actually happened, when it could not establish that itself.
+     *
+     * 🔴 THIS CLOSES A GAP PHASE 8 LEFT ON PURPOSE. The resolution route has been
+     * owner-guarded and mutation-covered since Phase 8 and had NO CLIENT — and its
+     * client could not be the CLI, because `server-client.ts` authenticates with a
+     * machine token and the route refuses a machine BY DESIGN. A machine settling
+     * its own ambiguity is the one thing the route exists to prevent. It belongs
+     * to a person, so it belongs here.
+     *
+     * ⚠️ `note` IS PRIVATE HUMAN TESTIMONY. It is why a person believes what they
+     * are asserting, it is kept out of every machine- and model-facing view, and a
+     * client must never render it into anything a model reads.
+     */
+    async resolveExecution(projectId, executionId, input) {
+        return await this.request('POST', `/v1/projects/${enc(projectId)}/executions/${enc(executionId)}/resolution`, input);
+    }
+    /* ────────────────────────────────────────────────────────────── safety ── */
+    /**
+     * Whether autonomous pursuit of a goal is still running, and why it stopped.
+     *
+     * ⚠️ THIS IS THE AUTONOMY VIEW, NOT A SAFETY ENDPOINT. There is no
+     * `/safety` route: a loop-safety hold is enforced ON THE MACHINE, in
+     * `loop-safety-store.ts`, and never travels to the server. What the server
+     * knows is that pursuit ENDED and the reason it was given — which is what a
+     * person needs to see, and is version-scoped because a hold on version 4 must
+     * not block version 5.
+     */
+    async autonomy(projectId, goalId) {
+        // Returned whole. The grants and the goal's current version arrive in one
+        // response so a caller cannot act on two answers from two moments.
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/goals/${enc(goalId)}/autonomy`);
+    }
+    /* ──────────────────────────────────────────────────────────── evidence ── */
+    /**
+     * What the server saw of a goal being delivered, per version.
+     *
+     * This used to say there was no `/evidence` route and that one would be a
+     * server change, not an SDK one. It is now that server change:
+     * `GET …/goals/:goalId/evidence` stitches, once, the runs that pursued each
+     * version, every round's commit with the gate's and the prover's verdicts,
+     * where each pursuit came to rest, and what was pushed under an approval.
+     *
+     * ⚠️ NOT THE MACHINE'S PROOF. Whether a goal was met is decided on the
+     * machine; this is what reached the server. Render `pursuits[].state ===
+     * 'satisfied'` as the machine's claim and `landed` as the commits behind it —
+     * never as "proven". Whitelisted: no gate output, no prover prose, no remote.
+     */
+    async goalEvidence(projectId, goalId) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/goals/${enc(goalId)}/evidence`);
+    }
+    /* ────────────────────────────────────────────────────────────── events ── */
+    /**
+     * One page of events, resuming from a cursor.
+     *
+     * 🔴 REST REPLAY IS THE CORRECTNESS PATH; A SOCKET IS ONLY AN ACCELERATOR. A
+     * client that has been away — asleep, offline, restarted — reconstructs by
+     * paging from the last cursor it stored. A live stream that missed an event
+     * has no way to notice, so it may never be the only way state arrives.
+     *
+     * ⚠️ DUPLICATES ARE SAFE AND EXPECTED. `id` is stable, so a client that has
+     * seen one can drop it; a client that has NOT seen one must not be missing it.
+     * Delivering twice is the cheap failure, and not delivering is the expensive
+     * one.
+     */
+    async events(projectId, opts = {}) {
+        return await this.request('GET', `/v1/projects/${enc(projectId)}/platform-events`, undefined, { after: opts.after, limit: opts.limit });
+    }
+    /* ───────────────────────────────────────────────────────────── plumbing ── */
+    /**
+     * 🔴 THE QUERY IS A SEPARATE ARGUMENT, NEVER INTERPOLATED INTO `path`.
+     *
+     * `path` is therefore always a literal route with parameter slots and nothing
+     * else, which is what lets `boundary.spec.ts` compare it to the server's route
+     * table exactly rather than by heuristic. An earlier version appended
+     * `${q}` inside the template and the guard could not tell a query suffix from
+     * a path segment — it read `/goals?state=x` as a route called `/goals:param`.
+     * Fixing the guard's parser instead would have left the ambiguity in place for
+     * the next method to trip over.
+     *
+     * `undefined` values are dropped rather than sent as the string "undefined".
+     */
+    async request(method, path, body, query) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const token = this.opts.getToken();
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(query ?? {})) {
+            if (v !== undefined)
+                params.set(k, String(v));
+        }
+        const suffix = params.toString() === '' ? '' : `?${params.toString()}`;
+        let res;
+        try {
+            res = await this.http(`${this.opts.baseUrl}${path}${suffix}`, {
+                method,
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(token === null ? {} : { Authorization: `Bearer ${token}` }),
+                },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            });
+        }
+        catch (e) {
+            clearTimeout(timer);
+            const aborted = e?.name === 'AbortError';
+            // Status 0: there was no HTTP answer at all. Distinguished from a 5xx
+            // because "no server" and "server said no" are different facts.
+            throw new errors_1.LooplyError({
+                status: 0,
+                message: aborted ? 'the request timed out' : 'could not reach looply',
+                serverCode: aborted ? 'timeout' : 'unavailable',
+            });
+        }
+        clearTimeout(timer);
+        const text = await res.text();
+        const parsed = text === '' ? null : safeJson(text);
+        if (!res.ok) {
+            if (res.status === 401)
+                this.opts.onUnauthorized?.();
+            throw new errors_1.LooplyError({
+                status: res.status,
+                message: messageOf(parsed) ?? `request failed (${res.status})`,
+                serverCode: codeOf(parsed),
+                currentVersion: versionOf(parsed),
+                body: parsed,
+            });
+        }
+        return parsed;
+    }
+}
+exports.LooplyClient = LooplyClient;
+/** Path segments are user data. A goal id with a slash must not become a route. */
+function enc(s) {
+    return encodeURIComponent(s);
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // A body that is not JSON is a proxy or a gateway talking, not Looply.
+        return { message: text.slice(0, 300) };
+    }
+}
+function field(body, name) {
+    return typeof body === 'object' && body !== null && name in body
+        ? body[name]
+        : undefined;
+}
+function messageOf(body) {
+    const m = field(body, 'message');
+    if (typeof m === 'string')
+        return m;
+    // Nest's validation pipe answers with an ARRAY of messages.
+    if (Array.isArray(m) && typeof m[0] === 'string')
+        return m.join('; ');
+    return undefined;
+}
+function codeOf(body) {
+    const c = field(body, 'code');
+    return typeof c === 'string' ? c : undefined;
+}
+function versionOf(body) {
+    const v = field(body, 'currentVersion') ?? field(body, 'version');
+    return typeof v === 'number' ? v : undefined;
+}
+/** The detail as the wire carries it (a `source` record beside its derived rows), flattened into one view. */
+function detailView(r) {
+    return {
+        ...r.source,
+        statements: r.statements,
+        classifications: r.classifications,
+        classifierVersion: r.classifierVersion,
+        dispositions: r.dispositions,
+        reconciledAt: r.reconciledAt,
+        attestations: r.attestations,
+    };
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,107 @@
+/**
+ * WHAT WENT WRONG, IN A FORM A PROGRAM CAN BRANCH ON.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 NO CLIENT MAY EVER PARSE AN ENGLISH MESSAGE.
+ *
+ * The server's wire shape is `{ statusCode, message }`, and the messages are
+ * good ones — controllers put real work into them, and a person reading a
+ * refusal should get a sentence rather than a symbol. But a message is written
+ * for a person and is changed for a person, so a client that branches on its
+ * text breaks the next time somebody improves the wording. That is the whole
+ * reason for this file.
+ *
+ * ⚠️ THE CODES ARE DERIVED FROM STATUS, NOT INVENTED ALONGSIDE IT. There are
+ * roughly 250 throw sites in the server and none of them carries a code today.
+ * Adding one to each would be a large, mechanical, error-prone edit whose only
+ * consumer is this file — so instead the mapping lives here, where it can be
+ * read in one screen, and a `code` the server DOES supply is preferred over the
+ * derived one. That is a narrower promise than "every refusal has a bespoke
+ * code", and it is the one that is true.
+ */
+export type LooplyErrorCode = 
+/** The credential is missing, expired or revoked. Signing in again is the fix. */
+'unauthorized'
+/** Authenticated, and not allowed to do this. Retrying changes nothing. */
+ | 'forbidden'
+/**
+ * There is no such resource — OR there is one and you may not know that.
+ *
+ * 🔴 THE AMBIGUITY IS DELIBERATE AND MUST BE PRESERVED. Several routes answer
+ * 404 for another project's resource on purpose, so that probing cannot tell
+ * "does not exist" from "not yours". A client that reported those differently
+ * would rebuild the oracle the server refuses to be.
+ */
+ | 'not_found'
+/**
+ * It existed, it is finished, and no retry brings it back.
+ *
+ * 🔴 DELIBERATELY NOT FOLDED INTO `not_found`, whose ambiguity above is load-
+ * bearing: 404 has to mean "no such thing, OR yours to not know about" so that
+ * probing another project's resources learns nothing. A 410 makes no such
+ * hedge — the server is saying it knows exactly what you asked for and it is
+ * over. An activation code that expired or was withdrawn is the first one;
+ * `apps/server/src/membership/membership.controller.ts` is where it is thrown.
+ *
+ * ⚠️ AND NOT `unavailable`, WHICH IS RETRYABLE. That was the live defect: the
+ * status census below caught 410 arriving unmapped, and unmapped means
+ * `unavailable`, which `isRetryable` calls true — so a caller would have been
+ * told to try an expired code again, forever.
+ */
+ | 'gone'
+/**
+ * The request lost a race, or repeated one it had already won differently.
+ *
+ * Carries the current version where the server supplies one, so an optimistic
+ * caller can re-read and retry rather than guess.
+ */
+ | 'conflict'
+/** The request itself was wrong. Retrying it unchanged will fail identically. */
+ | 'invalid_request'
+/** Looply could not be reached, or answered with a defect. Retryable. */
+ | 'unavailable'
+/** No answer within the client's own deadline. Retryable, and may have landed. */
+ | 'timeout';
+/**
+ * Whether trying the SAME request again could plausibly succeed.
+ *
+ * ⚠️ `timeout` IS RETRYABLE AND ALSO THE MOST DANGEROUS TO RETRY, which is why
+ * every mutating call in this SDK takes an idempotency key. A timed-out request
+ * may have been executed; retrying without a key is how one Start becomes two.
+ */
+export declare function isRetryable(code: LooplyErrorCode): boolean;
+/**
+ * The code for an HTTP status.
+ *
+ * Anything unmapped is `unavailable`: an unrecognised 5xx is Looply failing, and
+ * an unrecognised 4xx is a refusal this client does not model — which the caller
+ * should treat as "not now" rather than as a specific promise.
+ */
+export declare function codeForStatus(status: number): LooplyErrorCode;
+export interface LooplyErrorInit {
+    readonly status: number;
+    readonly message: string;
+    /** A code the SERVER supplied, which always wins over the derived one. */
+    readonly serverCode?: string;
+    /** The current version on a conflict, where the server names one. */
+    readonly currentVersion?: number;
+    readonly body?: unknown;
+}
+/**
+ * The one error type this SDK throws.
+ *
+ * 🔴 EVERY FAILURE PATH PRODUCES ONE OF THESE, including a network failure and a
+ * timeout — which are not HTTP statuses at all. A caller that has to distinguish
+ * "the server said no" from "there was no server" by catching two different
+ * shapes will eventually catch only one of them.
+ */
+export declare class LooplyError extends Error {
+    readonly status: number;
+    readonly code: LooplyErrorCode;
+    readonly currentVersion: number | undefined;
+    readonly body: unknown;
+    constructor(init: LooplyErrorInit);
+    /** Whether trying this exact request again could plausibly succeed. */
+    get retryable(): boolean;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,MAAM,eAAe;AACzB,kFAAkF;AAChF,cAAc;AAChB,2EAA2E;GACzE,WAAW;AACb;;;;;;;GAOG;GACD,WAAW;AACb;;;;;;;;;;;;;;GAcG;GACD,MAAM;AACR;;;;;GAKG;GACD,UAAU;AACZ,iFAAiF;GAC/E,iBAAiB;AACnB,yEAAyE;GACvE,aAAa;AACf,kFAAkF;GAChF,SAAS,CAAC;AAEd;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAE1D;AAYD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAwB7D;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,qEAAqE;IACrE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;gBAEX,IAAI,EAAE,eAAe;IASjC,uEAAuE;IACvE,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF"}