@astrosheep/square 0.3.106 → 0.4.0

package/dist/artifact.js

@@ -1,15 +1,27 @@
-import { DatabaseSync } from 'node:sqlite';
-import { retrySqliteBusy, inSqliteTransaction } from './sqlite-transaction.js';
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
 import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { observeFileVersion } from './file-changes.js';
+import fs from 'node:fs';
 import { canonicalPath } from './canonical-path.js';
 import { InternalSquareError, SquareError } from './model.js';
 import { wrapSquareWrite } from './square-domain.js';
-import { APPLICATION_ID, CURRENT_USER_VERSION, createSqliteDriver, initializeSqlite, exportSqliteState, inspectSqlite, invalidArtifact, validateSqliteHeader, emptyRuntimeState } from './square-sqlite.js';
+import { createSqliteDriver, initializeSqlite, exportSqliteState, inspectSqlite, emptyRuntimeState, squareStoreFormat } from './square-sqlite.js';
+import { createChannelSqlite } from './sqlite-channel.js';
+import { channelLowerSchema } from './channel-sqlite-schema.js';
+import { resetStorageMeta } from './sqlite-framing.js';
+import { createArtifactStore, createStoreFile, replaceStoreFile, inspectStore, observeStoreRevision } from './artifact-store.js';
+import { channelReads, channelWrites } from './channel-artifact.js';
+export { openExistingSquareDatabase } from './artifact-store.js';
+export function channelArtifact(port) {
+    return {
+        read: (select, signal) => port.read(facts => select(facts.channel), signal),
+        transactAs: (authority, change, signal) => port.transactAs(authority, facts => change(facts.channel), signal),
+        claimDelivery: (input, signal) => port.claimDelivery(input, signal),
+        prepareDelivery: (input, signal) => port.prepareDelivery(input, signal),
+        completeDelivery: (input, signal) => port.completeDelivery(input, signal),
+        cancelDeliveries: (seat, through, signal) => port.cancelDeliveries(seat, through, signal),
+        changed: (since, timeout, signal) => port.changed(since, timeout, signal), close: () => port.close(),
+    };
+}
+const format = squareStoreFormat(channelLowerSchema, resetStorageMeta);
 /** Explicit-lifetime holder of one reused artifact connection. Request cancellation
  * never becomes the shared connection's lifetime; close drains the owner once. */
 export function createSquareResourceOwner() {
@@ -53,26 +65,26 @@ function normalizedLines(value) {
     return normalized === '' ? [] : normalized.split('\n');
 }
 /** All build paths share configuration validation and lazy guide preparation. */
-export function prepareSquareBuild(options, snippet) {
+export function prepareSquareBuild(options, snippet, includeGuides = true) {
     if (options.hardCap !== undefined && options.hardCap !== null
         && (!Number.isSafeInteger(options.hardCap) || options.hardCap < 1))
         throw new SquareError('invalid_args', 'hardCap must be a positive integer or null');
     if (options.throttlePerMinute !== undefined
         && (!Number.isSafeInteger(options.throttlePerMinute) || options.throttlePerMinute < 1))
         throw new SquareError('invalid_args', 'throttlePerMinute must be a positive integer');
-    const guides = [readGuide('participant')];
-    if (options.template !== undefined)
+    const guides = includeGuides ? [readGuide('participant')] : [];
+    if (includeGuides && options.template !== undefined)
         guides.push(readGuide(options.template));
     return {
         hardCap: options.hardCap ?? null,
         ...(options.throttlePerMinute === undefined ? {} : { throttlePerMinute: options.throttlePerMinute }),
-        preamble: normalizedLines(snippet), warmup: normalizedLines(guides.join('\n\n')),
+        preamble: normalizedLines(snippet), warmup: includeGuides ? normalizedLines(guides.join('\n\n')) : [],
         acts: [], runtime: emptyRuntimeState(),
     };
 }
 /** File build owns publication and CLI conflict semantics, not host resources. */
-export async function createSquare(location, options, snippet, signal) {
-    const state = prepareSquareBuild(options, snippet);
+export async function createSquare(location, options, snippet, signal, includeGuides = true) {
+    const state = prepareSquareBuild(options, snippet, includeGuides);
     if (options.force) {
         await writeSquareFile(location, state, signal);
     }
@@ -81,359 +93,70 @@ export async function createSquare(location, options, snippet, signal) {
     }
     return { hardCap: state.hardCap, ...(state.throttlePerMinute === undefined ? {} : { throttlePerMinute: state.throttlePerMinute }) };
 }
-function requireSquareExtension(location) {
-    if (!location.endsWith('.square'))
-        throw new SquareError('invalid_args', `Square artifacts must use the .square extension: ${location}`);
-}
-function storageError(error, location) {
-    if (!(error instanceof Error) || error instanceof SquareError || error instanceof InternalSquareError)
-        return error;
-    if (/unable to open database file|no such file|SQLITE_CANTOPEN/i.test(error.message))
-        return new InternalSquareError('not_found', `square file not found: ${location}`);
-    if (/not a database|SQLITE_NOTADB/i.test(error.message))
-        return invalidArtifact('not a SQLite database.');
-    return error;
-}
-/** Private artifact-boundary connection shared with explicit migration. Never creates a path. */
-export function openExistingSquareDatabase(location) {
-    requireSquareExtension(location);
-    const uri = pathToFileURL(path.resolve(location));
-    uri.searchParams.set('mode', 'rw');
-    try {
-        return new DatabaseSync(uri.href);
-    }
-    catch (error) {
-        throw storageError(error, location);
-    }
-}
-function abort(signal) {
-    if (signal?.aborted)
-        throw signal.reason ?? new Error('Square artifact operation aborted');
-}
-function synchronous(value) {
-    if (value !== null && (typeof value === 'object' || typeof value === 'function') && typeof value.then === 'function') {
-        void Promise.resolve(value).catch(() => undefined);
-        throw new TypeError('Square artifact callbacks must be synchronous.');
-    }
-}
 const readMethods = [
     'header', 'participant', 'roster', 'attention', 'incomingAttention',
-    'activity', 'activityHeads', 'activities', 'activityCount', 'contextIndexes', 'sayOrdinals', 'recentSayTimes',
-    'audience', 'directed', 'directedAt', 'directedCount', 'pendingAudience',
+    'activity', 'activityByMessage', 'activityHeads', 'activities', 'activityCount', 'contextIndexes', 'sayOrdinals', 'recentSayTimes',
+    'audience', 'directed', 'directedAt', 'directedCount',
     'receipt', 'receiptFacts', 'lease', 'participantCounts', 'seat', 'seatsForOwner',
     'deliveryEvidence', 'deliveryByToken', 'cancelledThrough', 'deliveryDeferrals',
 ];
-const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'reattachSeat', 'detachSeat', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
-/** One connection, ordered operations, guarded synchronous transaction capabilities. */
+const writeMethods = ['applyLanding', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'reattachSeat', 'detachSeat'];
+/** Agora composition over the same lower SQL and ordered store used by standalone Channel. */
 export function createArtifactPort(location, initial, externalSignal) {
-    let database;
-    let closed = false, inCallback = false;
-    let tail = Promise.resolve();
-    const cancel = new AbortController();
-    const canonical = initial === undefined ? canonicalPath(location) : Promise.resolve(location);
-    if (initial !== undefined) {
-        database = new DatabaseSync(':memory:');
-        try {
-            initializeSqlite(database, initial);
-            database.exec(`PRAGMA application_id=${APPLICATION_ID}; PRAGMA user_version=${CURRENT_USER_VERSION}`);
-        }
-        catch (error) {
-            database.close();
-            throw error;
-        }
-    }
-    const combined = (signal) => AbortSignal.any([cancel.signal, ...(externalSignal ? [externalSignal] : []), ...(signal ? [signal] : [])]);
-    const validate = (db) => validateSqliteHeader(db, initial === undefined ? location : ':memory:');
-    async function connection(signal) {
-        if (database)
-            return database;
-        location = await canonical;
-        abort(signal);
-        database = openExistingSquareDatabase(location);
-        try {
-            await retrySqliteBusy(() => validate(database), signal);
-            database.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL');
-        }
-        catch (error) {
-            database.close();
-            database = undefined;
-            throw storageError(error, location);
-        }
-        return database;
-    }
-    function queue(operation, operationSignal) {
-        if (inCallback)
-            throw new TypeError('Square artifact operations cannot nest inside a callback.');
-        if (closed)
-            return Promise.reject(new Error('Square artifact is closed'));
-        const result = tail.then(() => {
-            abort(operationSignal);
-            return operation(operationSignal);
-        });
-        tail = result.then(() => undefined, () => undefined);
-        return result;
-    }
-    async function transaction(callback, write, signal, authority) {
-        const db = await connection(signal);
-        return inSqliteTransaction(db, write, () => validate(db), (header) => {
-            const driver = createSqliteDriver(db), version = header.revision;
-            let active = true, failed = false, failure;
-            function guard(fn) {
-                return ((...args) => {
-                    if (!active)
-                        throw new Error('Square artifact transaction capability expired');
-                    abort(signal);
-                    if (failed)
-                        throw failure;
-                    try {
-                        return fn(...args);
-                    }
-                    catch (error) {
-                        failed = true;
-                        failure = storageError(error, location);
-                        throw failure;
-                    }
-                });
-            }
-            const reads = Object.fromEntries(readMethods.map(name => [name, guard(driver[name])]));
-            const writes = Object.fromEntries(writeMethods.map(name => [name, guard(driver[name])]));
+    const store = createArtifactStore(location, format, initial === undefined ? undefined : db => initializeSqlite(db, initial, 0, channelLowerSchema), externalSignal);
+    function transaction(select, write, authority, signal, settlement = false) {
+        return store.run(write, ({ db, guard, track }) => {
+            const channel = createChannelSqlite(db);
+            const driver = createSqliteDriver(db, channel);
+            track(driver);
+            const reads = Object.assign(Object.fromEntries(readMethods.map(name => [name, guard(driver[name])])), { channel: channelReads(channel, guard) });
+            const writes = Object.assign(Object.fromEntries(writeMethods.map(name => [name, guard(driver[name])])), { channel: channelWrites(channel, guard) });
             const gate = write ? wrapSquareWrite(reads, writes, authority) : undefined;
-            const facts = gate?.facts ?? reads;
-            let value;
-            inCallback = true;
-            try {
-                value = callback(facts);
-                synchronous(value);
-                if (!failed)
-                    gate?.complete();
-            }
-            finally {
-                inCallback = false;
-                active = false;
-            }
-            if (failed)
-                throw failure;
-            const changed = write && driver.changed;
-            const deliveryChanged = write && driver.deliveryChanged;
-            if (changed || deliveryChanged) {
-                if (version === Number.MAX_SAFE_INTEGER)
-                    throw invalidArtifact('revision cannot advance beyond the safe integer limit.');
-                db.prepare('UPDATE square_meta SET revision=revision+?, delivery_revision=delivery_revision+? WHERE id=1').run(Number(changed), Number(deliveryChanged));
-            }
-            return {
-                value, version: version + Number(changed), changed, deliveryChanged
-            };
-        }, signal);
-    }
-    const revision = signal => queue(async (s) => {
-        const db = await connection(s);
-        return inSqliteTransaction(db, false, () => validate(db), (header) => header.revision, s);
-    }, combined(signal));
-    return {
-        read: (select, signal) => queue(async (s) => {
-            const { value, version } = await transaction(select, false, s);
-            return { value, version };
-        }, combined(signal)),
-        transactAs: (authority, change, signal) => queue(s => transaction(change, true, s, authority), combined(signal)),
-        // Keep the acquired connection and authority, not the cancelled work lifetime. A
-        // blocked evidence commit/cleanup gets five seconds, and close still cancels it.
-        settleAs: (authority, change) => queue(s => transaction(change, true, s, authority), AbortSignal.any([cancel.signal, AbortSignal.timeout(5000)])),
-        revision,
-        async deliveryRevision(signal) {
-            return queue(async (s) => {
-                const db = await connection(s);
-                return inSqliteTransaction(db, false, () => validate(db), (header) => header.deliveryRevision, s);
-            }, combined(signal));
-        },
-        async claimDelivery(input, signal) {
-            return (await this.transactAs({ kind: 'participant', seat: input.seat }, (facts) => facts.claimDelivery(input), signal)).value;
-        },
-        async prepareDelivery(input, signal) {
-            return (await this.transactAs({ kind: 'participant', seat: input.seat }, facts => facts.prepareDelivery(input), signal)).value;
-        },
-        async completeDelivery(input, signal) {
-            return (await this.transactAs({ kind: 'participant', seat: input.seat }, facts => facts.completeDelivery(input), signal)).value;
-        },
+            const value = select(gate?.facts ?? reads);
+            gate?.complete();
+            return value;
+        }, signal, settlement);
+    }
+    const port = {
+        read: (select, signal) => transaction(select, false, undefined, signal),
+        transactAs: (authority, change, signal) => transaction(change, true, authority, signal),
+        settleAs: (authority, change) => transaction(change, true, authority, undefined, true),
+        revision: store.revision, deliveryRevision: store.deliveryRevision,
+        async claimDelivery(input, signal) { return (await port.transactAs({ kind: 'participant', seat: input.seat }, facts => facts.channel.claimDelivery(input), signal)).value; },
+        async prepareDelivery(input, signal) { return (await port.transactAs({ kind: 'participant', seat: input.seat }, facts => facts.channel.prepareDelivery(input), signal)).value; },
+        async completeDelivery(input, signal) { return (await port.transactAs({ kind: 'participant', seat: input.seat }, facts => facts.channel.completeDelivery(input), signal)).value; },
         async cancelDeliveries(seat, through, signal) {
-            return (await this.transactAs({ kind: 'participant', seat }, facts => {
-                const boundary = through ?? facts.header().lastActIndex;
-                return boundary < 0 ? false : facts.cancelThrough(seat, boundary);
+            return (await port.transactAs({ kind: 'participant', seat }, facts => {
+                const boundary = through ?? facts.channel.header().lastMessageIndex;
+                return boundary < 0 ? false : facts.channel.cancelThrough(seat, boundary);
             }, signal)).value;
         },
-        async changed(since, timeout, signal) {
-            if (inCallback)
-                throw new TypeError('Square artifact operations cannot nest inside a callback.');
-            if (closed)
-                return false;
-            const s = combined(signal), deadline = Date.now() + Math.max(0, timeout);
-            if (initial !== undefined) {
-                try {
-                    do {
-                        if (await revision(s) > since)
-                            return true;
-                        if (Date.now() >= deadline)
-                            return false;
-                        await sleep(Math.min(25, deadline - Date.now()), undefined, { signal: s });
-                    } while (!closed);
-                }
-                catch (error) {
-                    if (closed)
-                        return false;
-                    abort(s);
-                    throw error;
-                }
-                return false;
-            }
-            const observer = await observeSquareRevision(await canonical);
-            try {
-                return await observer.changed(since, Math.max(0, deadline - Date.now()), s);
-            }
-            catch (error) {
-                if (closed)
-                    return false;
-                throw error;
-            }
-            finally {
-                observer.close();
-            }
-        },
-        async close() {
-            if (inCallback)
-                throw new TypeError('Square artifact cannot close inside a callback.');
-            if (closed) {
-                await tail;
-                return;
-            }
-            closed = true;
-            cancel.abort(new Error('Square artifact is closed'));
-            await tail;
-            database?.close();
-            database = undefined;
-        },
+        changed: store.changed, close: store.close,
     };
+    return port;
 }
-async function temporaryArtifact(location) {
-    await fs.promises.mkdir(path.dirname(location), { recursive: true });
-    const temporary = path.join(path.dirname(location), `.${path.basename(location)}.${process.pid}.${randomUUID()}.tmp`);
-    const handle = await fs.promises.open(temporary, 'wx');
-    await handle.close();
-    return temporary;
-}
-async function initializeFile(location, state, signal) {
-    const db = new DatabaseSync(location);
-    try {
-        db.exec('PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL');
-        await inSqliteTransaction(db, true, () => { }, () => {
-            initializeSqlite(db, state);
-            db.exec(`PRAGMA application_id=${APPLICATION_ID}; PRAGMA user_version=${CURRENT_USER_VERSION}`);
-        }, signal);
-    }
-    finally {
-        db.close();
-    }
-    const handle = await fs.promises.open(location, 'r+');
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-/** New-format creation; initial authority is accepted only at this explicit boundary. */
-export async function createSquareFile(location, state, signal) {
-    abort(signal);
-    location = await canonicalPath(location);
-    requireSquareExtension(location);
-    const temporary = await temporaryArtifact(location);
-    try {
-        await initializeFile(temporary, state, signal);
-        abort(signal);
-        try {
-            await fs.promises.link(temporary, location);
-            return true;
-        }
-        catch (error) {
-            if (error.code === 'EEXIST')
-                return false;
-            throw error;
-        }
-    }
-    finally {
-        await fs.promises.unlink(temporary).catch(() => undefined);
-    }
-}
-/** Explicit build --force / fixture import, never a runtime state-replacement callback. */
-export async function writeSquareFile(location, state, signal) {
-    location = await canonicalPath(location);
-    if (await createSquareFile(location, state, signal))
-        return;
-    abort(signal);
-    const db = openExistingSquareDatabase(location);
-    try {
-        await retrySqliteBusy(() => validateSqliteHeader(db, location), signal);
-        db.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL');
-        await inSqliteTransaction(db, true, () => validateSqliteHeader(db, location), () => {
-            const revision = createSqliteDriver(db).header().revision;
-            if (revision === Number.MAX_SAFE_INTEGER)
-                throw invalidArtifact('revision cannot advance beyond the safe integer limit.');
-            for (const table of ['landed_audience', 'attention', 'participants', 'delivery_deferrals', 'delivery_cancellations', 'delivery_evidence', 'seats', 'catch_leases', 'receipts', 'activities', 'square_meta'])
-                db.exec(`DROP TABLE ${table}`);
-            initializeSqlite(db, state, revision + 1);
-        }, signal);
-    }
-    finally {
-        db.close();
-    }
+export function createSquareFile(location, state, signal) {
+    return createStoreFile(location, format, db => initializeSqlite(db, state, 0, channelLowerSchema), signal);
 }
-async function inspectFile(location, select, signal) {
-    const db = openExistingSquareDatabase(location);
-    try {
-        return await inSqliteTransaction(db, false, () => validateSqliteHeader(db, location), () => select(db), signal);
-    }
-    catch (error) {
-        throw storageError(error, location);
-    }
-    finally {
-        db.close();
-    }
+export function writeSquareFile(location, state, signal) {
+    return replaceStoreFile(location, format, (db, revision) => initializeSqlite(db, state, revision, channelLowerSchema), signal);
 }
-/** Explicit test/export projection. Hot callers must use the typed port. */
 export function readSquareSnapshot(location, signal) {
-    return inspectFile(location, db => ({ state: exportSqliteState(db), revision: createSqliteDriver(db).header().revision }), signal);
+    return inspectStore(location, format, db => ({ state: exportSqliteState(db), revision: createSqliteDriver(db).header().revision }), signal);
 }
 export function readSquareRevision(location, signal) {
-    return inspectFile(location, db => createSqliteDriver(db).header().revision, signal);
+    return inspectStore(location, format, db => createSqliteDriver(db).header().revision, signal);
 }
 export function readSquareDeliveryRevision(location, signal) {
-    return inspectFile(location, db => createSqliteDriver(db).header().deliveryRevision, signal);
-}
-function observeRevision(location, revision) {
-    const read = revision === 'square-revision' ? readSquareRevision : readSquareDeliveryRevision;
-    return observeFileVersion(location, revision, async (file, signal) => {
-        try {
-            return await read(file, signal);
-        }
-        catch (error) {
-            abort(signal);
-            if (error instanceof InternalSquareError && error.code === 'not_found')
-                return null;
-            throw error;
-        }
-    });
-}
-export function observeSquareRevision(location) {
-    return observeRevision(location, 'square-revision');
-}
-export function observeSquareDeliveryRevision(location) {
-    return observeRevision(location, 'square-delivery-revision');
+    return inspectStore(location, format, db => createSqliteDriver(db).header().deliveryRevision, signal);
 }
+export const observeSquareRevision = (location) => observeStoreRevision(location, format);
+export const observeSquareDeliveryRevision = (location) => observeStoreRevision(location, format, true);
 export async function diagnoseSquareFile(location) {
     try {
-        return { problems: [], ...await inspectFile(await canonicalPath(location), inspectSqlite) };
+        return { problems: [], ...await inspectStore(await canonicalPath(location), format, db => inspectSqlite(db, channelLowerSchema)) };
     }
     catch (error) {
-        if (error instanceof SquareError && error.facts?.reason === 'migration_required')
-            return { migrationRequired: error.message, problems: [] };
         return { unfixable: error instanceof Error ? error.message : String(error), problems: [] };
     }
 }

package/dist/attention-presentation.d.ts

@@ -1,4 +1,5 @@
-import type { ActivityDelivery, DirectedNotificationRoute } from './model.js';
+export { projectChannelNotification, renderSquareReminder } from './channel-presentation.js';
+import type { DirectedNotificationRoute } from './model.js';
 export declare const ATTENTION_BODY_MAX = 200;
 export interface AttentionPreview {
     squarePath: string;
@@ -7,14 +8,39 @@ export interface AttentionPreview {
     actor: string;
     route: DirectedNotificationRoute;
     body: string;
-    delivery?: ActivityDelivery;
+    preview?: string;
 }
-export declare function previewAttentionBody(body: string, delivery?: ActivityDelivery): string;
-export declare function attentionBodyIsClipped(body: string, delivery?: ActivityDelivery): boolean;
+export declare function previewAttentionBody(body: string): string;
+export declare function attentionBodyIsClipped(body: string): boolean;
 export declare function displayAttentionPath(squarePath: string): string;
 export declare function renderAttentionDescription({ actor, route }: Pick<AttentionPreview, 'actor' | 'route'>): string;
-/** Full notification text for human-facing expansion, never the bounded model preview. */
+/** The sole source adapter: transports and cards consume this projection, not delivery modes. */
+export declare function projectNotification(attention: AttentionPreview): {
+    text: string;
+    full: string;
+    preview: string;
+    description: string;
+    clipped: boolean;
+    agora: boolean;
+};
+/** One stored message: Agora framing when an upper say owns it, Channel's raw frame otherwise. */
+export declare function projectMessageNotification(input: {
+    squarePath: string;
+    recipient: string;
+    actor: string;
+    body: string;
+    preview?: string;
+    agora?: {
+        readonly actIndex: number;
+        readonly route: DirectedNotificationRoute;
+    };
+}): {
+    text: string;
+    full: string;
+    preview: string;
+    description: string;
+    clipped: boolean;
+};
+/** Full human expansion never substitutes a sender-owned preview for the stored body. */
 export declare function renderAttentionFull(attention: AttentionPreview): string;
-/** Shared model-facing envelope; transport correlation and human cards stay outside it. */
-export declare function renderSquareReminder(previews: readonly string[], deliveries?: readonly (ActivityDelivery | undefined)[]): string;
 export declare function renderAttentionPreview(attention: AttentionPreview): string;

package/dist/attention-presentation.js

@@ -1,21 +1,17 @@
+import { escapeSquareTags, projectChannelNotification } from './channel-presentation.js';
+export { projectChannelNotification, renderSquareReminder } from './channel-presentation.js';
 import { homedir } from 'node:os';
 import { formatActivityId } from './square-core.js';
 export const ATTENTION_BODY_MAX = 200;
-export function previewAttentionBody(body, delivery) {
-    const compact = (delivery?.mode === 'direct' ? delivery.preview ?? body : body).replace(/\r\n/g, '\n');
-    if (delivery?.mode === 'direct' || compact.length <= ATTENTION_BODY_MAX)
-        return compact;
-    return `${compact.slice(0, ATTENTION_BODY_MAX).trimEnd()}…`;
+export function previewAttentionBody(body) {
+    const compact = body.replace(/\r\n/g, '\n');
+    return compact.length <= ATTENTION_BODY_MAX ? compact : `${compact.slice(0, ATTENTION_BODY_MAX).trimEnd()}…`;
 }
-export function attentionBodyIsClipped(body, delivery) {
-    return delivery?.mode === 'direct'
-        ? delivery.preview !== undefined
-        : body.replace(/\r\n/g, '\n').length > ATTENTION_BODY_MAX;
+export function attentionBodyIsClipped(body) {
+    return body.replace(/\r\n/g, '\n').length > ATTENTION_BODY_MAX;
 }
 export function displayAttentionPath(squarePath) {
-    return squarePath.startsWith(homedir())
-        ? `~${squarePath.slice(homedir().length)}`
-        : squarePath;
+    return squarePath.startsWith(homedir()) ? `~${squarePath.slice(homedir().length)}` : squarePath;
 }
 export function renderAttentionDescription({ actor, route }) {
     switch (route) {
@@ -25,56 +21,15 @@ export function renderAttentionDescription({ actor, route }) {
         case 'bell': return `${actor} rang the bell`;
     }
 }
-/** Full notification text for human-facing expansion, never the bounded model preview. */
-export function renderAttentionFull(attention) {
-    return attention.delivery?.mode === 'direct' ? renderDirectBlock(attention) : renderAttentionBlock(attention, attention.body);
-}
-/** Attribute values keep their quotes; the stored body and the human card stay unescaped. */
 function escapeAttribute(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/"/g, '&quot;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
-}
-/** A body may quote the envelope's own tags; in the preview they must never read as one. */
-function escapeSquareTags(text) {
-    return text.replace(/<(\/?)(square-|system-reminder)/gi, '<\\$1$2');
-}
-function renderAttentionBlock(attention, body) {
-    return [
-        '<square-activity>',
-        `· ${displayAttentionPath(attention.squarePath)} · ${attention.recipient} · ${formatActivityId(attention.actIndex)}`,
-        `● ${renderAttentionDescription(attention)}`,
-        '',
-        body,
-        '</square-activity>',
-    ].join('\n');
-}
-function renderDirectBlock(attention) {
-    return escapeSquareTags(previewAttentionBody(attention.body, attention.delivery));
-}
-/** Shared model-facing envelope; transport correlation and human cards stay outside it. */
-export function renderSquareReminder(previews, deliveries = []) {
-    if (previews.length === 0)
-        return '';
-    const header = deliveries.some(item => item?.mode === 'direct')
-        ? 'This is an external notification, not a direct message from the user.'
-        : 'This is an external reminder from Square, not a direct message from the user.';
-    return [
-        '',
-        '<system-reminder>',
-        header,
-        '',
-        previews.join('\n\n'),
-        '</system-reminder>',
-        '',
-    ].join('\n');
-}
-export function renderAttentionPreview(attention) {
-    if (attention.delivery?.mode === 'direct')
-        return renderDirectBlock(attention);
-    const remaining = attention.body.replace(/\r\n/g, '\n').length - ATTENTION_BODY_MAX;
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/** The sole source adapter: transports and cards consume this projection, not delivery modes. */
+export function projectNotification(attention) {
+    const body = attention.body.replace(/\r\n/g, '\n');
+    const description = renderAttentionDescription(attention);
+    const remaining = body.length - ATTENTION_BODY_MAX;
+    const preview = previewAttentionBody(body);
     const attributes = [
         `square="${escapeAttribute(displayAttentionPath(attention.squarePath))}"`,
         `as="${escapeAttribute(attention.recipient)}"`,
@@ -82,11 +37,20 @@ export function renderAttentionPreview(attention) {
         `from="${escapeAttribute(attention.actor)}"`,
         ...(remaining > 0 ? [`truncated="${remaining} more chars"`] : []),
     ];
-    return [
-        `<square-activity ${attributes.join(' ')}>`,
-        `${renderAttentionDescription(attention)}.`,
-        '',
-        escapeSquareTags(previewAttentionBody(attention.body)),
-        '</square-activity>',
-    ].join('\n');
-}
+    return {
+        text: [`<square-activity ${attributes.join(' ')}>`, `${description}.`, '', escapeSquareTags(preview), '</square-activity>'].join('\n'),
+        full: ['<square-activity>', `· ${displayAttentionPath(attention.squarePath)} · ${attention.recipient} · ${formatActivityId(attention.actIndex)}`,
+            `● ${description}`, '', body, '</square-activity>'].join('\n'),
+        preview, description, clipped: remaining > 0, agora: true,
+    };
+}
+/** One stored message: Agora framing when an upper say owns it, Channel's raw frame otherwise. */
+export function projectMessageNotification(input) {
+    if (input.agora === undefined)
+        return projectChannelNotification(input);
+    return projectNotification({ squarePath: input.squarePath, recipient: input.recipient, actor: input.actor,
+        route: input.agora.route, actIndex: input.agora.actIndex, body: input.body });
+}
+/** Full human expansion never substitutes a sender-owned preview for the stored body. */
+export function renderAttentionFull(attention) { return projectNotification(attention).full; }
+export function renderAttentionPreview(attention) { return projectNotification(attention).text; }

package/dist/boundary-presentation.d.ts

@@ -1,6 +1,4 @@
-import { pendingAtBoundary } from './inbox.js';
 import type { Owner, PendingMembership } from './model.js';
-export { pendingAtBoundary };
 export declare function renderPendingAtBoundary(inbox: PendingMembership[]): string;
 /**
  * Serialize a boundary across hook processes so one stale inbox cannot render twice.