@loopbacktools/server 0.0.0-stage → 0.4.1

package/dist/src/generated/schemas.gen.js

@@ -0,0 +1,306 @@
+// GENERATED by typespec-http-zod from the TypeSpec service definition. DO NOT EDIT.
+// Regenerate with: pnpm generate
+import { z } from "zod";
+import { SPEC_VOCABULARIES } from "@loopbacktools/protocol";
+/** Wire text as the JSON value it spells that the schema accepts: a number, a boolean, or the text. */
+function wireRead(raw, schema) {
+    if (typeof raw !== "string")
+        return raw;
+    const readings = [];
+    if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(raw) && Number.isFinite(Number(raw))) {
+        readings.push(Number(raw));
+    }
+    if (raw === "true" || raw === "false")
+        readings.push(raw === "true");
+    for (const reading of [...readings, raw])
+        if (schema.safeParse(reading).success)
+            return reading;
+    return readings[0] ?? raw;
+}
+export const problemSchema = z.strictObject({
+    code: z.string().describe("A stable, machine-readable reason, such as `ask.closed`."),
+    message: z.string(),
+}).describe("Why a request was refused.");
+export const actorSchema = z.strictObject({
+    id: z.string().describe("Stable within the deployment, as its gate names them."),
+    name: z.string().exactOptional().describe("How to show them, when the gate knows."),
+}).describe("Someone a deployment's gate recognised: a person, or the agent they authorised.");
+export const whoamiSchema = z.strictObject({
+    space: z.string(),
+    actor: actorSchema,
+}).describe("Who the caller is.");
+export const eventTicketSchema = z.strictObject({
+    ticket: z.string(),
+    expiresAt: z.iso.datetime({ offset: true }),
+}).describe("A one-time pass onto the event socket, for a client that cannot send headers there, as a browser\ncannot. Offer it as the subprotocol `loopback.ticket.<ticket>` alongside `loopback.v1`. It works\nonce, within a minute, so a copy that turns up in a log is of no use to anyone.");
+export const choiceSchema = z.strictObject({
+    label: z.string().min(1).max(80),
+    description: z.string().exactOptional(),
+}).describe("A choice offered with a question.");
+export const questionPromptSchema = z.strictObject({
+    question: z.string(),
+    options: z.array(choiceSchema),
+    multiple: z.boolean(),
+    context: z.string().exactOptional(),
+}).describe("A question as it is shown to the person.");
+export const askStatusSchema = z.enum(SPEC_VOCABULARIES.AskStatus).describe("Where an ask stands. While it is open, it is either the person's move or the agent's.");
+export const answeredSchema = z.strictObject({
+    outcome: z.literal("answered"),
+    selected: z.array(z.string()),
+    text: z.string().exactOptional(),
+}).describe("An answer to a question: the choices picked, words of their own, or both.");
+export const approvedSchema = z.strictObject({
+    outcome: z.literal("approved"),
+    note: z.string().exactOptional(),
+}).describe("A review approved, with an optional note.");
+export const changesRequestedSchema = z.strictObject({
+    outcome: z.literal("changes_requested"),
+    feedback: z.string().min(1),
+}).describe("A review sent back with feedback.");
+export const followUpSchema = z.strictObject({
+    outcome: z.literal("follow_up"),
+    question: z.string().min(1),
+}).describe("A question asked back before deciding. The ask stays open until the agent answers.");
+export const dismissedSchema = z.strictObject({
+    outcome: z.literal("dismissed"),
+}).describe("Declined without an answer.");
+export const pointReplySchema = z.strictObject({
+    point: z.string().min(1),
+    text: z.string().exactOptional().describe("What they said: a question, a push-back or a comment."),
+    resolved: z.boolean().exactOptional().describe("Whether they are done with the point, and everything beneath it."),
+}).describe("The person on one point of a briefing: words, resolved, or both.");
+export const respondedSchema = z.strictObject({
+    outcome: z.literal("responded"),
+    points: z.array(pointReplySchema).min(1),
+}).describe("Replies on the points of a briefing. The agent answers every point written on and left unresolved;\nthe briefing closes once every point is resolved.");
+export const replySchema = z.union([answeredSchema, approvedSchema, changesRequestedSchema, followUpSchema, dismissedSchema, respondedSchema]).describe("What a person replies. A `follow_up` hands the move to the agent; so does a `responded` that\nleaves any point unresolved. Every other reply closes the ask.");
+export const humanEntrySchema = z.strictObject({
+    author: z.literal("human"),
+    reply: replySchema,
+    by: actorSchema.exactOptional().describe("Who replied, when the deployment knows."),
+    at: z.iso.datetime({ offset: true }),
+}).describe("A reply the person gave.");
+export const markdownBlockSchema = z.strictObject({
+    type: z.literal("markdown"),
+    text: z.string().min(1),
+}).describe("Prose, copy or a plan, as GitHub-flavoured markdown.");
+export const codeBlockSchema = z.strictObject({
+    type: z.literal("code"),
+    code: z.string().min(1),
+    language: z.string().exactOptional().describe("A language name the highlighter knows, such as `ts` or `python`."),
+    filename: z.string().exactOptional(),
+}).describe("Source code, shown highlighted.");
+export const diffBlockSchema = z.strictObject({
+    type: z.literal("diff"),
+    diff: z.string().min(1),
+    filename: z.string().exactOptional(),
+}).describe("A unified diff, as `git diff` prints it.");
+export const imageBlockSchema = z.strictObject({
+    type: z.literal("image"),
+    uploadId: z.string().min(1),
+    caption: z.string().exactOptional(),
+}).describe("An image uploaded beforehand through an upload ticket.");
+export const blockSchema = z.union([markdownBlockSchema, codeBlockSchema, diffBlockSchema, imageBlockSchema]).describe("One piece of what is shown to the person.");
+export const pointSchema = z.strictObject({
+    id: z.string().describe("`3` for the third point of the briefing, `3.1` for the first beneath it."),
+    title: z.string().min(1).max(200).describe("The point in one line, shown while it is folded."),
+    detail: z.string().exactOptional().describe("The point explained, as markdown, shown when the person opens it."),
+    content: z.array(blockSchema).exactOptional().describe("Anything to look at with it: code, a diff or an image."),
+}).describe("A point of a briefing as it is shown, with the id replies name it by.");
+export const agentEntrySchema = z.strictObject({
+    author: z.literal("agent"),
+    answer: z.string(),
+    content: z.array(blockSchema).exactOptional(),
+    point: z.string().exactOptional().describe("The briefing point this answers."),
+    points: z.array(pointSchema).exactOptional().describe("Sub-points the answer broke the point into, with their ids."),
+    at: z.iso.datetime({ offset: true }),
+}).describe("An answer the agent gave: to a question asked back, or on one point of a briefing.");
+export const entrySchema = z.union([humanEntrySchema, agentEntrySchema]).describe("One turn in an ask's thread after it was opened.");
+export const questionAskSchema = z.strictObject({
+    kind: z.literal("question"),
+    prompt: questionPromptSchema,
+    id: z.string(),
+    status: askStatusSchema,
+    waiting: z.boolean().describe("Whether an agent is following this ask right now: waiting on its call, or polling it as a background task."),
+    project: z.string().exactOptional(),
+    client: z.string().exactOptional().describe("The MCP client that asked, such as `claude-code 2.1.0`."),
+    raisedBy: actorSchema.exactOptional().describe("Whose agent asked: the person its credential belongs to, when the deployment knows."),
+    thread: z.array(entrySchema).describe("Every turn after the ask was opened, oldest first."),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    closedAt: z.iso.datetime({ offset: true }).exactOptional(),
+}).describe("A question an agent asked.");
+export const reviewPromptSchema = z.strictObject({
+    title: z.string(),
+    content: z.array(blockSchema),
+    summary: z.string().exactOptional(),
+}).describe("A review as it is shown to the person.");
+export const reviewAskSchema = z.strictObject({
+    kind: z.literal("review"),
+    prompt: reviewPromptSchema,
+    revises: z.string().exactOptional().describe("The id of the review this one revises."),
+    id: z.string(),
+    status: askStatusSchema,
+    waiting: z.boolean().describe("Whether an agent is following this ask right now: waiting on its call, or polling it as a background task."),
+    project: z.string().exactOptional(),
+    client: z.string().exactOptional().describe("The MCP client that asked, such as `claude-code 2.1.0`."),
+    raisedBy: actorSchema.exactOptional().describe("Whose agent asked: the person its credential belongs to, when the deployment knows."),
+    thread: z.array(entrySchema).describe("Every turn after the ask was opened, oldest first."),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    closedAt: z.iso.datetime({ offset: true }).exactOptional(),
+}).describe("Work an agent put up for review.");
+export const briefingPromptSectionSchema = z.strictObject({
+    title: z.string().exactOptional(),
+    points: z.array(pointSchema),
+}).describe("A list of a briefing's points as it is shown.");
+export const briefingPromptSchema = z.strictObject({
+    title: z.string(),
+    summary: z.string().exactOptional(),
+    sections: z.array(briefingPromptSectionSchema),
+}).describe("A briefing as it is shown to the person, before any sub-points the agent adds while answering.");
+export const briefingAskSchema = z.strictObject({
+    kind: z.literal("briefing"),
+    prompt: briefingPromptSchema,
+    id: z.string(),
+    status: askStatusSchema,
+    waiting: z.boolean().describe("Whether an agent is following this ask right now: waiting on its call, or polling it as a background task."),
+    project: z.string().exactOptional(),
+    client: z.string().exactOptional().describe("The MCP client that asked, such as `claude-code 2.1.0`."),
+    raisedBy: actorSchema.exactOptional().describe("Whose agent asked: the person its credential belongs to, when the deployment knows."),
+    thread: z.array(entrySchema).describe("Every turn after the ask was opened, oldest first."),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    closedAt: z.iso.datetime({ offset: true }).exactOptional(),
+}).describe("Points an agent explained, for the person to reply on one at a time.");
+export const askSchema = z.union([questionAskSchema, reviewAskSchema, briefingAskSchema]).describe("Something an agent needs from a person: a short thread that ends with a reply.");
+export const snapshotSchema = z.strictObject({
+    open: z.array(askSchema),
+    recent: z.array(askSchema),
+}).describe("Open asks, newest first, and the most recently closed.");
+export const askPageSchema = z.strictObject({
+    items: z.array(askSchema),
+    nextBefore: z.iso.datetime({ offset: true }).exactOptional().describe("Pass as `before` for the next page. Absent on the last page."),
+}).describe("A page of closed asks, newest first.");
+export const imageTypeSchema = z.enum(["image/png", "image/jpeg", "image/webp", "image/gif"]).describe("Image formats an agent may upload for a review.");
+export const uploadReceiptSchema = z.strictObject({
+    uploadId: z.string(),
+    contentType: imageTypeSchema,
+    size: z.int32(),
+}).describe("A stored upload.");
+export const revisionsSchema = z.enum(SPEC_VOCABULARIES.Revisions).describe("The contract's revisions, oldest first. Change the shape of any message and declare it here as a\nnew revision, marking what changed with `@added`, `@removed`, `@renamedFrom` or `@typeChangedFrom`:\nevery part of a deployment names the revision it writes, and newer code upgrades older messages.\nNever edit a revision that has shipped; `revisions/` holds each one frozen, and a test fails when\nthe contract no longer emits it unchanged. See docs/design/versioned-messages.md.");
+export const askKindSchema = z.enum(SPEC_VOCABULARIES.AskKind).describe("What an agent is asking for: an answer to a question, a verdict on something it produced, or the\nperson's word on each point of something it explained.");
+export const briefingPointSchema = z.strictObject({
+    title: z.string().min(1).max(200).describe("The point in one line, shown while it is folded."),
+    detail: z.string().exactOptional().describe("The point explained, as markdown, shown when the person opens it."),
+    content: z.array(blockSchema).exactOptional().describe("Anything to look at with it: code, a diff or an image."),
+}).describe("One point of a briefing: a line the person sees folded, and what opens beneath it.");
+export const briefingSectionSchema = z.strictObject({
+    title: z.string().exactOptional(),
+    points: z.array(briefingPointSchema).min(1),
+}).describe("A list of points under an optional heading.");
+export const questionInputSchema = z.strictObject({
+    question: z.string().min(1).describe("The question, as markdown."),
+    options: z.array(choiceSchema).min(2).max(6).exactOptional().describe("Between two and six choices, offered as buttons."),
+    multiple: z.boolean().exactOptional().describe("Whether the person may pick more than one choice."),
+    context: z.string().exactOptional().describe("Background the person needs to answer, as markdown."),
+    project: z.string().min(1).describe("The project you are working in: the name of the folder at the root of its repository (the\nlast part of `git rev-parse --show-toplevel`), or of the working directory outside one. The\nperson works on many projects at once from one inbox; this is how they know who is asking."),
+}).describe("A question for the person, with optional choices. They may always answer in their own words. All\nof it together may be at most 256 KiB.");
+export const reviewInputSchema = z.strictObject({
+    title: z.string().min(1).max(200),
+    content: z.array(blockSchema).min(1).describe("What is being reviewed, in order."),
+    summary: z.string().exactOptional().describe("What changed, or what to look at."),
+    revises: z.string().exactOptional().describe("The id of the review this one revises, after changes were requested."),
+    project: z.string().min(1).describe("The project you are working in: the name of the folder at the root of its repository (the\nlast part of `git rev-parse --show-toplevel`), or of the working directory outside one. The\nperson works on many projects at once from one inbox; this is how they know who is asking."),
+}).describe("Work put in front of the person for approval or feedback. All of it together may be at most\n256 KiB: show the part that matters, or split it into several reviews.");
+export const briefingInputSchema = z.strictObject({
+    title: z.string().min(1).max(200),
+    summary: z.string().exactOptional().describe("What this explains, and why, as markdown."),
+    sections: z.array(briefingSectionSchema).min(1).describe("The points, in lists under optional headings."),
+    project: z.string().min(1).describe("The project you are working in: the name of the folder at the root of its repository (the\nlast part of `git rev-parse --show-toplevel`), or of the working directory outside one. The\nperson works on many projects at once from one inbox; this is how they know who is asking."),
+}).describe("Something explained as points the person can reply on one at a time: findings, options, steps, a\nlist of changes. They may write on any point, or mark it resolved, and you answer on each point\nthey wrote on until every point is resolved. Points are numbered for you, straight through every\nsection: at most fifty. All of it together may be at most 256 KiB.");
+export const pointAnswerSchema = z.strictObject({
+    point: z.string().min(1).describe("The point's id, such as `3` or `3.1`."),
+    answer: z.string().min(1).describe("The answer, as markdown."),
+    content: z.array(blockSchema).exactOptional().describe("Anything new to look at alongside the answer."),
+    points: z.array(briefingPointSchema).exactOptional().describe("Sub-points this point breaks into, numbered beneath it (`3.1`, `3.2`, \u2026), each of which the\nperson can reply on in turn. Points go at most three levels deep."),
+}).describe("Your answer on one point of a briefing.");
+export const briefingAnswerInputSchema = z.strictObject({
+    askId: z.string().min(1),
+    answers: z.array(pointAnswerSchema).min(1),
+}).describe("Your answers on a briefing, one per point: every point the person wrote on without resolving it,\nand any other open point you have more to say on. All of it together may be at most 256 KiB.");
+export const followUpInputSchema = z.strictObject({
+    askId: z.string().min(1),
+    answer: z.string().min(1).describe("The answer, as markdown."),
+    content: z.array(blockSchema).exactOptional().describe("Anything new to look at alongside the answer."),
+}).describe("The agent's answer to a question the person asked back, with its content at most 256 KiB.");
+export const uploadRequestSchema = z.strictObject({
+    contentType: imageTypeSchema,
+}).describe("A request for somewhere to upload an image.");
+export const uploadTicketSchema = z.strictObject({
+    uploadId: z.string(),
+    uploadUrl: z.string().describe("Send the image here with `PUT` and its `Content-Type`. No credentials needed."),
+    expiresAt: z.iso.datetime({ offset: true }),
+    maxBytes: z.int32(),
+    command: z.string().describe("A ready-to-run command that performs the upload; replace `FILE` with the image's path."),
+}).describe("Where to upload an image, once, before it expires.");
+export const inboxRequestSchema = z.strictObject({
+    askId: z.string().exactOptional().describe("An ask to open directly. Leave it out for the inbox itself."),
+}).describe("A request for the address of the person's inbox.");
+export const inboxLinkSchema = z.strictObject({
+    url: z.string(),
+}).describe("Where the person reads and answers everything agents ask.");
+export const askCommonSchema = z.strictObject({
+    id: z.string(),
+    status: askStatusSchema,
+    waiting: z.boolean().describe("Whether an agent is following this ask right now: waiting on its call, or polling it as a background task."),
+    project: z.string().exactOptional(),
+    client: z.string().exactOptional().describe("The MCP client that asked, such as `claude-code 2.1.0`."),
+    raisedBy: actorSchema.exactOptional().describe("Whose agent asked: the person its credential belongs to, when the deployment knows."),
+    thread: z.array(entrySchema).describe("Every turn after the ask was opened, oldest first."),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    closedAt: z.iso.datetime({ offset: true }).exactOptional(),
+}).describe("What every ask carries, whatever its kind.");
+export const toolReplySchema = z.strictObject({
+    askId: z.string(),
+    reply: replySchema,
+}).describe("What a blocking MCP tool returns: the reply that ended its wait.");
+export const snapshotEventSchema = z.strictObject({
+    type: z.literal("snapshot"),
+    snapshot: snapshotSchema,
+}).describe("The first frame on the event socket, and the state to start from.");
+export const askEventSchema = z.strictObject({
+    type: z.enum(["ask.opened", "ask.updated"]),
+    ask: askSchema,
+}).describe("An ask was opened, or changed: a new turn, a close, or an agent starting or stopping following it.");
+export const serverEventSchema = z.union([snapshotEventSchema, askEventSchema]).describe("A frame on the event socket.");
+export const Session_whoamiResponses = [{ status: 200, schema: whoamiSchema, contentTypes: ["application/json"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }];
+export const EventTickets_issueResponses = [{ status: 201, schema: eventTicketSchema, contentTypes: ["application/json"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }];
+export const Snapshots_readResponses = [{ status: 200, schema: snapshotSchema, contentTypes: ["application/json"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }];
+export const Asks_listQuery = z.object({
+    before: z.iso.datetime({ offset: true }).exactOptional().describe("Only asks closed before this moment."),
+    limit: z.preprocess((raw) => wireRead(raw, z.int32().min(1).max(100).exactOptional()), z.int32().min(1).max(100).exactOptional()),
+});
+export const Asks_listResponses = [{ status: 200, schema: askPageSchema, contentTypes: ["application/json"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }];
+export const Asks_readPath = z.object({
+    id: z.string(),
+});
+export const Asks_readResponses = [{ status: 200, schema: askSchema, contentTypes: ["application/json"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }, { status: 404, schema: problemSchema, contentTypes: ["application/json"] }];
+export const Asks_replyPath = z.object({
+    id: z.string(),
+});
+export const Asks_replyResponses = [{ status: 200, schema: askSchema, contentTypes: ["application/json"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }, { status: 404, schema: problemSchema, contentTypes: ["application/json"] }, { status: 409, schema: problemSchema, contentTypes: ["application/json"] }, { status: 422, schema: problemSchema, contentTypes: ["application/json"] }];
+export const Files_readPath = z.object({
+    uploadId: z.string(),
+});
+export const Files_readResponse200 = z.unknown();
+export const Files_readResponses = [{ status: 200, schema: Files_readResponse200, contentTypes: ["image/png", "image/jpeg", "image/webp", "image/gif"] }, { status: 401, schema: problemSchema, contentTypes: ["application/json"] }, { status: 404, schema: problemSchema, contentTypes: ["application/json"] }];
+export const Uploads_storePath = z.object({
+    spaceId: z.string(),
+    token: z.string(),
+});
+export const Uploads_storeHeader = z.object({
+    "Content-Type": z.string(),
+});
+export const Uploads_storeResponses = [{ status: 201, schema: uploadReceiptSchema, contentTypes: ["application/json"] }, { status: 404, schema: problemSchema, contentTypes: ["application/json"] }, { status: 410, schema: problemSchema, contentTypes: ["application/json"] }, { status: 413, schema: problemSchema, contentTypes: ["application/json"] }, { status: 422, schema: problemSchema, contentTypes: ["application/json"] }];

package/dist/src/generated/wire-contract.gen.d.ts

@@ -0,0 +1,77 @@
+import type { z } from "zod";
+import type * as Contracts from "@loopbacktools/protocol";
+import type { replySchema, whoamiSchema, problemSchema, eventTicketSchema, askSchema, snapshotSchema, askPageSchema, uploadReceiptSchema } from "./schemas.gen.js";
+/**
+ * Exact structural equality. The naive `A extends B ? B extends A` form reports two object types
+ * equal when one has an optional property the other lacks, which is the whole class of drift this
+ * exists to catch; the identity-function comparison does not.
+ */
+type Identical<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => (T extends B ? 1 : 2) ? true : ["the emitted validator and the shared wire type describe different shapes"];
+/**
+ * A shape with its index signatures removed, at every depth.
+ *
+ * **The two sides of this contract differ on exactly one axis, deliberately.** For an open model the
+ * validator's output carries `[key: string]: unknown`, because a loose parse really does pass
+ * unknown keys through. The shared wire type does not, because it is a FLOOR - the properties a
+ * producer must supply - and an index signature there is an obligation on the producer rather than a
+ * description of the payload. TypeScript gives an interface no implicit index signature, so carrying
+ * it made the published shape unsatisfiable by most domain types.
+ *
+ * So this comparison is over DECLARED PROPERTIES, the only claim both sides make. **That the
+ * validator is open wherever the document is open has not stopped being checked** - it is asserted
+ * directly by the emitter's own suite now, instead of falling out of this comparison as a side
+ * effect. Every other kind of drift still fails here exactly as before.
+ *
+ * Applied to the INFERRED side only. If the shared type ever grew an index signature of its own that
+ * is a real disagreement, and this still catches it.
+ *
+ * Deep, because openness recurs: a nested open model puts one at every level, which is why a single
+ * spread never repaired the shape it was supposed to repair.
+ *
+ * **An index signature arrives two ways and only one of them is openness.** A model spreading
+ * `...Record<unknown>` gains one because its validator is loose - a fact about the MODEL, which the
+ * contract type does not state, so it is stripped. A property declared `Record<unknown>` gains one
+ * because that IS its type, stated identically in both artefacts, and stripping it destroys the
+ * property: `Declared<Record<string, unknown>>` became `{}`, and any spec with a dictionary
+ * property emitted an assertion that does not compile.
+ *
+ * The two are told apart the same way `types.ts` already tells them apart: **a string indexer means
+ * "dictionary" only when there are no declared properties beside it.** So the index signature is
+ * dropped from a shape that has other keys, and kept - with its value type still mapped - from one
+ * that does not.
+ */
+type DeclaredKeyOf<T> = keyof {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: 0;
+};
+type Declared<T> = T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? {
+    [K in keyof T]: Declared<T[K]>;
+} : T extends object ? [DeclaredKeyOf<T>] extends [never] ? [T[keyof T]] extends [never] ? {} : {
+    [K in keyof T]: Declared<T[K]>;
+} : {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: Declared<T[K]>;
+} : T;
+/**
+ * **The contract type with its intersections written out**, as `Declared` writes out the validator's:
+ * `(A) & (Inner)` - a redeclaration merged with a `@oneOf` union it cannot be merged into key by key
+ * - and the one object type a mapping makes of it are one shape, which the identity check below tells
+ * apart by spelling. Mapped and nothing dropped, so an index signature the contract states is still
+ * compared.
+ */
+type Flat<T> = T extends (...args: never[]) => unknown ? T : T extends object ? [keyof T] extends [never] ? {} : {
+    [K in keyof T]: Flat<T[K]>;
+} : T;
+/**
+ * **The constraint is what fails the build.** `Identical<A, B> & true` merely produces an odd
+ * type when the two disagree, and a type alias to an odd type compiles fine - an assertion that
+ * asserts nothing. Only a constraint violation is an error.
+ */
+type MustHold<T extends true> = T;
+export type AssertReply = MustHold<Identical<Declared<z.input<typeof replySchema>>, Flat<Contracts.Reply>>>;
+export type AssertWhoami = MustHold<Identical<Declared<z.input<typeof whoamiSchema>>, Flat<Contracts.Whoami>>>;
+export type AssertProblem = MustHold<Identical<Declared<z.input<typeof problemSchema>>, Flat<Contracts.Problem>>>;
+export type AssertEventTicket = MustHold<Identical<Declared<z.input<typeof eventTicketSchema>>, Flat<Contracts.EventTicket>>>;
+export type AssertAsk = MustHold<Identical<Declared<z.input<typeof askSchema>>, Flat<Contracts.Ask>>>;
+export type AssertSnapshot = MustHold<Identical<Declared<z.input<typeof snapshotSchema>>, Flat<Contracts.Snapshot>>>;
+export type AssertAskPage = MustHold<Identical<Declared<z.input<typeof askPageSchema>>, Flat<Contracts.AskPage>>>;
+export type AssertUploadReceipt = MustHold<Identical<Declared<z.input<typeof uploadReceiptSchema>>, Flat<Contracts.UploadReceipt>>>;
+export {};

package/dist/src/generated/wire-contract.gen.js

@@ -0,0 +1,3 @@
+// GENERATED by typespec-http-zod from the TypeSpec service definition. DO NOT EDIT.
+// Regenerate with: pnpm generate
+export {};

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export { createLoopback, type LoopbackOptions } from "./loopback.ts";
+export { VERSION } from "./version.ts";
+export { Space } from "./space/object.ts";
+export { Declined, Unauthorized } from "./domain/errors.ts";
+export type { Declinable, SpaceClient } from "./space/rpc.ts";
+export { eraseSpace, Spaces } from "./worker/spaces.ts";
+export type { LoopbackBindings, WorkerBindings } from "./worker/env.ts";
+export { WorkerEnv } from "./worker/env.ts";
+export { type Access, credentialOf, DEFAULT_SPACE, Gate, NotConfigured, TokenGate, } from "./worker/gate.ts";
+export { ConfiguredGate, jwtGate, type JwtGateOptions } from "./worker/jwt.ts";
+export type { InboxLink } from "./worker/mcp.ts";

package/dist/src/index.js

@@ -0,0 +1,8 @@
+export { createLoopback } from "./loopback.js";
+export { VERSION } from "./version.js";
+export { Space } from "./space/object.js";
+export { Declined, Unauthorized } from "./domain/errors.js";
+export { eraseSpace, Spaces } from "./worker/spaces.js";
+export { WorkerEnv } from "./worker/env.js";
+export { credentialOf, DEFAULT_SPACE, Gate, NotConfigured, TokenGate, } from "./worker/gate.js";
+export { ConfiguredGate, jwtGate } from "./worker/jwt.js";

package/dist/src/loopback.d.ts

@@ -0,0 +1,27 @@
+import type { Layer } from "effect";
+import type { LoopbackBindings, WorkerEnv } from "./worker/env.ts";
+import type { Gate } from "./worker/gate.ts";
+import { type InboxLink } from "./worker/mcp.ts";
+import { Spaces } from "./worker/spaces.ts";
+export interface LoopbackOptions {
+    /** Decides who each request is from and which space it opens. */
+    readonly gate: Layer.Layer<Gate, never, WorkerEnv>;
+    /**
+     * How requests reach their spaces. The Worker's own `Space` objects unless said otherwise: a host
+     * wraps `Spaces.layer` to meter what its tenants open, or to decline it with a reason.
+     */
+    readonly spaces?: Layer.Layer<Spaces, never, WorkerEnv>;
+    /**
+     * Where the person reads and answers a space's asks, which `open_inbox` gives agents. This
+     * Worker's own inbox unless said otherwise: a host whose frontend lives elsewhere, or routes by
+     * space, says where.
+     */
+    readonly inboxUrl?: (link: InboxLink) => string;
+}
+/**
+ * A Loopback Worker's `fetch` handler. The deployment exports it as its default, beside the `Space`
+ * Durable Object class declared with SQLite storage, and binds `FILES`.
+ */
+export declare const createLoopback: (options: LoopbackOptions) => {
+    fetch: (request: Request, env: LoopbackBindings, ctx: ExecutionContext) => Promise<Response> | Response;
+};

package/dist/src/loopback.js

@@ -0,0 +1,16 @@
+import { makeApp } from "./worker/http.js";
+import { defaultInboxUrl } from "./worker/mcp.js";
+import { runtimes } from "./worker/run.js";
+import { Spaces } from "./worker/spaces.js";
+/**
+ * A Loopback Worker's `fetch` handler. The deployment exports it as its default, beside the `Space`
+ * Durable Object class declared with SQLite storage, and binds `FILES`.
+ */
+export const createLoopback = (options) => {
+    const app = makeApp(runtimes(options.gate, options.spaces ?? Spaces.layer), options.inboxUrl ?? defaultInboxUrl);
+    return {
+        // Any environment that declares Loopback's bindings: the host's own type, such as the one
+        // `wrangler types` writes, need not say it holds nothing else.
+        fetch: (request, env, ctx) => app.fetch(request, env, ctx),
+    };
+};

package/dist/src/space/arguments.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import type { Operations } from "./operations.ts";
+/**
+ * A call's arguments, decoded for its operation. Arguments that don't decode, or that hold something
+ * from a newer revision, are a fault in the caller: the operation never runs on them, and nothing is
+ * kept. A caller on a newer revision is refused as `Outdated` before this.
+ */
+export declare const readArguments: <K extends keyof Operations>(method: K, args: readonly unknown[]) => Effect.Effect<Parameters<Operations[K]>>;

package/dist/src/space/arguments.js

@@ -0,0 +1,52 @@
+import * as Contract from "@loopbacktools/protocol/schema";
+import { Effect, Result, Schema } from "effect";
+import { read } from "./read.js";
+/**
+ * What each space operation takes, as the space decodes it before running anything: the contract's
+ * messages with the schemas generated from it, and the ids and numbers beside them. Nothing a call
+ * passes is run unread. See docs/design/versioned-messages.md.
+ */
+const Id = Schema.String;
+const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const opening = (kind, input) => Schema.Struct({
+    kind: Schema.Literal(kind),
+    input,
+    client: Schema.optionalKey(Schema.String),
+    actor: Contract.Actor,
+});
+const OpenRequest = Schema.Union([
+    opening("question", Contract.QuestionInput),
+    opening("review", Contract.ReviewInput),
+    opening("briefing", Contract.BriefingInput),
+]);
+const taking = {
+    open: Schema.Tuple([OpenRequest]),
+    answerFollowUp: Schema.Tuple([Contract.FollowUpInput]),
+    answerBriefing: Schema.Tuple([Contract.BriefingAnswerInput]),
+    awaitReply: Schema.Tuple([Id, Count]),
+    markDelivered: Schema.Tuple([Id, Count]),
+    followTask: Schema.Tuple([Id, Count]),
+    cancelTask: Schema.Tuple([Id, Count]),
+    reply: Schema.Tuple([Id, Contract.Reply, Contract.Actor]),
+    get: Schema.Tuple([Id]),
+    snapshot: Schema.Tuple([]),
+    history: Schema.Tuple([Schema.UndefinedOr(Schema.String), Count]),
+    createUpload: Schema.Tuple([Contract.ImageType]),
+    claimUpload: Schema.Tuple([Schema.String, Schema.String]),
+    completeUpload: Schema.Tuple([Id, Count]),
+    findUpload: Schema.Tuple([Id]),
+    issueTicket: Schema.Tuple([Id]),
+    redeemTicket: Schema.Tuple([Schema.String]),
+};
+/** The compiler's check that every operation has a schema, and that none refuses what it accepts. */
+const everyOperationRead = true;
+void everyOperationRead;
+/**
+ * A call's arguments, decoded for its operation. Arguments that don't decode, or that hold something
+ * from a newer revision, are a fault in the caller: the operation never runs on them, and nothing is
+ * kept. A caller on a newer revision is refused as `Outdated` before this.
+ */
+export const readArguments = (method, args) => Result.match(read(taking[method], args), {
+    onSuccess: (decoded) => Effect.succeed(decoded),
+    onFailure: (why) => Effect.die(new Error(`Space.${method} can't read its arguments: ${why}`)),
+});

package/dist/src/space/migrations.d.ts

@@ -0,0 +1,10 @@
+import { SqliteMigrator } from "@effect/sql-sqlite-do";
+import { SqlClient } from "effect/sql";
+/**
+ * Gives every review kept without content a note saying so. A space still on code from before
+ * briefings, reached during a deploy by a Worker that knew them, kept a briefing as a review with
+ * no content: a record the contract refuses, which no inbox could show and no reply could return.
+ */
+export declare const REPAIR_CONTENTLESS_REVIEWS = "\n\tUPDATE asks\n\tSET prompt = json_set(\n\t\tprompt,\n\t\t'$.content',\n\t\tjson('[{\"type\":\"markdown\",\"text\":\"This arrived while Loopback was being updated, and what it showed was lost. Dismiss it, and the agent can send it again.\"}]')\n\t)\n\tWHERE kind = 'review' AND json_extract(prompt, '$.content') IS NULL\n";
+/** The space's schema, applied in order when its object starts. Never edit one that has shipped. */
+export declare const migrations: import("effect/Layer").Layer<never, SqliteMigrator.MigrationError | import("effect/sql/SqlError").SqlError, SqlClient.SqlClient>;

package/dist/src/space/migrations.js

@@ -0,0 +1,106 @@
+import { SqliteMigrator } from "@effect/sql-sqlite-do";
+import { Effect } from "effect";
+import { SqlClient, Migrator } from "effect/sql";
+/**
+ * Gives every review kept without content a note saying so. A space still on code from before
+ * briefings, reached during a deploy by a Worker that knew them, kept a briefing as a review with
+ * no content: a record the contract refuses, which no inbox could show and no reply could return.
+ */
+export const REPAIR_CONTENTLESS_REVIEWS = `
+	UPDATE asks
+	SET prompt = json_set(
+		prompt,
+		'$.content',
+		json('[{"type":"markdown","text":"This arrived while Loopback was being updated, and what it showed was lost. Dismiss it, and the agent can send it again."}]')
+	)
+	WHERE kind = 'review' AND json_extract(prompt, '$.content') IS NULL
+`;
+/** The space's schema, applied in order when its object starts. Never edit one that has shipped. */
+export const migrations = SqliteMigrator.layer({
+    loader: Migrator.fromRecord({
+        "0001_asks": Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            yield* sql `
+				CREATE TABLE asks (
+					id TEXT PRIMARY KEY,
+					kind TEXT NOT NULL,
+					key TEXT NOT NULL,
+					status TEXT NOT NULL,
+					prompt TEXT NOT NULL,
+					project TEXT,
+					client TEXT,
+					revises TEXT,
+					created_at TEXT NOT NULL,
+					updated_at TEXT NOT NULL,
+					closed_at TEXT,
+					last_waited_at TEXT
+				)
+			`;
+            yield* sql `CREATE INDEX asks_by_key ON asks (key)`;
+            yield* sql `CREATE INDEX asks_by_status ON asks (status, created_at)`;
+            yield* sql `CREATE INDEX asks_by_closed_at ON asks (closed_at)`;
+            yield* sql `
+				CREATE TABLE entries (
+					ask_id TEXT NOT NULL REFERENCES asks (id),
+					seq INTEGER NOT NULL,
+					author TEXT NOT NULL,
+					body TEXT NOT NULL,
+					delivered_at TEXT,
+					PRIMARY KEY (ask_id, seq)
+				)
+			`;
+            yield* sql `
+				CREATE TABLE uploads (
+					id TEXT PRIMARY KEY,
+					token_hash TEXT NOT NULL UNIQUE,
+					content_type TEXT NOT NULL,
+					max_bytes INTEGER NOT NULL,
+					status TEXT NOT NULL,
+					size INTEGER,
+					created_at TEXT NOT NULL,
+					expires_at TEXT NOT NULL
+				)
+			`;
+        }),
+        "0002_task_cancellations": Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            // An agent's background task follows the reply to one of its turns. Cancelling it is
+            // remembered, so the task keeps answering "cancelled" rather than going unknown.
+            yield* sql `
+				CREATE TABLE task_cancellations (
+					ask_id TEXT NOT NULL REFERENCES asks (id),
+					after_seq INTEGER NOT NULL,
+					cancelled_at TEXT NOT NULL,
+					PRIMARY KEY (ask_id, after_seq)
+				)
+			`;
+        }),
+        "0003_event_tickets": Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            // One-time passes onto the event socket, for browsers, which cannot send headers there.
+            yield* sql `
+				CREATE TABLE event_tickets (
+					token_hash TEXT PRIMARY KEY,
+					actor_id TEXT NOT NULL,
+					expires_at TEXT NOT NULL
+				)
+			`;
+        }),
+        "0004_raised_by": Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            // Whose agent asked, as the gate named them; asks opened before it was recorded have none.
+            yield* sql `ALTER TABLE asks ADD COLUMN raised_by TEXT`;
+        }),
+        "0005_repair_contentless_reviews": Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            yield* sql.unsafe(REPAIR_CONTENTLESS_REVIEWS);
+        }),
+        "0006_revisions": Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            // The revision of the contract each ask and entry was written at. Rows from before it was
+            // recorded are revision 1, as is anything code from before then writes after a rollback.
+            yield* sql `ALTER TABLE asks ADD COLUMN revision INTEGER NOT NULL DEFAULT 1`;
+            yield* sql `ALTER TABLE entries ADD COLUMN revision INTEGER NOT NULL DEFAULT 1`;
+        }),
+    }),
+});