@hanzo/build 0.2.52 → 0.2.53

package/lib/api/github.js

@@ -21,6 +21,8 @@
  * and that page completes it (`complete`, and `landed` in ../back.ts).
  */
 import { call, query, seg } from './call.js';
+import { codebases } from './codebases.js';
+import { links } from './links.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 const obj = (v) => v && typeof v === 'object' ? v : {};
@@ -36,6 +38,7 @@ export function repo(raw) {
         default_branch: str(r.default_branch),
         pushed_at: str(r.pushed_at),
         installation_id: num(r.installation_id),
+        codebase: str(r.codebase),
     };
 }
 export function branch(raw) {
@@ -94,21 +97,28 @@ export async function installations(t) {
         .map((i) => ({ login: str(i.login), type: str(i.type), grant: str(i.grant), connected: i.connected === true }))
         .filter((i) => i.login);
 }
+/**
+ * One row of GET /v1/provider/github/repos (apps/provider github_index.go
+ * repoView): `owner`, `name`, `full_name`, `private`, `default_branch`,
+ * `pushed_at`, `installation_id`, `codebase`. Whether it is on the forge is not
+ * in the row — `codebase` is the name it would take, not a sign it has — so
+ * `imported` is decided by `grants` from the links and the forge.
+ */
 export function grant(raw) {
-    const r = obj(raw);
-    const name = str(r.name);
-    if (!name)
+    const r = repo(raw);
+    if (!r.name)
         return null;
-    const full = str(r.fullName) || str(r.full_name);
-    const owner = str(r.owner) || (full.includes('/') ? full.slice(0, full.indexOf('/')) : '');
+    const full = r.full_name;
+    const owner = r.owner || (full.includes('/') ? full.slice(0, full.indexOf('/')) : '');
     return {
         owner,
-        name,
-        fullName: full || (owner ? `${owner}/${name}` : name),
-        private: r.private === true,
-        branch: str(r.defaultBranch) || str(r.default_branch) || 'main',
-        imported: r.imported === true,
-        status: str(r.syncStatus) || str(r.sync_status),
+        name: r.name,
+        fullName: full || (owner ? `${owner}/${r.name}` : r.name),
+        private: r.private,
+        branch: r.default_branch || 'main',
+        codebase: r.codebase,
+        imported: false,
+        status: '',
     };
 }
 /** Accounts the grant names, plus any account that could not be read. */
@@ -128,12 +138,39 @@ export function accounts(g) {
         return { name, count, blocked: unread.has(name) && count === 0 };
     });
 }
-/** Every repository the GitHub connection grants, with whether the forge already has it. */
+/** How many of GitHub's pages a full read takes at most: a hundred rows each. */
+const PAGES = 20;
+/**
+ * Every repository the GitHub connection grants, every page, with whether the
+ * forge already has it: a link that has landed (GET /v1/sync, its `native`
+ * state), or a forge repository under its codebase name (GET /v1/git/repos).
+ */
 export async function grants(t, signal) {
-    const raw = obj(await call(t, 'GET', '/v1/provider/github/repos', undefined, { signal }));
+    const rows = [];
+    let unread = [];
+    let after = '';
+    for (let n = 0; n < PAGES; n++) {
+        const page = await repos(t, { limit: 100, after }, signal);
+        rows.push(...page.repos);
+        unread = page.unread;
+        if (!page.next)
+            break;
+        after = page.next;
+    }
+    const [linked, held] = await Promise.all([links(t, signal).catch(() => []), codebases(t).catch(() => [])]);
+    const state = new Map(linked.map((l) => [`${l.owner}/${l.name}`.toLowerCase(), l.status]));
+    const names = new Set(held.map((c) => c.name.toLowerCase()));
     return {
-        repos: (Array.isArray(raw.repos) ? raw.repos : []).map(grant).filter((r) => r !== null),
-        unread: (Array.isArray(raw.unread) ? raw.unread : []).filter((x) => typeof x === 'string' && x !== ''),
+        repos: rows
+            .map(grant)
+            .filter((r) => r !== null)
+            .map((r) => {
+            // A link's state, '' when the forge could not be read for it; absent with no link.
+            const said = state.get(r.fullName.toLowerCase());
+            const there = names.has(r.codebase.toLowerCase());
+            return { ...r, imported: there || said === 'synced' || said === 'conflict' || said === 'paused', status: said || (there ? 'synced' : '') };
+        }),
+        unread: unread.filter(Boolean),
     };
 }
 /** Queue a mirror of the named repositories onto the forge. The names are `owner/name`. */
