@astrosheep/square 0.3.63 → 0.3.64

package/dist/paseo-connection.js

@@ -1,141 +0,0 @@
-import fs from 'node:fs';
-import { homedir } from 'node:os';
-import path from 'node:path';
-import { DaemonClient } from '@getpaseo/client/internal/daemon-client';
-import WebSocket from 'ws';
-const DEFAULT_HOST = 'localhost:6767';
-const DEFAULT_CONNECT_TIMEOUT_MS = 3_000;
-function paseoHome(env) {
-    return env.PASEO_HOME?.trim() || path.join(homedir(), '.paseo');
-}
-function expandHome(value) {
-    return value === '~' ? homedir() : value.startsWith('~/') ? path.join(homedir(), value.slice(2)) : value;
-}
-function normalizeHost(raw) {
-    if (typeof raw !== 'string' || raw.trim() === '')
-        return undefined;
-    const value = raw.trim();
-    if (value.startsWith('unix://') || value.startsWith('pipe://') || value.startsWith('tcp://'))
-        return value;
-    if (value.startsWith('\\\\.\\pipe\\'))
-        return `pipe://${value}`;
-    if (value.startsWith('/') || value.startsWith('~/'))
-        return `unix://${expandHome(value)}`;
-    if (/^\d+$/.test(value))
-        return `127.0.0.1:${value}`;
-    return value.includes(':') ? value : undefined;
-}
-function configuredHost(env) {
-    try {
-        const config = JSON.parse(fs.readFileSync(path.join(paseoHome(env), 'config.json'), 'utf8'));
-        return normalizeHost(config.daemon?.listen ?? config.listen);
-    }
-    catch {
-        return undefined;
-    }
-}
-function pidHost(env) {
-    try {
-        const pid = JSON.parse(fs.readFileSync(path.join(paseoHome(env), 'paseo.pid'), 'utf8'));
-        return normalizeHost(pid.listen ?? pid.sockPath);
-    }
-    catch {
-        return undefined;
-    }
-}
-function isIpc(host) {
-    return host !== undefined && (host.startsWith('unix://') || host.startsWith('pipe://'));
-}
-function supportsIpcHost(host) {
-    return process.platform !== 'win32' || !host.startsWith('unix://');
-}
-/** Match the host precedence used by the Paseo CLI for local daemon connections. */
-export function paseoDaemonHosts(env = process.env) {
-    const explicit = normalizeHost(env.PASEO_HOST);
-    if (explicit !== undefined)
-        return [explicit];
-    const candidates = [];
-    const listen = normalizeHost(env.PASEO_LISTEN);
-    const pid = pidHost(env);
-    const configured = configuredHost(env);
-    if (isIpc(listen) && supportsIpcHost(listen))
-        candidates.push(listen);
-    if (isIpc(pid) && supportsIpcHost(pid))
-        candidates.push(pid);
-    if (isIpc(configured) && supportsIpcHost(configured))
-        candidates.push(configured);
-    if (configured !== undefined && !isIpc(configured) && configured !== '127.0.0.1:6767')
-        candidates.push(configured);
-    candidates.push(DEFAULT_HOST);
-    return [...new Set(candidates)];
-}
-function uriPassword(uri) {
-    const value = uri.searchParams.get('password');
-    return value === null || value === '' ? undefined : value;
-}
-export function resolvePaseoDaemonTarget(host, env = process.env) {
-    const passwordFromEnv = env.PASEO_PASSWORD?.trim() || undefined;
-    if (host.startsWith('unix://') || host.startsWith('pipe://')) {
-        if (process.platform === 'win32' && host.startsWith('unix://')) {
-            throw new Error('Paseo Unix socket targets are unsupported on Windows; use pipe:// or tcp://.');
-        }
-        const prefix = host.startsWith('unix://') ? 'unix://' : 'pipe://';
-        const socketPath = expandHome(host.slice(prefix.length).trim());
-        if (socketPath === '')
-            throw new Error('Invalid Paseo IPC target: missing socket path.');
-        return {
-            type: 'ipc',
-            url: host.startsWith('unix://') ? `ws+unix://${socketPath}:/ws` : 'ws://localhost/ws',
-            socketPath,
-            ...(passwordFromEnv === undefined ? {} : { password: passwordFromEnv }),
-        };
-    }
-    if (host.startsWith('tcp://')) {
-        const uri = new URL(host);
-        const hostname = uri.hostname.replace(/^\[|\]$/g, '');
-        const endpoint = `${hostname.includes(':') ? `[${hostname}]` : hostname}:${uri.port || '6767'}`;
-        const secure = uri.searchParams.get('ssl') === 'true';
-        const password = uriPassword(uri) ?? passwordFromEnv;
-        return {
-            type: 'tcp',
-            url: `${secure ? 'wss' : 'ws'}://${endpoint}/ws`,
-            ...(password === undefined ? {} : { password }),
-        };
-    }
-    return {
-        type: 'tcp',
-        url: `ws://${host.replace(/\/$/, '')}/ws`,
-        ...(passwordFromEnv === undefined ? {} : { password: passwordFromEnv }),
-    };
-}
-function webSocketFactory(target) {
-    return (url, options) => new WebSocket(url, options?.protocols, {
-        headers: options?.headers,
-        ...(target.type === 'ipc' ? { socketPath: target.socketPath } : {}),
-    });
-}
-export async function connectPaseoDaemon(env = process.env, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
-    let lastError;
-    for (const host of paseoDaemonHosts(env)) {
-        const target = resolvePaseoDaemonTarget(host, env);
-        const client = new DaemonClient({
-            url: target.url,
-            clientId: `square-${process.pid}-${Date.now()}`,
-            clientType: 'cli',
-            appVersion: 'square',
-            password: target.password,
-            connectTimeoutMs,
-            webSocketFactory: webSocketFactory(target),
-            reconnect: { enabled: false },
-        });
-        try {
-            await client.connect();
-            return client;
-        }
-        catch (error) {
-            lastError = error;
-            await client.close().catch(() => { });
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error('Unable to connect to the Paseo daemon.');
-}

package/dist/presence.d.ts

@@ -1,2 +0,0 @@
-/** Commit seen only for complete, actually rendered boundary bodies. */
-export declare function markBoundarySeen(squarePath: string, name: string, actIndexes: readonly number[], at?: number): Promise<void>;

package/dist/presence.js

@@ -1,24 +0,0 @@
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
-import { recordObservation } from './runtime.js';
-/** Commit seen only for complete, actually rendered boundary bodies. */
-export async function markBoundarySeen(squarePath, name, actIndexes, at = Date.now()) {
-    let square;
-    try {
-        square = await openSquare(squarePath);
-    }
-    catch {
-        return;
-    }
-    try {
-        await square.artifact.transact((state) => {
-            let changed = false;
-            for (const index of actIndexes)
-                changed = recordObservation(state, name, index, 'seen', at) || changed;
-            return changed ? { state, result: undefined } : { result: undefined };
-        });
-    }
-    finally {
-        await closeOpenSquare(square);
-    }
-}

package/dist/presented.d.ts

@@ -1,2 +0,0 @@
-export declare function presentedPath(env?: NodeJS.ProcessEnv): string;
-export declare function hasPresentedForOwner(sessionId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;

package/dist/presented.js

@@ -1,10 +0,0 @@
-import os from 'node:os';
-import { hostLedgerRoot } from './host-ledger-root.js';
-import path from 'node:path';
-import { canonicalSquarePath } from './registry.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-import { formatActivityId } from './square-core.js';
-import { projectPresentationEvidence } from './square-projections.js';
-export function presentedPath(env = process.env) { return env.SQUARE_PRESENTED || path.join(os.homedir(), '.square', 'presented.ndjsonl'); }
-function evidence(env = process.env) { const file = presentedPath(env); return createHostLedgerPort({ rootPath: hostLedgerRoot(env) }); }
-export async function hasPresentedForOwner(sessionId, squarePath, name, actIndex, env = process.env, now = Date.now()) { const resolved = await canonicalSquarePath(squarePath); return (await projectPresentationEvidence({ hostLedger: evidence(env), now, location: resolved, participant: name, sessionId, activity: formatActivityId(actIndex) })).some((row) => row.outcome === 'presented'); }

package/dist/state-cell.d.ts

@@ -1,14 +0,0 @@
-import type { SquareState } from './model.js';
-/** Synchronous state transition seam shared by memory and file storage. */
-export interface StateCell {
-    transact<R>(fn: (state: SquareState, version: number) => {
-        state?: SquareState;
-        result: R;
-    }, signal?: AbortSignal): Promise<R>;
-    read(signal?: AbortSignal): Promise<{
-        state: SquareState;
-        version: number;
-    }>;
-    changed(sinceVersion: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
-    close(): Promise<void>;
-}

package/dist/wake-port.d.ts

@@ -1,23 +0,0 @@
-import type { WakeAdapter, WakeDispatchResult } from './delivery.js';
-import type { WakeRoute } from './model.js';
-export interface WakePortHooks {
-    nextAttemptN(): number | Promise<number>;
-    beforeSend(route: WakeRoute, attemptN: number): Promise<boolean>;
-    record(route: WakeRoute, attemptN: number, result: Exclude<WakeDispatchResult, {
-        outcome: 'cancelled' | 'unavailable';
-    }>): Promise<void>;
-    invalidate?(route: WakeRoute, result: Extract<WakeDispatchResult, {
-        outcome: 'unavailable';
-    }>): Promise<void>;
-}
-export type WakePortResult = {
-    outcome: 'accepted' | 'unknown' | 'cancelled';
-} | {
-    outcome: 'exhausted';
-};
-/** Select routes globally; adapters own only transport-specific live proof and dispatch. */
-export declare class WakePort {
-    private readonly adapters;
-    constructor(adapters: WakeAdapter[]);
-    dispatch(routes: readonly WakeRoute[], payload: string | ((route: WakeRoute) => string), hooks: WakePortHooks): Promise<WakePortResult>;
-}

package/dist/wake-port.js

@@ -1,27 +0,0 @@
-/** Select routes globally; adapters own only transport-specific live proof and dispatch. */
-export class WakePort {
-    adapters;
-    constructor(adapters) {
-        this.adapters = new Map(adapters.map((adapter) => [adapter.kind, adapter]));
-    }
-    async dispatch(routes, payload, hooks) {
-        for (const route of routes) {
-            const adapter = this.adapters.get(route.kind);
-            if (adapter === undefined)
-                continue;
-            const attemptN = await hooks.nextAttemptN();
-            const result = await adapter.dispatch(route.address, typeof payload === 'function' ? payload(route) : payload, () => hooks.beforeSend(route, attemptN));
-            if (result.outcome === 'cancelled')
-                return result;
-            if (result.outcome === 'unavailable') {
-                if (result.routeStale === true)
-                    await hooks.invalidate?.(route, result);
-                continue;
-            }
-            await hooks.record(route, attemptN, result);
-            if (result.outcome === 'accepted' || result.outcome === 'unknown')
-                return { outcome: result.outcome };
-        }
-        return { outcome: 'exhausted' };
-    }
-}