@hanzo/build 0.2.57 → 0.2.58

package/README.md

@@ -118,13 +118,14 @@ One of each, shared with Chat (@hanzo/rooms imports them):
 |---|---|
 | `''` | New — the empty state and the composer |
 | `sess_<32 hex>` | one run, live |
-| `-/automations` | repeating work, read from `/v1/auto/flows` |
+| `-/automations` | Scheduled tasks: your tasks, then Activity, every run across products |
+| `-/automations/<id>` | one task's editor and runs; `new` writes one |
 | `-/customize` · `-/customize/connectors` · `/plugins` · `/agents` | Customize: skills, connectors, plugins, agents |
 | `-/mcp` | Connectors → Browse with the fleet's native MCP servers listed |
 | `-/projects` | the org's projects: its repositories on the forge |
 | `-/sync` | link repositories from GitHub onto the forge |
 | `-/issues` | every project's issues, merged: the forge's and the task index's |
-| `-/artifacts` | what the org has built |
+| `-/artifacts` | the Library: everything you made in Chat, Dev and Studio; `?item=<id>` opens one; the org's sites at its foot |
 | `-/templates` | the public starters |
 | `-/plans` | the plans this brand sells, and the move to another |
 | `-/settings/<section>` | Billing, Usage, Members, Integrations, Notifications, … |
@@ -150,7 +151,7 @@ project it is for. A board's key is never taken for a repository.
 **The rail** (this page, or `rail` left on). At the top, the mark. Signed in to an organization,
 that spot is the organization switcher: the org, and the projects under it.
 New, then every place in view (nav.tsx) — Work: Projects, Issues; Make:
-Artifacts, Templates, Automations; Run: Machines, Environments; Setup:
+Library, Templates, Scheduled tasks; Run: Machines, Environments; Setup:
 Customize, Docs — then the org's coding runs newest first with a live status
 dot. Nothing waits behind a More. At the foot, a card offering Hanzo in Slack
 (dismissed once, gone in this browser) and the account, whose menu holds the
@@ -162,10 +163,31 @@ sits beside a plan: credits live in Billing. Collapse is an explicit
 toggle kept in this browser. A host with its own rail draws `DevSection` there
 instead.
 