@@ -142,7 +179,14 @@ export async function bring(t, repos) {
     if (names.length === 0)
         throw new Error('Choose a repository first');
     const raw = obj(await call(t, 'POST', '/v1/provider/github/repos/import', { repos: names }));
-    return num(raw.queued);
+    const said = Array.isArray(raw.repos) ? raw.repos : [];
+    const made = Array.isArray(raw.codebases) ? raw.codebases : [];
+    const codebases = {};
+    said.forEach((r, i) => {
+        if (typeof r === 'string' && typeof made[i] === 'string' && made[i])
+            codebases[r.toLowerCase()] = made[i];
+    });
+    return { queued: num(raw.queued), codebases };
 }
 /**
  * Mirror GitHub issues onto the board — open and closed, so a closed one reads as

package/lib/api/limits.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The plan's usage, as the gate counts it.
+ *
+ *   GET /v1/ai/limits   the plan, its request windows and each class it includes, as shares
+ *   PUT /v1/ai/limits   {creditsAfterAllowance}: keep using a model on credits once the
+ *                       plan's included usage of it is spent; answers the limits after it
+ *
+ * The shape is cloud's `aiLimits` (apps/ai/limits_ops.go): `plan` is the rung the
+ * caller is served as, `free` with none; `session` and `day` bound every request
+ * the plan covers; `classes.premium` (third-party frontier models) and
+ * `classes.ours` (Hanzo's) are each the billing period's share used, with a
+ * shorter `window` where the plan sets one. Never a dollar, a count or a cap.
+ *
+ * Only an org admin may change how a pooled org wallet pays (403 otherwise).
+ */
+import { type Share, type State } from '../plan.ts';
+import { type Target } from './call.ts';
+export type Class = 'premium' | 'ours';
+export declare const CLASSES: readonly Class[];
+/** A class's billing period, who pays for its next request, and its short window. */
+export interface Allowance extends Share {
+    /** plan, prepaid, credits, or none. */
+    paying: string;
+    window: Share | null;
+}
+/** A way past a limit, in the order the server sends them. */
+export interface Action {
+    /** upgrade and topup are pages (`url`); credits is the choice above; switch names a model. */
+    kind: 'upgrade' | 'topup' | 'credits' | 'switch';
+    label: string;
+    url: string;
+    plan: string;
+    model: string;
+}
+/** One model whose share of the plan is used for now, answered by its fallback in chat. */
+export interface Paused {
+    model: string;
+    fallback: string;
+    resets: string;
+}
+export interface Limits {
+    /** The rung served (`max-20x`); `free` where no plan counts. */
+    plan: string;
+    /** The billing period, RFC 3339; '' with no plan. */
+    start: string;
+    end: string;
+    /** The worst class's state. */
+    state: State;
+    session: Share | null;
+    day: Share | null;
+    classes: Partial<Record<Class, Allowance>>;
+    /** Present in limited mode: why, and in which classes. */
+    limited: {
+        reason: string;
+        classes: Class[];
+        message: string;
+    } | null;
+    actions: Action[];
+    /** The plan that raises these limits, '' at the top. */
+    upgrade: string;
+    /** Whether the payer keeps using a model on credits once the plan's usage of it is spent. */
+    credits: boolean;
+    paused: Paused[];
+}
+/** The body of `GET /v1/ai/limits`, read field by field: what is not there is not drawn. */
+export declare function parse(raw: unknown): Limits;
+export declare function limits(t: Target): Promise<Limits>;
+/** Turn on or off paying from credits once the plan's included usage runs out; answers the limits after. */
+export declare function allow(t: Target, on: boolean): Promise<Limits>;

package/lib/api/limits.js

