@astrosheep/square 0.3.93 → 0.3.94

package/plugins/paseo/client/palette.ts

@@ -1,34 +1,34 @@
 import type { PluginTheme } from "@getpaseo/plugin";
 
 /**
- * Square's own courtyard palette: cool pewter slate and a cold blue voice,
- * deliberately no relative of notesoup's warm parchment or pi-meantime's
- * neutral carbon. Every token here is opaque and self-contained — the card and
+ * Square's own courtyard palette: Carrara marble (grey-white stone with a
+ * slate-blue vein), deliberately no relative of notesoup's warm parchment or
+ * pi-meantime's neutral carbon. Every token here is opaque and self-contained — the card and
  * Markdown never borrow the host's surface ramp or accent, only its appearance
  * (read from the host ink) and its accentForeground, which paints text on top
  * of an accent fill.
  */
 const DARK = {
-  surface0: "#121519", // inset / code
-  surface1: "#171b20", // card
-  surface2: "#121519", // inset / code
-  border: "#262d36",
-  foreground: "#e6ebf2",
-  foregroundMuted: "#7d8999",
-  accent: "#60a5fa", // plaza ■ / links
+  surface0: "#14171b", // inset / code
+  surface1: "#1c2126", // card
+  surface2: "#14171b", // inset / code
+  border: "#2e353d",
+  foreground: "#e8edf3",
+  foregroundMuted: "#8b96a3",
+  accent: "#8ea8c3", // plaza ■ / links
 } as const;
 
 const LIGHT = {
-  surface0: "#e8edf3",
-  surface1: "#f3f6fa", // pewter slate, not notesoup's warm parchment
-  surface2: "#e8edf3",
-  border: "#d5dee8",
-  foreground: "#141b24",
-  foregroundMuted: "#64748b",
-  accent: "#2563eb",
+  surface0: "#e7ecf1",
+  surface1: "#f2f5f9", // cool marble white
+  surface2: "#e7ecf1",
+  border: "#d2dae3",
+  foreground: "#181d24",
+  foregroundMuted: "#67737f",
+  accent: "#4b6582",
 } as const;
 