-**Artifacts.** A few starters to make something new from, each copied into a
-project as Templates does, then every project under the month it was last
-edited, public or private, with rename, visibility and delete. A project belongs
-to the org and names no author, so there is no Yours or Shared with you.
+**Library.** Everything you made — Chat's pictures and files, Dev's patches and
+reports, Studio's posters and videos, a workflow's outputs — newest first under
+Today, Yesterday and the month, as a grid or a list, narrowed by kind, by the
+product that made it and by whose (yours, or what a colleague shared). A tile
+opens its item in the side panel (`Panel`, one tab per item; a sheet on a
+phone), read fresh so its signed URLs are live. Each item opens where it was
+made, downloads, is shared with the org or not, copies its link, is renamed,
+moved to a project, used in Studio or Chat, or deleted; what a colleague shared
+offers only what a reader may do. An item is its person's, so this list splits
+yours from shared, where the sites beneath it do not.
+
+**Sites**, at the Library's foot. A few starters to make something new from,
+each copied into a project as Templates does, then every deployed site under the
+month it was last edited, public or private, with rename, visibility and
+delete. A site belongs to the org and names no author.
+
+**Scheduled tasks.** Your tasks — prompts on a schedule from Chat and Dev, and
+workflows — each with when it runs next, where it came from, a switch that
+pauses and resumes it, and Run now, Edit and Delete; then Activity, every run
+across products (a task's, Dev's background runs, Studio's renders) with its
+state, how long it took, its cost and what it made, kept live by
+`/v1/auto/events`. A run opens with its summary or error, its log (the Dev
+run), its outputs as Library tiles and its cost. New task takes the schedule in
+plain words, which `/v1/auto/cron` reads back before anything is made. A Dev
+run's menu offers Schedule this, which opens New task with the run's ask.
 
 **Settings, Code.** Environments: every codebase that has one, opened in the
 same editor a run shows, forgotten by an org admin. Machines: `hanzo login` and
@@ -259,7 +281,9 @@ picker and open-in-tab; Share and Publish; the console dock under it.
 | `GET /v1/agent/sessions?kind=coding&status=&after=` | Find, by status, paged |
 | `GET`/`POST /v1/agent/targets` · `PATCH`/`DELETE …/{id}` · `POST …/{id}/key` | the org's machines, and a machine's claim key |
 | `GET`/`POST /v1/account/keys` · `DELETE …/{id}` | your API keys, as many as you need; one revoked at a time |
-| `GET /v1/auto/flows` · `POST /v1/auto/flows` · `POST /v1/auto/flows/{id}/enable` | automations |
+| `GET`/`POST /v1/auto/automations` · `GET`/`PATCH`/`DELETE …/{id}` · `POST …/{id}/run` · `GET …/{id}/runs` | Scheduled tasks, and one task's editor |
+| `GET /v1/auto/jobs` · `…/{id}` · `GET /v1/auto/events` (SSE over fetch) · `POST /v1/auto/cron` | Activity, live, and a schedule from plain words |
+| `GET /v1/library` · `GET`/`PATCH`/`DELETE /v1/library/{id}` · `POST /v1/library` | the Library |
 | `GET /v1/environment` · `GET`/`PUT`/`DELETE /v1/environment/{repo}` · `PUT`/`DELETE …/secrets/{name}` | a codebase's environment |
 | `GET /v1/agent/coding/{session}/changes` · `/tree` · `/blob` | what a run pushed, and its branch's files, from the forge |
 | `POST /v1/sandbox/{id}/screen/ticket` · `…/terminal/ticket` | the run's desktop and shell, framed with a single-use ticket |
@@ -270,7 +294,7 @@ picker and open-in-tab; Share and Publish; the console dock under it.
 | `GET /v1/task/projects` · `GET /v1/task/board` · `GET /v1/task/projects/{key}/issues` | boards, and every issue and pull request: the forge's and the task index's |
 | `GET /v1/provider/github/repos` · `…/{owner}/{repo}/branches` | kept for a host that still asks GitHub |
 | `POST /v1/provider/github/user/connect` | connect a person's GitHub |
-| `GET /v1/projects` · `PATCH`/`DELETE /v1/projects/{slug}` · `POST /v1/projects/fork` · `GET /v1/templates` | artifacts, templates |
+| `GET /v1/projects` · `PATCH`/`DELETE /v1/projects/{slug}` · `POST /v1/projects/fork` · `GET /v1/templates` | sites, templates |
 | `GET /v1/git/repos/{name}/tree` · `/blob` | Files and Code |
 | `POST /v1/platform/apps` · `GET /v1/platform/builds` | Add to project, Publish |
 | `POST /v1/mcp` | the native MCP servers, `tools/list` |
@@ -309,7 +333,9 @@ src/
   index.ts      the library surface
   builder.tsx   the rail and the pane the address names
   landing.tsx   New
-  forge.tsx     Automations, Projects, Issues
+  forge.tsx     Projects, Issues, and the screens it hands on
+  library.tsx   the Library; api/library.ts its wire
+  scheduled.tsx Scheduled tasks; activity.ts its words; automations.tsx one task's editor
   merge.ts      what is the same project and the same issue, which repository an issue is for
   run.tsx       one run
   transcript.tsx  a run's transcript, as cards
@@ -325,7 +351,7 @@ src/
   files.tsx     a run's files and artifacts
   environment.tsx a codebase's environment
   project.tsx   a project's workspace
-  shelf.tsx     Artifacts and Templates
+  shelf.tsx     Sites and Templates
   nav.tsx       the places, once, for every rail
   customize/    Customize: the shell, then one file per tab
   publish.tsx   Add to project / Publish

package/lib/activity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Activity's words: what a run's state is called and drawn as, how long it
+ * took, what it cost, and the one line under its title. Pure, so the screen and
+ * its tests read the same sentences.
+ */
+import type { SessionStatus } from '@hanzo/ui/chat';
+import type { Job, State } from './api/auto.ts';
+/** A job's state as the rail's dot draws it, and in words. */
+export declare const DOTS: Record<State, SessionStatus>;
+export declare const SAID: Record<State, string>;
+/** How long a run took, or has taken so far. */
+export declare function lasted(started: string, finished: string | null, now?: number): string;
+/** Cents as dollars. */
+export declare const dollars: (cents: number) => string;
+/** One line about a job: when it started, how long, what it cost, what it made. */
+export declare function about(j: Job, now?: number): string;
+/** The jobs, newest first, with `j` in its place. */
+export declare function merged(list: Job[], j: Job): Job[];
+/** A task's name from what it does: its first line, short. */
+export declare function titled(prompt: string): string;

package/lib/activity.js

@@ -0,0 +1,38 @@
+import { ago } from './ago.js';
+import { SOURCE } from './api/library.js';
+/** A job's state as the rail's dot draws it, and in words. */
+export const DOTS = { scheduled: 'idle', running: 'running', succeeded: 'done', failed: 'error', cancelled: 'stopped' };
+export const SAID = { scheduled: 'Scheduled', running: 'Running', succeeded: 'Succeeded', failed: 'Failed', cancelled: 'Cancelled' };
+/** How long a run took, or has taken so far. */
+export function lasted(started, finished, now = Date.now()) {
+    const a = Date.parse(started);
+    const b = finished ? Date.parse(finished) : now;
+    if (Number.isNaN(a) || Number.isNaN(b) || b < a)
+        return '';
+    const s = Math.round((b - a) / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m`;
+}
+/** Cents as dollars. */
+export const dollars = (cents) => `$${(cents / 100).toFixed(2)}`;
+/** One line about a job: when it started, how long, what it cost, what it made. */
+export function about(j, now = Date.now()) {
+    const made = j.outputs.length ? `${j.outputs.length} ${j.outputs.length === 1 ? 'output' : 'outputs'}` : '';
+    return [SOURCE[j.product], j.started ? ago(j.started) : '', lasted(j.started, j.finished, now), j.cost !== null ? dollars(j.cost) : '', made].filter(Boolean).join(' · ');
+}
+/** The jobs, newest first, with `j` in its place. */
+export function merged(list, j) {
+    const out = list.filter((x) => x.id !== j.id);
+    out.push(j);
+    return out.sort((a, b) => (b.started || b.updated).localeCompare(a.started || a.updated));
+}
+/** A task's name from what it does: its first line, short. */
+export function titled(prompt) {
+    const first = prompt.trim().split('\n')[0].trim();
+    return first.length > 60 ? `${first.slice(0, 57).trimEnd()}…` : first;
+}

package/lib/api/auto.d.ts

@@ -10,18 +10,24 @@
  *   GET    /v1/auto/automations/{id}/runs  {data: [run]}        newest first
  *   POST   /v1/auto/automations/{id}/runs/{run}/review  {post}  post a held post, or discard it
  *   GET    /v1/auto/templates              {data: [starter]}    to start a new one from
+ *   POST   /v1/auto/cron                   {schedule, says, next}  a schedule from a person's words
+ *   GET    /v1/auto/jobs                   {data: [job]}        what runs without you, across products
+ *   GET    /v1/auto/jobs/{id}              one job
+ *   GET    /v1/auto/events                 text/event-stream: `job` and `automation`, the reader's own
  *
  * Each run is one Dev run in this organization, started as the person who last
  * saved what it does. A draft is a flow named and not yet told what to do: it
  * runs once its instructions are saved.
  */
 import { type Target } from './call.ts';
-export type Kind = 'manual' | 'hourly' | 'daily' | 'weekdays' | 'weekly' | 'cron';
+import { type Source } from './library.ts';
+export type { Source };
+export type Kind = 'manual' | 'once' | 'hourly' | 'daily' | 'weekdays' | 'weekly' | 'cron';
 export type Permissions = 'ask' | 'auto';
 /** When it runs, in the person's own words and zone. */
 export interface Schedule {
     kind: Kind;
-    /** HH:MM, 24-hour, for daily, weekdays and weekly; 00:MM for hourly. */
+    /** HH:MM, 24-hour, for daily, weekdays and weekly; 00:MM for hourly; YYYY-MM-DDTHH:MM for once, absent to run now. */
     at?: string;
     /** mon … sun, for weekly. */
     day?: string;
@@ -42,6 +48,8 @@ export interface Draft {
     /** The connected accounts each run's answer is posted to: x, linkedin, facebook. */
     postTo: string[];
     enabled: boolean;
+    /** The product that made it: chat, dev, studio or workflow. */
+    source: Source;
 }
 export interface Last {
     id: string;
@@ -78,6 +86,8 @@ export interface Run {
     /** The post its agent wrote, for an automation that posts. */
     draft: string;
     posts: Posted[];
+    /** The Library items it made. */
+    outputs: string[];
 }
 /** One automation as the platform answers it, or null for a row with no id. */
 export declare function read(raw: unknown): Automation | null;
@@ -109,3 +119,68 @@ export interface Starter {
 }
 /** The starters, from GET /v1/auto/templates. */
 export declare function starters(t: Target): Promise<Starter[]>;
+/** What a person's words mean as a schedule: the schedule, how the platform says it back, and its next run. */
+export interface Parsed {
+    schedule: Schedule;
+    says: string;
+    /** RFC 3339, or null for one that runs only when asked. */
+    next: string | null;
+}
+/** A schedule from a person's own words ("every monday at 9am"), read in `tz`. */
+export declare function cron(t: Target, text: string, tz: string, init?: {
+    signal?: AbortSignal;
+}): Promise<Parsed>;
+/** What a job is doing, in the five words every product shares. */
+export type State = 'scheduled' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export declare const STATES: readonly State[];
+/** One run of anything that runs without its person watching. */
+export interface Job {
+    id: string;
+    product: Source;
+    kind: string;
+    title: string;
+    state: State;
+    /** The product's own word for it: queued, review, skipped… */
+    status: string;
+    /** 0 to 1, or null when the product does not say. */
+    progress: number | null;
+    automation: string | null;
+    /** The Dev run it started, whose transcript is its log. */
+    session: string | null;
+    ref: string;
+    origin: string;
+    summary: string;
+    error: string;
+    /** The Library items it made. */
+    outputs: string[];
+    /** Cents, or null while unknown. */
+    cost: number | null;
+    started: string;
+    finished: string | null;
+    updated: string;
+}
+/** One job as the platform answers it, or null for a row with no id. */
+export declare function job(raw: unknown): Job | null;
+export interface JobFilter {
+    product?: Source | '';
+    state?: State | '';
+    limit?: number;
+}
+export declare function jobs(t: Target, f?: JobFilter): Promise<Job[]>;
+export declare function one(t: Target, id: string): Promise<Job>;
+/** What the events stream says: a job or an automation, as it stands now. */
+export type Heard = {
+    kind: 'job';
+    job: Job;
+} | {
+    kind: 'automation';
+    automation: Automation;
+};
+/** One frame of /v1/auto/events, or null for one this page does not read. */
+export declare function heard(event: string, data: string): Heard | null;
+/**
+ * Read /v1/auto/events until `signal` ends it or the stream closes, calling `on`
+ * for each job and automation it names. A fetch, because EventSource cannot
+ * carry the bearer.
+ */
+export declare function events(t: Target, on: (h: Heard) => void, signal: AbortSignal, opened?: () => void): Promise<void>;

package/lib/api/auto.js

@@ -10,16 +10,25 @@
  *   GET    /v1/auto/automations/{id}/runs  {data: [run]}        newest first
  *   POST   /v1/auto/automations/{id}/runs/{run}/review  {post}  post a held post, or discard it
  *   GET    /v1/auto/templates              {data: [starter]}    to start a new one from
+ *   POST   /v1/auto/cron                   {schedule, says, next}  a schedule from a person's words
+ *   GET    /v1/auto/jobs                   {data: [job]}        what runs without you, across products
+ *   GET    /v1/auto/jobs/{id}              one job
+ *   GET    /v1/auto/events                 text/event-stream: `job` and `automation`, the reader's own
  *
  * Each run is one Dev run in this organization, started as the person who last
  * saved what it does. A draft is a flow named and not yet told what to do: it
  * runs once its instructions are saved.
  */
-import { call, seg } from './call.js';
+import { call, headers, query, reason, Refusal, seg } from './call.js';
+import { inApp } from './library.js';
+import { read as stream } from './sse.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const nullable = (v) => (typeof v === 'string' && v ? v : null);
 const obj = (v) => (v && typeof v === 'object' ? v : {});
-const KINDS = ['manual', 'hourly', 'daily', 'weekdays', 'weekly', 'cron'];
+const KINDS = ['manual', 'once', 'hourly', 'daily', 'weekdays', 'weekly', 'cron'];
+const SOURCES = ['chat', 'dev', 'studio', 'workflow'];
+const sourceOf = (v) => (SOURCES.includes(v) ? v : 'dev');
+const strings = (v) => (Array.isArray(v) ? v : []).filter((x) => typeof x === 'string' && x !== '');
 function schedule(raw) {
     const o = obj(raw);
     const kind = KINDS.includes(o.kind) ? o.kind : 'manual';
@@ -47,6 +56,7 @@ export function read(raw) {
         notify: o.notify === true,
         postTo: (Array.isArray(o.postTo) ? o.postTo : []).filter((x) => typeof x === 'string'),
         enabled: o.enabled === true,
+        source: sourceOf(o.source),
         draft: o.draft === true,
         next: nullable(o.next),
         last: str(last.id) ? { id: str(last.id), status: str(last.status), at: str(last.at), summary: str(last.summary) } : null,
@@ -114,19 +124,29 @@ function run(o) {
         .map(obj)
         .filter((p) => str(p.to))
         .map((p) => ({ to: str(p.to), url: /^https:\/\//.test(str(p.url)) ? str(p.url) : '', error: str(p.error) }));
-    return { id: str(o.id), status: str(o.status), at: str(o.at), finished: nullable(o.finished), summary: str(o.summary), session: session(o.transcript), draft: str(o.draft), posts };
+    return { id: str(o.id), status: str(o.status), at: str(o.at), finished: nullable(o.finished), summary: str(o.summary), session: session(o.transcript), draft: str(o.draft), posts, outputs: strings(o.outputs) };
 }
 /** Post a held post to the automation's accounts, or discard it. */
 export async function review(t, id, runId, post) {
     return run(obj(await call(t, 'POST', `/v1/auto/automations/${seg(id)}/runs/${seg(runId)}/review`, { post })));
 }
 const DAYS = { mon: 'Mondays', tue: 'Tuesdays', wed: 'Wednesdays', thu: 'Thursdays', fri: 'Fridays', sat: 'Saturdays', sun: 'Sundays' };
+/** A once schedule's local date and time, as a person reads it. */
+function once(at) {
+    const m = at.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/);
+    if (!m)
+        return at;
+    const d = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]));
+    return `${d.toLocaleDateString(undefined, { weekday: 'short', month: 'short', day: 'numeric' })} at ${m[4]}:${m[5]}`;
+}
 /** A schedule the way a person says it. */
 export function words(s) {
     const zone = ` · ${s.tz || 'UTC'}`;
     switch (s.kind) {
         case 'manual':
             return 'When you run it';
+        case 'once':
+            return s.at ? `Once, ${once(s.at)}${zone}` : 'Once, now';
         case 'hourly':
             return `Every hour at :${(s.at ?? '00:00').slice(3) || '00'}`;
         case 'daily':
@@ -135,8 +155,16 @@ export function words(s) {
             return `Weekdays at ${s.at}${zone}`;
         case 'weekly':
             return `${DAYS[s.day ?? ''] ?? s.day} at ${s.at}${zone}`;
-        case 'cron':
+        case 'cron': {
+            // The two a person says most, in their words; any other expression as written.
+            const minutes = (s.cron ?? '').match(/^\*\/(\d+) \* \* \* \*$/);
+            if (minutes)
+                return `Every ${minutes[1]} minutes${zone}`;
+            const hours = (s.cron ?? '').match(/^0 \*\/(\d+) \* \* \*$/);
+            if (hours)
+                return `Every ${hours[1]} hours${zone}`;
             return `Cron ${s.cron}${zone}`;
+        }
     }
 }
 /** The starters, from GET /v1/auto/templates. */
@@ -148,3 +176,108 @@ export async function starters(t) {
     })
         .filter((x) => x.key && x.name && x.instructions);
 }
+/** A schedule from a person's own words ("every monday at 9am"), read in `tz`. */
+export async function cron(t, text, tz, init) {
+    const o = obj(await call(t, 'POST', '/v1/auto/cron', { text, tz }, init));
+    return { schedule: schedule(o.schedule), says: str(o.says), next: nullable(o.next) };
+}
+export const STATES = ['scheduled', 'running', 'succeeded', 'failed', 'cancelled'];
+/** A state the platform did not name is read from the product's own word. */
+function stateOf(state, status) {
+    if (STATES.includes(state))
+        return state;
+    switch (status) {
+        case 'queued':
+            return 'scheduled';
+        case 'running':
+        case 'review':
+            return 'running';
+        case 'succeeded':
+            return 'succeeded';
+        case 'failed':
+        case 'refused':
+            return 'failed';
+        case 'skipped':
+            return 'cancelled';
+    }
+    return 'scheduled';
+}
+/** One job as the platform answers it, or null for a row with no id. */
+export function job(raw) {
+    const o = obj(raw);
+    const id = str(o.id);
+    if (!id)
+        return null;
+    const status = str(o.status);
+    const progress = typeof o.progress === 'number' && Number.isFinite(o.progress) ? Math.min(1, Math.max(0, o.progress)) : null;
+    const cost = typeof o.cost === 'number' && Number.isFinite(o.cost) && o.cost >= 0 ? Math.round(o.cost) : null;
+    const sess = str(o.session);
+    return {
+        id,
+        product: sourceOf(o.product),
+        kind: str(o.kind),
+        title: str(o.title) || id,
+        state: stateOf(o.state, status),
+        status,
+        progress,
+        automation: nullable(o.automation),
+        session: /^sess_[0-9a-f]{32}$/.test(sess) ? sess : null,
+        ref: str(o.ref),
+        origin: inApp(o.origin),
+        summary: str(o.summary),
+        error: str(o.error),
+        outputs: strings(o.outputs),
+        cost,
+        started: str(o.started),
+        finished: nullable(o.finished),
+        updated: str(o.updated),
+    };
+}
+export async function jobs(t, f = {}) {
+    return list(await call(t, 'GET', `/v1/auto/jobs${query({ product: f.product, state: f.state, limit: f.limit })}`))
+        .map(job)
+        .filter((j) => j !== null);
+}
+export async function one(t, id) {
+    const j = job(await call(t, 'GET', `/v1/auto/jobs/${seg(id)}`));
+    if (!j)
+        throw new Error('The job came back without an id');
+    return j;
+}
+/** One frame of /v1/auto/events, or null for one this page does not read. */
+export function heard(event, data) {
+    let raw;
+    try {
+        raw = JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+    if (event === 'job') {
+        const j = job(raw);
+        return j ? { kind: 'job', job: j } : null;
+    }
+    if (event === 'automation') {
+        const a = read(raw);
+        return a ? { kind: 'automation', automation: a } : null;
+    }
+    return null;
+}
+/**
+ * Read /v1/auto/events until `signal` ends it or the stream closes, calling `on`
+ * for each job and automation it names. A fetch, because EventSource cannot
+ * carry the bearer.
+ */
+export async function events(t, on, signal, opened) {
+    const res = await fetch(`${t.api}/v1/auto/events`, { headers: headers(t, { Accept: 'text/event-stream' }), cache: 'no-store', signal });
+    if (!res.ok)
+        throw new Refusal(res.status, (await reason(res)) || `GET /v1/auto/events answered ${res.status}`);
+    if (!res.body)
+        return;
+    opened?.();
+    await stream(res.body, (f) => {
+        const h = heard(f.event, f.data);
+        if (h)
+            on(h);
+    }, signal);
+}

package/lib/api/library.d.ts

@@ -0,0 +1,121 @@
+/**
+ * The Library: everything a person made, in Chat, Dev, Studio and workflows, in
+ * one index.
+ *
+ *   GET    /v1/library            {data: [item], next}   newest first, filtered
+ *   GET    /v1/library/{id}       one item, with fresh signed URLs
+ *   POST   /v1/library            keep one: its bytes as base64, at most 10 MiB
+ *   PATCH  /v1/library/{id}       rename, share with the org, move to a project
+ *   DELETE /v1/library/{id}       its row and its bytes
+ *
+ * An item is its owner's; another member of the org reads it only once its owner
+ * shares it, and changes it never. Its `url`, `download` and `preview` are
+ * signed and stop working at `expires`: read the item again for fresh ones.
+ */
+import { type Target } from './call.ts';
+export declare const KINDS: readonly ['image', 'video', 'audio', 'document', 'slides', 'type', 'model', 'code', 'file'];
+export type Kind = (typeof KINDS)[number];
+export declare const SOURCES: readonly ['chat', 'dev', 'studio', 'workflow'];
+export type Source = (typeof SOURCES)[number];
+export type Scope = 'all' | 'mine' | 'shared';
+/** A product, as a person names it. */
+export declare const SOURCE: Record<Source, string>;
+export interface Item {
+    id: string;
+    kind: Kind;
+    source: Source;
+    name: string;
+    mime: string;
+    bytes: number;
+    width: number;
+    height: number;
+    seconds: number;
+    pages: number;
+    /** The subject that made it. */
+    owner: string;
+    /** The reader made it. */
+    mine: boolean;
+    /** Its owner shared it with the org. */
+    shared: boolean;
+    project: string;
+    /** What made it: a conversation, a Dev run, a Studio run, an automation's run. */
+    ref: string;
+    /** The app path back to what made it, or '' for none. */
+    origin: string;
+    /** The original, to open in place. */
+    url: string;
+    /** The original, as a download. */
+    download: string;
+    /** A still that shows it, or ''. An image is its own. */
+    preview: string;
+    expires: string;
+    created: string;
+    updated: string;
+}
+/** What a list is narrowed to. */
+export interface Filter {
+    kind?: Kind | '';
+    source?: Source | '';
+    ref?: string;
+    project?: string;
+    q?: string;
+    /** RFC 3339 bounds on when an item was made. */
+    since?: string;
+    until?: string;
+    scope?: Scope;
+    limit?: number;
+    cursor?: string;
+}
+export interface Page {
+    data: Item[];
+    /** The cursor of the next page, or '' at the end. */
+    next: string;
+}
+/** An app path back to what made an item: under this origin, never another's. */
+export declare const inApp: (v: unknown) => string;
+/** One item as the platform answers it, or null for a row with no id. */
+export declare function item(raw: unknown): Item | null;
+export declare function items(t: Target, f?: Filter, init?: {
+    signal?: AbortSignal;
+}): Promise<Page>;
+export declare function get(t: Target, id: string): Promise<Item>;
+/** What an upload says about where a thing came from. */
+export interface Made {
+    source: Source;
+    kind?: Kind;
+    ref?: string;
+    origin?: string;
+    project?: string;
+    /** The same owner, source and key answer the item already made. */
+    key?: string;
+    width?: number;
+    height?: number;
+    seconds?: number;
+    pages?: number;
+}
+/** The largest thing one upload carries. */
+export declare const INLINE: number;
+/** Bytes as base64, in chunks a call stack holds. */
+export declare function base64(bytes: Uint8Array): string;
+/** Keep a file in the Library. */
+export declare function upload(t: Target, file: {
+    name: string;
+    type: string;
+    bytes: Uint8Array;
+}, made: Made): Promise<Item>;
+export interface Change {
+    name?: string;
+    shared?: boolean;
+    project?: string;
+}
+export declare function change(t: Target, id: string, c: Change): Promise<Item>;
+export declare function remove(t: Target, id: string): Promise<void>;
+/** A size the way a person reads it. */
+export declare function size(bytes: number): string;
+/** The day an instant falls on, as a section of the Library: Today, Yesterday, then the month. */
+export declare function day(iso: string, now?: Date): string;
+/** Items under the day each was made, in the order given (newest first). */
+export declare function days(list: Item[], now?: Date): {
+    label: string;
+    rows: Item[];
+}[];