@@ -0,0 +1,86 @@
+/**
+ * The plan's usage, as the gate counts it.
+ *
+ *   GET /v1/ai/limits   the plan, its request windows and each class it includes, as shares
+ *   PUT /v1/ai/limits   {creditsAfterAllowance}: keep using a model on credits once the
+ *                       plan's included usage of it is spent; answers the limits after it
+ *
+ * The shape is cloud's `aiLimits` (apps/ai/limits_ops.go): `plan` is the rung the
+ * caller is served as, `free` with none; `session` and `day` bound every request
+ * the plan covers; `classes.premium` (third-party frontier models) and
+ * `classes.ours` (Hanzo's) are each the billing period's share used, with a
+ * shorter `window` where the plan sets one. Never a dollar, a count or a cap.
+ *
+ * Only an org admin may change how a pooled org wallet pays (403 otherwise).
+ */
+import { share } from '../plan.js';
+import { call } from './call.js';
+export const CLASSES = ['premium', 'ours'];
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const arr = (v) => (Array.isArray(v) ? v : []);
+const KINDS = ['upgrade', 'topup', 'credits', 'switch'];
+const STATES = ['ok', 'near', 'limited'];
+/** A class off the wire: its period always carries a state, so one without is not a class. */
+function allowance(v) {
+    const w = share(v);
+    if (!w)
+        return null;
+    const o = obj(v);
+    return { ...w, paying: str(o.paying) || 'none', window: share(o.window) };
+}
+/** The body of `GET /v1/ai/limits`, read field by field: what is not there is not drawn. */
+export function parse(raw) {
+    const r = obj(raw);
+    const classes = {};
+    for (const c of CLASSES) {
+        const got = allowance(obj(r.classes)[c]);
+        if (got)
+            classes[c] = got;
+    }
+    const lim = r.limited ? obj(r.limited) : null;
+    return {
+        plan: str(r.plan) || 'free',
+        start: str(r.period_start),
+        end: str(r.period_end),
+        state: STATES.find((s) => s === r.state) ?? 'ok',
+        session: share(r.session),
+        day: share(r.day),
+        classes,
+        limited: lim
+            ? {
+                reason: str(lim.reason),
+                classes: arr(lim.classes).filter((c) => CLASSES.includes(c)),
+                message: str(lim.message),
+            }
+            : null,
+        actions: arr(r.actions)
+            .map(obj)
+            .flatMap((a) => {
+            const kind = KINDS.find((k) => k === a.kind);
+            if (!kind)
+                return [];
+            const url = str(a.url);
+            const model = str(a.model);
+            // A page with no address, or a switch to no model, is not a way past anything.
+            if ((kind === 'upgrade' || kind === 'topup') && !url)
+                return [];
+            if (kind === 'switch' && !model)
+                return [];
+            return [{ kind, label: str(a.label), url, plan: str(a.plan), model }];
+        }),
+        upgrade: str(r.upgrade),
+        credits: r.credits_after_allowance === true,
+        paused: arr(r.paused)
+            .map(obj)
+            .filter((p) => str(p.model))
+            .map((p) => ({ model: str(p.model), fallback: str(p.fallback), resets: str(p.resets_at) })),
+    };
+}
+export async function limits(t) {
+    return parse(await call(t, 'GET', '/v1/ai/limits'));
+}
+/** Turn on or off paying from credits once the plan's included usage runs out; answers the limits after. */
+export async function allow(t, on) {
+    return parse(await call(t, 'PUT', '/v1/ai/limits', { creditsAfterAllowance: on }));
+}

package/lib/api/links.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The repositories an organization has linked from GitHub, as the sync app
+ * holds them: one link per repository (an account link declares one for every
+ * repository its account holds), each with its copy on the forge.
+ *
+ *   GET /v1/sync   {data: [syncView]}   apps/sync sync_api.go
+ *
+ * A repository link's source is GitHub's https clone address; its target is the
+ * forge, by the bare name the copy has there. `updatedAt` is bumped by every
+ * reconcile, so it reads as the last time the link synced. `native` is the
+ * forge copy: its page, its default branch and how it stands — `synced`,
+ * `conflict`, `pending` (not on the forge yet) or `paused` — and is absent when
+ * the forge could not be read, which is not reported as healthy.
+ *
+ * Every link the sync app holds is also a row of GET /v1/projects (apps/sync
+ * project.go), so this list is the org's linked projects and not a copy of them.
+ */
+import { type Target } from './call.ts';
+export interface Link {
+    /** The GitHub account. */
+    owner: string;
+    /** The repository; '' for an account link. */
+    name: string;
+    /** The forge copy's name, which a run and an environment address; ''. */
+    forge: string;
+    /** RFC 3339: when it last synced, or ''. */
+    synced: string;
+    /** `synced`, `conflict`, `pending`, `paused`, or '' when the forge could not be read. */
+    status: string;
+    /** The forge copy's default branch, or ''. */
+    branch: string;
+    /** `both`, `pull`, `push` or `off`. */
+    direction: string;
+}
+/** `owner` and `name` of a GitHub https address, `name` '' for an account; null for any other host. */
+export declare function github(locator: string): {
+    owner: string;
+    name: string;
+} | null;
+export declare function link(raw: unknown): Link | null;
+/** Every repository link the org has; account links are left out, as each declares its repositories' own. */
+export declare function links(t: Target, signal?: AbortSignal): Promise<Link[]>;

