@astrosheep/square 0.3.106 → 0.4.1

package/dist/delivery.js

@@ -1,106 +0,0 @@
-import { renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
-import { parseActivityId } from './square-core.js';
-import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { automaticDispatchEligible, presentationBlocksDispatch } from './delivery-attempts.js';
-import { matchesCatchSelection } from './catch-selection.js';
-/** Exact stored activity projection for transports that send an awareness reminder. */
-export function wakePreview(facts, request) {
-    const index = parseActivityId(request.activity);
-    const head = index === undefined ? undefined : pendingHead(facts, request.participant, index);
-    const item = index === undefined ? undefined : facts.activity(index);
-    const seat = facts.seat(request.participant);
-    if (head === undefined || item?.kind !== 'say' || seat === undefined || seat.attachment !== 'attached'
-        || deliveryDeferralExpiry(facts, request.seat, item.index, Date.now()) !== undefined)
-        return undefined;
-    return renderSquareReminder([renderAttentionPreview({
-            squarePath: request.location, recipient: request.participant, actIndex: item.index,
-            actor: item.actor, route: head.route, body: item.body ?? '(structured activity)', delivery: item.delivery,
-        })], [item.delivery]);
-}
-function custody(evidence) {
-    return evidence.map(row => ({ purpose: row.kind === 'wake' ? 'dispatch' : 'presentation', outcome: row.outcome, expiresAt: row.expiresAt }));
-}
-/** Presentation custody blocks a wake, independently of native wake acceptance. */
-export function presentationBlocksWake(evidence, now) {
-    return presentationBlocksDispatch(custody(evidence), now);
-}
-/** Preselection only: an expired wake dispatch is uncertain, never safe automatic replay. */
-export function automaticWakeEligible(evidence, now) {
-    return automaticDispatchEligible(custody(evidence), now);
-}
-/** Notification pending is not cursor suffix or historical catch membership. */
-export function pendingHead(facts, name, index) {
-    const participant = facts.participant(name);
-    if (!participant?.joined || index <= (participant.lastJoinIndex ?? -1) || facts.receipt(participant.name, index))
-        return undefined;
-    return facts.directedAt(participant.name, index);
-}
-/** One activity's landed recipients that still owe a wake; the rest of the roster is untouched. */
-export function pendingRecipients(facts, index) {
-    return facts.audience(index).flatMap(({ recipient }) => {
-        const head = pendingHead(facts, recipient, index);
-        return head === undefined ? [] : [head];
-    });
-}
-/** Still-pending directed heads for one recipient, oldest first. Bodies belong to presentation. */
-export function pendingHeads(facts, name) {
-    const participant = facts.participant(name);
-    if (!participant?.joined)
-        return [];
-    const heads = [];
-    let afterIndex = participant.lastJoinIndex ?? -1;
-    for (;;) {
-        const page = facts.directed(participant.name, { afterIndex, unseenOnly: true }, { edge: 'oldest', limit: 100 });
-        heads.push(...page.items);
-        if (!page.hasMore)
-            break;
-        afterIndex = page.items.at(-1).index;
-    }
-    return heads;
-}
-export function capturePendingScan(facts) {
-    return { roster: facts.roster().filter((participant) => participant.joined), throughIndex: facts.header().lastActIndex };
-}
-export function sameJoin(facts, captured) {
-    const current = facts.participant(captured.name);
-    return current?.joined === captured.joined && current?.lastJoinIndex === captured.lastJoinIndex;
-}
-/** Finite bodyless pass: unrelated revisions never rewind the last examined group. */
-export async function* pendingPages(artifact, scan, afterIndex = -1) {
-    const captured = new Map(scan.roster.map((participant) => [participant.name, participant]));
-    while (afterIndex < scan.throughIndex) {
-        const { value: page } = await artifact.read((facts) => {
-            const page = facts.pendingAudience(afterIndex, scan.throughIndex, 100);
-            return { ...page, groups: page.groups.map((group) => ({ ...group, recipients: group.recipients.filter((recipient) => {
-                        const participant = captured.get(recipient.recipient);
-                        return participant !== undefined && sameJoin(facts, participant);
-                    }) })) };
-        });
-        yield page.groups.flatMap((group) => group.recipients.map(({ recipient, route }) => ({
-            index: group.index, at: group.at, actor: group.actor, recipient, route,
-        })));
-        if (!page.hasMore)
-            break;
-        afterIndex = page.groups.at(-1).index;
-    }
-}
-/** A pass retains only its captured joins; routes and individual receipts are fresh. */
-export function pendingFacts(facts, scan, heads) {
-    const joined = new Set(scan.roster.filter((participant) => sameJoin(facts, participant)).map((participant) => participant.name));
-    return { pending: heads.filter((head) => joined.has(head.recipient)
-            && pendingHead(facts, head.recipient, head.index) !== undefined) };
-}
-/** Global discovery alone sweeps pendingAudience; exact dispatch uses pendingRecipients. */
-export async function collectPending(artifact) {
-    const { value: scan } = await artifact.read(capturePendingScan);
-    const pending = [];
-    for await (const page of pendingPages(artifact, scan))
-        pending.push(...page);
-    const { value } = await artifact.read((facts) => ({ scan, ...pendingFacts(facts, scan, pending) }));
-    return value;
-}
-/** A live catch owns every matching notification, independent of its page size. */
-export function leaseOwnsNotification(lease, notification) {
-    return matchesCatchSelection(notification.actor, notification.route === 'bell' ? { kind: 'bell' }
-        : { kind: 'mentions', names: notification.route === 'mention' ? [notification.recipient] : [] }, lease.filter ?? {}, notification.route === 'reply' ? notification.recipient : undefined);
-}

package/dist/plugins/opencode/delivery.d.ts

@@ -1,19 +0,0 @@
-import { type OpenCodeNativeSession } from '../../packages/agent-delivery/src/opencode-native.js';
-export interface OpenCodeContextMessage {
-    readonly id?: string;
-    readonly role: string;
-    readonly content: readonly {
-        readonly type: string;
-        readonly text?: string;
-    }[];
-}
-export declare function indexedOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<readonly string[]>;
-export declare function discoverOpenCodeSeats(sessionId: string, env: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<import("../../model.js").LocatedSeat[]>;
-/** The exact prepared native message can authorize artifact-backed presentation once. */
-export declare function observeOpenCodeContext(sessionId: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
-export declare function receiveOpenCodePending(target: OpenCodeNativeSession, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-/** Publish the native address into current artifact seats; the legacy route projection is not read. */
-export declare function publishOpenCodeAddress(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<boolean>;
-export declare function cancelOpenCodeDeliveries(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-export declare function endOpenCodeSession(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;

package/dist/plugins/opencode/delivery.js

@@ -1,238 +0,0 @@
-import { createHash } from 'node:crypto';
-import { createArtifactPort } from '../../artifact.js';
-import { deliverPending } from '../../delivery-operations.js';
-import { nativePendingPreview, observeSessionPending, projectSessionSeats } from '../../inbox.js';
-import { automaticWakeEligible, presentationBlocksWake } from '../../delivery.js';
-import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
-import { formatActivityId, parseActivityId } from '../../square-core.js';
-import { indexedSquareEntries } from '../../square-index.js';
-import { asSeatRef } from '../../seats.js';
-import { restoreSessionSeats } from '../../session-lifecycle.js';
-import { presentPending } from '../../presentation-operations.js';
-import { createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
-const routeKind = 'opencode-server';
-const ownerFor = (sessionId) => harnessOwner({ channel: 'opencode', session: sessionId });
-const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
-function preview(facts, location, captured, index) {
-    const seat = facts.seat(captured.participant);
-    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== captured.generation || seat.owner !== captured.owner)
-        return undefined;
-    const wake = seat.wakeAddress;
-    if (wake?.kind !== routeKind)
-        return undefined;
-    return nativePendingPreview(facts, {
-        location, routeKind, generation: seat.generation, participant: seat.participant,
-        actIndex: index, address: wake.address, now: Date.now(),
-    });
-}
-export async function indexedOpenCodeSessions(env) {
-    return [...new Set((await indexedSquareEntries({}, env)).flatMap((entry) => {
-            const coordinate = decodeHarnessOwner(entry.owner);
-            return coordinate?.channel === 'opencode' ? [coordinate.session] : [];
-        }))];
-}
-export async function discoverOpenCodeSeats(sessionId, env, signal) {
-    return projectSessionSeats({ owner: ownerFor(sessionId), env }, signal);
-}
-function sameSeat(left, right) {
-    return left !== undefined && left.attachment === 'attached' && left.generation === right.generation && left.owner === right.owner;
-}
-function createOpenCodeWakeTransport(target, lifetime) {
-    return {
-        probe: async (route) => !lifetime.aborted && route.kind === routeKind
-            && route.address.sessionId === target.sessionId,
-        async attempt(request, timeoutMs, beforeSend) {
-            const index = parseActivityId(request.activity);
-            const artifact = request.artifact;
-            if (artifact === undefined || request.claimToken === undefined || index === undefined
-                || request.route.kind !== routeKind || request.route.address.sessionId !== target.sessionId) {
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention has no matching artifact claim or session.' };
-            }
-            const signal = AbortSignal.any([lifetime, AbortSignal.timeout(timeoutMs)]);
-            const started = Date.now();
-            if (signal.aborted || !await beforeSend())
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention changed before send.' };
-            const { value: prepared } = await artifact.read((facts) => preview(facts, request.location, request.seat, index), signal);
-            if (prepared === undefined)
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention is no longer current.' };
-            const inputId = createNativeInputId();
-            const correlation = { harness: 'opencode', token: inputId, payloadHash: payloadHash(prepared.payload) };
-            if (!await artifact.prepareDelivery({ seat: request.seat, claimToken: request.claimToken, correlation }, signal))
-                return { outcome: 'not-capable', diagnostic: 'OpenCode delivery claim is no longer current.' };
-            const fresh = await artifact.read((facts) => preview(facts, request.location, request.seat, index), signal);
-            if (fresh.value === undefined || payloadHash(fresh.value.payload) !== correlation.payloadHash)
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention changed before native send.' };
-            if (signal.aborted || !await beforeSend())
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention was consumed before send.' };
-            const result = await sendNativeText(target, prepared.payload, {
-                inputId, delivery: 'steer', timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)), signal,
-            });
-            if (result.state === 'accepted')
-                return { outcome: 'accepted' };
-            if (result.state === 'unavailable')
-                return { outcome: 'failed', signature: result.code };
-            return { outcome: 'unknown', signature: result.code };
-        },
-    };
-}
-function textMessage(message) {
-    if (message.role !== 'user' || message.id === undefined || !message.content.every((part) => part.type === 'text' && typeof part.text === 'string'))
-        return undefined;
-    return message.content.map((part) => part.text).join('');
-}
-/** The exact prepared native message can authorize artifact-backed presentation once. */
-export async function observeOpenCodeContext(sessionId, messages, env, signal) {
-    const observed = new Map(messages.flatMap((message) => {
-        const text = textMessage(message);
-        return text === undefined ? [] : [[message.id, payloadHash(text)]];
-    }));
-    if (observed.size === 0 || signal.aborted)
-        return;
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            const { value: matches } = await artifact.read((facts) => {
-                if (!sameSeat(facts.seat(seat.participant), seat))
-                    return [];
-                return facts.deliveryEvidence(seat.participant, seat.generation).flatMap((evidence) => {
-                    const token = evidence.correlation?.harness === 'opencode' ? evidence.correlation.token : undefined;
-                    const hash = token === undefined ? undefined : observed.get(token);
-                    const index = parseActivityId(evidence.activity);
-                    if (token === undefined || hash === undefined || evidence.claimToken === undefined || index === undefined
-                        || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
-                        || evidence.correlation?.payloadHash !== hash)
-                        return [];
-                    const prepared = preview(facts, location, seat, index);
-                    if (prepared === undefined || payloadHash(prepared.payload) !== hash
-                        || presentationBlocksWake(facts.deliveryEvidence(seat.participant, seat.generation, evidence.activity), Date.now()))
-                        return [];
-                    return [{ evidence, index, hash, clipped: prepared.clipped }];
-                });
-            }, signal);
-            for (const { evidence, index, hash, clipped } of matches) {
-                if (signal.aborted || evidence.claimToken === undefined)
-                    return;
-                await presentPending({ artifact, location, participant: seat.participant,
-                    activity: formatActivityId(index), seat: asSeatRef(seat), observationOf: evidence.claimToken, sink: { present() { } }, markSeen: !clipped, signal,
-                    current: (facts) => {
-                        const current = facts.seat(seat.participant);
-                        const prepared = current === undefined || !sameSeat(current, seat) ? undefined : preview(facts, location, seat, index);
-                        const correlation = facts.deliveryByToken(evidence.claimToken);
-                        return prepared !== undefined && payloadHash(prepared.payload) === hash
-                            && correlation?.correlation?.harness === 'opencode'
-                            && correlation.correlation.token !== undefined
-                            && correlation.correlation.payloadHash === hash;
-                    },
-                });
-            }
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-}
-/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
-export async function receiveOpenCodePending(target, env, signal) {
-    const observer = await observeSessionPending(ownerFor(target.sessionId), env);
-    const transport = createOpenCodeWakeTransport(target, signal);
-    let waiting;
-    try {
-        while (!signal.aborted) {
-            const armed = new Promise((resolve) => {
-                waiting = observer.wait(Infinity, { signal, skipImmediate: true, onChangeArmed: resolve });
-                void waiting.catch(() => resolve(false));
-            });
-            if (!await armed) {
-                await waiting;
-                break;
-            }
-            for (const membership of await observer.read({ signal })) {
-                const { location, seat } = membership;
-                if (signal.aborted)
-                    return;
-                const artifact = createArtifactPort(location, undefined, signal);
-                try {
-                    const { value: notifications } = await artifact.read((facts) => {
-                        if (!sameSeat(facts.seat(seat.participant), seat))
-                            return [];
-                        return membership.notifications.filter((note) => automaticWakeEligible(facts.deliveryEvidence(seat.participant, seat.generation, formatActivityId(note.actIndex)), Date.now()));
-                    }, signal);
-                    for (const note of notifications) {
-                        if (signal.aborted)
-                            return;
-                        await deliverPending({ artifact, transport, location, activity: formatActivityId(note.actIndex), now: Date.now() });
-                    }
-                }
-                catch (error) {
-                    if (signal.aborted)
-                        throw signal.reason ?? error;
-                    // A candidate that became unreadable cannot authorize sending; the shared observer
-                    // keeps its subscription and will reconsider the artifact after repair.
-                }
-                finally {
-                    await artifact.close();
-                }
-            }
-            await waiting;
-            waiting = undefined;
-        }
-    }
-    catch (error) {
-        if (!signal.aborted)
-            throw error;
-    }
-    finally {
-        observer.close();
-        await waiting?.catch(() => { });
-    }
-}
-/** Publish the native address into current artifact seats; the legacy route projection is not read. */
-export async function publishOpenCodeAddress(sessionId, env, signal) {
-    await restoreSessionSeats(ownerFor(sessionId), env, { kind: routeKind, address: { sessionId } }, signal);
-    const seats = (await discoverOpenCodeSeats(sessionId, env, signal)).filter(({ seat }) => seat.attachment === 'attached');
-    for (const { location, seat } of seats) {
-        if (signal.aborted)
-            return false;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            await artifact.transactAs({ kind: 'participant', seat: asSeatRef(seat) }, (facts) => facts.updateWakeAddress(asSeatRef(seat), { kind: routeKind, address: { sessionId } }));
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-    return seats.length > 0;
-}
-export async function cancelOpenCodeDeliveries(sessionId, env, signal) {
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        if (seat.attachment !== 'attached')
-            continue;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            const { value: through } = await artifact.read((facts) => facts.header().lastActIndex, signal);
-            if (through >= 0)
-                await artifact.cancelDeliveries(asSeatRef(seat), through, signal);
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-}
-export async function endOpenCodeSession(sessionId, env, signal) {
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        const { Square } = await import('../../square-api.js');
-        const square = await Square.at({ path: location, env });
-        try {
-            await square.endHeld(seat.participant, { owner: seat.owner, generation: seat.generation });
-        }
-        finally {
-            await square.close();
-        }
-    }
-}

package/dist/presentation-operations.d.ts

@@ -1,18 +0,0 @@
-import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Prepare custody before any external effect. A batch prepares every included item first. */
-export declare function preparePendingPresentation(input: Omit<PresentPendingInput, 'sink'>): Promise<import("./delivery-effects.js").PreparedPresentation<{
-    kind: "say";
-    actor: import("./square-core.js").Participant;
-    at?: number;
-    body?: string;
-    metadata?: import("./model.js").ActivityMetadata;
-    delivery?: import("./model.js").ActivityDelivery;
-    mentions?: readonly import("./square-core.js").Participant[];
-    reach?: import("./square-core.js").Reach;
-    reply?: number;
-} & {
-    index: number;
-    at: number;
-}> | undefined>;
-/** A sink error cannot prove that content was never injected. */
-export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -1,86 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { formatActivityId, parseActivityId } from './square-core.js';
-import { isSquareError } from './model.js';
-import { pendingHead, sameJoin } from './delivery.js';
-import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { asSeatRef } from './seats.js';
-import { preparePresentation, presentPrepared } from './delivery-effects.js';
-/** Prepare custody before any external effect. A batch prepares every included item first. */
-export async function preparePendingPresentation(input) {
-    const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
-    if (index === undefined)
-        return undefined;
-    const initial = await input.artifact.read((facts) => {
-        const participant = facts.participant(input.participant);
-        const seat = facts.seat(input.participant);
-        if (!participant?.joined || seat === undefined || seat.attachment !== 'attached' || input.generation !== undefined && input.generation !== seat.generation
-            || input.seat !== undefined && (input.seat.generation !== seat.generation || input.seat.owner !== seat.owner)
-            || input.current?.(facts) === false || !pendingHead(facts, participant.name, index)
-            || deliveryDeferralExpiry(facts, seat, index, input.now ?? Date.now()) !== undefined)
-            return undefined;
-        const item = facts.activity(index);
-        return item?.kind === 'say' ? { participant, seat, item } : undefined;
-    }, input.signal).catch(() => undefined);
-    if (initial?.value === undefined)
-        return undefined;
-    const { participant, seat, item } = initial.value;
-    const ref = asSeatRef(seat);
-    const owns = (facts) => {
-        const current = facts.seat(seat.participant);
-        return current !== undefined && current.attachment === 'attached' && current.owner === seat.owner && current.generation === seat.generation
-            && sameJoin(facts, participant);
-    };
-    const claimToken = randomUUID();
-    return preparePresentation({
-        payload: item, coverage: input.markSeen === false ? 'clipped' : 'full',
-        port: {
-            async claim(signal) {
-                const claimed = await input.artifact.claimDelivery({ seat: ref, activity: formatActivityId(index), kind: 'presentation',
-                    observationOf: input.observationOf, at: input.now ?? Date.now(), leaseMs: input.timeoutMs ?? 5000, claimToken }, signal).catch(() => ({ status: 'stale' }));
-                return claimed.status === 'acquired' ? { token: claimToken, ordinal: claimed.attemptN } : undefined;
-            },
-            async current(signal) {
-                return (await input.artifact.read(facts => owns(facts) && input.current?.(facts) !== false
-                    && pendingHead(facts, participant.name, index) !== undefined
-                    && deliveryDeferralExpiry(facts, seat, index, input.now ?? Date.now()) === undefined, signal ?? input.signal)).value;
-            },
-            async settle(claim, completion) {
-                const success = completion.outcome === 'presented' || completion.outcome === 'clipped';
-                const { value } = await input.artifact.settleAs({ kind: 'participant', seat: ref }, facts => {
-                    // Captured ownership fences truth; post-effect policy/cancellation cannot veto it.
-                    if (!owns(facts))
-                        return false;
-                    if (!facts.completeDelivery({ seat: ref, activity: formatActivityId(index), claimToken: claim.token,
-                        outcome: completion.outcome, at: success ? input.now ?? Date.now() : Date.now(),
-                        ...(completion.reason === 'threw' ? { message: completion.error instanceof Error ? completion.error.message : String(completion.error) } : {}),
-                    }))
-                        return false;
-                    if (completion.outcome === 'presented')
-                        facts.markSeen(participant.name, [index], input.now ?? Date.now());
-                    return true;
-                }).catch(error => {
-                    if (!success || isSquareError(error) && error.code === 'already_joined')
-                        return { value: false };
-                    throw error;
-                });
-                return value;
-            },
-        },
-    }, { signal: input.signal });
-}
-/** A sink error cannot prove that content was never injected. */
-export async function presentPending(input) {
-    const prepared = await preparePendingPresentation(input);
-    if (prepared === undefined)
-        return { presented: false };
-    const report = await presentPrepared(prepared, activity => input.sink.present(activity), {
-        signal: input.signal,
-    });
-    if (report.observation.kind === 'threw')
-        throw report.observation.error;
-    const result = report.settlements[0].result;
-    if (result.persistence.status === 'error')
-        throw result.persistence.error;
-    return report.observation.kind === 'returned' && result.persistence.status === 'recorded'
-        ? { presented: true, activity: prepared.payload } : { presented: false };
-}

package/dist/square-index.d.ts

@@ -1,16 +0,0 @@
-import { type VersionObserver } from './file-changes.js';
-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 owner: Owner;
-}
-export interface SquareIndexQuery {
-    readonly owner?: Owner;
-}
-export declare function squareIndexPath(env?: NodeJS.ProcessEnv): string;
-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, owner: Owner, index: string): Promise<boolean>;
-export declare function observeSquareIndex(env?: NodeJS.ProcessEnv): Promise<VersionObserver<string>>;

package/dist/square-index.js

@@ -1,106 +0,0 @@
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { withFileLock } from './file-lock.js';
-import { canonicalPath } from './canonical-path.js';
-import { observeFileMetadata } from './file-changes.js';
-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'));
-}
-function lockPath(index) {
-    return `${index}.lock`;
-}
-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) || typeof row.owner !== 'string')
-        return undefined;
-    try {
-        validateOwner(row.owner);
-    }
-    catch {
-        return undefined;
-    }
-    if (Object.keys(row).some((key) => !['location', 'owner'].includes(key)))
-        return undefined;
-    return { location: row.location, owner: row.owner };
-}
-async function readEntries(index) {
-    let content;
-    try {
-        content = await fs.readFile(index, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const entries = [];
-    for (const line of content.split('\n')) {
-        if (line.trim() === '')
-            continue;
-        try {
-            const entry = validEntry(JSON.parse(line));
-            if (entry !== undefined)
-                entries.push(entry);
-        }
-        catch { /* Disposable discovery input. */ }
-    }
-    return entries;
-}
-function matches(entry, query) {
-    return query.owner === undefined || entry.owner === query.owner;
-}
-export async function indexedSquareEntries(query = {}, env = process.env) {
-    const entries = await readEntries(squareIndexPath(env));
-    const result = [];
-    const seen = new Set();
-    for (const entry of entries) {
-        if (!matches(entry, query))
-            continue;
-        let location;
-        try {
-            location = await canonicalPath(entry.location);
-        }
-        catch {
-            continue;
-        }
-        const key = JSON.stringify([location, entry.owner]);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        result.push({ location, owner: entry.owner });
-    }
-    return result;
-}
-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, 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 && entry.owner === owner))
-            return false;
-        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 });
-            await fs.rename(temporary, index);
-        }
-        finally {
-            await fs.rm(temporary, { force: true });
-        }
-        return true;
-    }) ?? false;
-}
-export function observeSquareIndex(env = process.env) {
-    return observeFileMetadata(squareIndexPath(env));
-}

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

@@ -1,11 +0,0 @@
-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
- * contents (including legacy routes), changes pragmas, or performs DDL.
- */
-export declare function legacyRowFramingIssue(database: DatabaseSync, applicationId: number, version: 2 | 3, location: string, currentSchemaSql: string): string | undefined;