@retinue/agentkit 0.1.0 → 0.3.0

package/dist/adapters/embeddings/openai.js

@@ -0,0 +1,109 @@
+/**
+ * An OpenAI-compatible embedding adapter — REQ-050 (#209), task #219.
+ *
+ * The `EmbeddingProvider` port has existed since #136 with **no adapter of any kind**, which means the semantic
+ * half of hybrid retrieval has never run against a real model in this repository: every test supplies a stub, and
+ * a stub measures the stub. That is why this exists before the eval does — a retrieval score computed over
+ * hash-based pseudo-vectors is a number about nothing.
+ *
+ * OpenAI's shape rather than OpenAI specifically: the same request works against Azure OpenAI, Together, a local
+ * `llama.cpp` server and anything else that copied the endpoint, so `baseUrl` is the whole configuration story.
+ *
+ * ## Two properties worth stating
+ *
+ * **Order is checked, not assumed.** The API returns objects carrying an `index`, and the port's contract is one
+ * vector per input *in order*. A provider that returned them out of order — or dropped one — would silently pair
+ * every chunk with its neighbour's vector, and retrieval would still work well enough to look fine. So the
+ * response is sorted by `index` and the count is verified.
+ *
+ * **The model reference records a version.** Providers change what a model id returns without renaming it, and a
+ * corpus embedded across such a change has two incomparable halves. The port carries the ref per chunk precisely
+ * so that is detectable; this passes the caller's version through rather than inventing one.
+ */
+import { AgentPlatformError } from "../../core/errors.js";
+export const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+export const DEFAULT_EMBEDDING_BATCH = 96;
+export const createOpenAiEmbeddings = (config) => {
+    const modelId = config.modelId ?? DEFAULT_EMBEDDING_MODEL;
+    const model = {
+        modelId,
+        version: config.version ?? "1",
+        dimensions: config.dimensions ?? 1536,
+    };
+    const doFetch = config.fetchImpl ?? fetch;
+    const base = (config.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    const batchSize = config.batchSize ?? DEFAULT_EMBEDDING_BATCH;
+    const embedBatch = async (texts) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), config.timeoutMs ?? 60_000);
+        let response;
+        try {
+            response = await doFetch(`${base}/embeddings`, {
+                method: "POST",
+                signal: controller.signal,
+                headers: { authorization: `Bearer ${config.apiKey}`, "content-type": "application/json" },
+                body: JSON.stringify({
+                    model: modelId,
+                    input: texts,
+                    // Asked for explicitly, because the 3-series models support shortening and a deployment that pinned
+                    // 1536 in its column must get 1536 rather than whatever the default becomes.
+                    ...(model.dimensions === 1536 ? {} : { dimensions: model.dimensions }),
+                }),
+            });
+        }
+        catch (error) {
+            throw new AgentPlatformError({
+                code: error.name === "AbortError" ? "timeout" : "provider_unavailable",
+                message: `The embedding endpoint did not respond: ${error.message}`,
+                retryable: true,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const payload = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            const rateLimited = response.status === 429;
+            throw new AgentPlatformError({
+                code: rateLimited ? "rate_limited" : response.status >= 500 ? "provider_unavailable" : "provider_error",
+                message: `The embedding endpoint returned ${response.status}: ${payload.error?.message ?? "no message"}`,
+                // A 5xx and a rate limit are worth retrying; a 400 means the request is wrong and will stay wrong.
+                retryable: rateLimited || response.status >= 500,
+            });
+        }
+        const data = [...(payload.data ?? [])].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        if (data.length !== texts.length) {
+            throw new AgentPlatformError({
+                code: "provider_error",
+                message: `Asked for ${texts.length} embeddings and received ${data.length}. Pairing them would attach every chunk to the wrong vector.`,
+                retryable: false,
+            });
+        }
+        return data.map((entry, at) => {
+            const vector = entry.embedding;
+            if (vector === undefined || vector.length !== model.dimensions) {
+                throw new AgentPlatformError({
+                    code: "provider_error",
+                    message: `Embedding ${at} has ${vector?.length ?? 0} dimensions; this deployment records ${model.dimensions}.`,
+                    retryable: false,
+                });
+            }
+            return vector;
+        });
+    };
+    return {
+        model,
+        async embed(texts) {
+            if (texts.length === 0)
+                return [];
+            const out = [];
+            // Sequential batches, deliberately: parallel ones hit the rate limit on a first index of a real corpus,
+            // and the failure arrives as a 429 in the middle of a job rather than as a slower job.
+            for (let at = 0; at < texts.length; at += batchSize) {
+                out.push(...(await embedBatch(texts.slice(at, at + batchSize))));
+            }
+            return out;
+        },
+    };
+};
+//# sourceMappingURL=openai.js.map