-const VOICE = { dark: "#93c5fd", light: "#3b82f6" } as const;
+const VOICE = { dark: "#8b96a3", light: "#67737f" } as const; // grey: only the ■ carries colour
 
 export interface SquarePalette {
   /** Complete theme for the card and its Markdown surfaces. */

package/plugins/paseo/client/square-message.tsx

@@ -28,48 +28,42 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
   const speakers = [...new Set(names.filter((name): name is string => name !== undefined))];
   const squareName = latest?.square ?? blocks[0].meta?.split("·")[1]?.trim() ?? "Square";
   const bell = latest?.route === "bell" || single?.bell === true;
-  const trailing = `· ${squareName}${expanded && single?.actId ? ` · ${single.actId}` : !expanded && items && items.length > 1 ? ` · ${items.length}` : ""}`;
+  // Header is the same in both states; act id is always shown when we know it.
+  const actIds = [...new Set(blocks.flatMap(block => {
+    const id = parseSquareVoice(block.actor, block.meta).actId;
+    return id ? [id] : [];
+  }))];
+  const trailing = `· ${squareName}${actIds.length ? ` · ${actIds.join(", ")}` : ""}${items && items.length > 1 ? ` · ${items.length}` : ""}`;
   const { accent, border, foreground, foregroundMuted: muted, surface1 } = palette.theme.colors;
   const row = { flexDirection: "row" as const, alignItems: "center" as const, gap: 6 };
   const indent = { paddingLeft: 15 };
 
   return (
-    <View style={{ backgroundColor: surface1, borderWidth: StyleSheet.hairlineWidth, borderColor: border, borderRadius: 8, paddingHorizontal: 12, paddingVertical: 9, gap: expanded ? 8 : 3 }}>
+    <View style={{ backgroundColor: surface1, borderWidth: StyleSheet.hairlineWidth, borderColor: border, borderRadius: 4, paddingHorizontal: 12, paddingVertical: 9 }}>
       <Pressable
         accessibilityRole="button"
         accessibilityLabel={`${expanded ? "收起" : "展开"} ${squareName}: ${speakers.join(", ") || "Square"}`}
         aria-expanded={expanded}
         onPress={() => setExpanded(value => !value)}
-        style={({ pressed }) => ({ gap: 3, opacity: pressed ? 0.7 : 1 })}
+        style={({ pressed }) => ({ opacity: pressed ? 0.7 : 1 })}
       >
-        <View style={expanded && multi
-          ? { ...row, paddingBottom: 7, borderBottomWidth: StyleSheet.hairlineWidth, borderBottomColor: border }
-          : row}>
+        <View style={row}>
           <Text style={{ color: accent, fontSize: 9 }}>■</Text>
-          {expanded && multi ? (
-            <>
-              <Text numberOfLines={1} style={{ color: foreground, fontSize: 12.5, fontWeight: "500", flex: 1 }}>{squareName}</Text>
-              <Icon name="ChevronUp" size={15} color={muted} />
-            </>
-          ) : (
-            <>
-              <Text numberOfLines={1} style={{ color: foreground, fontSize: 13, fontWeight: "500", flex: 1 }}>
-                {speakers.join(", ") || "Square"}
-                {bell && <Text style={{ color: muted, fontWeight: "400" }}> · rang the bell</Text>}
-              </Text>
-              <Text style={{ color: muted, fontSize: 12 }}>{trailing}</Text>
-              <Icon name={expanded ? "ChevronUp" : "ChevronDown"} size={15} color={muted} />
-            </>
-          )}
+          <Text numberOfLines={1} style={{ color: foreground, fontSize: 13, fontWeight: "500", flex: 1 }}>
+            {speakers.join(", ") || "Square"}
+            {bell && <Text style={{ color: muted, fontWeight: "400" }}> · rang the bell</Text>}
+          </Text>
+          <Text style={{ color: muted, fontSize: 12 }}>{trailing}</Text>
+          <Icon name={expanded ? "ChevronUp" : "ChevronDown"} size={15} color={muted} />
         </View>
         {!expanded && preview !== undefined && preview !== "" && (
-          <View style={indent}>
+          <View style={{ ...indent, marginTop: 3 }}>
             <SquareInline text={preview} theme={palette.theme} numberOfLines={2} />
           </View>
         )}
       </Pressable>
       {expanded && (
-        <ScrollView style={{ maxHeight: layout.compact ? 280 : 400 }} nestedScrollEnabled>
+        <ScrollView style={{ maxHeight: layout.compact ? 280 : 400, marginTop: 3 }} nestedScrollEnabled>
           {multi ? (
             <View style={{ gap: 10 }}>
               {blocks.map((block, index) => {

package/plugins/pi/square-pi.js

@@ -2,12 +2,12 @@ import path from 'node:path';
 import { Container, Markdown, Spacer, Text } from '@earendil-works/pi-tui';
 import { z } from 'zod/v4';
 
-import { Square } from '../../dist/square-api.js';
+import { Square, harnessOwner } from '../../dist/square-api.js';
 import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolFailure, squareToolFailureText } from '../../dist/square-tools.js';
 
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../../dist/boundary-presentation.js';
 import { operationEnv } from '../../dist/participant-identity.js';
-import { endSessionMemberships } from '../../dist/session-lifecycle.js';
+import { detachSessionSeats, restoreSessionSeats } from '../../dist/session-lifecycle.js';
 import { projectSessionSeats, observeSessionPending, pendingKey } from '../../dist/inbox.js';
 import { previewAttentionBody, renderAttentionDescription, renderAttentionFull } from '../../dist/attention-presentation.js';
 import { formatActivityId } from '../../dist/square-core.js';
@@ -147,7 +147,6 @@ export default function squarePiExtension(pi) {
       label: `Square ${tool.name}`,
       description: tool.description,
       parameters: z.toJSONSchema(tool.inputSchema, { target: 'draft-7' }),
-      outputSchema: { type: 'object', additionalProperties: true },
       exposure: 'codemode',
       namespace: { name: 'square', description: 'A shared square where agents gather to talk, think, and act together.', instructions: SQUARE_TOOL_INSTRUCTIONS },
       async execute(_id, args, signal, _onUpdate, ctx) {
@@ -156,17 +155,15 @@ export default function squarePiExtension(pi) {
           const square = await Square.at({
             cwd: ctx.cwd,
             env: operationEnv('pi', sessionId, process.env),
-            body: { channel: 'pi', session: sessionId },
             path: args.location,
-            participant: args.as,
           }, { signal });
-          let data;
-          try { data = await tool.run(square, args, { signal, observe: true }); }
+          let text;
+          try { text = await tool.run(square, args, { signal }, { owner: harnessOwner({ channel: 'pi', session: sessionId }) }); }
           finally { await square.close(); }
-          return { content: [{ type: 'text', text: tool.render(data, args) ?? '' }], details: data, structuredContent: data };
+          return { content: [{ type: 'text', text }] };
         } catch (error) {
-          const data = { error: squareToolFailure(error, signal) };
-          return { isError: true, content: [{ type: 'text', text: squareToolFailureText(data.error, { location: args.location ?? process.env.SQUARE_LOCATION, participant: args.as }) }], details: data, structuredContent: data };
+          const failure = squareToolFailure(error, signal);
+          return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, { location: args.location ?? process.env.SQUARE_LOCATION, participant: args.as }) }] };
         }
       },
     });
@@ -256,12 +253,13 @@ export default function squarePiExtension(pi) {
     const previous = pendingCancellations.get(id) ?? Promise.resolve();
     let operation;
     operation = previous.then(async () => {
-      const body = { channel: 'pi', session: id };
+      const owner = harnessOwner({ channel: 'pi', session: id });
       const env = sessionEnv(id);
-      const seats = await projectSessionSeats({ body, env });
+      const seats = await projectSessionSeats({ owner, env });
       for (const { location, seat } of seats) {
-        const square = await Square.at({ path: location, env, body, participant: seat.participant });
-        try { await square.cancelDeliveries(seat.participant, seat.generation); }
+        if (seat.attachment !== 'attached') continue;
+        const square = await Square.at({ path: location, env });
+        try { await square.cancelDeliveries(seat.participant, { owner, generation: seat.generation }); }
         finally { await square.close(); }
       }
     }).then(() => {
@@ -307,7 +305,7 @@ export default function squarePiExtension(pi) {
   const wake = async (token, signal) => {
     const boundSessionId = sessionId;
     const env = sessionEnv(boundSessionId);
-    const observer = await observeSessionPending({ channel: 'pi', session: boundSessionId }, env);
+    const observer = await observeSessionPending(harnessOwner({ channel: 'pi', session: boundSessionId }), env);
     try {
       if (signal.aborted || token !== generation) return;
       const armDeferredRetry = () => {
@@ -361,7 +359,7 @@ export default function squarePiExtension(pi) {
         let keepDeferred = false;
         try {
           await presentPendingAtBoundary(
-            { channel: 'pi', session: boundSessionId },
+            harnessOwner({ channel: 'pi', session: boundSessionId }),
             async (content) => {
               if (signal.aborted || currentRunSignal?.aborted) throw new Error('Pi notification delivery cancelled');
               // One card for the human: a compact heading, expandable to the full body.
@@ -428,6 +426,8 @@ export default function squarePiExtension(pi) {
     if (token !== generation || cancellationFailures.has(sessionId)) return;
     watcherAbort = new AbortController();
     const signal = watcherAbort.signal;
+    await restoreSessionSeats(harnessOwner({ channel: 'pi', session: sessionId }), sessionEnv(sessionId), undefined, signal).catch(() => undefined);
+    if (token !== generation || signal.aborted) return;
     watcher = wake(token, signal).catch(() => undefined);
   });
 
@@ -502,6 +502,6 @@ export default function squarePiExtension(pi) {
     currentRunSignal = undefined;
     await stopped;
     await waitForSessionCancellation(endedId);
-    if (endedId) await endSessionMemberships('pi', endedId, endedEnv).catch(() => undefined);
+    if (endedId) await detachSessionSeats('pi', endedId, endedEnv).catch(() => undefined);
   });
 }

package/dist/square-backend.d.ts

@@ -1,13 +0,0 @@
-import type { SqliteSquare } from './sqlite-square.js';
-/** Structural resource contract extracted from the existing implementation.
- * Backends implement the actual resource, not a second operation/policy dispatcher.
- * Host-internal methods may explicitly refuse where their capabilities do not exist. */
-export interface SquareBackend extends Pick<SqliteSquare, keyof SqliteSquare> {
-}
-export interface StdioBackendConfiguration {
-    readonly command: string;
-    readonly args?: readonly string[];
-    readonly cwd?: string;
-    readonly env?: Readonly<Record<string, string>>;
-}
-export type SquareBackends = Readonly<Record<string, StdioBackendConfiguration>>;

package/dist/square-backend.js

@@ -1 +0,0 @@
-export {};

package/dist/square-stdio.d.ts

@@ -1,22 +0,0 @@
-import { type SquareErrorCode, type SquareErrorFacts } from './model.js';
-import type { SquareBackends, SquareBackend } from './square-backend.js';
-import type { ParsedSquareLocation } from './square-location.js';
-import type { OperationControl, OperationFailureDetail, SquareAtInput, SquareBuildInput } from './square-facade.js';
-export declare const STDIO_PROTOCOL_VERSION = 2;
-export declare const STDIO_MAX_FRAME_BYTES: number;
-export declare const identityVariables: (import("./participant-identity.js").HarnessSessionVariable | "CLAUDE_CODE_CHILD_SESSION")[];
-export declare function wireIdentity(env: NodeJS.ProcessEnv): Record<string, string>;
-export interface WireError {
-    readonly code: number;
-    readonly message: string;
-    readonly data?: {
-        readonly code?: SquareErrorCode;
-        readonly facts?: SquareErrorFacts;
-        readonly operation?: OperationFailureDetail;
-    };
-}
-export declare function encodeError(error: unknown): WireError;
-export declare function unsupported(feature: string): never;
-export declare function openStdioSquare(location: string, selected: Extract<ParsedSquareLocation, {
-    kind: 'stdio';
-}>, input: SquareAtInput, backends: SquareBackends, build?: Pick<SquareBuildInput, 'markdown' | 'hardCap' | 'throttlePerMinute' | 'template' | 'force'>, control?: OperationControl): Promise<SquareBackend>;

package/dist/square-stdio.js

@@ -1,235 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { validateMetadataMatch, validateDeferralDuration, validateDeferralId } from './delivery-deferral.js';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { createInterface } from 'node:readline';
-import { SquareError } from './model.js';
-import { harnessSessionSources } from './participant-identity.js';
-import { requireJoinName } from './seats.js';
-export const STDIO_PROTOCOL_VERSION = 2;
-export const STDIO_MAX_FRAME_BYTES = 8 * 1024 * 1024;
-export const identityVariables = [...harnessSessionSources.flatMap(source => [source.variable, ...(source.childVariable ? [source.childVariable] : [])])];
-export function wireIdentity(env) {
-    return Object.fromEntries(identityVariables.map(key => [key, env[key] ?? '']));
-}
-export function encodeError(error) {
-    const e = error;
-    return { code: -32000, message: e.message ?? 'Backend request failed', data: { code: e.code, facts: e.facts, operation: e.operation } };
-}
-function decodeError(error) {
-    return Object.assign(error.data?.code ? new SquareError(error.data.code, error.message, error.data.facts) : new Error(error.message), error.data?.operation ? { operation: error.data.operation } : {});
-}
-export function unsupported(feature) {
-    throw new SquareError('invalid_args', `The stdio backend does not support ${feature}; use explicit catch/history or a local resource`);
-}
-/** One process per opened Square. No replay, pooling, or operation policy. */
-class Connection {
-    nextId = 0;
-    closed = false;
-    closing;
-    pending = new Map();
-    child;
-    exited;
-    constructor(command, args, cwd, env) {
-        this.child = spawn(command, [...args], { cwd, env, shell: false, stdio: 'pipe' });
-        this.exited = new Promise(resolve => this.child.once('close', () => resolve()));
-        // Diagnostic bytes are deliberately not included in errors (they can contain credentials).
-        this.child.stderr.resume();
-        const lines = createInterface({ input: this.child.stdout, crlfDelay: Infinity });
-        let frameBytes = 0;
-        this.child.stdout.on('data', chunk => {
-            for (const byte of chunk) {
-                if (byte === 10)
-                    frameBytes = 0;
-                else if (++frameBytes > STDIO_MAX_FRAME_BYTES) {
-                    this.fail('Backend frame exceeds the protocol limit');
-                    break;
-                }
-            }
-        });
-        lines.on('line', line => {
-            try {
-                const message = JSON.parse(line);
-                if (message.jsonrpc !== '2.0')
-                    throw new Error();
-                if (message.method === 'square/progress') {
-                    const pending = this.pending.get(message.params?.id);
-                    if (pending && message.params?.progress) {
-                        try {
-                            pending.control?.onProgress?.(message.params.progress);
-                        }
-                        catch { /* progress observers cannot corrupt framing */ }
-                    }
-                    return;
-                }
-                if (!Number.isSafeInteger(message.id) || (Object.hasOwn(message, 'result') === Object.hasOwn(message, 'error')))
-                    throw new Error();
-                const pending = this.pending.get(message.id);
-                if (!pending)
-                    throw new Error();
-                this.pending.delete(message.id);
-                pending.dispose();
-                if (message.error)
-                    pending.reject(decodeError(message.error));
-                else
-                    pending.resolve(message.result);
-            }
-            catch {
-                this.fail('Malformed backend protocol response');
-            }
-        });
-        lines.once('close', () => this.fail('Backend stdout ended'));
-        this.child.once('error', () => this.fail('Cannot start configured backend; check command and cwd'));
-        this.child.once('exit', () => this.fail('Backend process exited'));
-        this.child.stdin.on('error', () => this.fail('Backend stdin closed'));
-    }
-    fail(message) {
-        if (this.closed)
-            return;
-        this.closed = true;
-        for (const pending of this.pending.values()) {
-            pending.dispose();
-            const error = new SquareError('unavailable', message);
-            if (pending.method === 'express')
-                Object.assign(error, { operation: { operation: 'express', expressEffect: 'unknown' } });
-            pending.reject(error);
-        }
-        this.pending.clear();
-        this.child.stdin.destroy();
-        this.child.kill();
-        const timer = setTimeout(() => this.child.kill('SIGKILL'), 500);
-        timer.unref();
-        void this.exited.then(() => clearTimeout(timer));
-    }
-    request(method, params, control) {
-        if (control?.signal?.aborted)
-            return Promise.reject(control.signal.reason ?? new Error('Operation cancelled'));
-        if (this.closed)
-            return Promise.reject(new SquareError('unavailable', 'Backend connection is closed'));
-        const id = ++this.nextId;
-        let frame;
-        try {
-            frame = JSON.stringify({ jsonrpc: '2.0', id, method, params }, (_key, value) => {
-                if (typeof value === 'number' && !Number.isFinite(value))
-                    throw new Error('Non-finite number');
-                return value;
-            }) + '\n';
-            if (Buffer.byteLength(frame) > STDIO_MAX_FRAME_BYTES)
-                throw new Error('Frame too large');
-        }
-        catch {
-            const error = new SquareError('invalid_args', 'Backend request must be JSON-serializable with finite numbers and fit the protocol frame limit');
-            if (method === 'express')
-                Object.assign(error, { operation: { operation: 'express', expressEffect: 'unsent' } });
-            return Promise.reject(error);
-        }
-        return new Promise((resolve, reject) => {
-            const abort = () => {
-                // Wait for the response: server cleanup (including catch lease release) must finish first.
-                if (!this.closed)
-                    this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: '$/cancelRequest', params: { id } }) + '\n');
-            };
-            this.pending.set(id, { resolve, reject, method, control, dispose: () => control?.signal?.removeEventListener('abort', abort) });
-            control?.signal?.addEventListener('abort', abort, { once: true });
-            this.child.stdin.write(frame);
-        });
-    }
-    close() {
-        return this.closing ??= (async () => {
-            const timer = setTimeout(() => this.fail('Backend close timed out'), 1000);
-            try {
-                if (!this.closed)
-                    await this.request('square/close', {});
-            }
-            catch { /* disconnect already rejects outstanding work */ }
-            finally {
-                clearTimeout(timer);
-                this.fail('Backend connection closed');
-                await this.exited;
-            }
-        })();
-    }
-}
-class StdioSquare {
-    location;
-    connection;
-    handle;
-    constructor(location, connection, handle) {
-        this.location = location;
-        this.connection = connection;
-        this.handle = handle;
-    }
-    call(method, args, control, participant, participantHandle) {
-        return this.connection.request(method, { handle: this.handle, args, ...(participant === undefined ? {} : { participant, participantHandle }) }, control);
-    }
-    participantHandle(name, reference) {
-        const call = (method, args, control) => this.call(method, args, control, name, reference);
-        return {
-            name,
-            express: ((bodyOrInput, optionsOrControl, control) => {
-                if (typeof bodyOrInput === 'object' && bodyOrInput !== null)
-                    return call('express', [bodyOrInput, undefined], optionsOrControl);
-                return call('express', [bodyOrInput, optionsOrControl], control);
-            }),
-            catch: (options, control) => call('catch', [options], control),
-            listen: (target, options, control) => call('listen', [target, options], control),
-            ignore: (target, options, control) => call('ignore', [target, options], control),
-            unlisten: (target, options, control) => call('unlisten', [target, options], control),
-            listening: (options, control) => call('listening', [options], control),
-            hold: (reason, options, control) => call('hold', [reason, options], control),
-            resume: (options, control) => call('resume', [options], control),
-            done: (body, options, control) => call('done', [body, options], control),
-            deferDelivery: async (input, control) => {
-                const match = validateMetadataMatch(input?.match), durationMs = validateDeferralDuration(input?.durationMs);
-                return call('deferDelivery', [{ match, durationMs }], control);
-            },
-            renewDeliveryDeferral: async (id, durationMs, control) => call('renewDeliveryDeferral', [validateDeferralId(id), validateDeferralDuration(durationMs)], control),
-            releaseDeliveryDeferral: async (id, control) => call('releaseDeliveryDeferral', [validateDeferralId(id)], control),
-            history: (query, control) => this.history(query, control),
-        };
-    }
-    async participant(name) {
-        const reference = randomUUID();
-        return this.participantHandle(await this.call('participant', [name, reference]), reference);
-    }
-    async join(...[name, options, control]) {
-        requireJoinName(name);
-        const reference = randomUUID();
-        const result = await this.call('join', [name, options, reference], control);
-        return { ...result, participant: this.participantHandle(result.participant, reference) };
-    }
-    history(...[query, control]) { return this.call('history', [query], control); }
-    status(...[options, control]) { return this.call('status', [options], control); }
-    participants(...[options, control]) { return this.call('participants', [options], control); }
-    recovery(...[name, control]) { return this.call('recovery', [name], control); }
-    snapshot() { return Promise.reject(new SquareError('invalid_args', 'stdio does not support function-valued snapshot; use status/participants/history')); }
-    stream() { unsupported('stream'); }
-    recognize() { return Promise.reject(new SquareError('invalid_args', 'stdio does not support host recognition; select a participant explicitly')); }
-    implicitJoin() { unsupported('host implicit join'); }
-    endOwnedSession() { unsupported('host session cleanup'); }
-    cancelDeliveries() { unsupported('host delivery cancellation'); }
-    close() { return this.connection.close(); }
-}
-export async function openStdioSquare(location, selected, input, backends, build, control) {
-    if (input.clock || input.wakeTransport)
-        unsupported('client clock or wakeTransport injection');
-    if (control?.signal?.aborted)
-        throw control.signal.reason ?? new Error('Operation cancelled');
-    const backend = Object.hasOwn(backends, selected.backend) ? backends[selected.backend] : undefined;
-    if (!backend)
-        throw new SquareError('invalid_args', `Backend ${selected.backend} is not configured; set backends or SQUARE_BACKENDS_CONFIG`);
-    const cwd = input.cwd ?? process.cwd();
-    const command = backend.command.includes('/') || backend.command.includes('\\') ? path.resolve(cwd, backend.command) : backend.command;
-    const connection = new Connection(command, backend.args ?? [], path.resolve(cwd, backend.cwd ?? '.'), { ...(input.env ?? process.env), ...backend.env });
-    try {
-        const result = await connection.request('square/open', { version: STDIO_PROTOCOL_VERSION, key: selected.key, location,
-            identity: wireIdentity(input.env ?? process.env), body: input.body, participant: input.participant, build }, control);
-        if (result.version !== STDIO_PROTOCOL_VERSION || typeof result.handle !== 'string')
-            throw new SquareError('unavailable', 'Backend protocol version mismatch');
-        return new StdioSquare(location, connection, result.handle);
-    }
-    catch (error) {
-        await connection.close();
-        throw error;
-    }
-}

package/dist/stdio-server.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-/** Serve the existing resource API. This adapter contains no activity policy. */
-export declare function runSquareStdioServer(root: string): Promise<void>;