package/lib/api/links.js

@@ -0,0 +1,65 @@
+/**
+ * The repositories an organization has linked from GitHub, as the sync app
+ * holds them: one link per repository (an account link declares one for every
+ * repository its account holds), each with its copy on the forge.
+ *
+ *   GET /v1/sync   {data: [syncView]}   apps/sync sync_api.go
+ *
+ * A repository link's source is GitHub's https clone address; its target is the
+ * forge, by the bare name the copy has there. `updatedAt` is bumped by every
+ * reconcile, so it reads as the last time the link synced. `native` is the
+ * forge copy: its page, its default branch and how it stands — `synced`,
+ * `conflict`, `pending` (not on the forge yet) or `paused` — and is absent when
+ * the forge could not be read, which is not reported as healthy.
+ *
+ * Every link the sync app holds is also a row of GET /v1/projects (apps/sync
+ * project.go), so this list is the org's linked projects and not a copy of them.
+ */
+import { call } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+/** `owner` and `name` of a GitHub https address, `name` '' for an account; null for any other host. */
+export function github(locator) {
+    try {
+        const u = new URL(locator.trim());
+        if (u.protocol !== 'https:' || u.hostname.toLowerCase() !== 'github.com')
+            return null;
+        const [owner = '', name = '', ...rest] = u.pathname
+            .replace(/\.git$/, '')
+            .split('/')
+            .filter(Boolean);
+        if (!owner || rest.length)
+            return null;
+        return { owner, name };
+    }
+    catch {
+        return null;
+    }
+}
+export function link(raw) {
+    const o = obj(raw);
+    if (str(o.kind) && str(o.kind) !== 'git')
+        return null;
+    const source = obj(o.source);
+    const target = obj(o.target);
+    const at = str(source.provider) === 'github' ? github(str(source.locator)) : null;
+    if (!at)
+        return null;
+    const native = o.native ? obj(o.native) : null;
+    return {
+        owner: at.owner,
+        name: str(o.scope) === 'account' ? '' : at.name,
+        forge: str(target.provider) === 'hanzo-git' ? str(target.locator) : '',
+        synced: str(o.updatedAt),
+        status: native ? str(native.status) : '',
+        branch: native ? str(native.branch) : '',
+        direction: str(o.direction),
+    };
+}
+/** Every repository link the org has; account links are left out, as each declares its repositories' own. */
+export async function links(t, signal) {
+    const raw = obj(await call(t, 'GET', '/v1/sync', undefined, { signal }));
+    return (Array.isArray(raw.data) ? raw.data : [])
+        .map(link)
+        .filter((l) => l !== null && l.name !== '');
+}

package/lib/api/pref.d.ts

@@ -14,10 +14,12 @@ import { type Target } from './call.ts';
 export type Theme = 'system' | 'light' | 'dark';
 export type Text = 'small' | 'medium' | 'large';
 export type Motion = 'system' | 'reduced';