package/dist/adapters/memory/connections.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The reference `ConnectionStore` — task #261.
+ *
+ * The baseline the other adapters are compared against, and the one the conformance suite runs first. It holds
+ * `SealedSecret`s exactly as Postgres does: an in-memory adapter that stored plaintext would make the raw-row
+ * assertion pass for the wrong reason, and the suite would then be asserting a different guarantee per adapter.
+ */
+import type { ConnectionStore } from "../../connections/index.js";
+export declare const createMemoryConnectionStore: (now?: () => string) => ConnectionStore;
+//# sourceMappingURL=connections.d.ts.map

package/dist/adapters/memory/connections.js

@@ -0,0 +1,87 @@
+/**
+ * The reference `ConnectionStore` — task #261.
+ *
+ * The baseline the other adapters are compared against, and the one the conformance suite runs first. It holds
+ * `SealedSecret`s exactly as Postgres does: an in-memory adapter that stored plaintext would make the raw-row
+ * assertion pass for the wrong reason, and the suite would then be asserting a different guarantee per adapter.
+ */
+import { AgentPlatformError } from "../../core/errors.js";
+const notFound = (id) => new AgentPlatformError({ code: "not_found", message: `no connection "${id}" for this tenant`, retryable: false });
+export const createMemoryConnectionStore = (now = () => new Date().toISOString()) => {
+    // Keyed by tenant, so a missing tenant filter is a missing map rather than a leak.
+    const byTenant = new Map();
+    const of = (tenantId) => {
+        const existing = byTenant.get(tenantId);
+        if (existing !== undefined)
+            return existing;
+        const created = new Map();
+        byTenant.set(tenantId, created);
+        return created;
+    };
+    return {
+        async create({ tenantId, connection }) {
+            const rows = of(tenantId);
+            if (rows.has(connection.id))
+                throw new AgentPlatformError({
+                    code: "conflict",
+                    message: `connection "${connection.id}" already exists for this tenant`,
+                    retryable: false,
+                });
+            const at = now();
+            const row = { ...connection, createdAt: at, updatedAt: at };
+            rows.set(connection.id, row);
+            return row;
+        },
+        async get({ tenantId, id, kind }) {
+            const row = of(tenantId).get(id);
+            // A caller that did not ask for an app registration must not receive one — see `ConnectionKind`.
+            if (row !== undefined && (row.kind ?? "connection") !== (kind ?? "connection"))
+                return null;
+            // A revoked connection reads as absent. Anything else would let a caller resolve a credential somebody
+            // deliberately withdrew.
+            return row === undefined || row.revokedAt !== undefined ? null : row;
+        },
+        async list({ tenantId, provider, kind }) {
+            return [...of(tenantId).values()]
+                .filter((c) => c.revokedAt === undefined &&
+                (provider === undefined || c.provider === provider) &&
+                (c.kind ?? "connection") === (kind ?? "connection"))
+                .sort((a, b) => (a.createdAt === b.createdAt ? a.id.localeCompare(b.id) : a.createdAt.localeCompare(b.createdAt)));
+        },
+        async update({ tenantId, id, patch }) {
+            const rows = of(tenantId);
+            const existing = rows.get(id);
+            if (existing === undefined || existing.revokedAt !== undefined)
+                throw notFound(id);
+            const updated = {
+                ...existing,
+                ...(patch.label === undefined ? {} : { label: patch.label }),
+                ...(patch.sealed === undefined ? {} : { sealed: patch.sealed }),
+                ...(patch.metadata === undefined ? {} : { metadata: patch.metadata }),
+                ...(patch.grantedScopes === undefined ? {} : { grantedScopes: patch.grantedScopes }),
+                ...(patch.expiresAt === undefined ? {} : { expiresAt: patch.expiresAt }),
+                updatedAt: now(),
+            };
+            rows.set(id, updated);
+            return updated;
+        },
+        async revoke({ tenantId, id }) {
+            const rows = of(tenantId);
+            const existing = rows.get(id);
+            if (existing === undefined)
+                throw notFound(id);
+            // Idempotent: revoking twice is not an error, because a caller retrying a disconnect should not have to
+            // distinguish "already gone" from "failed".
+            if (existing.revokedAt !== undefined)
+                return;
+            rows.set(id, { ...existing, revokedAt: now(), updatedAt: now() });
+        },
+        async purge({ tenantId }) {
+            const rows = byTenant.get(tenantId);
+            const count = rows?.size ?? 0;
+            byTenant.delete(tenantId);
+            return count;
+        },
+    };
+};
+//# sourceMappingURL=connections.js.map

