@astrosheep/square 0.3.106 → 0.4.1

package/dist/square-legacy-framing.js

@@ -1,64 +0,0 @@
-export const FORMAT4_ADDED_OBJECTS = new Set([
-    'seats', 'seat_body', 'delivery_evidence', 'delivery_claim_token', 'delivery_activity', 'delivery_cancellations',
-]);
-export const FORMAT4_REPLACED_OBJECTS = new Set(['routes', 'route_participant', 'route_session']);
-const LEGACY_ROUTES_SQL = `CREATE TABLE routes (
-  position INTEGER PRIMARY KEY CHECK (position >= 0),
-  participant_key_json TEXT COLLATE BINARY NOT NULL,
-  session_json TEXT COLLATE BINARY NOT NULL,
-  kind TEXT NOT NULL CHECK (kind IN ('opencode-server','codex-queue','claude-native','paseo')),
-  updated_at REAL NOT NULL,
-  payload_json TEXT NOT NULL CHECK (json_valid(payload_json))
-);
-CREATE INDEX route_participant ON routes(participant_key_json, position);
-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) => {
-        const match = /^(?:CREATE (?:UNIQUE )?TABLE|CREATE (?:UNIQUE )?INDEX)\s+([a-z_]+)/i.exec(statement);
-        return match === null || !FORMAT4_ADDED_OBJECTS.has(match[1]) && !FORMAT4_REPLACED_OBJECTS.has(match[1]);
-    });
-    const legacyStatements = statements.join(';\n')
-        .replace('  delivery_revision INTEGER NOT NULL CHECK (delivery_revision BETWEEN 0 AND 9007199254740991),\n', '')
-        .replace('  generation_json TEXT NOT NULL DEFAULT \'""\',\n', '');
-    const allStatements = [...legacyStatements.split(';').map((statement) => statement.trim()).filter(Boolean),
-        ...LEGACY_ROUTES_SQL.split(';').map((statement) => statement.trim()).filter(Boolean)];
-    let schema = allStatements.join(';\n');
-    if (version === 2) {
-        schema = schema.replace("kind IN ('join','done','say','hold','resume','read','listen','ignore','unlisten')", "kind IN ('join','done','say','hold','resume','read','listen','ignore')");
-    }
-    return schema.split(';').map((statement) => normalizedSql(statement)).filter(Boolean).sort();
-}
-/**
- * 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 function legacyRowFramingIssue(database, applicationId, version, location, currentSchemaSql) {
-    const identity = database.prepare('SELECT application_id, user_version FROM pragma_application_id, pragma_user_version').get();
-    if (identity.application_id !== applicationId)
-        return 'unrelated SQLite database.';
-    if (identity.user_version !== version)
-        return 'unsupported SQLite format version.';
-    const actual = database.prepare("SELECT sql FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*' AND sql IS NOT NULL").all()
-        .map((row) => typeof row.sql === 'string' ? normalizedSql(row.sql) : '')
-        .sort();
-    const expected = legacyRowSchema(currentSchemaSql, version);
-    if (actual.length !== expected.length || actual.some((sql, index) => sql !== expected[index]))
-        return 'unsupported row schema.';
-    const journalMode = database.prepare('PRAGMA journal_mode').get().journal_mode;
-    if (journalMode !== (location === ':memory:' ? 'memory' : 'delete'))
-        return 'unsupported journal mode.';
-    return undefined;
-}

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

@@ -1,26 +0,0 @@
-import { type HarnessCoordinate } from './owner.js';
-/** Offline conversion input only; never a runtime ownership or evidence reader. */
-export interface LegacyOwner {
-    readonly participant: string;
-    readonly coordinate: HarnessCoordinate;
-}
-export interface LegacyHostData {
-    readonly owners: readonly LegacyOwner[];
-    readonly evidence: readonly LegacyDeliveryEvidence[];
-}
-export interface LegacyDeliveryEvidence {
-    readonly v: 1;
-    readonly location: string;
-    readonly participant: string;
-    readonly session: string;
-    readonly activity: string;
-    readonly kind: 'wake' | 'presentation' | 'lifecycle';
-    readonly outcome: string;
-    readonly at?: number;
-    readonly expiresAt?: number;
-    readonly attemptN?: number;
-    readonly claimToken?: string;
-    readonly [key: string]: unknown;
-}
-/** One frozen snapshot, latest owners only; no age, expiry, or ownership history inference. */
-export declare function readLegacyHostData(location: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<LegacyHostData>;

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

@@ -1,169 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { canonicalPath } from './canonical-path.js';
-import { inSqliteTransaction } from './sqlite-transaction.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;
-const tableSchema = {
-    host_meta: 'CREATE TABLE host_meta (id INTEGER PRIMARY KEY CHECK(id=1), presence_revision INTEGER NOT NULL, evidence_revision INTEGER NOT NULL)',
-    host_presence: 'CREATE TABLE host_presence (seq INTEGER PRIMARY KEY AUTOINCREMENT, location_key TEXT NOT NULL, participant_key TEXT NOT NULL, session_key TEXT NOT NULL, channel_key TEXT NOT NULL, effective_at REAL NOT NULL, row_json TEXT NOT NULL)',
-    host_evidence: 'CREATE TABLE host_evidence (seq INTEGER PRIMARY KEY AUTOINCREMENT, location_key TEXT NOT NULL, participant_key TEXT NOT NULL, session_key TEXT NOT NULL, activity_key TEXT NOT NULL, kind TEXT NOT NULL, outcome TEXT NOT NULL, claim_token_key TEXT, effective_at REAL NOT NULL, row_json TEXT NOT NULL)',
-    host_native_tokens: "CREATE TABLE host_native_tokens (harness TEXT NOT NULL CHECK(harness='claude'), session_key TEXT NOT NULL, token_key TEXT NOT NULL, PRIMARY KEY(harness,session_key,token_key)) WITHOUT ROWID",
-};
-const indexes = {
-    host_presence_identity: ['host_presence', 'location_key', 'participant_key', 'seq'],
-    host_presence_session: ['host_presence', 'session_key', 'seq'],
-    host_presence_time: ['host_presence', 'effective_at'],
-    host_evidence_attention: ['host_evidence', 'location_key', 'participant_key', 'activity_key', 'kind', 'session_key', 'seq'],
-    host_evidence_kind_session: ['host_evidence', 'kind', 'session_key', 'seq'],
-    host_evidence_session: ['host_evidence', 'session_key', 'seq'],
-    host_evidence_token: ['host_evidence', 'location_key', 'participant_key', 'activity_key', 'session_key', 'claim_token_key', 'seq'],
-    host_evidence_outcome_time: ['host_evidence', 'outcome', 'effective_at'],
-    host_evidence_time: ['host_evidence', 'effective_at'],
-    host_evidence_native_token: ['host_evidence', 'session_key', 'claim_token_key', 'seq'],
-};
-const LEGACY_FILES = ['presence.ndjsonl', 'evidence.ndjsonl'];
-function indexSql(name, fields) {
-    return `CREATE INDEX ${name} ON ${fields[0]} (${fields.slice(1).join(',')})`;
-}
-function normalizedSql(sql) {
-    return sql.replace(/\s+/g, '').replace(/;$/, '');
-}
-function recordKey(value) { return JSON.stringify(value); }
-function validateLedger(database) {
-    const application = database.prepare('PRAGMA application_id').get().application_id;
-    const version = database.prepare('PRAGMA user_version').get().user_version;
-    if (application !== LEDGER_APPLICATION_ID || version !== LEDGER_VERSION)
-        throw invalid('unsupported format.');
-    if (database.prepare('PRAGMA journal_mode').get().journal_mode !== 'delete')
-        throw invalid('unsupported journal mode.');
-    const expected = new Map([
-        ...Object.entries(tableSchema),
-        ...Object.entries(indexes).map(([name, fields]) => [name, indexSql(name, fields)]),
-    ]);
-    const schema = database.prepare("SELECT name,sql FROM sqlite_schema WHERE name NOT LIKE 'sqlite_%'").all();
-    if (schema.length !== expected.size || schema.some((row) => typeof row.name !== 'string' || typeof row.sql !== 'string'
-        || !expected.has(row.name) || normalizedSql(row.sql) !== normalizedSql(expected.get(row.name))))
-        throw invalid('schema or indexes are malformed.');
-    const meta = database.prepare('SELECT id,presence_revision,evidence_revision FROM host_meta').all();
-    if (meta.length !== 1 || meta[0].id !== 1 || ![meta[0].presence_revision, meta[0].evidence_revision].every((value) => Number.isSafeInteger(value) && value >= 0))
-        throw invalid('revision header is malformed.');
-    const integrity = database.prepare('PRAGMA integrity_check').all();
-    if (integrity.length !== 1 || integrity[0].integrity_check !== 'ok')
-        throw invalid('integrity check failed.');
-    // Token-only tombstones have no artifact coordinate. Never guess or discard replay protection.
-    if (database.prepare('SELECT 1 FROM host_native_tokens LIMIT 1').get() !== undefined)
-        throw invalid('native token tombstones cannot be mapped safely; preserve replay protection and resolve the ledger offline.');
-}
-function ledgerRoot(env) {
-    return path.resolve(env.SQUARE_HOST_LEDGER_ROOT
-        ?? (env.SQUARE_REGISTRY === undefined ? path.join(env.HOME ?? os.homedir(), '.square', 'host-ledger') : path.dirname(env.SQUARE_REGISTRY)));
-}
-function invalid(detail) {
-    return new Error(`Invalid legacy host ledger: ${detail}`);
-}
-function finite(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}
-function decodeEvidence(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        throw invalid('evidence record is not an object.');
-    const row = value;
-    if (row.v !== 1 || typeof row.location !== 'string' || typeof row.participant !== 'string' || typeof row.session !== 'string'
-        || typeof row.activity !== 'string' || !['wake', 'presentation', 'lifecycle'].includes(row.kind)
-        || typeof row.outcome !== 'string')
-        throw invalid('evidence record fields are malformed.');
-    if (row.at !== undefined && !finite(row.at))
-        throw invalid('evidence time is malformed.');
-    if (row.expiresAt !== undefined && !finite(row.expiresAt))
-        throw invalid('evidence expiry is malformed.');
-    if (row.attemptN !== undefined && (!Number.isSafeInteger(row.attemptN) || row.attemptN < 0))
-        throw invalid('evidence attempt is malformed.');
-    if (row.claimToken !== undefined && (typeof row.claimToken !== 'string' || row.claimToken.length === 0))
-        throw invalid('evidence claim token is malformed.');
-    return row;
-}
-function record(row) {
-    if (!Number.isSafeInteger(row.seq) || row.seq < 1 || typeof row.row_json !== 'string')
-        throw invalid('row framing is malformed.');
-    let value;
-    try {
-        value = JSON.parse(row.row_json);
-    }
-    catch {
-        throw invalid('record JSON is malformed.');
-    }
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        throw invalid('record is not an object.');
-    return value;
-}
-function projections(row, expected) {
-    if (Object.entries(expected).some(([key, value]) => row[key] !== value))
-        throw invalid('record projections are malformed.');
-}
-/** One frozen snapshot, latest owners only; no age, expiry, or ownership history inference. */
-export async function readLegacyHostData(location, env = process.env, signal) {
-    if (signal?.aborted)
-        throw signal.reason;
-    const root = ledgerRoot(env);
-    const file = path.join(root, LEDGER_FILENAME);
-    try {
-        await fs.promises.stat(file);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-        for (const legacy of LEGACY_FILES) {
-            try {
-                await fs.promises.stat(path.join(root, legacy));
-                throw invalid('legacy line sources require separate host-ledger migration.');
-            }
-            catch (nested) {
-                if (nested.code !== 'ENOENT')
-                    throw nested;
-            }
-        }
-        return { owners: [], evidence: [] };
-    }
-    const uri = pathToFileURL(file);
-    uri.searchParams.set('mode', 'ro');
-    const database = new DatabaseSync(uri.href);
-    try {
-        const canonical = await canonicalPath(location);
-        return await inSqliteTransaction(database, false, () => validateLedger(database), () => {
-            const owners = database.prepare(`SELECT * FROM (
-        SELECT *,row_number() OVER (PARTITION BY participant_key ORDER BY effective_at DESC,seq DESC) AS ordinal
-        FROM host_presence WHERE location_key=?) WHERE ordinal=1`).all(recordKey(canonical)).map(row => {
-                const value = record(row);
-                const at = value.at ?? value.updatedAt;
-                if (value.v !== 1 || value.location !== canonical || typeof value.participant !== 'string'
-                    || !finite(at))
-                    throw invalid('owner fields are malformed.');
-                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(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));
-                if (value.location !== canonical || !finite(value.at))
-                    throw invalid('evidence fields are malformed.');
-                projections(row, { location_key: recordKey(canonical), participant_key: recordKey(nameKey(value.participant)), session_key: recordKey(value.session),
-                    activity_key: recordKey(value.activity), kind: value.kind, outcome: value.outcome,
-                    claim_token_key: value.claimToken === undefined ? null : recordKey(value.claimToken), effective_at: value.at });
-                return value;
-            });
-            return { owners, evidence };
-        }, signal);
-    }
-    finally {
-        database.close();
-    }
-}

package/dist/square-migration.d.ts

@@ -1,30 +0,0 @@
-import { type SquareState } from './square-sqlite.js';
-/** Validate persisted v1 JSON; row codecs share activity and lease acceptance. */
-export declare function validateSquareState(value: unknown): SquareState;
-export interface MigrationCounts {
-    readonly activities: number;
-    readonly receipts: number;
-    readonly leases: number;
-    readonly routes: number;
-    readonly recoveredSeats: number;
-    readonly unownedStanding: number;
-    readonly sharedBodySeats: number;
-    readonly skippedEvidence: number;
-}
-export interface MigrationOutcome {
-    readonly status: 'migrated' | 'already-current';
-    /** Participants standing after the conversion, for the CLI header. */
-    readonly standing: number;
-    readonly counts?: MigrationCounts;
-}
-/**
- * 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-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.
- */
-export declare function migrateSquareFile(location: string, signal?: AbortSignal, env?: NodeJS.ProcessEnv): Promise<MigrationOutcome>;