allyhub 0.7.0 → 0.8.0

package/dist/node_modules/@allyhub/protocol/dist/snapshots.d.ts

@@ -0,0 +1,417 @@
+import { z } from "zod";
+import { type Place } from "./editor.js";
+/** The manifest's format; a reader that does not know it asks for the machine. */
+export declare const SNAPSHOT_FORMAT = 1;
+export declare const ConversationEntrySchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    agent: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    transcript: z.ZodString;
+}, z.core.$strip>;
+export type ConversationEntry = z.infer<typeof ConversationEntrySchema>;
+/**
+ * A conversation as the window replays it: the messages Studio's Host
+ * relayed to its clients (ACP's `session/update` and Studio's own
+ * notifications), in order.
+ */
+export declare const TranscriptSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnknown;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Transcript = z.infer<typeof TranscriptSchema>;
+/**
+ * What a snapshot is of: a project, or the Host's own home (its settings,
+ * schedules, skills, plugins and the agents' stores of their
+ * conversations; files only, no tree), one per person's Studio.
+ */
+export declare const SNAPSHOT_KINDS: readonly ["project", "home"];
+export type SnapshotKind = (typeof SNAPSHOT_KINDS)[number];
+/**
+ * What showing one item read only reaches (a share's view of it): the
+ * tree's paths its editor and its stage load, the project's files its
+ * editor reads, and the tree's files its view serves in place of the
+ * project's at the same path (the item list and the check's results,
+ * reduced to it). A path the manifest does not have is not served.
+ */
+export declare const ItemReachSchema: z.ZodObject<{
+    tree: z.ZodArray<z.ZodString>;
+    files: z.ZodArray<z.ZodString>;
+    own: z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodInt;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ItemReach = z.infer<typeof ItemReachSchema>;
+/** What each item a share can show reaches, worked out as the snapshot is recorded. */
+export declare const SnapshotReachSchema: z.ZodObject<{
+    shared: z.ZodArray<z.ZodString>;
+    items: z.ZodRecord<z.ZodString, z.ZodObject<{
+        tree: z.ZodArray<z.ZodString>;
+        files: z.ZodArray<z.ZodString>;
+        own: z.ZodRecord<z.ZodString, z.ZodObject<{
+            sha256: z.ZodString;
+            size: z.ZodInt;
+            type: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SnapshotReach = z.infer<typeof SnapshotReachSchema>;
+export declare const SnapshotManifestSchema: z.ZodObject<{
+    format: z.ZodLiteral<1>;
+    kind: z.ZodEnum<{
+        home: "home";
+        project: "project";
+    }>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+    host: z.ZodObject<{
+        version: z.ZodString;
+    }, z.core.$strip>;
+    madeAt: z.ZodISODateTime;
+    files: z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodInt;
+    }, z.core.$strip>>;
+    tree: z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodInt;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+    conversations: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        agent: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        transcript: z.ZodString;
+    }, z.core.$strip>>;
+    reach: z.ZodOptional<z.ZodObject<{
+        shared: z.ZodArray<z.ZodString>;
+        items: z.ZodRecord<z.ZodString, z.ZodObject<{
+            tree: z.ZodArray<z.ZodString>;
+            files: z.ZodArray<z.ZodString>;
+            own: z.ZodRecord<z.ZodString, z.ZodObject<{
+                sha256: z.ZodString;
+                size: z.ZodInt;
+                type: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SnapshotManifest = z.infer<typeof SnapshotManifestSchema>;
+/**
+ * A manifest as a share's view of one item shows it: its files and tree
+ * only what the item reaches (its own files in place of the project's),
+ * no conversations; undefined when the snapshot did not record the
+ * item's reach. A view serves nothing its manifest does not name, so
+ * this is the whole of a view's scope.
+ */
+export declare function scopedManifest(m: SnapshotManifest, item: string): SnapshotManifest | undefined;
+/**
+ * What a project's backup leaves out, as folders anywhere in it: what is
+ * made again from the rest (dependencies, caches, exports).
+ */
+export declare const SNAPSHOT_SKIPPED: readonly ["node_modules", ".allyhub/cache", ".allyhub/out"];
+/**
+ * The tree a read view serves, by its top folders. Every address inside
+ * it is relative, so it is the same tree a live dev server serves under
+ * its stage's base.
+ */
+export declare const SNAPSHOT_TREE: {
+    /** The editors' page (editor-web's build). */
+    readonly editor: "editor/";
+    /** The stage's runtime, its pages and its fonts. */
+    readonly runtime: "runtime/";
+    /** The pieces' bundles. */
+    readonly build: "build/";
+    /** The project's media the builds found, by their project path. */
+    readonly media: "media/";
+    /** Derived media: a person's matte, by the media's project path. */
+    readonly matte: "matte/";
+    /** The sceneries' bundles, bakes and decoders. */
+    readonly scenery: "scenery/";
+    readonly bakes: "bakes/";
+    /** An item's component pictures (a deck's, a doc's), by what they show (`stillPath`), and a snapshot's lists of them (`stillsIndexPath`). */
+    readonly stills: "stills/";
+    /** The answers the editors ask for, recorded (snapshotAnswerPath). */
+    readonly answers: "answers/";
+    /** Each item's gallery preview, by its folder (snapshotPreviewPath). */
+    readonly previews: "previews/";
+};
+/**
+ * Where a project tool's recorded answer is in the tree: by the tool's
+ * name and its params, so the reader finds the answer to the call it makes.
+ */
+export declare const snapshotAnswerPath: (tool: string, params: unknown) => string;
+/**
+ * A recorded answer, as JSON-RPC's response carries one: the result, or
+ * the error the host gave (its code, its message, what it named).
+ */
+export declare const RecordedAnswerSchema: z.ZodObject<{
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordedAnswer = z.infer<typeof RecordedAnswerSchema>;
+/**
+ * Where a host's answer to one of its own reads is recorded (a home's, or
+ * a project's): its params without the folder, which a snapshot is of, so
+ * a client asking with its own name for the folder finds it.
+ */
+export declare const recordedReadPath: (method: string, params: unknown) => string;
+/** A component's picture in the tree, by its key (`components/stills`'): a transparent WebP that never changes. */
+export declare const stillPath: (key: string) => string;
+/**
+ * Where an item version's component pictures are listed in a snapshot's
+ * tree: every component its slides or its blocks show as they are edited, drawn when
+ * the snapshot was made, so a read view answers `components/stills`
+ * for any of them.
+ */
+export declare const stillsIndexPath: (item: string, version: string) => string;
+/** An item version's component pictures: each picture's key (`stillPath`), by its component (`stillsIndexKey`). */
+export declare const StillsIndexSchema: z.ZodObject<{
+    stills: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type StillsIndex = z.infer<typeof StillsIndexSchema>;
+/** A component as `components/stills` takes it (its name, props, size and moment), as one string: its keys sorted. */
+export declare const stillsIndexKey: (component: unknown) => string;
+/** An item's gallery preview in the tree: its `Preview` (a picture, words or rows), as JSON. */
+export declare const snapshotPreviewPath: (itemDir: string) => string;
+/**
+ * The tree's fixed pages: each reads what to show from its own address.
+ * - the stage: `?piece=<id>&combo=<key>` and where it starts (`t`,
+ *   `part`, `offset`, `dur`), `play=1`, `chrome=0`, `mode=code|component` (`components/stage` asks the second);
+ *   it loads the piece's source (`pieceSourcePath`); without `piece` it is
+ *   the bare stage a host drives (`window.allyhub`);
+ * - a scenery's viewer: `?file=<the scenery's or model's file>` and
+ *   `camera=<JSON>`; it loads its source (`scenerySourcePath`);
+ * - the probe, which says by postMessage that a sandboxed frame loads.
+ */
+export declare const TREE_PAGES: {
+    readonly stage: "runtime/stage.html";
+    readonly viewer: "runtime/viewer.html";
+    readonly probe: "runtime/probe.html";
+};
+/** Where a piece's `BuildSource` is in the tree: its addresses are relative to the tree's root. */
+export declare const pieceSourcePath: (piece: string) => string;
+/**
+ * What a scenery's viewer loads: its bundle, three.js's decoders and
+ * manifold's wasm, each a path from the tree's root, and the bakes on
+ * disk by name (`<digest>.<renderer>`, served at `bakes/<name>.bin`).
+ */
+export interface ScenerySource {
+    module: string;
+    decoders: string;
+    manifoldWasm: string;
+    bakes: string[];
+}
+/** Where a scenery's (or a 3D model's) `ScenerySource` is in the tree. */
+export declare const scenerySourcePath: (file: string) => string;
+/**
+ * A path of the tree as an address relative to its root: each segment
+ * percent-encoded, so a server that decodes the address once finds the
+ * path (an answer's or a source's name holds encoded characters itself).
+ */
+export declare const treeHref: (path: string) => string;
+/**
+ * Where a live server makes a sound as the export decodes it (a take
+ * denoised or sped, a stem filtered), on demand. Not recorded: a
+ * snapshot's stage plays the recording instead.
+ */
+export declare const SOUND_FOLDER = "sound/";
+/**
+ * The stage's and the viewer's CSP, wherever the tree is served (`tree`:
+ * its root's absolute address, ending in "/"): the runtime, the builds and
+ * the media, nothing else; framed only by `ancestors` (origins). A 3D
+ * scenery needs three things more, all its own: three.js's decoders run in
+ * workers made from blob: addresses, with WebAssembly; a glTF's embedded
+ * pictures, which its loader fetches from blob: addresses; and
+ * 'unsafe-eval', because the Basis transcoder's bindings make functions
+ * from strings as it starts. The stage runs the project's own code
+ * already, so evaluating strings gives it nothing it lacks; what the
+ * policy keeps is where the page can reach, which none of these widens
+ * beyond the tree.
+ */
+export declare function stageCsp(tree: string, ancestors: readonly string[]): string;
+/**
+ * The editors' page of a read view showing one item, read only, as the
+ * window frames it: `<origin>/editor/?item=<dir>&embed=studio&snapshot=1`
+ * and the window's theme. For a share's viewer (`viewer`, `&viewer=1`):
+ * the item alone, nothing offered that changes it or needs the machine
+ * (HostContext's `viewer`). Opened at a place (`place`): where the person
+ * was in the item (`t=`, `slide=`).
+ */
+export declare function snapshotEditorUrl(origin: string, item: string, o?: {
+    theme?: "light" | "dark";
+    viewer?: boolean;
+    place?: Place | undefined;
+}): string;
+export declare const EXECUTOR_KINDS: readonly ["cloud", "computer"];
+export type ExecutorKind = (typeof EXECUTOR_KINDS)[number];
+/** The header a computer's Host sends with its sign-in: the id it made for itself. */
+export declare const COMPUTER_HEADER = "x-allyhub-computer";
+/** A computer's id: what it made once, kept with its Host. */
+export declare const ComputerIdSchema: z.ZodString;
+/** The error code a snapshot or a move answers with when another executor works on the project (409). */
+export declare const WORKED_ELSEWHERE = "worked_elsewhere";
+/** Which executor works on a project, and whether it is the one asking. */
+export declare const ExecutorSchema: z.ZodObject<{
+    kind: z.ZodUnion<readonly [z.ZodEnum<{
+        cloud: "cloud";
+        computer: "computer";
+    }>, z.core.$ZodBranded<z.ZodString, "Unknown", "out">]>;
+    here: z.ZodBoolean;
+}, z.core.$strip>;
+export type Executor = z.infer<typeof ExecutorSchema>;
+/**
+ * `POST { blobs }`: which of these the organization lacks; answers a
+ * signed PUT for each (its sha256 signed in), none for what it holds.
+ */
+export declare const SNAPSHOT_BLOBS_PATH = "/api/snapshots/blobs";
+/**
+ * `POST { project, manifest }`: a snapshot recorded, its manifest a blob
+ * put already, by the project's executor. `project.id` absent: a project
+ * the server has not seen, made now, worked on by the executor that
+ * recorded it. Answers 409 with the blobs storage does not hold, or 409
+ * WORKED_ELSEWHERE when another executor works on the project.
+ */
+export declare const SNAPSHOTS_PATH = "/api/snapshots";
+export declare const SnapshotCreateSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            home: "home";
+            project: "project";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    manifest: z.ZodString;
+}, z.core.$strict>;
+export type SnapshotCreate = z.infer<typeof SnapshotCreateSchema>;
+export declare const SnapshotCreatedSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export type SnapshotCreated = z.infer<typeof SnapshotCreatedSchema>;
+export declare const SnapshotMissingSchema: z.ZodObject<{
+    missing: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** `GET`: the person's projects in the organization and their Studio's home, each with its latest snapshot. */
+export declare const PROJECTS_PATH = "/api/projects";
+export declare const SnapshotInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    madeAt: z.ZodISODateTime;
+    hostVersion: z.ZodString;
+}, z.core.$strip>;
+export type SnapshotInfo = z.infer<typeof SnapshotInfoSchema>;
+export declare const ProjectInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        home: "home";
+        project: "project";
+    }>;
+    name: z.ZodString;
+    latest: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        madeAt: z.ZodISODateTime;
+        hostVersion: z.ZodString;
+    }, z.core.$strip>>;
+    executor: z.ZodObject<{
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            cloud: "cloud";
+            computer: "computer";
+        }>, z.core.$ZodBranded<z.ZodString, "Unknown", "out">]>;
+        here: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProjectInfo = z.infer<typeof ProjectInfoSchema>;
+export declare const ProjectsResponseSchema: z.ZodObject<{
+    projects: z.ZodPipe<z.ZodArray<z.ZodUnknown>, z.ZodTransform<{
+        id: string;
+        kind: "home" | "project";
+        name: string;
+        latest: {
+            id: string;
+            madeAt: string;
+            hostVersion: string;
+        } | null;
+        executor: {
+            kind: (string & z.core.$brand<"Unknown">) | "cloud" | "computer";
+            here: boolean;
+        };
+    }[], unknown[]>>;
+}, z.core.$strip>;
+/** `DELETE`: a project forgotten with its snapshots. */
+export declare const projectPath: (id: string) => string;
+/**
+ * `PUT { kind }`: the project moved to another executor, answered as its
+ * `ProjectInfo`: to the person's cloud Studio from anywhere they are
+ * signed in, to a computer only by that computer (COMPUTER_HEADER). The
+ * executor it leaves is refused from then on (WORKED_ELSEWHERE). A home
+ * stays where it is.
+ */
+export declare const projectExecutorPath: (id: string) => string;
+export declare const ExecutorMoveSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        cloud: "cloud";
+        computer: "computer";
+    }>;
+}, z.core.$strict>;
+export type ExecutorMove = z.infer<typeof ExecutorMoveSchema>;
+/**
+ * `POST`: a read view of a snapshot, answered `{ origin, expiresAt }`: a
+ * host of its own on the Studio domain, serving the manifest at
+ * `manifest.json`, the tree at its paths, the project's files under
+ * `files/` and the transcripts under `conversations/<sessionId>.json`,
+ * until it expires. Its name is the capability.
+ */
+export declare const snapshotViewPath: (id: string) => string;
+export declare const SnapshotViewSchema: z.ZodObject<{
+    origin: z.ZodURL;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type SnapshotView = z.infer<typeof SnapshotViewSchema>;
+/** A read view's paths besides the tree's. */
+export declare const SNAPSHOT_VIEW: {
+    readonly manifest: "manifest.json";
+    readonly files: "files/";
+    readonly conversations: "conversations/";
+};
+/**
+ * The JSON-RPC error a read-only host answers for what needs the machine
+ * (a change, an export, a check run, the agent): the window offers to wake
+ * it.
+ */
+export declare const NEEDS_MACHINE = -32010;
+/** Whether an error is the one for what only a running machine does (`NEEDS_MACHINE`), whichever client carried it. */
+export declare const isNeedsMachine: (e: unknown) => boolean;
+/**
+ * The JSON-RPC error a Host answers for a change to a project another
+ * executor works on (an editor's save, an agent's turn, an upload): one
+ * place works on a project at a time, every other reads it; the window
+ * offers the move.
+ */
+export declare const ELSEWHERE = -32011;
+/**
+ * The JSON-RPC error a move answers when the folder it would replace has
+ * changes made here since its base (the snapshot it last recorded or was
+ * made from) that the latest snapshot lacks: nothing moved; the data names
+ * them (MoveChangesSchema), and the move asked again with `replace`
+ * replaces them.
+ */
+export declare const CHANGED_HERE = -32012;
+export declare const MoveChangesSchema: z.ZodObject<{
+    changed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type MoveChanges = z.infer<typeof MoveChangesSchema>;
+//# sourceMappingURL=snapshots.d.ts.map

package/dist/node_modules/@allyhub/protocol/dist/snapshots.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{z as e}from"zod";import{BlobSchema as f,Sha256Schema as l,TreeFileSchema as h,TreePathSchema as p}from"./blobs.js";import{placeParams as x}from"./editor.js";import{openEnum as b,readable as S}from"./open.js";export const SNAPSHOT_FORMAT=1,ConversationEntrySchema=e.object({sessionId:e.string().min(1),agent:e.string().min(1),title:e.string().optional(),createdAt:e.iso.datetime(),updatedAt:e.iso.datetime(),transcript:l}),TranscriptSchema=e.object({sessionId:e.string().min(1),messages:e.array(e.object({method:e.string().min(1),params:e.unknown()}))}),SNAPSHOT_KINDS=["project","home"];const j=e.string().refine(t=>t.endsWith("/")&&p.safeParse(t.slice(0,-1)).success,"a folder of the tree, ending in /");export const ItemReachSchema=e.object({tree:e.array(p),files:e.array(p),own:e.record(p,h)}),SnapshotReachSchema=e.object({shared:e.array(j),items:e.record(e.string(),ItemReachSchema)}),SnapshotManifestSchema=e.object({format:e.literal(SNAPSHOT_FORMAT),kind:e.enum(SNAPSHOT_KINDS),project:e.object({name:e.string().min(1).max(255)}),host:e.object({version:e.string().min(1)}),madeAt:e.iso.datetime(),files:e.record(p,f),tree:e.record(p,h),conversations:e.array(ConversationEntrySchema),reach:SnapshotReachSchema.optional()});export function scopedManifest(t,n){const o=t.reach,r=o!==void 0&&Object.hasOwn(o.items,n)?o.items[n]:void 0;if(o===void 0||r===void 0)return;const c={};for(const[s,i]of Object.entries(t.tree))o.shared.some(m=>s.startsWith(m))&&(c[s]=i);for(const s of r.tree){const i=Object.hasOwn(t.tree,s)?t.tree[s]:void 0;i!==void 0&&(c[s]=i)}Object.assign(c,r.own);const a={};for(const s of r.files){const i=Object.hasOwn(t.files,s)?t.files[s]:void 0;i!==void 0&&(a[s]=i)}return{format:t.format,kind:t.kind,project:t.project,host:t.host,madeAt:t.madeAt,files:a,tree:c,conversations:[]}}export const SNAPSHOT_SKIPPED=["node_modules",".allyhub/cache",".allyhub/out"],SNAPSHOT_TREE={editor:"editor/",runtime:"runtime/",build:"build/",media:"media/",matte:"matte/",scenery:"scenery/",bakes:"bakes/",stills:"stills/",answers:"answers/",previews:"previews/"};function d(t){return Array.isArray(t)?t.map(d):t!==null&&typeof t=="object"?Object.fromEntries(Object.keys(t).sort().map(n=>[n,d(t[n])])):t}export const snapshotAnswerPath=(t,n)=>`${SNAPSHOT_TREE.answers}${t}/${encodeURIComponent(JSON.stringify(d(n??{})))}.json`,RecordedAnswerSchema=e.object({result:e.unknown().optional(),error:e.object({code:e.number(),message:e.string(),data:e.unknown().optional()}).optional()}),recordedReadPath=(t,n)=>snapshotAnswerPath(t,Object.fromEntries(Object.entries(n??{}).filter(([o,r])=>o!=="folder"&&r!==void 0))),stillPath=t=>`${SNAPSHOT_TREE.stills}${t}.webp`,stillsIndexPath=(t,n)=>`${SNAPSHOT_TREE.stills}index/${encodeURIComponent(t)}/${encodeURIComponent(n)}.json`,StillsIndexSchema=e.object({stills:e.record(e.string(),e.string().regex(/^[0-9a-f]{64}$/u))}),stillsIndexKey=t=>JSON.stringify(d(t)),snapshotPreviewPath=t=>`${SNAPSHOT_TREE.previews}${encodeURIComponent(t===""?".":t)}.json`,TREE_PAGES={stage:`${SNAPSHOT_TREE.runtime}stage.html`,viewer:`${SNAPSHOT_TREE.runtime}viewer.html`,probe:`${SNAPSHOT_TREE.runtime}probe.html`},pieceSourcePath=t=>`${SNAPSHOT_TREE.build}sources/${encodeURIComponent(t)}.json`,scenerySourcePath=t=>`${SNAPSHOT_TREE.scenery}sources/${encodeURIComponent(t)}.json`,treeHref=t=>t.split("/").map(encodeURIComponent).join("/"),SOUND_FOLDER="sound/";export function stageCsp(t,n){const o=u=>`${t}${u}`,r=o(SNAPSHOT_TREE.runtime),c=o(SNAPSHOT_TREE.build),a=o(SNAPSHOT_TREE.scenery),s=o(SNAPSHOT_TREE.media),i=o(SNAPSHOT_TREE.matte),m=o(SOUND_FOLDER);return["default-src 'none'",`script-src 'unsafe-eval' 'wasm-unsafe-eval' ${r} ${c} ${a}`,"worker-src blob:",`style-src 'unsafe-inline' ${r} ${c} ${a}`,`font-src ${r} ${c} ${s} data:`,`img-src ${s} ${c} ${a} data: blob:`,`media-src ${s} ${i} ${m} blob:`,`connect-src ${s} ${i} ${m} ${c} ${a} ${o(SNAPSHOT_TREE.bakes)} ${r} blob: data:`,`frame-ancestors ${n.length>0?n.join(" "):"'none'"}`].join("; ")}export function snapshotEditorUrl(t,n,o={}){const r=Object.entries({item:n,embed:"studio",snapshot:"1",...o.viewer===!0?{viewer:"1"}:{},...o.theme===void 0?{}:{theme:o.theme},...x(o.place)}).map(([c,a])=>`${c}=${encodeURIComponent(a)}`);return`${t.replace(/\/$/u,"")}/${SNAPSHOT_TREE.editor}?${r.join("&")}`}export const EXECUTOR_KINDS=["cloud","computer"],COMPUTER_HEADER="x-allyhub-computer",ComputerIdSchema=e.string().regex(/^[A-Za-z0-9_-]{16,64}$/u),WORKED_ELSEWHERE="worked_elsewhere",ExecutorSchema=e.object({kind:b(EXECUTOR_KINDS),here:e.boolean()}),SNAPSHOT_BLOBS_PATH="/api/snapshots/blobs",SNAPSHOTS_PATH="/api/snapshots",SnapshotCreateSchema=e.strictObject({project:e.strictObject({id:e.string().min(1).optional(),kind:e.enum(SNAPSHOT_KINDS),name:e.string().min(1).max(255)}),manifest:l}),SnapshotCreatedSchema=e.object({id:e.string().min(1),projectId:e.string().min(1)}),SnapshotMissingSchema=e.object({missing:e.array(l)}),PROJECTS_PATH="/api/projects",SnapshotInfoSchema=e.object({id:e.string().min(1),madeAt:e.iso.datetime(),hostVersion:e.string()}),ProjectInfoSchema=e.object({id:e.string().min(1),kind:e.enum(SNAPSHOT_KINDS),name:e.string(),latest:SnapshotInfoSchema.nullable(),executor:ExecutorSchema}),ProjectsResponseSchema=e.object({projects:S(ProjectInfoSchema)}),projectPath=t=>`${PROJECTS_PATH}/${encodeURIComponent(t)}`,projectExecutorPath=t=>`${projectPath(t)}/executor`,ExecutorMoveSchema=e.strictObject({kind:e.enum(EXECUTOR_KINDS)}),snapshotViewPath=t=>`${SNAPSHOTS_PATH}/${encodeURIComponent(t)}/view`,SnapshotViewSchema=e.object({origin:e.url(),expiresAt:e.iso.datetime()}),SNAPSHOT_VIEW={manifest:"manifest.json",files:"files/",conversations:"conversations/"},NEEDS_MACHINE=-32010,isNeedsMachine=t=>typeof t=="object"&&t!==null&&t.code===NEEDS_MACHINE,ELSEWHERE=-32011,CHANGED_HERE=-32012,MoveChangesSchema=e.object({changed:e.array(e.string())});

package/dist/node_modules/@allyhub/protocol/dist/sources.d.ts

@@ -0,0 +1,14 @@
+/**
+ * - `public`: data anyone may read (the resources registry);
+ * - `account`: the API, with the person's session;
+ * - `project`: the project's snapshot (its files, its recorded answers);
+ * - `home`: the home snapshot (what the host recorded of itself), or the
+ *   project's for a read asked of a project and recorded there;
+ * - `asleep`: what is so while nothing runs (no jobs, no tabs): a fixed
+ *   answer, or refused as needing the machine, never waking it;
+ * - `machine`: a running host; asked with none, it wakes the machine and
+ *   waits for it.
+ */
+export declare const METHOD_SOURCE_NAMES: readonly ["public", "account", "project", "home", "asleep", "machine"];
+export type MethodSource = (typeof METHOD_SOURCE_NAMES)[number];
+//# sourceMappingURL=sources.d.ts.map

package/dist/node_modules/@allyhub/protocol/dist/sources.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export const METHOD_SOURCE_NAMES=["public","account","project","home","asleep","machine"];

package/dist/node_modules/@allyhub/protocol/dist/teams.d.ts

@@ -0,0 +1,195 @@
+import { z } from "zod";
+/** `GET`: the organizations the person is in, the one a request acts in unless it names another first; `POST { name }`: a new team. */
+export declare const ORGANIZATIONS_PATH = "/api/organizations";
+export declare const OrganizationsSchema: z.ZodObject<{
+    organizations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        role: z.ZodString;
+        dissolvedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Organizations = z.infer<typeof OrganizationsSchema>;
+/** `GET`: the members of the organization the request acts in; a member sees their own row alone. */
+export declare const MEMBERS_PATH = "/api/organization/members";
+export declare const MembersSchema: z.ZodObject<{
+    members: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        email: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodString;
+        limit: z.ZodNullable<z.ZodNumber>;
+        used: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Members = z.infer<typeof MembersSchema>;
+/** A member's limit in credits a month, null for none (`members/limit`, account.ts). */
+export declare const MemberLimitSchema: z.ZodObject<{
+    monthly: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+/** `DELETE`, its owner's: the team the request acts in dissolved; `PUT { name }`, an owner's or an admin's: renamed. */
+export declare const ORGANIZATION_PATH = "/api/organization";
+/** `GET`: the person's cloud Studio, if any, and what an hour of it costs; `DELETE`: it gone. */
+export declare const STUDIO_PATH = "/api/studio";
+/** Whether a cloud Studio is running or asleep. */
+export declare const STUDIO_STATES: readonly ["running", "paused"];
+export declare const StudioSchema: z.ZodObject<{
+    studio: z.ZodNullable<z.ZodObject<{
+        state: z.ZodUnion<readonly [z.ZodEnum<{
+            running: "running";
+            paused: "paused";
+        }>, z.core.$ZodBranded<z.ZodString, "Unknown", "out">]>;
+        organizationId: z.ZodString;
+    }, z.core.$strip>>;
+    creditsPerHour: z.ZodNumber;
+    idle: z.ZodOptional<z.ZodObject<{
+        minutes: z.ZodNumber;
+        chosen: z.ZodNullable<z.ZodNumber>;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strip>>;
+    update: z.ZodOptional<z.ZodObject<{
+        since: z.ZodString;
+        by: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StudioInfo = z.infer<typeof StudioSchema>;
+/** `POST`: Restart to update, the person's; refused while an agent's turn or a job runs. */
+export declare const STUDIO_RESTART_PATH = "/api/studio/restart";
+/** `PATCH` on STUDIO_PATH: the person's own idle window, minutes, within `idle`'s range; null for the default. */
+export declare const StudioSettingsSchema: z.ZodObject<{
+    idleMinutes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+/** `GET`, `PUT`: what an organization allows its members' cloud Studios (owners and admins put it). */
+export declare const STUDIO_POLICY_PATH = "/api/organization/studio";
+export declare const StudioPolicySchema: z.ZodObject<{
+    idleMaxMinutes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type StudioPolicy = z.infer<typeof StudioPolicySchema>;
+/**
+ * `POST`, a browser's: the Studio made or woken, answered with its Host's
+ * origin on the gateway and a ticket. The window connects to
+ * `<origin as ws(s)>/studio?ticket=<ticket>`; the gateway takes a ticket
+ * once.
+ */
+export declare const STUDIO_OPEN_PATH = "/api/studio/open";
+/**
+ * The stages of opening a Studio the server measures, in their order
+ * (docs/design/studio-wake.md, "Every wake measured"): the person's
+ * balance, the Studio held, its machine made or resumed, its Host's
+ * health asked, the release read (what is left of it: it is read beside
+ * the resume and the health), its Host installed, its Host started,
+ * its time charged (measured only where the answer waits for it: a
+ * Worker's open answers first), its ticket. A stage not needed is not
+ * measured.
+ */
+export declare const STUDIO_OPEN_STAGES: readonly ["balance", "hold", "create", "resume", "health", "release", "install", "start", "charge", "ticket"];
+export type StudioOpenStage = (typeof STUDIO_OPEN_STAGES)[number];
+/** How long each stage took, ms; a stage this client does not know is kept as it is. */
+export declare const StudioOpenStagesSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
+export type StudioOpenStages = Partial<Record<StudioOpenStage, number>>;
+export declare const StudioOpenedSchema: z.ZodObject<{
+    origin: z.ZodURL;
+    ticket: z.ZodString;
+    stages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type StudioOpened = z.infer<typeof StudioOpenedSchema>;
+/**
+ * Asked for with `Accept: application/x-ndjson`, opening a Studio says
+ * how it goes as it goes, one JSON object a line, as Docker's API streams
+ * an image's pull: each step as it begins, then the Studio opened (or the
+ * error envelope, with the status it would have had). Without it, the
+ * answer is the Studio opened alone, as it always was.
+ */
+export declare const NDJSON = "application/x-ndjson";
+/**
+ * The steps of opening a Studio, in their order: its machine made
+ * (`first`: none was there) or resumed, its Host installed (a new release,
+ * or the first time), its Host started. A step not needed is not said.
+ */
+export declare const STUDIO_OPEN_STEPS: readonly ["machine", "install", "start"];
+export type StudioOpenStep = (typeof STUDIO_OPEN_STEPS)[number];
+export declare const StudioOpenLineSchema: z.ZodUnion<readonly [z.ZodObject<{
+    step: z.ZodEnum<{
+        install: "install";
+        start: "start";
+        machine: "machine";
+    }>;
+    first: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodNumber;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    origin: z.ZodURL;
+    ticket: z.ZodString;
+    stages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>]>;
+export type StudioOpenLine = z.infer<typeof StudioOpenLineSchema>;
+/**
+ * `POST`, a browser's: a ticket for the person's running Studio (to
+ * connect again, or for one upload: `POST <origin>/upload?…&ticket=`);
+ * 409 when it is not running.
+ */
+export declare const STUDIO_TICKET_PATH = "/api/studio/ticket";
+export declare const StudioTicketSchema: z.ZodObject<{
+    ticket: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `POST`, a browser's: a first Studio made ahead for the person, who has
+ * none, and paused, so their first work resumes it (`{ prepared }`: false
+ * when they had one, or no credits). Answered once it is done; the window
+ * does not wait for it.
+ */
+export declare const STUDIO_PREPARE_PATH = "/api/studio/prepare";
+export declare const StudioPreparedSchema: z.ZodObject<{
+    prepared: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `POST`, a browser's: the person's running Studio paused now, as an idle
+ * one is, its snapshots made first (`{ paused }`: false when it was not
+ * running). What a benchmark of waking starts each run from.
+ */
+export declare const STUDIO_PAUSE_PATH = "/api/studio/pause";
+export declare const StudioPausedSchema: z.ZodObject<{
+    paused: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `POST`, a browser's: how a wake went as the window saw it, recorded with
+ * the server's stages so a wake is measured end to end (204). The window's
+ * stages: the API's open as it waited for it, the connection to the Host,
+ * the project entered on it (listed, brought, opened).
+ */
+export declare const STUDIO_WAKES_PATH = "/api/studio/wakes";
+export declare const STUDIO_WAKE_OUTCOMES: readonly ["live", "failed"];
+export declare const StudioWakeReportSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        failed: "failed";
+        live: "live";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    server: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    window: z.ZodObject<{
+        open: z.ZodOptional<z.ZodNumber>;
+        connect: z.ZodOptional<z.ZodNumber>;
+        enter: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodNumber;
+    }, z.core.$strict>;
+    first: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type StudioWakeReport = z.infer<typeof StudioWakeReportSchema>;
+/**
+ * `PUT { at }`, a cloud Studio's own Host's (its API key): when its next
+ * scheduled task is due, null for none. A paused Studio is woken then, its
+ * Host runs the task as it would on a computer, and it pauses again once
+ * idle.
+ */
+export declare const STUDIO_WAKE_PATH = "/api/studio/wake";
+export declare const StudioWakeSchema: z.ZodObject<{
+    at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+//# sourceMappingURL=teams.d.ts.map

package/dist/node_modules/@allyhub/protocol/dist/teams.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{z as t}from"zod";import{openEnum as e}from"./open.js";export const ORGANIZATIONS_PATH="/api/organizations",OrganizationsSchema=t.object({organizations:t.array(t.object({id:t.string(),name:t.string(),slug:t.string(),role:t.string(),dissolvedAt:t.iso.datetime().nullable()}))}),MEMBERS_PATH="/api/organization/members",MembersSchema=t.object({members:t.array(t.object({userId:t.string(),email:t.string(),name:t.string(),role:t.string(),limit:t.number().nullable(),used:t.number()}))}),MemberLimitSchema=t.strictObject({monthly:t.number().nonnegative().nullable()}),ORGANIZATION_PATH="/api/organization",STUDIO_PATH="/api/studio",STUDIO_STATES=["running","paused"],StudioSchema=t.object({studio:t.object({state:e(STUDIO_STATES),organizationId:t.string()}).nullable(),creditsPerHour:t.number(),idle:t.object({minutes:t.number(),chosen:t.number().nullable(),min:t.number(),max:t.number()}).optional(),update:t.object({since:t.string(),by:t.string()}).optional()}),STUDIO_RESTART_PATH="/api/studio/restart",StudioSettingsSchema=t.strictObject({idleMinutes:t.number().int().nullable()}),STUDIO_POLICY_PATH="/api/organization/studio",StudioPolicySchema=t.strictObject({idleMaxMinutes:t.number().int().nullable()}),STUDIO_OPEN_PATH="/api/studio/open",STUDIO_OPEN_STAGES=["balance","hold","create","resume","health","release","install","start","charge","ticket"],StudioOpenStagesSchema=t.record(t.string(),t.number()),StudioOpenedSchema=t.object({origin:t.url(),ticket:t.string().min(1),stages:StudioOpenStagesSchema.optional()}),NDJSON="application/x-ndjson",STUDIO_OPEN_STEPS=["machine","install","start"],StudioOpenLineSchema=t.union([t.object({step:t.enum(STUDIO_OPEN_STEPS),first:t.boolean().optional()}),t.object({status:t.number(),error:t.object({code:t.string(),message:t.string(),data:t.record(t.string(),t.unknown()).optional()})}),StudioOpenedSchema]),STUDIO_TICKET_PATH="/api/studio/ticket",StudioTicketSchema=t.object({ticket:t.string().min(1)}),STUDIO_PREPARE_PATH="/api/studio/prepare",StudioPreparedSchema=t.object({prepared:t.boolean()}),STUDIO_PAUSE_PATH="/api/studio/pause",StudioPausedSchema=t.object({paused:t.boolean()}),STUDIO_WAKES_PATH="/api/studio/wakes",STUDIO_WAKE_OUTCOMES=["live","failed"],StudioWakeReportSchema=t.strictObject({outcome:t.enum(STUDIO_WAKE_OUTCOMES),error:t.string().max(500).optional(),server:StudioOpenStagesSchema.optional(),window:t.strictObject({open:t.number().optional(),connect:t.number().optional(),enter:t.number().optional(),total:t.number()}),first:t.boolean().optional()}),STUDIO_WAKE_PATH="/api/studio/wake",StudioWakeSchema=t.strictObject({at:t.iso.datetime().nullable()});