@astrosheep/square 0.3.93 → 0.3.95

package/dist/square-facade.d.ts

@@ -1,17 +1,16 @@
-import type { SquareBackends } from './square-backend.js';
 import type { DeliveryDeferral, MetadataMatch } from './delivery-deferral.js';
 export type { DeliveryDeferral, MetadataMatch, MetadataScalar } from './delivery-deferral.js';
 import type { ActivityId, Perception, Reach } from './square-core.js';
-import type { Body, StoredAct, WakeAddress, ActivityMetadata } from './model.js';
-import type { WakeTransportPort, DeliveryResult, SquareResourceOwner } from './ports.js';
+import type { Owner, StoredAct, WakeAddress, ActivityMetadata, DirectedNotificationRoute } from './model.js';
+import type { WakeTransportPort, SquareResourceOwner } from './ports.js';
 export type { ActivityId, Perception, Reach } from './square-core.js';
-export type { Body, WakeAddress, ActivityMetadata, JsonValue } from './model.js';
-/** Indexed archive event, including read and historical actorless lifecycle records. */
+export type { Owner, WakeAddress, ActivityMetadata, JsonValue, DirectedNotificationRoute } from './model.js';
+/** Indexed archive event, including read bookkeeping. */
 export type ArchiveRecord = Readonly<StoredAct>;
 export interface Activity {
     readonly id: ActivityId;
     readonly at: number;
-    readonly kind: 'join' | 'say' | 'done' | 'hold' | 'resume' | 'listen' | 'ignore' | 'unlisten';
+    readonly kind: 'join' | 'say' | 'done' | 'listen' | 'ignore' | 'unlisten';
     readonly actor: string;
     readonly body?: string;
     readonly metadata?: ActivityMetadata;
@@ -22,6 +21,7 @@ export interface Activity {
 }
 export interface PerceivedActivity extends Activity {
     readonly perception: Perception;
+    readonly via?: DirectedNotificationRoute;
 }
 /** Request extra facts for rendering, without changing operation semantics. */
 export interface ObservationOptions {
@@ -39,12 +39,8 @@ export interface ExpressOptions extends ObservationOptions {
 export interface ExpressInput extends ExpressOptions {
     readonly body?: string;
 }
-export interface ActivityResult {
+export interface ExpressResult {
     readonly activity: Activity;
-    readonly delivery?: DeliveryResult;
-}
-export interface ExpressResult extends ActivityResult {
-    readonly waited: boolean;
     /** The replied-to author was not standing when the reply landed. */
     readonly replyAuthorNotHere?: string;
     /** Body @name tokens with no standing match at landing; never stored on the activity. */
@@ -61,8 +57,9 @@ export interface ListeningResult {
     readonly listening: readonly string[];
     readonly observation?: SquareObservation;
 }
-export interface LifecycleResult extends ActivityResult {
-    readonly observation?: LifecycleObservation;
+export interface LifecycleResult {
+    readonly activity: Activity;
+    readonly observation?: SquareObservation;
 }
 export interface CatchOptions extends ObservationOptions {
     readonly id?: ActivityId;
@@ -72,12 +69,11 @@ export interface CatchOptions extends ObservationOptions {
     readonly limit?: number;
     readonly replace?: boolean;
 }
+export type CatchReason = 'drained' | 'idle' | 'capped' | 'quorum' | 'replaced' | 'already-active';
 export interface CatchResult {
     readonly activities: readonly PerceivedActivity[];
-    readonly consumedThrough: ActivityId | null;
-    readonly idleExpired: boolean;
     readonly remaining: number;
-    readonly status?: CatchTerminalStatus;
+    readonly reason: CatchReason;
     /** Occasional participant-facing nudge; not part of any activity. */
     readonly hint?: string;
     readonly observation?: CatchObservation;
@@ -89,10 +85,8 @@ export interface CatchWaitStart {
 }
 export type OperationProgress = {
     readonly kind: 'waiting';
-    readonly reason: 'held' | 'throttled';
+    readonly reason: 'throttled';
     readonly delayMs?: number;
-    readonly holder?: string;
-    readonly holdReason?: string;
 } | ({
     readonly kind: 'catch-started';
     readonly participant: string;
@@ -134,32 +128,17 @@ export interface HistoryResult {
     readonly activities: readonly Activity[];
     readonly observation?: HistoryObservation;
 }
-export interface ParticipantStatus {
-    readonly name: string;
-    readonly state: 'joined' | 'done';
-    readonly consumedThrough: ActivityId | null;
-    readonly watching: boolean;
-    readonly listening: readonly string[];
-}
 export interface SquareSnapshot {
     readonly context: string;
     readonly actCount: number;
     readonly hardCap: number | null;
     readonly throttlePerMinute?: number;
-    readonly held: {
-        readonly by: string;
-        readonly reason?: string;
-    } | null;
-    readonly participants: readonly ParticipantStatus[];
+    readonly participants: readonly Pick<ParticipantSummary, 'name' | 'presence' | 'listening'>[];
     delivered(name: string, id: ActivityId): boolean;
 }
 export interface OpenOptions {
     readonly clock?: () => number;
-    readonly wakeTransport?: WakeTransportPort;
-    /** Explicit execution coordinate resolved by an adapter. */
-    readonly body?: Body;
-    /** Optional wake address attached to this body. */
-    readonly wakeAddress?: WakeAddress;
+    readonly wakeTransport?: WakeTransportPort | false;
 }
 export interface SquareLocation {
     readonly path?: string;
@@ -167,8 +146,6 @@ export interface SquareLocation {
     readonly env?: NodeJS.ProcessEnv;
 }
 export interface SquareAtInput extends SquareLocation, OpenOptions {
-    readonly backends?: SquareBackends;
-    readonly participant?: string;
     /** A caller-owned connection; closing this Square never closes its owner. */
     readonly resources?: SquareResourceOwner;
 }
@@ -180,6 +157,8 @@ export interface SquareBuildInput extends SquareAtInput {
     readonly force?: boolean;
 }
 export interface JoinOptions extends ObservationOptions {
+    readonly owner: Owner;
+    readonly wakeAddress?: WakeAddress;
     readonly takeover?: boolean;
     readonly last?: number;
 }
@@ -187,8 +166,6 @@ export interface JoinResult {
     readonly participant: Participant;
     readonly activity: Activity | null;
     readonly kind: 'joined' | 'reconnected' | 'taken-over';
-    /** Known joined-or-done participants, not the current standing count. */
-    readonly participantCount: number;
     readonly observation?: JoinObservation;
 }
 export interface Participant {
@@ -200,9 +177,6 @@ export interface Participant {
     unlisten(target: string, options?: ObservationOptions, control?: OperationControl): Promise<ListenerChangeResult>;
     listening(options?: ObservationOptions, control?: OperationControl): Promise<ListeningResult>;
     catch(options?: CatchOptions, control?: OperationControl): Promise<CatchResult>;
-    history(query?: HistoryQuery, control?: OperationControl): Promise<HistoryResult>;
-    hold(reason?: string, options?: ObservationOptions, control?: OperationControl): Promise<LifecycleResult>;
-    resume(options?: ObservationOptions, control?: OperationControl): Promise<LifecycleResult>;
     /** Leave without a message. Only an omitted or empty body is accepted. */
     done(body?: string, options?: ObservationOptions, control?: OperationControl): Promise<LifecycleResult>;
     deferDelivery(input: Readonly<{
@@ -212,12 +186,15 @@ export interface Participant {
     renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
     releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
 }
-export type CatchTerminalStatus = 'already-active' | 'replaced' | 'capped' | 'quorum';
-export type CatchStopStatus = CatchTerminalStatus | 'empty-now' | 'stale';
-export type ParticipantPresence = 'never-joined' | 'active' | 'watching' | 'done';
+export interface HeldSeat {
+    readonly name: string;
+    readonly generation: ActivityId;
+    readonly attachment: 'attached' | 'detached';
+}
+export type ParticipantPresence = 'never-joined' | 'active' | 'watching' | 'away' | 'done';
 export interface ParticipantSummary {
     readonly name: string;
-    readonly state: 'active' | 'done' | 'not joined';
+    readonly deliveryAvailable: boolean;
     readonly listening: readonly string[];
     readonly activityCount: number;
     readonly lastActiveAt?: number;
@@ -232,16 +209,9 @@ export interface StatusResult {
     /** Present when a viewer resolves; an empty list means they listen to nobody. */
     readonly listening?: readonly string[];
     readonly hardCap: number | null;
-    readonly activeCount: number;
-    readonly doneCount: number;
     readonly participants: readonly ParticipantSummary[];
     readonly now: number;
     readonly throttlePerMinute?: number;
-    readonly hold: {
-        readonly by?: string;
-        readonly reason?: string;
-        readonly at?: number;
-    } | null;
     readonly latestActivity?: Activity;
     readonly observation?: StatusObservation;
 }
@@ -283,11 +253,8 @@ export interface InboxResult {
 export interface RecoveryResult {
     readonly participant?: string;
     readonly standingCount?: number;
-    readonly held?: boolean;
-    readonly holdReason?: string;
     readonly ownActivityCount?: number;
     readonly hardCap?: number | null;
-    readonly roster?: readonly string[];
     readonly activitySummaries?: readonly UnreadActivitySummary[];
 }
 export type StreamStart = {
@@ -295,90 +262,70 @@ export type StreamStart = {
     readonly last: number;
 } | {
     readonly kind: 'after';
-    readonly after: number;
+    readonly after: ActivityId;
 };
 export interface StreamOptions {
     readonly recipient?: string;
     readonly start?: StreamStart;
 }
-export type StreamRecord = ArchiveRecord & {
-    readonly seq: number;
-    readonly square: string;
-    readonly route?: string;
-};
-export interface UnreadActivityPreview {
-    readonly number: number;
-    readonly act: Extract<ArchiveRecord, {
-        kind: 'say';
-    }>;
-    readonly perception: Perception;
-}
+export type StreamRecord = Activity | PerceivedActivity;
 export interface UnreadActivitySummary {
     readonly name: string;
     readonly count: number;
     readonly latestActivityAgeMs: number;
-    readonly previews: readonly UnreadActivityPreview[];
+    readonly preview: Extract<ArchiveRecord, {
+        kind: 'say';
+    }>;
 }
 export interface EntryPresentation {
     readonly joinedBefore: boolean;
     readonly scene: string;
     readonly joinContext: string;
-    readonly recentActivities: readonly ArchiveRecord[];
-    readonly perceptions: Readonly<Record<number, Perception>>;
-    readonly sayNumbers: Readonly<Record<number, number>>;
-}
-export interface ListPresentation {
-    readonly context: readonly string[];
-    readonly participants: readonly string[];
-    readonly activities: number;
+    readonly recentActivities: readonly PerceivedActivity[];
 }
 export interface PresenceClassification {
     readonly orderedHereNames: readonly string[];
     readonly lingeringCount: number;
-    readonly classificationByName: Readonly<Record<string, 'here' | 'lingering' | 'done' | 'not-joined'>>;
+    readonly classificationByName: Readonly<Record<string, 'here' | 'lingering' | 'away' | 'done' | 'not-joined'>>;
 }
 export interface CatchPresence {
     readonly participants: readonly ParticipantSummary[];
     readonly now: number;
 }
-export interface StreamProjection {
-    readonly activities: readonly {
-        readonly activity: ArchiveRecord;
-        readonly route?: string;
-    }[];
-    readonly cursor: number;
-    readonly hasMore: boolean;
-}
 export interface SquareObservation {
     readonly location: string;
     readonly standingCount: number;
-    readonly held: boolean;
     readonly now: number;
     readonly participant?: string;
-    readonly automaticDeliveryAvailable: boolean;
 }
 export interface JoinObservation extends SquareObservation {
+    readonly deliveryAvailable: boolean;
     readonly entry?: EntryPresentation;
     /** The receipt succeeded, but optional recent-history/context enrichment was unavailable. */
     readonly enrichmentUnavailable?: true;
 }
-export interface ExpressionObservation extends Pick<SquareObservation, 'standingCount' | 'held' | 'now'> {
+export interface ExpressionObservation extends Pick<SquareObservation, 'standingCount' | 'now'> {
     readonly ownActivityCount: number;
     readonly hardCap: number | null;
 }
+export interface ExpressContext {
+    readonly activities: readonly {
+        readonly id: ActivityId;
+        readonly actor: string;
+        readonly preview: string;
+        readonly truncated: boolean;
+    }[];
+    /** Unread activities outside this preview, not a consumption cursor. */
+    readonly remaining: number;
+}
 export interface ExpressObservation extends SquareObservation, ExpressionObservation {
     readonly participant: string;
-    readonly pendingPublic: readonly ArchiveRecord[];
-    readonly sayNumbers: Readonly<Record<number, number>>;
-    readonly perceptions: Readonly<Record<number, Perception>>;
+    readonly context: ExpressContext;
 }
 export interface CatchObservation extends SquareObservation, ExpressionObservation {
+    readonly deliveryAvailable: boolean;
     readonly participant: string;
-    readonly sayNumbers: Readonly<Record<number, number>>;
     readonly presence?: CatchPresence;
-    readonly stop?: CatchStopStatus;
-    readonly waitStarted?: boolean;
-    readonly replaced?: boolean;
     readonly enrichmentUnavailable?: true;
 }
 export interface HistoryContinuation {
@@ -397,17 +344,12 @@ export interface HistoryObservation extends SquareObservation {
 export interface ListenerObservation extends SquareObservation {
     readonly participant: string;
     readonly target: string;
-    readonly requestedTarget: string;
-}
-export interface LifecycleObservation extends SquareObservation {
-    readonly activity: ArchiveRecord;
 }
-export interface StatusObservation extends SquareObservation, PresenceClassification {
+export interface StatusObservation extends Omit<SquareObservation, 'now'>, PresenceClassification {
     readonly knownParticipantCount: number;
-    readonly latestActNumber?: number;
     readonly latestPerception?: Perception;
     readonly joins: readonly {
-        readonly activity: ArchiveRecord;
+        readonly activity: Activity;
         readonly rejoined: boolean;
     }[];
     readonly joinCount: number;

package/dist/square-index.d.ts

@@ -1,24 +1,16 @@
 import { type VersionObserver } from './file-changes.js';
-import { type Body } from './model.js';
-/** A rebuildable discovery hint: the body that may have used an artifact and its path.
- * It is deliberately not a participant, generation, ownership, suppression, or evidence row. */
+import { type Owner } from './model.js';
+/** A rebuildable discovery hint: the owner that may have used an artifact and its path. */
 export interface SquareIndexEntry {
     readonly location: string;
-    readonly body: Body;
+    readonly owner: Owner;
 }
 export interface SquareIndexQuery {
-    readonly body?: Body;
-    readonly channel?: string;
-    readonly session?: string;
-    readonly agent?: string;
+    readonly owner?: Owner;
 }
-/** The index is the only host-side Square state. Its path is test/configuration plumbing, not authority. */
 export declare function squareIndexPath(env?: NodeJS.ProcessEnv): string;
-/** Read and verify the disposable index. Paths are canonicalized on access and duplicates collapse. */
 export declare function indexedSquareEntries(query?: SquareIndexQuery, env?: NodeJS.ProcessEnv): Promise<readonly SquareIndexEntry[]>;
 export declare function indexedSquarePaths(query?: SquareIndexQuery, env?: NodeJS.ProcessEnv): Promise<readonly string[]>;
 /** Best-effort discovery only: a busy index skips publication, never queues or delays artifact work. */
-export declare function rememberSquarePath(location: string, body: Body, index: string): Promise<boolean>;
-/** Index loss is tolerated by every caller; this observer is only a wake hint for rediscovery. */
+export declare function rememberSquarePath(location: string, owner: Owner, index: string): Promise<boolean>;
 export declare function observeSquareIndex(env?: NodeJS.ProcessEnv): Promise<VersionObserver<string>>;
-export declare function bodyKey(body: Body): string;

package/dist/square-index.js

@@ -5,8 +5,7 @@ import { randomUUID } from 'node:crypto';
 import { withFileLock } from './file-lock.js';
 import { canonicalPath } from './canonical-path.js';
 import { observeFileMetadata } from './file-changes.js';
-import { sameBody, validateBody } from './model.js';
-/** The index is the only host-side Square state. Its path is test/configuration plumbing, not authority. */
+import { validateOwner } from './model.js';
 export function squareIndexPath(env = process.env) {
     const configured = env.SQUARE_INDEX?.trim();
     return path.resolve(configured ?? path.join(os.homedir(), '.square', 'index.ndjsonl'));
@@ -18,24 +17,17 @@ function validEntry(value) {
     if (value === null || typeof value !== 'object' || Array.isArray(value))
         return undefined;
     const row = value;
-    if (typeof row.location !== 'string' || !path.isAbsolute(row.location)
-        || row.body === null || typeof row.body !== 'object' || Array.isArray(row.body))
+    if (typeof row.location !== 'string' || !path.isAbsolute(row.location) || typeof row.owner !== 'string')
         return undefined;
-    const raw = row.body;
-    const body = {
-        channel: raw.channel,
-        session: raw.session,
-        ...(raw.agent === undefined ? {} : { agent: raw.agent }),
-    };
     try {
-        validateBody(body);
+        validateOwner(row.owner);
     }
     catch {
         return undefined;
     }
-    if (Object.keys(raw).some((key) => !['channel', 'session', 'agent'].includes(key)))
+    if (Object.keys(row).some((key) => !['location', 'owner'].includes(key)))
         return undefined;
-    return { location: row.location, body };
+    return { location: row.location, owner: row.owner };
 }
 async function readEntries(index) {
     let content;
@@ -56,25 +48,13 @@ async function readEntries(index) {
             if (entry !== undefined)
                 entries.push(entry);
         }
-        catch {
-            // The index is disposable discovery input. A malformed line is ignored rather than
-            // becoming a second authority or preventing access to valid entries beside it.
-        }
+        catch { /* Disposable discovery input. */ }
     }
     return entries;
 }
 function matches(entry, query) {
-    if (query.body !== undefined && !sameBody(entry.body, query.body))
-        return false;
-    if (query.channel !== undefined && entry.body.channel !== query.channel)
-        return false;
-    if (query.session !== undefined && entry.body.session !== query.session)
-        return false;
-    if (query.agent !== undefined && entry.body.agent !== query.agent)
-        return false;
-    return true;
+    return query.owner === undefined || entry.owner === query.owner;
 }
-/** Read and verify the disposable index. Paths are canonicalized on access and duplicates collapse. */
 export async function indexedSquareEntries(query = {}, env = process.env) {
     const entries = await readEntries(squareIndexPath(env));
     const result = [];
@@ -89,11 +69,11 @@ export async function indexedSquareEntries(query = {}, env = process.env) {
         catch {
             continue;
         }
-        const key = JSON.stringify([location, entry.body.channel, entry.body.session, entry.body.agent ?? null]);
+        const key = JSON.stringify([location, entry.owner]);
         if (seen.has(key))
             continue;
         seen.add(key);
-        result.push({ location, body: entry.body });
+        result.push({ location, owner: entry.owner });
     }
     return result;
 }
@@ -101,15 +81,15 @@ export async function indexedSquarePaths(query = {}, env = process.env) {
     return [...new Set((await indexedSquareEntries(query, env)).map((entry) => entry.location))];
 }
 /** Best-effort discovery only: a busy index skips publication, never queues or delays artifact work. */
-export async function rememberSquarePath(location, body, index) {
-    validateBody(body);
+export async function rememberSquarePath(location, owner, index) {
+    validateOwner(owner);
     const canonical = await canonicalPath(location);
     await fs.mkdir(path.dirname(index), { recursive: true });
     return await withFileLock(lockPath(index), { retryMs: 10, skipIfBusy: true }, async () => {
         const entries = await readEntries(index);
-        if (entries.some((entry) => entry.location === canonical && sameBody(entry.body, body)))
+        if (entries.some((entry) => entry.location === canonical && entry.owner === owner))
             return false;
-        const next = [...entries, { location: canonical, body }];
+        const next = [...entries, { location: canonical, owner }];
         const temporary = `${index}.${process.pid}.${randomUUID()}.tmp`;
         try {
             await fs.writeFile(temporary, next.map((entry) => JSON.stringify(entry)).join('\n') + '\n', { flag: 'wx', mode: 0o600 });
@@ -121,11 +101,6 @@ export async function rememberSquarePath(location, body, index) {
         return true;
     }) ?? false;
 }
-/** Index loss is tolerated by every caller; this observer is only a wake hint for rediscovery. */
 export function observeSquareIndex(env = process.env) {
     return observeFileMetadata(squareIndexPath(env));
 }
-export function bodyKey(body) {
-    validateBody(body);
-    return JSON.stringify([body.channel, body.session, body.agent ?? null]);
-}

package/dist/square-legacy-framing.d.ts

@@ -1,6 +1,8 @@
 import type { DatabaseSync } from 'node:sqlite';
 export declare const FORMAT4_ADDED_OBJECTS: ReadonlySet<string>;
 export declare const FORMAT4_REPLACED_OBJECTS: ReadonlySet<string>;
+/** Historical activity framing only; no runtime activity decoder accepts these kinds. */
+export declare function legacyActivitySchema(currentSchemaSql: string): string;
 /**
  * Read-only recognition of the exact row framing accepted by explicit migration.
  * It inspects identity, owned schema and journal mode only; it never reads row

package/dist/square-legacy-framing.js

@@ -15,6 +15,14 @@ CREATE INDEX route_session ON routes(session_json, position);`;
 function normalizedSql(sql) {
     return sql.trim().replace(/;$/, '').replace(/\s+/g, ' ').replace(/\s*([(),=])\s*/g, '$1');
 }
+/** Historical activity framing only; no runtime activity decoder accepts these kinds. */
+export function legacyActivitySchema(currentSchemaSql) {
+    return currentSchemaSql
+        .replace("kind IN ('join','done','say','read','listen','ignore','unlisten')", "kind IN ('join','done','say','hold','resume','read','listen','ignore','unlisten')")
+        .replace('  actor_json TEXT COLLATE BINARY NOT NULL,', '  actor_json TEXT COLLATE BINARY,')
+        .replace('  actor_key_json TEXT COLLATE BINARY NOT NULL,', '  actor_key_json TEXT COLLATE BINARY,')
+        .replace("  CHECK (kind = 'say' OR (reach IS NULL AND reply_index IS NULL))", "  CHECK ((actor_json IS NULL) = (actor_key_json IS NULL)),\n  CHECK (kind IN ('hold','resume') OR actor_json IS NOT NULL),\n  CHECK (kind = 'say' OR (reach IS NULL AND reply_index IS NULL))");
+}
 function legacyRowSchema(currentSchemaSql, version) {
     const statements = currentSchemaSql.split(';').map((statement) => statement.trim()).filter(Boolean)
         .filter((statement) => {

package/dist/square-location.d.ts

@@ -1,15 +1,2 @@
-import type { SquareAtInput, SquareLocation } from './square-facade.js';
-import type { SquareBackends } from './square-backend.js';
-export type ParsedSquareLocation = {
-    readonly kind: 'local';
-    readonly path: string;
-} | {
-    readonly kind: 'stdio';
-    readonly backend: string;
-    readonly key: string;
-    readonly uri: string;
-};
-export declare function parseSquareLocation(value: string): ParsedSquareLocation;
+import type { SquareLocation } from './square-facade.js';
 export declare function squareLocation(input: SquareLocation): string;
-export declare function localSquareLocation(input: SquareLocation): string;
-export declare function backendConfiguration(input: SquareAtInput): Promise<SquareBackends>;

package/dist/square-location.js

@@ -1,77 +1,11 @@
 import path from 'node:path';
-import os from 'node:os';
-import { readFile } from 'node:fs/promises';
 import { SquareError } from './model.js';
-export function parseSquareLocation(value) {
-    // Windows roots include drive-relative prefixes such as D:.
-    if (path.win32.parse(value).root !== '' || !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(value))
-        return { kind: 'local', path: value };
-    // Parse the raw components, before URL dot-segment normalization or host lowercasing.
-    const match = /^stdio:\/\/([A-Za-z0-9_-]+)\/([^/?#]+)$/.exec(value);
-    if (!match)
-        throw new SquareError('invalid_args', 'Expected a local path or stdio://<configured-name>/<encoded-square-key>; no credentials, port, query or fragment');
-    let key;
-    try {
-        key = decodeURIComponent(match[2]);
-    }
-    catch {
-        throw new SquareError('invalid_args', 'Invalid percent encoding in stdio square key');
-    }
-    if (!key || key === '.' || key === '..' || /[/\\\x00-\x1f\x7f]/.test(key))
-        throw new SquareError('invalid_args', 'A stdio square key must be one nonempty name, not a path');
-    return { kind: 'stdio', backend: match[1], key, uri: `stdio://${match[1]}/${encodeURIComponent(key)}` };
-}
 export function squareLocation(input) {
     const selected = input.path ?? (input.env ?? process.env).SQUARE_LOCATION;
     if (selected === undefined || selected.trim() === '')
         throw new SquareError('invalid_args', 'Square needs a location');
-    const location = parseSquareLocation(selected);
-    return location.kind === 'local' ? path.resolve(input.cwd ?? process.cwd(), location.path) : location.uri;
-}
-export function localSquareLocation(input) {
-    const location = squareLocation(input);
-    if (parseSquareLocation(location).kind !== 'local')
-        throw new SquareError('invalid_args', 'This file operation requires a local square artifact; backend URIs are not supported');
-    return location;
-}
-function validateBackends(value) {
-    const object = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-    const invalid = () => new SquareError('invalid_args', 'Invalid backend configuration: expected {backends:{name:{command,args?,cwd?,env?}}}');
-    if (!object(value))
-        throw invalid();
-    for (const [name, entry] of Object.entries(value)) {
-        if (!/^[A-Za-z0-9_-]+$/.test(name) || !object(entry) || typeof entry.command !== 'string' || !entry.command.trim()
-            || Object.keys(entry).some(key => !['command', 'args', 'cwd', 'env'].includes(key))
-            || (entry.args !== undefined && (!Array.isArray(entry.args) || entry.args.some(arg => typeof arg !== 'string')))
-            || (entry.cwd !== undefined && typeof entry.cwd !== 'string')
-            || (entry.env !== undefined && (!object(entry.env) || Object.values(entry.env).some(v => typeof v !== 'string'))))
-            throw invalid();
-    }
-    return value;
-}
-export async function backendConfiguration(input) {
-    if (input.backends !== undefined)
-        return validateBackends(input.backends);
-    const env = input.env ?? process.env;
-    const configured = env.SQUARE_BACKENDS_CONFIG;
-    const file = configured === undefined ? path.join(env.HOME ?? os.homedir(), '.config/square/backends.json')
-        : path.resolve(input.cwd ?? process.cwd(), configured);
-    let text;
-    try {
-        text = await readFile(file, 'utf8');
-    }
-    catch (error) {
-        if (configured === undefined && error.code === 'ENOENT')
-            return {};
-        throw new SquareError('invalid_args', 'Cannot read backend configuration; check SQUARE_BACKENDS_CONFIG');
-    }
-    try {
-        const parsed = JSON.parse(text);
-        if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object' || Object.keys(parsed).some(key => key !== 'backends') || parsed.backends === undefined)
-            throw new Error();
-        return validateBackends(parsed.backends);
-    }
-    catch {
-        throw new SquareError('invalid_args', 'Invalid backend configuration; expected {backends:{name:{command,args?,cwd?,env?}}}');
-    }
+    // Windows roots include drive-relative prefixes such as D:.
+    if (path.win32.parse(selected).root === '' && /^[A-Za-z][A-Za-z0-9+.-]*:/.test(selected))
+        throw new SquareError('invalid_args', 'Expected a local square artifact path');
+    return path.resolve(input.cwd ?? process.cwd(), selected);
 }

package/dist/square-migration-host-ledger.d.ts

@@ -1,8 +1,8 @@
-import { type Body } from './model.js';
+import { type HarnessCoordinate } from './owner.js';
 /** Offline conversion input only; never a runtime ownership or evidence reader. */
 export interface LegacyOwner {
     readonly participant: string;
-    readonly body: Body;
+    readonly coordinate: HarnessCoordinate;
 }
 export interface LegacyHostData {
     readonly owners: readonly LegacyOwner[];

package/dist/square-migration-host-ledger.js

@@ -5,7 +5,8 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { canonicalPath } from './canonical-path.js';
 import { inSqliteTransaction } from './sqlite-transaction.js';
-import { nameKey, validateBody } from './model.js';
+import { harnessOwner } from './owner.js';
+import { nameKey } from './model.js';
 const LEDGER_FILENAME = 'host-ledger.sqlite';
 const LEDGER_APPLICATION_ID = 0x5351484c;
 const LEDGER_VERSION = 2;
@@ -144,11 +145,11 @@ export async function readLegacyHostData(location, env = process.env, signal) {
                 if (value.v !== 1 || value.location !== canonical || typeof value.participant !== 'string'
                     || !finite(at))
                     throw invalid('owner fields are malformed.');
-                const body = { channel: value.channel, session: value.session, ...(value.agent === undefined ? {} : { agent: value.agent }) };
-                validateBody(body);
+                const coordinate = { channel: value.channel, session: value.session, ...(value.agent === undefined ? {} : { agent: value.agent }) };
+                harnessOwner(coordinate);
                 projections(row, { location_key: recordKey(canonical), participant_key: recordKey(nameKey(value.participant)),
-                    channel_key: recordKey(body.channel), session_key: recordKey(body.session), effective_at: at });
-                return { participant: value.participant, body };
+                    channel_key: recordKey(coordinate.channel), session_key: recordKey(coordinate.session), effective_at: at });
+                return { participant: value.participant, coordinate };
             });
             const evidence = database.prepare("SELECT * FROM host_evidence WHERE location_key=? AND kind IN ('wake','presentation') ORDER BY seq").all(recordKey(canonical)).map(row => {
                 const value = decodeEvidence(record(row));

package/dist/square-migration.d.ts

@@ -20,7 +20,10 @@ export interface MigrationOutcome {
 /**
  * Explicit conversion of the supported legacy formats. Row-backed versions 2 and 3 are
  * preflighted read-only, then receive ownership/evidence and deferral storage in one
- * format-5 transaction. Format 4 adds only the empty deferral table and its index.
+ * format-8 transaction. Formats 4/5 gain attachment; format 4 also gains empty deferrals.
+ * All legacy seats are encoded as opaque owners, preserving format-6 attachment.
+ * Every source drops obsolete activities and their identity references, clears dangling
+ * replies and rebuilds derived indices; surviving ids and allocation watermarks remain stable.
  * Legacy delivery evidence is copied from HostLedger only when its owner/session mapping is
  * unique; no source record is retired. Version 1 is not a supported source for this format transition.
  */