allyhub 0.5.0 → 0.7.0

package/dist/node_modules/@allyhub-next/protocol/dist/sites.d.ts

@@ -0,0 +1,293 @@
+import { z } from "zod";
+/** The manifest's format; a reader that does not know it serves nothing. */
+export declare const SITE_MANIFEST_FORMAT = 1;
+/** What one deployment may hold, each checked by the server. */
+export declare const SITE_LIMITS: {
+    readonly files: 20000;
+    readonly bytes: number;
+    /** Rules of a site's `_redirects`. */
+    readonly redirects: 2000;
+    /** Rules of a site's `_headers`. */
+    readonly headers: 100;
+};
+/** How long an address is. */
+export declare const SLUG_LENGTH: {
+    readonly min: 3;
+    readonly max: 40;
+};
+/**
+ * Addresses no site may have: the platform's own, and names mail, browsers
+ * and other clients ask for by themselves.
+ */
+export declare const RESERVED_SLUGS: ReadonlySet<string>;
+/** Why a slug cannot be one; undefined when it can. */
+export declare function slugProblem(slug: string): string | undefined;
+export declare const SiteSlugSchema: z.ZodString;
+/** The statuses a `_redirects` rule answers with: a redirect, a rewrite, or a page shown as missing or gone. */
+export declare const REDIRECT_STATUSES: readonly [200, 301, 302, 303, 307, 308, 404, 410];
+export declare const RedirectRuleSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    status: z.ZodUnion<z.ZodLiteral<200 | 301 | 302 | 303 | 307 | 308 | 404 | 410>[]>;
+    force: z.ZodBoolean;
+}, z.core.$strict>;
+export type RedirectRule = z.infer<typeof RedirectRuleSchema>;
+/** Headers a site cannot set: a site's bytes and transport are the platform's, and it sets no cookies on a shared domain. */
+export declare const PLATFORM_HEADERS: ReadonlySet<string>;
+export declare const HeaderRuleSchema: z.ZodObject<{
+    for: z.ZodString;
+    set: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+export type HeaderRule = z.infer<typeof HeaderRuleSchema>;
+/**
+ * What a site is: its files by path from its root, each a blob and the
+ * type it is served as, and its `_redirects` and `_headers`, read. Nothing
+ * in it names a project or a person.
+ */
+export declare const SiteManifestSchema: z.ZodObject<{
+    format: z.ZodLiteral<1>;
+    files: z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodInt;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+    redirects: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        status: z.ZodUnion<z.ZodLiteral<200 | 301 | 302 | 303 | 307 | 308 | 404 | 410>[]>;
+        force: z.ZodBoolean;
+    }, z.core.$strict>>;
+    headers: z.ZodArray<z.ZodObject<{
+        for: z.ZodString;
+        set: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SiteManifest = z.infer<typeof SiteManifestSchema>;
+/** How a deployment was made: its files uploaded, or from a project's git. */
+export declare const SITE_SOURCE_KINDS: readonly ["upload", "git"];
+/** Where a deployment came from. `commit` once a project is in git; `digest`, the website's folder when it was built. */
+export declare const SiteSourceSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        upload: "upload";
+        git: "git";
+    }>;
+    commit: z.ZodOptional<z.ZodString>;
+    digest: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SiteSource = z.infer<typeof SiteSourceSchema>;
+export declare const DeploymentSchema: z.ZodObject<{
+    id: z.ZodString;
+    siteId: z.ZodString;
+    source: z.ZodObject<{
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            upload: "upload";
+            git: "git";
+        }>, z.core.$ZodBranded<z.ZodString, "Unknown", "out">]>;
+        commit: z.ZodOptional<z.ZodString>;
+        digest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    note: z.ZodNullable<z.ZodString>;
+    files: z.ZodNumber;
+    bytes: z.ZodNumber;
+    createdBy: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    live: z.ZodBoolean;
+}, z.core.$strip>;
+export type Deployment = z.infer<typeof DeploymentSchema>;
+export declare const SiteSchema: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    url: z.ZodURL;
+    liveDeployment: z.ZodNullable<z.ZodString>;
+    approved: z.ZodBoolean;
+    autoPublish: z.ZodBoolean;
+    indexing: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type Site = z.infer<typeof SiteSchema>;
+/** `GET`: the organization's sites. `POST { slug, name }`: a site made. */
+export declare const SITES_PATH = "/api/sites";
+export declare const SiteCreateSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type SiteCreate = z.infer<typeof SiteCreateSchema>;
+export declare const SitesResponseSchema: z.ZodObject<{
+    sites: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        url: z.ZodURL;
+        liveDeployment: z.ZodNullable<z.ZodString>;
+        approved: z.ZodBoolean;
+        autoPublish: z.ZodBoolean;
+        indexing: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    domain: z.ZodString;
+    hosting: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `GET`: a site and its versions, newest first. `DELETE ?person=1`: the site
+ * offline for good; its address is never given to anyone else. A site its
+ * organization removed answers 410, so a folder that still names it can make
+ * another; one that was never the organization's answers 404.
+ */
+export declare const sitePath: (id: string) => string;
+export declare const SiteDetailSchema: z.ZodObject<{
+    site: z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        url: z.ZodURL;
+        liveDeployment: z.ZodNullable<z.ZodString>;
+        approved: z.ZodBoolean;
+        autoPublish: z.ZodBoolean;
+        indexing: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    deployments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        siteId: z.ZodString;
+        source: z.ZodObject<{
+            kind: z.ZodUnion<readonly [z.ZodEnum<{
+                upload: "upload";
+                git: "git";
+            }>, z.core.$ZodBranded<z.ZodString, "Unknown", "out">]>;
+            commit: z.ZodOptional<z.ZodString>;
+            digest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        note: z.ZodNullable<z.ZodString>;
+        files: z.ZodNumber;
+        bytes: z.ZodNumber;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        live: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SiteDetail = z.infer<typeof SiteDetailSchema>;
+/** `POST { blobs }` (`BlobsRequestSchema`): which of these the site's organization lacks, each with where to put it. */
+export declare const siteBlobsPath: (site: string) => string;
+/**
+ * `POST { manifest, source, note }`: a version made from its manifest, a
+ * blob put already. Refused as a conflict, with the blobs storage does not
+ * hold, and nothing is recorded: a version is whole or it is not there.
+ */
+export declare const siteDeploymentsPath: (site: string) => string;
+export declare const DeploymentCreateSchema: z.ZodObject<{
+    manifest: z.ZodString;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            upload: "upload";
+            git: "git";
+        }>;
+        commit: z.ZodOptional<z.ZodString>;
+        digest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DeploymentCreate = z.infer<typeof DeploymentCreateSchema>;
+export declare const DeploymentMadeSchema: z.ZodObject<{
+    site: z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        url: z.ZodURL;
+        liveDeployment: z.ZodNullable<z.ZodString>;
+        approved: z.ZodBoolean;
+        autoPublish: z.ZodBoolean;
+        indexing: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    deployment: z.ZodObject<{
+        id: z.ZodString;
+        siteId: z.ZodString;
+        source: z.ZodObject<{
+            kind: z.ZodUnion<readonly [z.ZodEnum<{
+                upload: "upload";
+                git: "git";
+            }>, z.core.$ZodBranded<z.ZodString, "Unknown", "out">]>;
+            commit: z.ZodOptional<z.ZodString>;
+            digest: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        note: z.ZodNullable<z.ZodString>;
+        files: z.ZodNumber;
+        bytes: z.ZodNumber;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        live: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DeploymentMade = z.infer<typeof DeploymentMadeSchema>;
+/**
+ * `PUT { deployment }`: the site serves this version, a publish and a
+ * rollback alike. `DELETE ?person=1`: it serves nothing, and keeps its
+ * address.
+ *
+ * Going public is a person's to say, and who asks is one of three:
+ *
+ * - the browser: a session on the account site's own origin, on the page
+ *   `confirm` names. The first time a site goes public takes this. An agent
+ *   has no session of its own, so this stops it from taking a site public by
+ *   the CLI or the API. It is not proof against everything on the computer:
+ *   the sign-in there can ask for a link that signs a browser in, which is
+ *   how Studio opens that page, and something that drives a browser could
+ *   press the button.
+ * - the person: `?person=1`, sent by Studio's window and never by the CLI.
+ *   It moves a site already approved, and is all that changes a site's
+ *   settings. An agent shares a computer's sign-in, so this keeps an agent
+ *   that uses the CLI out, not one that forges a request.
+ * - the agent: anything else. It moves a site whose person let it
+ *   (`autoPublish`), and does nothing else.
+ */
+export declare const siteLivePath: (site: string) => string;
+export declare const SiteLiveSchema: z.ZodObject<{
+    deployment: z.ZodString;
+}, z.core.$strict>;
+export type SiteLive = z.infer<typeof SiteLiveSchema>;
+export declare const SiteLiveAnswerSchema: z.ZodObject<{
+    site: z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+        name: z.ZodString;
+        url: z.ZodURL;
+        liveDeployment: z.ZodNullable<z.ZodString>;
+        approved: z.ZodBoolean;
+        autoPublish: z.ZodBoolean;
+        indexing: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    live: z.ZodBoolean;
+    confirm: z.ZodOptional<z.ZodURL>;
+}, z.core.$strip>;
+export type SiteLiveAnswer = z.infer<typeof SiteLiveAnswerSchema>;
+/** The query that says a person asked, from Studio's window. */
+export declare const SITE_PERSON_QUERY = "person=1";
+/** The account site's page where a person says yes to a site going public. */
+export declare const SITE_CONFIRM_PAGE = "/publish";
+/** That page, for a version of a site. */
+export declare const siteConfirmPath: (o: {
+    site: string;
+    version: string;
+    organization: string;
+}) => string;
+/** `PUT ?person=1`: what the person changes of a site. */
+export declare const siteSettingsPath: (site: string) => string;
+export declare const SiteSettingsSchema: z.ZodObject<{
+    autoPublish: z.ZodOptional<z.ZodBoolean>;
+    indexing: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type SiteSettings = z.infer<typeof SiteSettingsSchema>;
+/** What the edge reads for a hostname. */
+export declare const SitePointerSchema: z.ZodObject<{
+    site: z.ZodString;
+    organization: z.ZodString;
+    deployment: z.ZodString;
+    manifest: z.ZodString;
+    indexing: z.ZodBoolean;
+}, z.core.$strip>;
+export type SitePointer = z.infer<typeof SitePointerSchema>;
+/** Where the edge's store keeps a hostname's pointer. */
+export declare const sitePointerKey: (hostname: string) => string;
+//# sourceMappingURL=sites.d.ts.map

package/dist/node_modules/@allyhub-next/protocol/dist/sites.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{Sha256Schema as o,TreeFileSchema as i,TreePathSchema as a}from"./blobs.js";import{openEnum as c}from"./open.js";export const SITE_MANIFEST_FORMAT=1,SITE_LIMITS={files:2e4,bytes:5*1024*1024*1024,redirects:2e3,headers:100},SLUG_LENGTH={min:3,max:40},RESERVED_SLUGS=new Set(["abuse","account","accounts","admin","administrator","allyhub","api","app","assets","auth","autoconfig","autodiscover","billing","blog","cdn","dashboard","dev","dns","docs","download","downloads","ftp","help","hostmaster","imap","login","mail","mta-sts","ns1","ns2","ops","pop","postmaster","preview","root","security","signin","smtp","staging","static","status","studio","support","test","webmaster","wpad","www"]);export function slugProblem(t){if(t.length<SLUG_LENGTH.min||t.length>SLUG_LENGTH.max)return`An address is ${String(SLUG_LENGTH.min)} to ${String(SLUG_LENGTH.max)} characters.`;if(!/^[a-z0-9-]+$/u.test(t))return"An address is lowercase letters, digits and hyphens.";if(t.startsWith("-")||t.endsWith("-"))return"An address neither starts nor ends with a hyphen.";if(t.includes("--"))return"An address does not have two hyphens in a row.";if(RESERVED_SLUGS.has(t))return"That address is reserved."}export const SiteSlugSchema=e.string().superRefine((t,r)=>{const n=slugProblem(t);n!==void 0&&r.addIssue({code:"custom",message:n})}),REDIRECT_STATUSES=[200,301,302,303,307,308,404,410];const s=e.string().min(1).max(1024).regex(/^\/[^\s]*$/u,"A rule's path starts with /.");export const RedirectRuleSchema=e.strictObject({from:s,to:e.string().min(1).max(2048).regex(/^(\/[^\s]*|https?:\/\/[^\s]+)$/u,"A rule goes to a path or an http(s) address."),status:e.union(REDIRECT_STATUSES.map(t=>e.literal(t))),force:e.boolean()}),PLATFORM_HEADERS=new Set(["accept-ranges","connection","content-encoding","content-length","content-range","date","keep-alive","set-cookie","strict-transport-security","trailer","transfer-encoding","upgrade","x-content-type-options"]);const p=e.string().regex(/^[A-Za-z0-9-]+$/u).max(128).refine(t=>!PLATFORM_HEADERS.has(t.toLowerCase()),"That header is the platform's.");export const HeaderRuleSchema=e.strictObject({for:s,set:e.record(p,e.string().max(2048))}),SiteManifestSchema=e.strictObject({format:e.literal(SITE_MANIFEST_FORMAT),files:e.record(a,i),redirects:e.array(RedirectRuleSchema).max(SITE_LIMITS.redirects),headers:e.array(HeaderRuleSchema).max(SITE_LIMITS.headers)}),SITE_SOURCE_KINDS=["upload","git"],SiteSourceSchema=e.strictObject({kind:e.enum(SITE_SOURCE_KINDS),commit:e.string().min(1).max(64).optional(),digest:o.optional()}),DeploymentSchema=e.object({id:e.string(),siteId:e.string(),source:e.object({...SiteSourceSchema.shape,kind:c(SITE_SOURCE_KINDS)}),note:e.string().nullable(),files:e.number(),bytes:e.number(),createdBy:e.string(),createdAt:e.iso.datetime(),live:e.boolean()}),SiteSchema=e.object({id:e.string(),slug:e.string(),name:e.string(),url:e.url(),liveDeployment:e.string().nullable(),approved:e.boolean(),autoPublish:e.boolean(),indexing:e.boolean(),createdAt:e.iso.datetime()}),SITES_PATH="/api/sites",SiteCreateSchema=e.strictObject({slug:SiteSlugSchema,name:e.string().min(1).max(255)}),SitesResponseSchema=e.object({sites:e.array(SiteSchema),domain:e.string(),hosting:e.boolean()}),sitePath=t=>`${SITES_PATH}/${encodeURIComponent(t)}`,SiteDetailSchema=e.object({site:SiteSchema,deployments:e.array(DeploymentSchema)}),siteBlobsPath=t=>`${sitePath(t)}/blobs`,siteDeploymentsPath=t=>`${sitePath(t)}/deployments`,DeploymentCreateSchema=e.strictObject({manifest:o,source:SiteSourceSchema,note:e.string().max(500).optional()}),DeploymentMadeSchema=e.object({site:SiteSchema,deployment:DeploymentSchema}),siteLivePath=t=>`${sitePath(t)}/live`,SiteLiveSchema=e.strictObject({deployment:e.string().min(1)}),SiteLiveAnswerSchema=e.object({site:SiteSchema,live:e.boolean(),confirm:e.url().optional()}),SITE_PERSON_QUERY="person=1",SITE_CONFIRM_PAGE="/publish",siteConfirmPath=t=>`${SITE_CONFIRM_PAGE}?site=${encodeURIComponent(t.site)}&version=${encodeURIComponent(t.version)}&org=${encodeURIComponent(t.organization)}`,siteSettingsPath=t=>`${sitePath(t)}/settings`,SiteSettingsSchema=e.strictObject({autoPublish:e.boolean().optional(),indexing:e.boolean().optional()}),SitePointerSchema=e.object({site:e.string(),organization:e.string(),deployment:e.string(),manifest:o,indexing:e.boolean()}),sitePointerKey=t=>`host:${t}`;

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

@@ -0,0 +1,377 @@
+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/";
+    /** A deck's component pictures, 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 deck's component picture in the tree, by its key (`slides/component-stills`'): a transparent WebP that never changes. */
+export declare const stillPath: (key: string) => string;
+/**
+ * Where a deck version's component pictures are listed in a snapshot's
+ * tree: every component its slides show as they are edited, drawn when
+ * the snapshot was made, so a read view answers `slides/component-stills`
+ * for any of them.
+ */
+export declare const stillsIndexPath: (item: string, version: string) => string;
+/** A deck 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 `slides/component-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`;
+ *   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;
+//# sourceMappingURL=snapshots.d.ts.map