@byokit/accounts 0.1.0

package/README.md

@@ -0,0 +1,32 @@
+# @byokit/accounts
+
+Sign in with the AI plan you already pay for (ChatGPT, OpenRouter; Grok and GitHub Copilot on request), inside your
+own app, into your app's own store. Built on Pi's [`@earendil-works/pi-ai`](https://www.npmjs.com/package/@earendil-works/pi-ai)
+sign-in flows, pinned exactly.
+
+```ts
+import { isolate } from '@byokit/accounts/isolate'; // first, before any Pi import
+isolate('/path/to/app/engine');                     // scrub inherited Pi settings and provider keys
+import { Accounts, fileStore } from '@byokit/accounts';
+
+const accounts = new Accounts({ store: (member) => fileStore(`/path/to/app/people/${member}/auth.json`) });
+const shown = await accounts.login(1, 'chatgpt', { via: 'code' }); // { state: 'waiting', code, url }
+// show shown.code and shown.url; the sign-in finishes by itself
+(await accounts.status(1, 'chatgpt')).words;                     // "ChatGPT is connected."
+```
+
+- **Catalogue** (`catalogue.json`): each provider with its terms status (`allowed`, `grey`, `partner`), a one-line reason
+  and a source. The kit labels; your app decides what to offer (`new Accounts({ offer: ['chatgpt', 'grok'] })`).
+  Claude plan sign-in is never offered: Anthropic reserves it for its own apps.
+- **Sign-in**: the provider's own page by default. For ChatGPT, whose page returns to this computer's port 1455, the kit
+  listens there itself, so the tab shows your app's words (`new Accounts({ app: 'My App' })`) and only once they are
+  true. A code takes over when asked ("Having trouble?"), when the page never comes back, or when the port is taken by
+  another sign-in. A 15-minute cap, nothing kept unless the engine can use it, and every failure is one plain sentence
+  (`words.json`) with a `why` for apps that word it themselves. `plan(member)` tells a work ChatGPT from a personal one.
+- **One person, one store**: `memoryStore()` or `fileStore(path)` (0600, the same shape as Pi's `auth.json`). Never a
+  shared fallback. Using another engine with the same seam (Pi's coding-agent `ModelRuntime`)? Override `open(member)`.
+- **Limits**: `failed(member, key, error)` rests an account until the provider said (or a default), marks a plan that
+  doesn't include this use, and signs out only a sign-in that no longer refreshes. `ladder()` picks the next usable
+  account; `keepFresh()` refreshes ahead of expiry. Limits come from errors only; no undocumented usage endpoint is read.
+- **Isolation**: ambient discovery is off (no environment variable or credential file is ever consulted), and
+  `@byokit/accounts/testing` has the decoy-HOME harness and fs tracer to prove it in your own tests.

package/dist/accounts.d.ts

@@ -0,0 +1,126 @@
+import type { CredentialStore, Models } from '@earendil-works/pi-ai';
+import { type Provider } from './catalogue.ts';
+import { type Kind } from './limits.ts';
+import { type Why } from './words.ts';
+/** What signing in needs from an engine: Pi's `Models`, or anything shaped like it (the coding agent's `ModelRuntime`). */
+export type AuthHost = Pick<Models, 'login' | 'logout' | 'checkAuth' | 'getAuth'>;
+export type Member = string | number;
+/** What the person sees while signing in: the provider's own page to open (`via: 'browser'`), or a code to type there
+ *  (`via: 'code'`), never the engine's own prompts. `why` names how a failed one failed, for apps that word it themselves. */
+export type SignIn = {
+    state: 'waiting' | 'done' | 'failed';
+    via?: 'browser' | 'code';
+    url?: string;
+    code?: string;
+    expiresAt?: number;
+    error?: string;
+    why?: Why;
+};
+export type Status = {
+    account: string;
+    name: string;
+    state: 'ready' | 'signing' | 'resting' | 'signed_out' | 'needs_again' | 'not_included';
+    until?: number;
+    words: string;
+};
+export type AccountsOptions<M extends Member = Member> = {
+    /** The accounts this app offers, in order. Default: every provider not hidden (ChatGPT, OpenRouter). */
+    offer?: readonly string[];
+    /** Each member's own store. Default: in memory. */
+    store?: (member: M) => CredentialStore;
+    /** The app's name, for the page the provider's sign-in sends the browser back to. */
+    app?: string;
+    /** Longest a sign-in may wait: longer than any provider's code lives. */
+    signInMs?: number;
+    /** No redirect back by then: the page is probably stuck (or on a phone), so a code takes over by itself. */
+    redirectMs?: number;
+    /** Listen here for the provider's redirect instead of its fixed port (tests, so they never meet a real sign-in). */
+    callbackPort?: number;
+};
+/** The ChatGPT plan behind a sign-in, from its own token: a work plan (Business, Enterprise, Edu) follows the employer's rules. */
+export declare function planOf(access: string): {
+    plan: string;
+    email: string;
+    work: boolean;
+};
+export declare class Accounts<R extends AuthHost = AuthHost, M extends Member = Member> {
+    readonly providers: Provider[];
+    private opts;
+    private runtimes;
+    private stores;
+    private flows;
+    private ready;
+    private lapsed;
+    /** Signed in, but the plan doesn't include this use (ChatGPT's own "usage not included"). ponytail: in memory, so a
+     *  restart simply tries once more. */
+    private without;
+    private rests;
+    onChange?: (member: M, key: string) => void;
+    /** A sign-in just finished and works. */
+    onSignedIn?: (member: M, key: string) => void;
+    /** Said once when a sign-in can no longer be refreshed. */
+    onExpired?: (member: M, key: string) => void;
+    constructor(opts?: AccountsOptions<M>);
+    /** A member's own store. */
+    protected store(member: M): CredentialStore;
+    /** A member's engine, holding only their own sign-ins (`store(member)`). Override to use another engine with the same seam. */
+    protected open(member: M): Promise<R>;
+    runtime(member: M): Promise<R>;
+    private offer;
+    /** Signed in, from the engine's own side-effect-free check. */
+    signedIn(member: M, key: string): Promise<boolean>;
+    /** Which ChatGPT the member signed in with: its plan, email, and whether it is a work account. Null when not signed in. */
+    plan(member: M): Promise<{
+        plan: string;
+        email: string;
+        work: boolean;
+    } | null>;
+    /** Whether the member's plan lacks this use; `on` records what the provider said, or that the person changed plans. */
+    notIncluded(member: M, key: string, on?: boolean): boolean;
+    /** Known to be unusable: signed out, or a plan without this use. An unchecked account counts as usable, so a first run still tries. */
+    unready(member: M, key: string): boolean;
+    /** The account turned a request away (its sign-in lapsed): signed out until the person signs in again. */
+    forget(member: M, key: string): void;
+    /** 0 when the account is available; otherwise when it stops resting. */
+    restingUntil(member: M, key: string): number;
+    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
+     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
+     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
+     *  or null for an error that is not about the account; `network` changes nothing. */
+    failed(member: M, key: string, error: string): Promise<{
+        kind: Kind;
+        until: number;
+    } | null>;
+    /** The first choice whose account is neither resting nor known to be unusable: the fallback ladder. */
+    ladder<T>(member: M, choices: readonly T[], key?: (c: T) => string): T | undefined;
+    /** Where one account stands, in one plain sentence every app shows the same way. */
+    status(member: M, key: string): Promise<Status>;
+    /** Start "Sign in with …". The provider's own page by default: where it has a fixed redirect back to this computer
+     *  (ChatGPT), the kit listens there itself, so the tab shows the app's words, and only once they are true. The code is
+     *  the fallback: asked for (`via: 'code'`, "Having trouble?", even mid-way), or by itself when no redirect has come back
+     *  in time, or when a browser sign-in could not return at all. `fresh` asks the page which account again. A flow that
+     *  stalls times out; nothing is kept unless the engine then sees a working sign-in; every failure ends in one plain
+     *  sentence. Returns as soon as there is a page to open or a code to show (or it is over); the rest carries on by itself. */
+    login(member: M, key: string, body?: {
+        via?: 'code' | 'browser';
+        fresh?: boolean;
+    }): Promise<SignIn | null>;
+    /** The whole sign-in, for when the caller wants to wait for its end (tests do). */
+    finished(member: M, key: string): Promise<void>;
+    private toCode;
+    private signIn;
+    /** Listen where the provider sends the browser back; rejects if something else on this computer already listens there. */
+    private catchRedirect;
+    /** The redirect address (or a code) pasted back, for when the browser couldn't return to this computer by itself. */
+    paste(member: M, key: string, text: string): void;
+    /** Stop a sign-in and forget it; nothing it started is kept. */
+    cancel(member: M, key: string): void;
+    /** Refresh every signed-in account an hour ahead of expiry (call it now and then), so a sign-in never lapses while
+     *  nobody is looking. Only the provider refusing signs it out, and `onExpired` says so once; a network hiccup doesn't. */
+    keepFresh(members: readonly M[]): Promise<void>;
+    /** After the account turned a request away: true if its sign-in still refreshes; if not, it is signed out for good. */
+    recheck(member: M, key: string): Promise<boolean>;
+    logout(member: M, key: string): Promise<void>;
+    view(member: M, key: string): SignIn | null;
+    stop(): void;
+}

package/dist/accounts.js

@@ -0,0 +1,332 @@
+// Sign in with the AI plan you already pay for, one person at a time, into that person's own store. Sharing one
+// person's plan breaks the vendors' terms, so every sign-in, rest and refresh is keyed by member and account.
+// Pi's own sign-in flows do the work; the app only shows the provider's page to open or the code to type.
+import { createServer } from 'node:http';
+import { builtinModels } from '@earendil-works/pi-ai/providers/all';
+import { offered, provider } from "./catalogue.js";
+import { emptyAuthContext } from "./isolate.js";
+import { classify, REST_MS } from "./limits.js";
+import { memoryStore } from "./stores.js";
+import { callbackPage, clock, failure, say, signInError } from "./words.js";
+/** The ChatGPT plan behind a sign-in, from its own token: a work plan (Business, Enterprise, Edu) follows the employer's rules. */
+export function planOf(access) {
+    let claims = {};
+    try {
+        claims = JSON.parse(Buffer.from(access.split('.')[1] ?? '', 'base64url').toString());
+    }
+    catch { }
+    const plan = String(claims['https://api.openai.com/auth']?.chatgpt_plan_type ?? '').toLowerCase();
+    return { plan, email: String(claims['https://api.openai.com/profile']?.email ?? claims.email ?? ''), work: /^(team|business|enterprise|edu|education|k12)/.test(plan) };
+}
+const offline = (e) => failure(String(e?.message)) === 'offline';
+export class Accounts {
+    providers;
+    opts;
+    runtimes = new Map();
+    stores = new Map();
+    flows = new Map();
+    ready = new Map();
+    lapsed = new Set();
+    /** Signed in, but the plan doesn't include this use (ChatGPT's own "usage not included"). ponytail: in memory, so a
+     *  restart simply tries once more. */
+    without = new Set();
+    rests = new Map();
+    onChange;
+    /** A sign-in just finished and works. */
+    onSignedIn;
+    /** Said once when a sign-in can no longer be refreshed. */
+    onExpired;
+    constructor(opts = {}) { this.opts = opts; this.providers = offered(opts.offer); }
+    /** A member's own store. */
+    store(member) {
+        let s = this.stores.get(String(member));
+        if (!s)
+            this.stores.set(String(member), s = (this.opts.store ?? memoryStore)(member));
+        return s;
+    }
+    /** A member's engine, holding only their own sign-ins (`store(member)`). Override to use another engine with the same seam. */
+    open(member) {
+        return Promise.resolve(builtinModels({ credentials: this.store(member), authContext: emptyAuthContext }));
+    }
+    runtime(member) {
+        let r = this.runtimes.get(String(member));
+        if (!r)
+            this.runtimes.set(String(member), r = this.open(member));
+        return r;
+    }
+    offer(key) {
+        const p = provider(key);
+        if (!this.providers.includes(p))
+            throw Object.assign(new Error('AI account not offered here'), { status: 404 });
+        return p;
+    }
+    /** Signed in, from the engine's own side-effect-free check. */
+    async signedIn(member, key) {
+        const ok = !!(await (await this.runtime(member)).checkAuth(this.offer(key).pi).catch(() => undefined));
+        this.ready.set(`${member}:${key}`, ok);
+        if (ok)
+            this.lapsed.delete(`${member}:${key}`);
+        return ok;
+    }
+    /** Which ChatGPT the member signed in with: its plan, email, and whether it is a work account. Null when not signed in. */
+    async plan(member) {
+        const c = await this.store(member).read(this.offer('chatgpt').pi).catch(() => undefined);
+        return c?.type === 'oauth' ? planOf(c.access) : null;
+    }
+    /** Whether the member's plan lacks this use; `on` records what the provider said, or that the person changed plans. */
+    notIncluded(member, key, on) {
+        const id = `${member}:${key}`;
+        if (on !== undefined) {
+            if (on)
+                this.without.add(id);
+            else
+                this.without.delete(id);
+            this.onChange?.(member, key);
+        }
+        return this.without.has(id);
+    }
+    /** Known to be unusable: signed out, or a plan without this use. An unchecked account counts as usable, so a first run still tries. */
+    unready(member, key) { return this.ready.get(`${member}:${key}`) === false || this.without.has(`${member}:${key}`); }
+    /** The account turned a request away (its sign-in lapsed): signed out until the person signs in again. */
+    forget(member, key) {
+        this.ready.set(`${member}:${key}`, false);
+        this.lapsed.add(`${member}:${key}`);
+        this.onChange?.(member, key);
+    }
+    /** 0 when the account is available; otherwise when it stops resting. */
+    restingUntil(member, key) {
+        const r = this.rests.get(`${member}:${key}`);
+        return r && r.until > Date.now() ? r.until : 0;
+    }
+    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
+     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
+     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
+     *  or null for an error that is not about the account; `network` changes nothing. */
+    async failed(member, key, error) {
+        const c = classify(error);
+        if (!c || c.kind === 'network')
+            return c;
+        if (c.kind === 'signed_out' && await this.recheck(member, key))
+            c.kind = 'overloaded';
+        if (c.kind === 'not_included')
+            this.notIncluded(member, key, true);
+        else if (c.kind !== 'signed_out') {
+            c.until ||= Date.now() + REST_MS[c.kind];
+            this.rests.set(`${member}:${key}`, { until: c.until, kind: c.kind });
+            this.onChange?.(member, key);
+        }
+        return c;
+    }
+    /** The first choice whose account is neither resting nor known to be unusable: the fallback ladder. */
+    ladder(member, choices, key = String) {
+        return choices.find((c) => !this.restingUntil(member, key(c)) && !this.unready(member, key(c)));
+    }
+    /** Where one account stands, in one plain sentence every app shows the same way. */
+    async status(member, key) {
+        const { name } = this.offer(key);
+        const id = `${member}:${key}`;
+        const s = (state, w, until) => ({ account: key, name, state, until, words: say(w, { name, until: until ? clock(until) : '' }) });
+        if (this.flows.get(id)?.state === 'waiting')
+            return s('signing', 'status.signing');
+        const until = this.restingUntil(member, key);
+        if (until)
+            return s('resting', this.rests.get(id).kind === 'rate_limit' ? 'status.resting' : 'status.busy', until);
+        if (!(this.ready.get(id) ?? await this.signedIn(member, key)))
+            return this.lapsed.has(id) ? s('needs_again', 'status.needsAgain') : s('signed_out', 'status.signedOut');
+        return this.without.has(id) ? s('not_included', 'status.notIncluded') : s('ready', 'status.ready');
+    }
+    /** Start "Sign in with …". The provider's own page by default: where it has a fixed redirect back to this computer
+     *  (ChatGPT), the kit listens there itself, so the tab shows the app's words, and only once they are true. The code is
+     *  the fallback: asked for (`via: 'code'`, "Having trouble?", even mid-way), or by itself when no redirect has come back
+     *  in time, or when a browser sign-in could not return at all. `fresh` asks the page which account again. A flow that
+     *  stalls times out; nothing is kept unless the engine then sees a working sign-in; every failure ends in one plain
+     *  sentence. Returns as soon as there is a page to open or a code to show (or it is over); the rest carries on by itself. */
+    async login(member, key, body = {}) {
+        this.offer(key);
+        const id = `${member}:${key}`;
+        const now = this.flows.get(id);
+        if (now?.state === 'waiting' && body.via === 'code' && now.via === 'browser') {
+            // "Having trouble?": the same sign-in carries on with a code instead.
+            const visible = new Promise((r) => (now.shown = r));
+            this.toCode(now);
+            await Promise.race([visible, now.done]);
+        }
+        else if (now?.state !== 'waiting') {
+            const flow = { state: 'waiting', abort: new AbortController() };
+            this.flows.set(id, flow);
+            const visible = new Promise((r) => (flow.shown = r));
+            flow.done = this.signIn(member, key, body, flow);
+            await Promise.race([visible, flow.done]);
+        }
+        return this.view(member, key);
+    }
+    /** The whole sign-in, for when the caller wants to wait for its end (tests do). */
+    finished(member, key) { return this.flows.get(`${member}:${key}`)?.done ?? Promise.resolve(); }
+    toCode(flow) {
+        if (flow.state !== 'waiting' || flow.via !== 'browser' || flow.toCode)
+            return;
+        flow.toCode = true;
+        flow.refuse?.(new Error('switching to a code'));
+    }
+    async signIn(member, key, body, flow) {
+        const p = this.offer(key);
+        const id = `${member}:${key}`;
+        const rt = await this.runtime(member);
+        let codeOffered = false;
+        const attempt = (via) => rt.login(p.pi, 'oauth', {
+            signal: flow.abort.signal,
+            prompt: (q) => {
+                if (q.type === 'select') {
+                    const device = q.options.find((o) => /device/i.test(o.id));
+                    codeOffered = !!device;
+                    return Promise.resolve((via === 'code' && device ? device : q.options.find((o) => o !== device) ?? q.options[0]).id);
+                }
+                if (q.type === 'text')
+                    return Promise.resolve(''); // GitHub Enterprise domain: never, for a household
+                // "Paste the redirect address": the kit's own listener (or the person) hands the engine the address the browser landed on.
+                return new Promise((resolve, reject) => {
+                    Object.assign(flow, { paste: resolve, refuse: reject });
+                    q.signal?.addEventListener('abort', () => reject(new Error('answered elsewhere')));
+                });
+            },
+            notify: (e) => {
+                if (e.type === 'auth_url') {
+                    const url = new URL(e.url);
+                    if (body.fresh)
+                        url.searchParams.set('prompt', 'login'); // "Use my personal account": ask which account, again
+                    Object.assign(flow, { via: 'browser', url: url.toString(), code: undefined, oauthState: url.searchParams.get('state') ?? undefined });
+                }
+                if (e.type === 'device_code')
+                    Object.assign(flow, { via: 'code', code: e.userCode, url: e.verificationUri, expiresAt: e.expiresInSeconds ? Date.now() + e.expiresInSeconds * 1000 : undefined });
+                if (flow.url)
+                    flow.shown?.();
+                this.onChange?.(member, key);
+            },
+        });
+        const timer = setTimeout(() => { flow.timedOut = true; flow.abort.abort(); }, this.opts.signInMs ?? 15 * 60_000);
+        const stuck = setTimeout(() => this.toCode(flow), this.opts.redirectMs ?? 3 * 60_000);
+        // Listen where the provider sends the browser back (the engine then finds the port taken and waits to be handed the address).
+        const port = p.callbackPort && (this.opts.callbackPort ?? p.callbackPort);
+        const catcher = port && body.via !== 'code' ? await this.catchRedirect(flow, p.name, port).catch(() => null) : undefined;
+        try {
+            if (catcher === null)
+                throw Object.assign(new Error('port busy'), { why: 'busy' });
+            try {
+                await attempt(body.via ?? (catcher ? 'browser' : undefined));
+            }
+            catch (e) {
+                // The code instead: asked for, or the page never came back. Also when a browser sign-in could not return here at all.
+                if (!flow.toCode && (catcher || body.via === 'code' || !codeOffered || flow.abort.signal.aborted))
+                    throw e;
+                Object.assign(flow, { url: undefined, code: undefined, via: 'code' });
+                catcher?.close();
+                catcher?.closeIdleConnections();
+                await attempt('code');
+            }
+            // Never half signed in: only a sign-in the engine can use counts.
+            if (!(await rt.checkAuth(p.pi).catch(() => undefined))) {
+                await rt.logout(p.pi).catch(() => { });
+                throw new Error('no usable credential');
+            }
+            flow.state = 'done';
+            this.ready.set(id, true);
+            for (const s of [this.lapsed, this.without])
+                s.delete(id);
+            this.rests.delete(id);
+            this.onSignedIn?.(member, key);
+        }
+        catch (e) {
+            if (flow.state !== 'waiting')
+                return; // cancelled: already settled
+            const error = String(e?.message ?? e);
+            console.error(`sign-in ${key} for member ${member}:`, error);
+            const why = e?.why ?? (flow.timedOut ? 'tooLong' : failure(error));
+            Object.assign(flow, { state: 'failed', url: undefined, code: undefined, expiresAt: undefined, why,
+                error: why === 'busy' || why === 'tooLong' ? say(`signIn.${why}`, { name: p.name }) : signInError(p.name, error) });
+        }
+        finally {
+            clearTimeout(timer);
+            clearTimeout(stuck);
+            catcher?.close();
+            catcher?.closeIdleConnections();
+            this.onChange?.(member, key);
+        }
+    }
+    /** Listen where the provider sends the browser back; rejects if something else on this computer already listens there. */
+    catchRedirect(flow, name, port) {
+        const app = this.opts.app ?? 'the app';
+        const server = createServer(async (req, res) => {
+            const q = new URL(req.url ?? '/', 'http://localhost').searchParams;
+            // No keep-alive: a browser must never land on a listener from an earlier try.
+            const page = (status, words, close = false) => { res.writeHead(status, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', connection: 'close' }); res.end(callbackPage(this.opts.app ?? name, words, close)); };
+            if (!flow.oauthState || q.get('state') !== flow.oauthState || flow.state !== 'waiting')
+                return page(400, say('callback.outOfDate', { app, name }));
+            if (q.get('error'))
+                flow.refuse?.(new Error(q.get('error')));
+            // The engine only reads the query; the address it expects is the provider's registered one, on its fixed port.
+            else
+                flow.paste?.(`http://localhost:${port}${req.url}`);
+            // The tab waits for the real outcome (a few seconds at most), so it never says "signed in" before it is.
+            await Promise.race([flow.done, new Promise((r) => setTimeout(r, 30_000).unref())]);
+            const end = flow.state;
+            if (end === 'done')
+                return page(200, say('callback.done', { app }), true);
+            if (flow.why === 'declined')
+                return page(200, say('callback.declined', { app }), true);
+            page(200, end === 'failed' ? say('callback.failed', { app, error: flow.error ?? '' }) : say('callback.nearly', { app }));
+        });
+        return new Promise((resolve, reject) => { server.once('error', reject).listen(port, '127.0.0.1', () => resolve(server)); });
+    }
+    /** The redirect address (or a code) pasted back, for when the browser couldn't return to this computer by itself. */
+    paste(member, key, text) {
+        const f = this.flows.get(`${member}:${key}`);
+        if (f?.state !== 'waiting' || !f.paste)
+            throw Object.assign(new Error('no sign-in is waiting'), { status: 409 });
+        f.paste(text.trim());
+    }
+    /** Stop a sign-in and forget it; nothing it started is kept. */
+    cancel(member, key) {
+        const f = this.flows.get(`${member}:${key}`);
+        if (f?.state === 'waiting') {
+            f.state = 'failed';
+            f.abort.abort();
+            f.refuse?.(new Error('cancelled'));
+        }
+        this.flows.delete(`${member}:${key}`);
+        this.onChange?.(member, key);
+    }
+    /** Refresh every signed-in account an hour ahead of expiry (call it now and then), so a sign-in never lapses while
+     *  nobody is looking. Only the provider refusing signs it out, and `onExpired` says so once; a network hiccup doesn't. */
+    async keepFresh(members) {
+        for (const m of members)
+            for (const p of this.providers) {
+                if (this.ready.get(`${m}:${p.key}`) !== true)
+                    continue;
+                const ok = await (await this.runtime(m)).getAuth(p.pi, { minOAuthValidityMs: 60 * 60_000 }).then(Boolean, offline);
+                if (!ok) {
+                    this.forget(m, p.key);
+                    this.onExpired?.(m, p.key);
+                }
+            }
+    }
+    /** After the account turned a request away: true if its sign-in still refreshes; if not, it is signed out for good. */
+    async recheck(member, key) {
+        const ok = await (await this.runtime(member)).getAuth(this.offer(key).pi, { minOAuthValidityMs: 365 * 86_400_000 }).then(Boolean, offline);
+        if (!ok) {
+            await this.logout(member, key).catch(() => { });
+            this.forget(member, key);
+        }
+        return ok;
+    }
+    async logout(member, key) {
+        await (await this.runtime(member)).logout(this.offer(key).pi);
+        this.ready.set(`${member}:${key}`, false);
+        this.onChange?.(member, key);
+    }
+    view(member, key) {
+        const f = this.flows.get(`${member}:${key}`);
+        return f ? { state: f.state, via: f.via, url: f.url, code: f.code, expiresAt: f.state === 'waiting' ? f.expiresAt : undefined, error: f.error, why: f.why } : null;
+    }
+    stop() { for (const f of this.flows.values())
+        f.abort.abort(); }
+}

package/dist/catalogue.d.ts

@@ -0,0 +1,21 @@
+export type Terms = 'allowed' | 'grey' | 'partner' | 'forbidden';
+/** `callbackPort`: where the provider sends the browser back after its own sign-in page, fixed for the client Pi signs in as. */
+export type Provider = {
+    key: string;
+    pi: string;
+    name: string;
+    company: string;
+    models: {
+        strong: string;
+        fast?: string;
+    };
+    callbackPort?: number;
+    terms: Terms;
+    hidden: boolean;
+    why: string;
+    source: string;
+};
+export declare const PROVIDERS: Record<string, Provider>;
+export declare function provider(key: string): Provider;
+/** What an app offers: the keys it names, in its order, or every provider not hidden by default. */
+export declare const offered: (keys?: readonly string[]) => Provider[];

package/dist/catalogue.js

@@ -0,0 +1,14 @@
+// The AI accounts a person can bring, by the name they know, with each provider's terms status as data (catalogue.json,
+// readable from Kotlin too). The kit labels; the app decides what to offer. Claude plan sign-in is absent on purpose:
+// Anthropic reserves it for its own apps, so no app can wire it by mistake. Meta and Kimi are left out too (a
+// competitor by the owner's choice; Kimi refuses anything but coding agents).
+import CATALOGUE from './catalogue.json' with { type: 'json' };
+export const PROVIDERS = Object.fromEntries(Object.entries(CATALOGUE).map(([key, p]) => [key, { key, ...p }]));
+export function provider(key) {
+    const p = PROVIDERS[key];
+    if (!p)
+        throw Object.assign(new Error('no such AI account'), { status: 404 });
+    return p;
+}
+/** What an app offers: the keys it names, in its order, or every provider not hidden by default. */
+export const offered = (keys) => keys ? keys.map(provider) : Object.values(PROVIDERS).filter((p) => !p.hidden);

package/dist/catalogue.json

@@ -0,0 +1,52 @@
+{
+    "chatgpt": {
+        "pi": "openai-codex",
+        "name": "ChatGPT",
+        "company": "OpenAI",
+        "models": {
+            "strong": "gpt-6-sol",
+            "fast": "gpt-6-luna"
+        },
+        "callbackPort": 1455,
+        "terms": "grey",
+        "hidden": false,
+        "why": "Signs in through Codex's own sign-in. OpenAI documents it for Codex, not for other apps, and has endorsed one other app using it.",
+        "source": "https://developers.openai.com/codex/auth"
+    },
+    "openrouter": {
+        "pi": "openrouter",
+        "name": "OpenRouter",
+        "company": "OpenRouter",
+        "models": {
+            "strong": "moonshotai/kimi-k2.6"
+        },
+        "terms": "allowed",
+        "hidden": false,
+        "why": "Documented sign-in for any app, no registration. Pay-as-you-go credits, not a subscription.",
+        "source": "https://openrouter.ai/docs/guides/overview/auth/oauth"
+    },
+    "grok": {
+        "pi": "xai",
+        "name": "Grok",
+        "company": "xAI",
+        "models": {
+            "strong": "grok-4.7"
+        },
+        "terms": "partner",
+        "hidden": true,
+        "why": "xAI allows plan sign-in only in apps it has partnered with.",
+        "source": "https://x.ai/news/grok-opencode"
+    },
+    "copilot": {
+        "pi": "github-copilot",
+        "name": "GitHub Copilot",
+        "company": "GitHub",
+        "models": {
+            "strong": "gpt-5.4"
+        },
+        "terms": "partner",
+        "hidden": true,
+        "why": "GitHub allows Copilot sign-in only in apps it has partnered with; this uses VS Code's client.",
+        "source": "https://github.blog/changelog/2026-01-16-github-copilot-now-supports-opencode"
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Accounts, planOf, type AccountsOptions, type AuthHost, type Member, type SignIn, type Status } from './accounts.ts';
+export { PROVIDERS, offered, provider, type Provider, type Terms } from './catalogue.ts';
+export { INHERITED, emptyAuthContext, isolate } from './isolate.ts';
+export { REST_MS, classify, type Kind } from './limits.ts';
+export { fileStore, memoryStore } from './stores.ts';
+export { WORDS, callbackPage, clock, failure, say, signInError, type WordKey, type Why } from './words.ts';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { Accounts, planOf } from "./accounts.js";
+export { PROVIDERS, offered, provider } from "./catalogue.js";
+export { INHERITED, emptyAuthContext, isolate } from "./isolate.js";
+export { REST_MS, classify } from "./limits.js";
+export { fileStore, memoryStore } from "./stores.js";
+export { WORDS, callbackPage, clock, failure, say, signInError } from "./words.js";

package/dist/isolate.d.ts

@@ -0,0 +1,7 @@
+import type { AuthContext } from '@earendil-works/pi-ai';
+/** Inherited Pi settings, and provider keys that would let the app run on someone's account without signing in. */
+export declare const INHERITED: RegExp;
+/** Ambient discovery switched off: no environment variable or credential file is ever consulted. */
+export declare const emptyAuthContext: AuthContext;
+/** Scrub inherited settings and keys from this process, and pin Pi's agent folder to `dir` (never ~/.pi). Returns `dir`. */
+export declare function isolate(dir: string): string;

package/dist/isolate.js

@@ -0,0 +1,16 @@
+// Nothing from the person's own AI tools or shell may reach the app's engine. No Pi import here: an app imports this
+// first, because Pi's coding agent reads some of these at import time.
+import { mkdirSync } from 'node:fs';
+/** Inherited Pi settings, and provider keys that would let the app run on someone's account without signing in. */
+export const INHERITED = /^(PI_|AI_AGENT$|ANTHROPIC_|AWS_|AZURE_|GOOGLE_|GCLOUD_|CLOUDFLARE_)|_API_KEY$|^(COPILOT_GITHUB_TOKEN|GH_TOKEN|GITHUB_TOKEN|HF_TOKEN)$/;
+/** Ambient discovery switched off: no environment variable or credential file is ever consulted. */
+export const emptyAuthContext = { env: async () => undefined, fileExists: async () => false };
+/** Scrub inherited settings and keys from this process, and pin Pi's agent folder to `dir` (never ~/.pi). Returns `dir`. */
+export function isolate(dir) {
+    for (const k of Object.keys(process.env))
+        if (INHERITED.test(k))
+            delete process.env[k];
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    Object.assign(process.env, { PI_CODING_AGENT_DIR: dir, PI_OFFLINE: '1', PI_TELEMETRY: '0', PI_SKIP_VERSION_CHECK: '1' });
+    return dir;
+}

package/dist/limits.d.ts

@@ -0,0 +1,8 @@
+export type Kind = 'rate_limit' | 'overloaded' | 'signed_out' | 'not_included' | 'network';
+/** How long an account rests when its error didn't say. */
+export declare const REST_MS: Record<Kind, number>;
+/** `until` is 0 when the error didn't say. Anything unrecognised is null: the app fails that one request. */
+export declare function classify(error: string): {
+    kind: Kind;
+    until: number;
+} | null;

package/dist/limits.js

@@ -0,0 +1,20 @@
+/** How long an account rests when its error didn't say. */
+export const REST_MS = { rate_limit: 60 * 60_000, overloaded: 5 * 60_000, signed_out: 0, not_included: 0, network: 0 };
+/** `until` is 0 when the error didn't say. Anything unrecognised is null: the app fails that one request. */
+export function classify(error) {
+    const m = /try again in ~?(\d+)\s*(min|h)/i.exec(error);
+    const until = m ? Date.now() + Number(m[1]) * (m[2].toLowerCase() === 'h' ? 3_600_000 : 60_000) : 0;
+    // ChatGPT words "your plan doesn't include this" (usage_not_included) like a limit, but with no time to come back.
+    // ponytail: told apart by the missing "try again"; a real limit always says when it resets.
+    if (/usage limit/i.test(error) && !m)
+        return { kind: 'not_included', until };
+    if (/usage limit|rate.?limit|quota|too many requests|\b429\b/i.test(error))
+        return { kind: 'rate_limit', until };
+    if (/overloaded|high demand|\b50[234]\b|unavailable/i.test(error))
+        return { kind: 'overloaded', until };
+    if (/unauthori[sz]ed|\b40[13]\b|sign in again|expired|invalid.*token|authentication/i.test(error))
+        return { kind: 'signed_out', until };
+    if (/fetch failed|network|ENOTFOUND|EAI_AGAIN|ECONN|socket hang up/i.test(error))
+        return { kind: 'network', until };
+    return null;
+}

package/dist/stores.d.ts

@@ -0,0 +1,5 @@
+import { type CredentialStore } from '@earendil-works/pi-ai';
+export declare const memoryStore: () => CredentialStore;
+/** One person's sign-ins in a JSON file the app chooses (0600, in a 0700 folder), in the same shape as Pi's auth.json.
+ *  ponytail: writes are serialized within this process only; add a file lock if two processes ever share one file. */
+export declare function fileStore(path: string): CredentialStore;

package/dist/stores.js

@@ -0,0 +1,42 @@
+// Credential stores behind Pi's own CredentialStore seam: one per person, never a shared fallback.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { InMemoryCredentialStore } from '@earendil-works/pi-ai';
+export const memoryStore = () => new InMemoryCredentialStore();
+/** One person's sign-ins in a JSON file the app chooses (0600, in a 0700 folder), in the same shape as Pi's auth.json.
+ *  ponytail: writes are serialized within this process only; add a file lock if two processes ever share one file. */
+export function fileStore(path) {
+    let chain = Promise.resolve();
+    const serial = (fn) => { const r = chain.then(fn); chain = r.catch(() => { }); return r; };
+    const load = () => {
+        try {
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return {};
+            throw e;
+        }
+    };
+    const save = (data) => {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        writeFileSync(`${path}.tmp`, JSON.stringify(data, null, 2), { mode: 0o600 });
+        renameSync(`${path}.tmp`, path);
+    };
+    return {
+        read: async (id) => load()[id],
+        list: async () => Object.entries(load()).map(([providerId, c]) => ({ providerId, type: c.type })),
+        modify: (id, fn) => serial(async () => {
+            const current = load()[id];
+            const next = await fn(current);
+            if (next === undefined)
+                return current;
+            save({ ...load(), [id]: next }); // re-read: a sign-in can take minutes, and other providers may have changed meanwhile
+            return next;
+        }),
+        delete: (id) => serial(async () => { const data = load(); if (id in data) {
+            delete data[id];
+            save(data);
+        } }),
+    };
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,19 @@
+export declare const CANARY = "canary-byokit-7f3a9c";
+/** Preload this with `node --import` to record touches under `TRACE_ROOTS` in `TRACE_LOG` (both set in `decoy().env`). */
+export declare const traceFs: string;
+export declare function decoy(root?: string): {
+    root: string;
+    home: string;
+    roots: string[];
+    marks: string;
+    /** For a child process: the decoy HOME, the tracer's settings, and what a shell inside someone's Pi inherits. */
+    env: Record<string, string>;
+    /** Paths the tracer saw touched, one per line; empty when nothing was. */
+    touched: () => string;
+    /** Decoy files whose bytes or modification time changed, or that appeared or vanished. */
+    changed: () => string[];
+    /** Files under `dir` carrying a canary: a key or sign-in from the decoy leaked into the app's own storage. */
+    leaks: (dir: string) => string[];
+    /** Marks left by the decoy's extension or CLIs: something ran code from someone else's setup. */
+    ran: () => string[];
+};

package/dist/testing/index.js

@@ -0,0 +1,50 @@
+// The isolation harness every byokit package (and every app built on it) tests with: a throwaway HOME holding a decoy
+// of each agent setup a person may already have signed in (Pi, Codex, Claude, shared agent skills), the environment a
+// shell inside one of them hands down, and an fs tracer. A run must leave the decoys byte for byte as they were, never
+// touch them at all, and never carry a canary into the app's own files.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const CANARY = 'canary-byokit-7f3a9c';
+/** Preload this with `node --import` to record touches under `TRACE_ROOTS` in `TRACE_LOG` (both set in `decoy().env`). */
+export const traceFs = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './trace-fs.ts' : './trace-fs.js', import.meta.url));
+const put = (p, text) => { mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, text); };
+const files = (dir) => existsSync(dir)
+    ? readdirSync(dir, { recursive: true, withFileTypes: true }).filter((e) => e.isFile()).map((e) => join(e.parentPath, e.name)) : [];
+const hashes = (dirs) => Object.fromEntries(dirs.flatMap(files).map((p) => [p, createHash('sha256').update(readFileSync(p)).digest('hex') + statSync(p).mtimeMs]));
+export function decoy(root = mkdtempSync(join(tmpdir(), 'byokit-decoy-'))) {
+    const home = join(root, 'home');
+    const marks = join(root, 'marks');
+    const trace = join(root, 'trace.log');
+    const pi = join(home, '.pi'), codex = join(home, '.codex'), claude = join(home, '.claude'), agents = join(home, '.agents');
+    const token = { type: 'oauth', access: `${CANARY}-access`, refresh: `${CANARY}-refresh`, expires: Date.now() + 86_400_000 };
+    put(join(pi, 'agent', 'auth.json'), JSON.stringify({ 'openai-codex': token, xai: token }));
+    put(join(pi, 'agent', 'settings.json'), JSON.stringify({ defaultProvider: 'openai-codex', defaultModel: 'gpt-6-sol', packages: ['npm:evil'] }));
+    put(join(pi, 'agent', 'extensions', 'evil.ts'), `import { writeFileSync } from 'node:fs'; writeFileSync(${JSON.stringify(join(marks, 'extension'))}, 'loaded'); export default () => {};`);
+    put(join(codex, 'auth.json'), JSON.stringify({ tokens: { access_token: `${CANARY}-codex`, refresh_token: `${CANARY}-codex-refresh` } }));
+    put(join(claude, '.credentials.json'), JSON.stringify({ claudeAiOauth: { accessToken: `${CANARY}-claude` } }));
+    put(join(agents, 'skills', 'owner-skill', 'SKILL.md'), '---\nname: owner-skill\ndescription: the person\'s own skill\n---\n');
+    mkdirSync(marks, { recursive: true });
+    writeFileSync(trace, '');
+    const roots = [pi, codex, claude, agents];
+    const before = hashes(roots);
+    return {
+        root, home, roots, marks,
+        /** For a child process: the decoy HOME, the tracer's settings, and what a shell inside someone's Pi inherits. */
+        env: {
+            HOME: home, TRACE_ROOTS: roots.join(':'), TRACE_LOG: trace,
+            PI_CODING_AGENT_DIR: join(pi, 'agent'), PI_PROVIDER: 'openai-codex', PI_MODEL: 'gpt-6-sol', PI_CODING_AGENT: 'true', AI_AGENT: 'pi',
+            OPENAI_API_KEY: `${CANARY}-key`, XAI_API_KEY: `${CANARY}-xai`, OPENROUTER_API_KEY: `${CANARY}-or`, GH_TOKEN: `${CANARY}-gh`,
+        },
+        /** Paths the tracer saw touched, one per line; empty when nothing was. */
+        touched: () => readFileSync(trace, 'utf8').trim(),
+        /** Decoy files whose bytes or modification time changed, or that appeared or vanished. */
+        changed: () => { const now = hashes(roots); return [...new Set([...Object.keys(before), ...Object.keys(now)])].filter((p) => before[p] !== now[p]); },
+        /** Files under `dir` carrying a canary: a key or sign-in from the decoy leaked into the app's own storage. */
+        leaks: (dir) => files(dir).filter((f) => readFileSync(f).includes(CANARY)),
+        /** Marks left by the decoy's extension or CLIs: something ran code from someone else's setup. */
+        ran: () => readdirSync(marks),
+    };
+}

package/dist/testing/trace-fs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/testing/trace-fs.js

@@ -0,0 +1,30 @@
+// Preload (node --import) that records every file-system call naming a path under TRACE_ROOTS (colon-separated), one
+// line per touch in TRACE_LOG. It keeps the original appendFileSync for itself, so it never traces its own writes.
+import fs from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+import { resolve } from 'node:path';
+const roots = (process.env.TRACE_ROOTS ?? '').split(':').filter(Boolean);
+const log = process.env.TRACE_LOG;
+const append = fs.appendFileSync;
+const hit = (p) => {
+    if (typeof p === 'number' || p == null)
+        return;
+    const s = resolve(String(p instanceof URL ? p.pathname : p));
+    if (roots.some((r) => s === r || s.startsWith(r + '/')))
+        append(log, `${s}\n`);
+};
+const wrap = (obj, name) => {
+    const f = obj[name];
+    if (typeof f !== 'function' || (name === 'appendFileSync' && obj === fs))
+        return;
+    obj[name] = function (a, b, ...rest) { hit(a); if (/rename|copy|link|symlink|cp/i.test(name))
+        hit(b); return f.call(this, a, b, ...rest); };
+};
+if (log && roots.length) {
+    for (const name of Object.keys(fs))
+        if (/^[a-z]/.test(name) && !['watch', 'watchFile', 'unwatchFile'].includes(name))
+            wrap(fs, name);
+    for (const name of Object.keys(fs.promises))
+        wrap(fs.promises, name);
+    syncBuiltinESMExports();
+}

package/dist/words.d.ts

@@ -0,0 +1,14 @@
+import WORDS from './words.json';
+export type WordKey = keyof typeof WORDS;
+export { WORDS };
+/** A sentence with its `{slots}` filled. */
+export declare const say: (key: WordKey, slots?: Record<string, string>) => string;
+/** "3:40pm", or "Fri 3:40pm" when it isn't today. */
+export declare const clock: (t: number) => string;
+/** Why a sign-in failed, from the engine's own error. */
+export type Why = 'expired' | 'declined' | 'offline' | 'deviceCodeOff' | 'busy' | 'tooLong' | 'failed';
+export declare function failure(error: string): Why;
+/** A failed sign-in in one plain sentence with one next step. */
+export declare const signInError: (name: string, error: string) => string;
+/** The app's own page for the browser tab a provider sends back: it says how it really went, never "success" before it is. */
+export declare const callbackPage: (title: string, words: string, close?: boolean) => string;

package/dist/words.js

@@ -0,0 +1,28 @@
+// Every sentence a person can see, in one file other languages can read too (words.json). Plain words only: no codes,
+// commands, paths, model ids or percentages; test/words.test.ts holds the line.
+import WORDS from './words.json' with { type: 'json' };
+export { WORDS };
+/** A sentence with its `{slots}` filled. */
+export const say = (key, slots = {}) => WORDS[key].replace(/\{(\w+)\}/g, (_, k) => slots[k] ?? '');
+/** "3:40pm", or "Fri 3:40pm" when it isn't today. */
+export const clock = (t) => (new Date(t).toDateString() === new Date().toDateString() ? '' : new Date(t).toLocaleDateString('en-US', { weekday: 'short' }) + ' ') +
+    new Date(t).toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' }).toLowerCase();
+export function failure(error) {
+    if (/token exchange failed|missing fields|accountId/i.test(error))
+        return 'failed'; // said yes on the page, refused after
+    if (/expired|expire/i.test(error))
+        return 'expired';
+    if (/denied|declined|access_denied|rejected|cancel/i.test(error))
+        return 'declined';
+    if (/fetch failed|network|ENOTFOUND|EAI_AGAIN|ECONN|timed? ?out|socket/i.test(error))
+        return 'offline';
+    if (/device code.*(disabled|not enabled)|enable device/i.test(error))
+        return 'deviceCodeOff';
+    return 'failed';
+}
+/** A failed sign-in in one plain sentence with one next step. */
+export const signInError = (name, error) => say(`signIn.${failure(error)}`, { name });
+/** The app's own page for the browser tab a provider sends back: it says how it really went, never "success" before it is. */
+export const callbackPage = (title, words, close = false) => '<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width">' +
+    `<title>${title.replace(/[<&]/g, '')}</title><body style="font:18px system-ui;margin:3em auto;max-width:26em;padding:0 1em;text-align:center;color:#2e2a40">${words.replace(/[<&]/g, '')}` +
+    (close ? '<script>setTimeout(() => window.close(), 1500)</script>' : '') + '</body>';

package/dist/words.json

@@ -0,0 +1,22 @@
+{
+    "signIn.expired": "The code expired before it was used. Tap Sign in with {name} for a new one.",
+    "signIn.declined": "The sign-in was declined on the {name} page. Tap Sign in with {name} to try again.",
+    "signIn.offline": "Couldn't reach {name}. Check the internet connection, then tap Sign in again.",
+    "signIn.deviceCodeOff": "{name} needs device sign-in turned on first: in {name}, Settings, Security, turn on device code sign-in, then try again.",
+    "signIn.tooLong": "The sign-in took too long. Tap Sign in with {name} to start again.",
+    "signIn.busy": "Something else on this computer is signing in to {name}. Try again in a minute.",
+    "signIn.failed": "{name} didn't finish the sign-in. Tap Sign in with {name} to try again.",
+    "status.ready": "{name} is connected.",
+    "status.signing": "Signing in to {name}…",
+    "status.resting": "{name} is resting until {until}.",
+    "status.busy": "{name} is busy right now.",
+    "status.signedOut": "{name} isn't signed in yet.",
+    "status.needsAgain": "{name} needs you to sign in again.",
+    "terms.grey": "Uses your {name} plan. {company} may change this at any time.",
+    "status.notIncluded": "Your {name} plan doesn't include this yet.",
+    "callback.done": "You're signed in. You can go back to {app} now.",
+    "callback.declined": "No problem. Nothing was changed. You can go back to {app}.",
+    "callback.failed": "{error} Go back to {app}.",
+    "callback.nearly": "Nearly there. Go back to {app} to finish.",
+    "callback.outOfDate": "This sign-in page is out of date. Go back to {app} and tap Sign in with {name} again."
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@byokit/accounts",
+  "version": "0.1.0",
+  "description": "Sign in with the AI plan you already pay for, into your app's own store.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/umeranjum17/byokit.git",
+    "directory": "packages/accounts"
+  },
+  "engines": {
+    "node": ">=22.18"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./isolate": {
+      "types": "./dist/isolate.d.ts",
+      "default": "./dist/isolate.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "tsc -b"
+  },
+  "dependencies": {
+    "@earendil-works/pi-ai": "0.87.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}