package/dist/adapters/memory/graph.d.ts

@@ -0,0 +1,17 @@
+/**
+ * In-memory `GraphStore` — the reference implementation (REQ-064 #270, task #271).
+ *
+ * The same standard the in-memory `KnowledgeStore` holds itself to: this is not a stub that makes tests pass,
+ * it is the definition of the contract that the Postgres adapter is then held to by the same conformance suite.
+ * Three things it takes as seriously as a database would:
+ *
+ * - **Tenant isolation is structural.** Every map is keyed by tenant first, so cross-tenant reads are not
+ *   prevented by a filter somebody could forget — there is nowhere for another tenant's rows to be.
+ * - **Provenance is enforced, not assumed.** A row with no chunks is refused here, so the refusal is part of
+ *   the contract rather than a Postgres constraint that the reference adapter quietly tolerates.
+ * - **A source's contribution is what is replaced.** Entities are shared between sources; re-indexing one
+ *   document withdraws its claims and prunes only what nothing else asserts.
+ */
+import type { GraphStore } from "../../persistence/index.js";
+export declare const createMemoryGraphStore: () => GraphStore;
+//# sourceMappingURL=graph.d.ts.map

package/dist/adapters/memory/graph.js

@@ -0,0 +1,267 @@
+/**
+ * In-memory `GraphStore` — the reference implementation (REQ-064 #270, task #271).
+ *
+ * The same standard the in-memory `KnowledgeStore` holds itself to: this is not a stub that makes tests pass,
+ * it is the definition of the contract that the Postgres adapter is then held to by the same conformance suite.
+ * Three things it takes as seriously as a database would:
+ *
+ * - **Tenant isolation is structural.** Every map is keyed by tenant first, so cross-tenant reads are not
+ *   prevented by a filter somebody could forget — there is nowhere for another tenant's rows to be.
+ * - **Provenance is enforced, not assumed.** A row with no chunks is refused here, so the refusal is part of
+ *   the contract rather than a Postgres constraint that the reference adapter quietly tolerates.
+ * - **A source's contribution is what is replaced.** Entities are shared between sources; re-indexing one
+ *   document withdraws its claims and prunes only what nothing else asserts.
+ */
+import { AgentPlatformError } from "../../core/errors.js";
+const sourceKey = (sourceType, sourceId) => `${sourceType} ${sourceId}`;
+const DEFAULT_SETTINGS = { enabled: false, updatedAt: "1970-01-01T00:00:00.000Z" };
+const uniqueSorted = (values) => [...new Set(values)].sort();
+const byId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+/**
+ * Every contribution, merged into the graph a reader sees.
+ *
+ * Recomputed on read rather than maintained on write. That is the right trade for a reference adapter: the
+ * merge rule then exists in exactly one place, and a bug in it cannot leave a stored graph subtly inconsistent
+ * with the contributions it came from. Postgres maintains merged rows for query speed and is held to producing
+ * the same answer by `fingerprint`.
+ */
+const mergeAll = (source) => {
+    /**
+     * Materialised, because this function walks it **twice** — entities, then relationships.
+     *
+     * The first version took the `Iterable` and looped it directly, which works for an array and is silently
+     * wrong for `Map.values()`: an iterator is exhausted by the first pass, so the second saw nothing and *every
+     * edge was dropped*. Entities were correct, so the graph looked plausible; only a traversal returned empty.
+     * Found by the neighbour-ordering test, and worth the parameter rename so the two loops cannot drift back.
+     */
+    const contributions = [...source];
+    const entities = new Map();
+    const relationships = new Map();
+    for (const contribution of contributions) {
+        for (const entity of contribution.entities) {
+            const existing = entities.get(entity.id);
+            if (existing === undefined) {
+                entities.set(entity.id, entity);
+                continue;
+            }
+            const description = (entity.description ?? "").length > (existing.description ?? "").length ? entity.description : existing.description;
+            entities.set(entity.id, {
+                id: entity.id,
+                // Lexicographically first, matching `mergeContributions`. "First written" would depend on source order,
+                // and source order is a thing that changes without the corpus changing.
+                name: existing.name < entity.name ? existing.name : entity.name,
+                type: existing.type,
+                ...(description === undefined ? {} : { description }),
+                surfaceForms: uniqueSorted([...existing.surfaceForms, ...entity.surfaceForms]),
+                provenance: uniqueSorted([...existing.provenance, ...entity.provenance]),
+            });
+        }
+    }
+    for (const contribution of contributions) {
+        for (const edge of contribution.relationships) {
+            const existing = relationships.get(edge.id);
+            if (existing === undefined) {
+                relationships.set(edge.id, edge);
+                continue;
+            }
+            const description = (edge.description ?? "").length > (existing.description ?? "").length ? edge.description : existing.description;
+            const provenance = uniqueSorted([...existing.provenance, ...edge.provenance]);
+            relationships.set(edge.id, {
+                ...existing,
+                ...(description === undefined ? {} : { description }),
+                weight: provenance.length,
+                provenance,
+            });
+        }
+    }
+    // An edge whose endpoints are gone goes with them — the state after a source is removed.
+    const kept = [...relationships.values()].filter((edge) => entities.has(edge.fromId) && entities.has(edge.toId));
+    return { entities: [...entities.values()].sort(byId), relationships: kept.sort(byId) };
+};
+/** Refuses an untraceable claim. See `GraphStore` — provenance is structural. */
+const assertProvenance = (contribution) => {
+    for (const entity of contribution.entities) {
+        if (entity.provenance.length === 0)
+            throw new AgentPlatformError({
+                code: "invalid_input",
+                message: `entity ${entity.id} has no provenance; a graph claim with no chunk behind it is one the model would cite`,
+                retryable: false,
+            });
+    }
+    for (const edge of contribution.relationships) {
+        if (edge.provenance.length === 0)
+            throw new AgentPlatformError({
+                code: "invalid_input",
+                message: `relationship ${edge.id} has no provenance; a graph claim with no chunk behind it is one the model would cite`,
+                retryable: false,
+            });
+    }
+};
+export const createMemoryGraphStore = () => {
+    const tenants = new Map();
+    const graphOf = (tenantId) => {
+        let graph = tenants.get(tenantId);
+        if (!graph) {
+            tenants.set(tenantId, (graph = { settings: DEFAULT_SETTINGS, sourceFlags: new Map(), contributions: new Map(), communities: new Map() }));
+        }
+        return graph;
+    };
+    const page = (items, limit, cursor) => {
+        const offset = cursor === undefined ? 0 : Number.parseInt(cursor, 10) || 0;
+        const slice = items.slice(offset, offset + limit);
+        const next = offset + slice.length;
+        return next < items.length ? { items: slice, nextCursor: String(next) } : { items: slice };
+    };
+    return {
+        async getSettings({ tenantId }) {
+            return graphOf(tenantId).settings;
+        },
+        async setEnabled({ tenantId, enabled, at }) {
+            const graph = graphOf(tenantId);
+            graph.settings = { enabled, updatedAt: at };
+            return graph.settings;
+        },
+        async setSourceEnabled({ tenantId, sourceType, sourceId, enabled }) {
+            // Stored regardless of the tenant switch — AC-2. Marking a handbook today and enabling the tenant next
+            // week must not require re-marking anything, so this never consults `settings`.
+            graphOf(tenantId).sourceFlags.set(sourceKey(sourceType, sourceId), enabled);
+        },
+        async isSourceEnabled({ tenantId, sourceType, sourceId }) {
+            return graphOf(tenantId).sourceFlags.get(sourceKey(sourceType, sourceId)) === true;
+        },
+        async listEnabledSources({ tenantId, limit, cursor }) {
+            const rows = [...graphOf(tenantId).sourceFlags.entries()]
+                .filter(([, enabled]) => enabled)
+                .map(([key]) => {
+                const at = key.indexOf(" ");
+                return { sourceType: key.slice(0, at), sourceId: key.slice(at + 1) };
+            })
+                .sort((a, b) => (sourceKey(a.sourceType, a.sourceId) < sourceKey(b.sourceType, b.sourceId) ? -1 : 1));
+            return page(rows, limit, cursor);
+        },
+        async replaceSourceGraph({ tenantId, sourceType, sourceId, contribution }) {
+            assertProvenance(contribution);
+            const graph = graphOf(tenantId);
+            const before = mergeAll(graph.contributions.values()).entities.length;
+            const key = sourceKey(sourceType, sourceId);
+            if (contribution.entities.length === 0 && contribution.relationships.length === 0) {
+                graph.contributions.delete(key);
+            }
+            else {
+                graph.contributions.set(key, { entities: contribution.entities, relationships: contribution.relationships });
+            }
+            const after = mergeAll(graph.contributions.values());
+            return {
+                entities: after.entities.length,
+                relationships: after.relationships.length,
+                // What this replacement removed from the graph, not what it removed from the source. An operator asking
+                // "did re-indexing lose anything" is asking the first question.
+                pruned: Math.max(0, before - after.entities.length),
+            };
+        },
+        async deleteSourceGraph({ tenantId, sourceType, sourceId }) {
+            const graph = graphOf(tenantId);
+            const before = mergeAll(graph.contributions.values()).entities.length;
+            graph.contributions.delete(sourceKey(sourceType, sourceId));
+            const after = mergeAll(graph.contributions.values()).entities.length;
+            return { pruned: Math.max(0, before - after) };
+        },
+        async getEntity({ tenantId, id }) {
+            return mergeAll(graphOf(tenantId).contributions.values()).entities.find((entity) => entity.id === id) ?? null;
+        },
+        async getEntities({ tenantId, ids }) {
+            const wanted = new Set(ids);
+            return mergeAll(graphOf(tenantId).contributions.values()).entities.filter((entity) => wanted.has(entity.id));
+        },
+        async resolveEntities({ tenantId, normalisedNames }) {
+            if (normalisedNames.length === 0)
+                return [];
+            // The name is everything after the first colon; `normaliseName` cannot produce one, so the split is safe.
+            const wanted = new Set(normalisedNames);
+            return mergeAll(graphOf(tenantId).contributions.values()).entities.filter((entity) => wanted.has(entity.id.slice(entity.id.indexOf(":") + 1)));
+        },
+        async listEntities({ tenantId, limit, cursor, type }) {
+            const all = mergeAll(graphOf(tenantId).contributions.values()).entities;
+            return page(type === undefined ? all : all.filter((entity) => entity.type === type), limit, cursor);
+        },
+        async neighbours({ tenantId, entityIds, limit }) {
+            const wanted = new Set(entityIds);
+            const { relationships } = mergeAll(graphOf(tenantId).contributions.values());
+            return relationships
+                .filter((edge) => wanted.has(edge.fromId) || wanted.has(edge.toId))
+                // Heaviest first — the edge the most chunks asserted is the one most worth traversing. Ties broken by
+                // id so the order is total, which is what makes a truncated traversal reproducible.
+                .sort((a, b) => (b.weight - a.weight) || byId(a, b))
+                .slice(0, Math.max(0, limit));
+        },
+        async replaceCommunities({ tenantId, communities }) {
+            const graph = graphOf(tenantId);
+            const previous = new Map(graph.communities);
+            graph.communities.clear();
+            let summariesKept = 0;
+            for (const community of communities) {
+                const before = previous.get(community.id);
+                /**
+                 * A summary survives a re-clustering **only when the membership is identical**.
+                 *
+                 * Carrying it over on id alone would attach a summary of the old members to the new ones — a
+                 * confidently wrong description of a community that changed, which is worse than having none.
+                 */
+                const keep = before?.summary !== undefined && before.summaryFingerprint === community.fingerprint;
+                if (keep)
+                    summariesKept += 1;
+                graph.communities.set(community.id, {
+                    ...community,
+                    ...(keep && before !== undefined
+                        ? {
+                            summary: before.summary,
+                            summaryFingerprint: before.summaryFingerprint,
+                            ...(before.summarisedAt === undefined ? {} : { summarisedAt: before.summarisedAt }),
+                        }
+                        : {}),
+                });
+            }
+            return { written: communities.length, summariesKept };
+        },
+        async listCommunities({ tenantId, limit, cursor, level }) {
+            const all = [...graphOf(tenantId).communities.values()]
+                .filter((community) => level === undefined || community.level === level)
+                .sort((a, b) => a.level - b.level || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+            return page(all, limit, cursor);
+        },
+        async getCommunity({ tenantId, id }) {
+            return graphOf(tenantId).communities.get(id) ?? null;
+        },
+        async setCommunitySummary({ tenantId, id, summary, fingerprint, at }) {
+            const graph = graphOf(tenantId);
+            const community = graph.communities.get(id);
+            if (community === undefined)
+                return;
+            graph.communities.set(id, { ...community, summary, summaryFingerprint: fingerprint, summarisedAt: at });
+        },
+        async fingerprint({ tenantId }) {
+            const { entities, relationships } = mergeAll(graphOf(tenantId).contributions.values());
+            /**
+             * A stable serialisation, on the port rather than in a test — AC-6.
+             *
+             * Every field that a re-index could plausibly reorder is included: surface forms and provenance are the
+             * two that actually caught bugs, because both are sets that arrive in whatever order extraction produced.
+             * Leaving them out would let the fingerprint agree while the graph differed.
+             */
+            const lines = [
+                ...entities.map((entity) => [
+                    "E",
+                    entity.id,
+                    entity.name,
+                    entity.type,
+                    entity.description ?? "",
+                    entity.surfaceForms.join(","),
+                    entity.provenance.join(","),
+                ].join("
")),
+                ...relationships.map((edge) => ["R", edge.id, edge.type, String(edge.weight), edge.description ?? "", edge.provenance.join(",")].join("
")),
+            ];
+            return lines.join("\n");
+        },
+    };
+};
+//# sourceMappingURL=graph.js.map

package/dist/adapters/memory/index.d.ts

@@ -20,6 +20,7 @@ export * from "./files.js";
 export * from "./artifacts.js";
 export * from "./artifact-exports.js";
 export * from "./knowledge.js";
+export * from "./graph.js";
 export * from "./evaluation.js";
 /** Idempotency store reference adapter. */
 export * from "./idempotency.js";
@@ -36,4 +37,6 @@ export * from "./principal-memory.js";
 /** Message + agent reference adapters (used by the embedded agent facade). */
 export * from "./message-store.js";
 export * from "./flows.js";
+export * from "./rate-limit.js";
+export * from "./connections.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/adapters/memory/index.js

@@ -88,6 +88,7 @@ export * from "./files.js";
 export * from "./artifacts.js";
 export * from "./artifact-exports.js";
 export * from "./knowledge.js";
+export * from "./graph.js";
 export * from "./evaluation.js";
 /** Idempotency store reference adapter. */
 export * from "./idempotency.js";
@@ -104,4 +105,6 @@ export * from "./principal-memory.js";
 /** Message + agent reference adapters (used by the embedded agent facade). */
 export * from "./message-store.js";
 export * from "./flows.js";
+export * from "./rate-limit.js";
+export * from "./connections.js";
 //# sourceMappingURL=index.js.map

package/dist/adapters/memory/rate-limit.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The rate-limit counter in memory — task #248.
+ *
+ * **For tests and a single-process deployment only.** Two workers each hold their own `Map`, so each allows the
+ * full rate and a limit of 60/minute becomes 60×N. That is not a caveat to be worked around; it is why
+ * `createRedisRateLimitStore` exists, and why the cross-process test in this task's suite runs against a real
+ * Redis rather than this.
+ *
+ * Old windows are dropped on write rather than on a timer: a timer in a store would keep a process alive and
+ * would need clearing, and the number of live windows is one per tenant.
+ */
+import type { RateLimitStore } from "../../usage/index.js";
+export declare const createMemoryRateLimitStore: () => RateLimitStore;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/adapters/memory/rate-limit.js

@@ -0,0 +1,28 @@
+/**
+ * The rate-limit counter in memory — task #248.
+ *
+ * **For tests and a single-process deployment only.** Two workers each hold their own `Map`, so each allows the
+ * full rate and a limit of 60/minute becomes 60×N. That is not a caveat to be worked around; it is why
+ * `createRedisRateLimitStore` exists, and why the cross-process test in this task's suite runs against a real
+ * Redis rather than this.
+ *
+ * Old windows are dropped on write rather than on a timer: a timer in a store would keep a process alive and
+ * would need clearing, and the number of live windows is one per tenant.
+ */
+export const createMemoryRateLimitStore = () => {
+    const counts = new Map();
+    return {
+        async consume({ tenantId, windowStartMs }) {
+            const key = `${tenantId}:${windowStartMs}`;
+            // Every other window for this tenant is over, so nothing else can be incremented again.
+            for (const existing of counts.keys()) {
+                if (existing.startsWith(`${tenantId}:`) && existing !== key)
+                    counts.delete(existing);
+            }
+            const next = (counts.get(key) ?? 0) + 1;
+            counts.set(key, next);
+            return next;
+        },
+    };
+};
+//# sourceMappingURL=rate-limit.js.map

package/dist/adapters/postgres/connections.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `ConnectionStore` over Postgres — task #261.
+ *
+ * Pure SQL over `SqlExecutor`, like every other adapter here. The store never sees a plaintext secret: it
+ * writes the four columns of a `SealedSecret` and reads them back, so an adapter cannot leak something it does
+ * not have.
+ *
+ * Every query is tenant-scoped in its `WHERE`, and there is no `findById(id)` — governing principle 1. That is
+ * not belt-and-braces over RLS; it is the layer RLS is defence in depth *for*, and #91 is the reminder that a
+ * method accepting a tenant scope and not using it typechecks perfectly.
+ */
+import type { ConnectionStore } from "../../connections/index.js";
+import type { SqlExecutor } from "./sql.js";
+export declare const createPostgresConnectionStore: (sql: SqlExecutor) => ConnectionStore;
+//# sourceMappingURL=connections.d.ts.map