-/** Where and how a new run starts when New has no choice of its own kept. */
+/**
+ * Where and how a new run starts when New has no choice of its own kept. The
+ * model and effort are not here: they are the one choice Chat and Dev share,
+ * kept in the browser (mind.tsx).
+ */
 export interface Code {
-    model?: string;
-    effort?: 'low' | 'medium' | 'high';
     mode?: 'build' | 'plan';
     /** A machine's id, or '' for the sandbox. */
     place?: string;

package/lib/api/pref.js

@@ -14,7 +14,6 @@ import { call } from './call.js';
 const THEMES = ['system', 'light', 'dark'];
 const TEXTS = ['small', 'medium', 'large'];
 const MOTIONS = ['system', 'reduced'];
-const EFFORTS = ['low', 'medium', 'high'];
 const MODES = ['build', 'plan'];
 const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
 const text = (v) => (typeof v === 'string' && v.trim() ? v : undefined);
@@ -26,8 +25,6 @@ function defined(o) {
 export function code(raw) {
     const c = obj(raw);
     const out = defined({
-        model: text(c.model),
-        effort: one(c.effort, EFFORTS),
         mode: one(c.mode, MODES),
         place: typeof c.place === 'string' ? c.place : undefined,
     });

package/lib/api/turn.d.ts

@@ -24,9 +24,18 @@
 import type { Event } from './sessions.ts';
 /** The payload as an object. A live frame may carry it as a JSON string. */
 export declare function decode(payload: unknown): Record<string, unknown> | string | null;
+/**
+ * Whether an error is a model vendor's own words: a provider's name, its rate
+ * headers, a key, or the JSON body it answers with. Those never reach the run
+ * page — they say whose model it was and nothing a person can act on — so the
+ * run says its plain line alone.
+ */
+export declare function vendor(error: string): boolean;
+/** An error as the run page may show it: its own words, or the plain line when they are a vendor's. */
+export declare const scrub: (error: string) => string;
 /**
  * A run's error as one plain line with what to do, never the log it came from:
- * that goes in the Error step beside it (cards).
+ * that goes in the Error step beside it (cards), unless it is a vendor's.
  */
 export declare function plain(error: string): string;
 /**

package/lib/api/turn.js

@@ -59,9 +59,20 @@ function status(b, mode) {
     }
     return str(b.status);
 }
+/**
+ * Whether an error is a model vendor's own words: a provider's name, its rate
+ * headers, a key, or the JSON body it answers with. Those never reach the run
+ * page — they say whose model it was and nothing a person can act on — so the
+ * run says its plain line alone.
+ */
+export function vendor(error) {
+    return /open\s?router|anthropic|openai|azure|bedrock|vertex|gemini|mistral|cohere|deepinfra|fireworks|together\.ai|groq|x-ratelimit|upstream|\bprovider\b|\bsk-[A-Za-z0-9_-]{6,}|"(error|code|message)"\s*:/i.test(error);
+}
+/** An error as the run page may show it: its own words, or the plain line when they are a vendor's. */
+export const scrub = (error) => (vendor(error) ? plain(error) : error);
 /**
  * A run's error as one plain line with what to do, never the log it came from:
- * that goes in the Error step beside it (cards).
+ * that goes in the Error step beside it (cards), unless it is a vendor's.
  */
 export function plain(error) {
     if (!error)
@@ -101,7 +112,7 @@ export function said(e, mode = '') {
                 : `Done — changed ${names.length} files`;
     }
     if (str(body.type) === 'error')
-        return str(body.error) || 'The run hit an error';
+        return scrub(str(body.error)) || 'The run hit an error';
     return str(body.step) || str(body.name);
 }
 /**
@@ -197,7 +208,7 @@ export function failure(events) {
         const b = decode(e.payload);
         if (!b || typeof b === 'string' || !str(b.status))
             continue;
-        out = str(b.status) === 'error' ? str(b.error) || 'The run hit an error' : '';
+        out = str(b.status) === 'error' ? scrub(str(b.error)) || 'The run hit an error' : '';
     }
     return out;
 }
@@ -324,7 +335,8 @@ export function cards(events, mode = '') {
             return;
         failures.add(message);
         out.push({ kind: 'note', key: mint(), text: plain(message) });
-        if (message)
+        // The reason, read whole, when it is the run's own; a vendor's words stay off the page.
+        if (message && !vendor(message))
             out.push({ kind: 'step', key: mint(), name: 'Error', detail: '', output: message, ran: 'error' });
     };
     for (const e of [...events].sort((a, b) => a.seq - b.seq)) {

package/lib/api/work.d.ts

@@ -1,53 +1,90 @@
 /**
- * Projects and issues, as the forge holds them.
+ * The work an organization does: its projects, their issues, and its boards.
  *
- * A project is a board. A board is a repository that has work on it, so the
- * list is the forge's answer and not a second copy of it.
+ *   GET /v1/provider/github/repos?q=&owner=&limit=&after=   what the GitHub connection grants, most recently pushed first
+ *   GET /v1/provider/github/installations                    the GitHub accounts it grants them from
+ *   GET /v1/git/repos                                        the forge's repositories
+ *   GET /v1/task/board                                       every issue and pull request: the forge's, and the task index's
+ *   GET /v1/task/projects                                    the boards
+ *   GET /v1/task/projects/{key}/issues                       one board's
  *
- *   GET /v1/task/projects                     the boards
- *   GET /v1/task/board                        every board's issues
- *   GET /v1/task/projects/{key}/issues        one board's issues
+ * A project is a repository, so the list is those sources merged (merge.ts) and
+ * not a second copy of them. An issue row from the board is read for what it
+ * is: a forge issue names its forge repository and links to its page; a GitHub
+ * issue the index mirrors names its address only in `extRef`
+ * (`github:<owner>/<name>#<n>`), and its `number` there is the board's, not
+ * GitHub's; any other index row's `repo` is what its writer said — a run's
+ * repository, or a Linear team's key — and is resolved, never used raw.
  *
  * Creating, renaming and deleting a board are forge operations. This surface
  * reads the work and opens a run against it.
  */
 import { type Target } from './call.ts';
+import { type Repo } from './github.ts';
+import { type Held, type Issue, type Linked, type Site } from '../merge.ts';
 export interface Board {
     id: string;
     key: string;
     name: string;
     description: string;
 }
-export interface Work {
-    id: string;
-    /** `<key>#<number>`, the handle a person reads. */
-    identifier: string;
-    project: string;
-    number: number;
-    kind: string;
-    title: string;
-    status: string;
-    priority: string;
-    assignee: string;
-    /** The repository the item is bound to, or ''. */
-    repo: string;
-    /** Where it was opened: `git` (the forge, or mirrored from GitHub), `team`, `agent`, … */
-    source: string;
-    labels: string[];
-    /** Its page upstream (a GitHub issue for a mirrored one), https only, or ''. */
-    url: string;
-    /** Unix milliseconds, or 0 when the platform did not say. */
-    created: number;
-    updated: number;
-}
-/** The project an item is filed under: its repository, else its board. */
-export declare const projectOf: (w: Work) => string;
-/** Done and canceled are closed; every other column is open work. */
-export declare const closed: (w: Work) => boolean;
-/** Whether `w` belongs to the project `key` — by repository or by board, either case. */
-export declare function inProject(w: Work, key: string): boolean;
 export declare function board(raw: unknown): Board | null;
-export declare function work(raw: unknown): Work | null;
-export declare function boards(t: Target): Promise<Board[]>;
-/** A board's issues, or every board's when `key` is empty. */
-export declare function issues(t: Target, key?: string): Promise<Work[]>;
+/** One board row as an issue: what it is, where it lives, and which repository it says it is for. */
+export declare function work(raw: unknown): Issue | null;
+export declare function boards(t: Target, signal?: AbortSignal): Promise<Board[]>;
+/** Every issue and pull request the org has, from the forge and the task index, each once. */
+export declare function everything(t: Target, signal?: AbortSignal): Promise<Issue[]>;
+/** The rows a list of projects is assembled from (merge.ts `assemble`), and which sources did not answer. */
+export interface Sources {
+    /** GitHub's grants to the org's connection, every page read so far: empty for anyone it does not answer. */
+    hub: Repo[];
+    /** The repositories linked from GitHub. */
+    linked: Linked[];
+    /** The forge's repositories. */
+    held: Held[];
+    /** The org's projects that build from a repository. */
+    sites: Site[];
+    /** The GitHub accounts the org's connection grants from, for the owner filter. */
+    owners: string[];
+    /** GitHub's cursor for its next page, or ''. */
+    next: string;
+    /** GitHub accounts the connection could not read. */
+    unread: string[];
+    /** Sources that did not answer, as a reader names them. */
+    missing: string[];
+}
+export interface SourceQuery {
+    /** Searched by GitHub; the rest are searched where they are drawn. */
+    q?: string;
+    /** One GitHub account. */
+    owner?: string;
+    /** GitHub's cursor: read only GitHub's page after it. */
+    after?: string;
+}
+/**
+ * What the org's projects are made from, each read on its own: the links (GET
+ * /v1/sync), the forge's repositories, the org's projects, and GitHub's grants
+ * — searched and paged by GitHub, and empty for an operator with no GitHub of
+ * their own, which is why it is never the only source. One that fails leaves the
+ * others standing and is named in `missing`. A next page reads GitHub alone.
+ */
+export declare function sources(t: Target, p?: SourceQuery, signal?: AbortSignal): Promise<Sources>;
+/** A repository a run and an environment can address on the forge, by the name its copy has there. */
+export interface Home {
+    /** The forge name: what a run's `repo` and `/v1/environment/{repo}` take. */
+    name: string;
+    /** `owner/name` as people know it: GitHub's address for a linked one, the org's for one made on the forge. */
+    label: string;
+    branch: string;
+}
+export interface Homes {
+    homes: Home[];
+    /** Both sources answered, so a name missing from `homes` is not the org's. */
+    whole: boolean;
+}
+/**
+ * Every repository on the forge a run can work on: the forge's own and every
+ * linked repository's copy (GET /v1/git/repos does not list an estate's copies;
+ * GET /v1/sync does). Throws only when neither answered.
+ */
+export declare function homes(t: Target, signal?: AbortSignal): Promise<Homes>;