@astrosheep/square 0.3.70 → 0.3.72

package/dist/square-core.d.ts

@@ -4,18 +4,13 @@ export type Audience = {
     readonly kind: 'bell';
 } | {
     readonly kind: 'mentions';
-    readonly names: readonly string[];
+    readonly names: readonly Participant[];
 };
 export type ActivityId = `act/${number}`;
+export type Perception = 'full' | 'presence';
 export declare const MAX_IDENTITY_SET_SIZE = 10;
 export declare function formatActivityId(index: number): ActivityId;
 export declare function parseActivityId(value: string): number | undefined;
-export interface Hold {
-    active: boolean;
-    at?: number;
-    reason?: string;
-    actor?: Participant;
-}
 export type Act = {
     kind: 'join';
     actor: Participant;
@@ -30,7 +25,7 @@ export type Act = {
     actor: Participant;
     at?: number;
     body: string;
-    mentions: readonly Participant[];
+    mentions?: readonly Participant[];
     reach?: Reach;
     reply?: number;
 } | {
@@ -58,95 +53,9 @@ export type Act = {
     target: Participant;
     at?: number;
 };
-export interface SquareValidationOptions {
-    hardCap?: number | null;
-    throttlePerMinute?: number;
-    throttleWindowMs?: number;
-}
-export type Perception = 'full' | 'presence';
-interface ParticipantSnapshot {
-    name: Participant;
-    key: string;
-    joined: boolean;
-    done: boolean;
-    activityCount: number;
-    lastActiveAt?: number;
-    lastReadThrough: number;
-}
-export interface FoldedSquareState {
-    participants: ParticipantSnapshot[];
-    hold: Hold;
-    joined: Participant[];
-    done: Participant[];
-    throttleActivityAts: number[];
-    bellSayAtsByActor: Map<string, number[]>;
-    listening: Map<string, Participant[]>;
-    /** Derived sender blocks; kept outside the artifact schema. */
-    ignored: Map<string, Participant[]>;
-}
-export interface LandedAudienceReplay {
-    readonly participants: readonly Participant[];
-    readonly joined: readonly Participant[];
-    readonly replayedActivityCount: number;
-    recipientsFor(activity: Act): readonly Participant[];
-    includes(activity: Act, participant: Participant): boolean;
-    lastJoinIndex(participant: Participant): number | undefined;
-    resolveParticipant(name: Participant): Participant | undefined;
-}
-export type ValidationResult = {
-    ok: true;
-} | {
-    ok: false;
-    reason: 'already_joined';
-} | {
-    ok: false;
-    reason: 'not_joined';
-} | {
-    ok: false;
-    reason: 'done';
-} | {
-    ok: false;
-    reason: 'held';
-    hold: Hold;
-} | {
-    ok: false;
-    reason: 'hard_cap';
-    count: number;
-    hardCap: number;
-} | {
-    ok: false;
-    reason: 'throttled';
-    delayMs: number;
-} | {
-    ok: false;
-    reason: 'bell_quota';
-    nextAt: number;
-} | {
-    ok: false;
-    reason: 'mention_limit';
-    limit: number;
-} | {
-    ok: false;
-    reason: 'listening_limit';
-    limit: number;
-};
 export declare function audienceOf(say: {
     body: string;
     mentions?: readonly Participant[];
     reach?: Reach;
 }): Audience;
 export declare function audienceIncludes(audience: Audience, name: string): boolean;
-export declare function resolveAudience(audience: Audience, candidateNames: readonly string[]): string[];
-export declare function activeListeners(state: FoldedSquareState, sender: string): string[];
-export declare function isIgnored(state: FoldedSquareState, listener: string, sender: string): boolean;
-/** The author of every landed activity, keyed by index; a reply audience derives from this. */
-export declare function activityAuthors(acts: readonly Act[]): Map<number, Participant>;
-export declare function listeningTo(state: FoldedSquareState, listener: string): string[];
-export declare function isListening(state: FoldedSquareState, listener: string, sender: string): boolean;
-export declare function actorOf(act: Act): Participant | undefined;
-export declare function fold(acts: readonly Act[]): FoldedSquareState;
-/** Replay the activity stream once to fix every say's audience at landing. */
-export declare function replayLandedAudiences(acts: readonly Act[]): LandedAudienceReplay;
-export declare function validate(state: FoldedSquareState, act: Act, options?: SquareValidationOptions): ValidationResult;
-export declare function perceive(act: Act, viewer: Participant | string): Perception;
-export {};

package/dist/square-core.js

@@ -1,8 +1,8 @@
+import { sameName } from './model.js';
 export const MAX_IDENTITY_SET_SIZE = 10;
 export function formatActivityId(index) {
-    if (!Number.isSafeInteger(index) || index < 0) {
+    if (!Number.isSafeInteger(index) || index < 0)
         throw new Error(`Invalid activity index: ${index}`);
-    }
     return `act/${index}`;
 }
 export function parseActivityId(value) {
@@ -13,360 +13,15 @@ export function parseActivityId(value) {
     const index = Number(value.slice(4));
     return Number.isSafeInteger(index) ? index : undefined;
 }
-function nameKey(name) {
-    return name.toLocaleLowerCase();
-}
-function sameName(a, b) {
-    return nameKey(a) === nameKey(b);
-}
-function uniqueMentionNames(names) {
-    const unique = [];
-    for (const name of names) {
-        if (unique.some((existing) => sameName(existing, name)))
-            continue;
-        unique.push(name);
-    }
-    return unique;
-}
 export function audienceOf(say) {
     if (say.reach === 'bell')
         return { kind: 'bell' };
-    return { kind: 'mentions', names: uniqueMentionNames(say.mentions ?? []) };
+    const names = [];
+    for (const name of say.mentions ?? [])
+        if (!names.some((existing) => sameName(existing, name)))
+            names.push(name);
+    return { kind: 'mentions', names };
 }
 export function audienceIncludes(audience, name) {
-    if (audience.kind === 'bell')
-        return true;
-    return audience.names.some((mentioned) => sameName(mentioned, name));
-}
-export function resolveAudience(audience, candidateNames) {
-    if (audience.kind === 'bell')
-        return [...candidateNames];
-    const resolved = [];
-    for (const mention of audience.names) {
-        const known = candidateNames.find((candidate) => sameName(candidate, mention));
-        if (known !== undefined && !resolved.some((existing) => sameName(existing, known))) {
-            resolved.push(known);
-        }
-    }
-    return resolved;
-}
-export function activeListeners(state, sender) {
-    return state.participants
-        .filter((participant) => participant.joined
-        && !(state.ignored.get(nameKey(participant.name)) ?? []).some((target) => sameName(target, sender))
-        && (state.listening.get(nameKey(participant.name)) ?? []).some((target) => sameName(target, sender)))
-        .map((participant) => participant.name);
-}
-export function isIgnored(state, listener, sender) {
-    return (state.ignored.get(nameKey(listener)) ?? []).some((target) => sameName(target, sender));
-}
-/** The author of every landed activity, keyed by index; a reply audience derives from this. */
-export function activityAuthors(acts) {
-    const authors = new Map();
-    for (const act of acts) {
-        const actor = actorOf(act);
-        if (actor === undefined || !('index' in act) || typeof act.index !== 'number')
-            continue;
-        authors.set(act.index, actor);
-    }
-    return authors;
-}
-function recipientsAtLanding(before, say, authors) {
-    const audience = audienceOf(say);
-    const standing = before.participants.filter((participant) => participant.joined).map((participant) => participant.name);
-    const mentionTargets = resolveAudience(audience, standing);
-    // A reply is directed attention in its own right: it reaches the author of the
-    // replied-to activity under the same standing and ignore rules as a mention.
-    const replyAuthor = say.reply === undefined ? undefined : authors.get(say.reply);
-    const replyTargets = replyAuthor === undefined ? [] : resolveAudience({ kind: 'mentions', names: [replyAuthor] }, standing);
-    const listeners = activeListeners(before, say.actor);
-    const recipients = [];
-    for (const name of [...mentionTargets, ...replyTargets, ...listeners]) {
-        if (sameName(name, say.actor) || recipients.some((existing) => sameName(existing, name)))
-            continue;
-        if (audience.kind !== 'bell' && isIgnored(before, name, say.actor))
-            continue;
-        recipients.push(name);
-    }
-    return recipients;
-}
-export function listeningTo(state, listener) {
-    return [...(state.listening.get(nameKey(listener)) ?? [])];
-}
-export function isListening(state, listener, sender) {
-    return listeningTo(state, listener).some((target) => sameName(target, sender));
-}
-export function actorOf(act) {
-    if ('actor' in act && typeof act.actor === 'string')
-        return act.actor;
-    return undefined;
-}
-function touchParticipant(byKey, ordered, actor) {
-    const key = nameKey(actor);
-    const existing = byKey.get(key);
-    if (existing !== undefined)
-        return existing;
-    const created = {
-        name: actor,
-        key,
-        joined: false,
-        done: false,
-        activityCount: 0,
-        lastReadThrough: -1,
-    };
-    byKey.set(key, created);
-    ordered.push(created);
-    return created;
-}
-function pushThrottleAt(state, at) {
-    if (typeof at === 'number' && Number.isFinite(at))
-        state.throttleActivityAts.push(at);
-}
-function currentParticipant(state, participant) {
-    return state.participants.find((item) => sameName(item.name, participant));
-}
-function pushBellAt(state, actor, at) {
-    if (typeof at !== 'number' || !Number.isFinite(at))
-        return;
-    const key = nameKey(actor);
-    const current = state.bellSayAtsByActor.get(key) ?? [];
-    current.push(at);
-    state.bellSayAtsByActor.set(key, current);
-}
-function bellRecentAt(state, actor, at, windowMs) {
-    const events = state.bellSayAtsByActor.get(nameKey(actor)) ?? [];
-    let latest;
-    for (const eventAt of events) {
-        if (at - eventAt >= windowMs)
-            continue;
-        latest = latest === undefined ? eventAt : Math.max(latest, eventAt);
-    }
-    return latest;
-}
-function createFoldAccumulator() {
-    const ordered = [];
-    const byKey = new Map();
-    const hold = { active: false };
-    return {
-        byKey,
-        ordered,
-        state: {
-            participants: ordered,
-            hold,
-            joined: [],
-            done: [],
-            throttleActivityAts: [],
-            bellSayAtsByActor: new Map(),
-            listening: new Map(),
-            ignored: new Map(),
-        },
-    };
-}
-function applyActivity(accumulator, act) {
-    const { state, byKey, ordered } = accumulator;
-    const actor = actorOf(act);
-    const snapshot = actor === undefined ? undefined : touchParticipant(byKey, ordered, actor);
-    if (snapshot !== undefined && act.at !== undefined) {
-        snapshot.lastActiveAt = Math.max(snapshot.lastActiveAt ?? -Infinity, act.at);
-    }
-    switch (act.kind) {
-        case 'join':
-            if (snapshot !== undefined) {
-                snapshot.joined = true;
-                snapshot.done = false;
-            }
-            break;
-        case 'done':
-            if (snapshot !== undefined) {
-                snapshot.joined = false;
-                snapshot.done = true;
-                state.listening.delete(nameKey(snapshot.name));
-            }
-            break;
-        case 'listen': {
-            const key = nameKey(act.actor);
-            const targets = state.listening.get(key) ?? [];
-            if (!targets.some((target) => sameName(target, act.target)))
-                targets.push(act.target);
-            state.listening.set(key, targets);
-            const ignored = (state.ignored.get(key) ?? []).filter((target) => !sameName(target, act.target));
-            if (ignored.length === 0)
-                state.ignored.delete(key);
-            else
-                state.ignored.set(key, ignored);
-            break;
-        }
-        case 'ignore': {
-            const key = nameKey(act.actor);
-            const targets = (state.listening.get(key) ?? []).filter((target) => !sameName(target, act.target));
-            if (targets.length === 0)
-                state.listening.delete(key);
-            else
-                state.listening.set(key, targets);
-            const ignored = state.ignored.get(key) ?? [];
-            if (!ignored.some((target) => sameName(target, act.target)))
-                ignored.push(act.target);
-            state.ignored.set(key, ignored);
-            break;
-        }
-        case 'say':
-            if (snapshot !== undefined) {
-                snapshot.activityCount += 1;
-            }
-            pushThrottleAt(state, act.at);
-            if (act.reach === 'bell')
-                pushBellAt(state, act.actor, act.at);
-            break;
-        case 'hold':
-            state.hold.active = true;
-            state.hold.at = act.at;
-            state.hold.reason = act.body;
-            state.hold.actor = act.actor;
-            break;
-        case 'resume':
-            state.hold.active = false;
-            delete state.hold.at;
-            delete state.hold.reason;
-            delete state.hold.actor;
-            break;
-        case 'read':
-            if (snapshot !== undefined) {
-                snapshot.lastReadThrough = Math.max(snapshot.lastReadThrough, act.through);
-            }
-            break;
-    }
-}
-function finishFold(accumulator) {
-    const { state, ordered } = accumulator;
-    state.joined = ordered.filter((item) => item.joined).map((item) => item.name);
-    state.done = ordered.filter((item) => item.done).map((item) => item.name);
-    return state;
-}
-export function fold(acts) {
-    const accumulator = createFoldAccumulator();
-    for (const act of acts)
-        applyActivity(accumulator, act);
-    return finishFold(accumulator);
-}
-/** Replay the activity stream once to fix every say's audience at landing. */
-export function replayLandedAudiences(acts) {
-    const accumulator = createFoldAccumulator();
-    const byActivity = new Map();
-    const byIndex = new Map();
-    const lastJoinByKey = new Map();
-    const authors = activityAuthors(acts);
-    for (const act of acts) {
-        if (act.kind === 'say') {
-            const recipients = recipientsAtLanding(accumulator.state, act, authors);
-            byActivity.set(act, recipients);
-            const index = 'index' in act ? act.index : undefined;
-            if (typeof index === 'number')
-                byIndex.set(index, recipients);
-        }
-        if (act.kind === 'join' && 'index' in act && typeof act.index === 'number') {
-            lastJoinByKey.set(nameKey(act.actor), act.index);
-        }
-        applyActivity(accumulator, act);
-    }
-    const state = finishFold(accumulator);
-    const participants = state.participants.map((participant) => participant.name);
-    function recipientsFor(activity) {
-        const direct = byActivity.get(activity);
-        if (direct !== undefined)
-            return direct;
-        const index = 'index' in activity ? activity.index : undefined;
-        return typeof index === 'number' ? byIndex.get(index) ?? [] : [];
-    }
-    function resolveParticipant(name) {
-        return participants.find((participant) => sameName(participant, name));
-    }
-    return {
-        participants,
-        joined: state.joined,
-        replayedActivityCount: acts.length,
-        recipientsFor,
-        includes: (activity, participant) => activity.kind === 'say'
-            && !sameName(activity.actor, participant)
-            && recipientsFor(activity).some((recipient) => sameName(recipient, participant)),
-        lastJoinIndex: (participant) => lastJoinByKey.get(nameKey(participant)),
-        resolveParticipant,
-    };
-}
-export function validate(state, act, options = {}) {
-    const actor = actorOf(act);
-    const current = actor === undefined ? undefined : currentParticipant(state, actor);
-    switch (act.kind) {
-        case 'join':
-            return current?.joined ? { ok: false, reason: 'already_joined' } : { ok: true };
-        case 'done':
-            if (current?.done)
-                return { ok: false, reason: 'done' };
-            if (current?.joined !== true)
-                return { ok: false, reason: 'not_joined' };
-            return { ok: true };
-        case 'listen':
-        case 'ignore':
-            if (current?.done)
-                return { ok: false, reason: 'done' };
-            if (current?.joined !== true)
-                return { ok: false, reason: 'not_joined' };
-            if (act.kind === 'listen'
-                && !isListening(state, act.actor, act.target)
-                && listeningTo(state, act.actor).length >= MAX_IDENTITY_SET_SIZE) {
-                return { ok: false, reason: 'listening_limit', limit: MAX_IDENTITY_SET_SIZE };
-            }
-            return { ok: true };
-        case 'say': {
-            if (current?.done)
-                return { ok: false, reason: 'done' };
-            if (current?.joined !== true)
-                return { ok: false, reason: 'not_joined' };
-            const audience = audienceOf(act);
-            const mentionCount = audience.kind === 'mentions' ? audience.names.length : 0;
-            if (mentionCount > MAX_IDENTITY_SET_SIZE) {
-                return { ok: false, reason: 'mention_limit', limit: MAX_IDENTITY_SET_SIZE };
-            }
-            if (state.hold.active)
-                return { ok: false, reason: 'held', hold: state.hold };
-            const activityCount = current?.activityCount ?? 0;
-            if (options.hardCap !== undefined && options.hardCap !== null && activityCount >= options.hardCap) {
-                return { ok: false, reason: 'hard_cap', count: activityCount, hardCap: options.hardCap };
-            }
-            const limit = options.throttlePerMinute;
-            const at = act.at;
-            if (act.reach === 'bell' && typeof at === 'number' && Number.isFinite(at)) {
-                const bellWindowMs = 60 * 60 * 1000;
-                const latestBellAt = bellRecentAt(state, act.actor, at, bellWindowMs);
-                if (latestBellAt !== undefined) {
-                    return { ok: false, reason: 'bell_quota', nextAt: latestBellAt + bellWindowMs };
-                }
-            }
-            if (limit !== undefined && typeof at === 'number' && Number.isFinite(at)) {
-                const windowMs = options.throttleWindowMs ?? 60000;
-                const recent = state.throttleActivityAts.filter((eventAt) => at - eventAt < windowMs).sort((a, b) => a - b);
-                if (recent.length >= limit) {
-                    const releaseAt = recent[recent.length - limit] + windowMs;
-                    const delayMs = Math.max(1, releaseAt - at);
-                    return { ok: false, reason: 'throttled', delayMs };
-                }
-            }
-            return { ok: true };
-        }
-        case 'hold':
-        case 'resume':
-            if (current?.done)
-                return { ok: false, reason: 'done' };
-            if (current?.joined !== true)
-                return { ok: false, reason: 'not_joined' };
-            return { ok: true };
-        case 'read':
-            return { ok: true };
-    }
-}
-export function perceive(act, viewer) {
-    if (act.kind !== 'say')
-        return 'full';
-    if (sameName(act.actor, viewer))
-        return 'full';
-    return audienceIncludes(audienceOf(act), viewer) ? 'full' : 'presence';
+    return audience.kind === 'bell' || audience.names.some((mentioned) => sameName(mentioned, name));
 }

package/dist/square-domain.d.ts

@@ -0,0 +1,24 @@
+import { type StoredAct } from './model.js';
+import type { AttentionFact, LandedRecipient, ParticipantFact, SquareRead, SquareWrite } from './ports.js';
+export interface LandingEffect {
+    readonly activity: StoredAct;
+    readonly participant?: ParticipantFact;
+    readonly removeListeningOf?: string;
+    readonly replaceAttention?: AttentionFact;
+    readonly audience: readonly LandedRecipient[];
+}
+export interface LandingFacts {
+    readonly actor?: ParticipantFact;
+    readonly standing: readonly ParticipantFact[];
+    readonly incoming: readonly AttentionFact[];
+    readonly outgoing: readonly AttentionFact[];
+    readonly replyAuthor?: string;
+}
+/** The single landing transition, shared by both adapters and explicit rebuild. */
+export declare function deriveLanding(activity: StoredAct, facts: LandingFacts): LandingEffect;
+export declare function landingFacts(read: SquareRead, activity: StoredAct): LandingFacts;
+export interface LandingWriter extends Pick<SquareWrite, 'markSeen' | 'putLease' | 'removeLease' | 'replaceRoutes'> {
+    applyLanding(effect: LandingEffect): void;
+}
+/** Driver-owned methods validate rows/writes and track changes; the domain owns allocation. */
+export declare function wrapSquareWrite(read: SquareRead, writes: LandingWriter): SquareWrite;

package/dist/square-domain.js

@@ -0,0 +1,77 @@
+import { SquareError, sameName } from './model.js';
+/** The single landing transition, shared by both adapters and explicit rebuild. */
+export function deriveLanding(activity, facts) {
+    const audience = [];
+    if (activity.kind === 'say') {
+        const add = (requested, route) => {
+            const recipient = facts.standing.find((item) => sameName(item.name, requested))?.name;
+            if (recipient === undefined || sameName(recipient, activity.actor)
+                || audience.some((item) => sameName(item.recipient, recipient)))
+                return;
+            if (activity.reach !== 'bell' && facts.incoming.some((item) => item.kind === 'ignore' && sameName(item.listener, recipient)))
+                return;
+            audience.push({ recipient, route });
+        };
+        if (activity.reach === 'bell') {
+            for (const peer of facts.standing)
+                add(peer.name, 'bell');
+        }
+        else {
+            for (const mention of activity.mentions ?? [])
+                add(mention, 'mention');
+            if (facts.replyAuthor !== undefined)
+                add(facts.replyAuthor, 'reply');
+            for (const peer of facts.standing) {
+                if (facts.incoming.some((item) => item.kind === 'listen' && sameName(item.listener, peer.name)))
+                    add(peer.name, 'attention');
+            }
+        }
+    }
+    const actor = activity.actor;
+    if (actor === undefined)
+        return { activity, audience };
+    const previous = facts.actor ?? { name: actor, firstIndex: activity.index, joined: false, done: false, sayCount: 0 };
+    const participant = {
+        ...previous,
+        lastActiveAt: Math.max(previous.lastActiveAt ?? -Infinity, activity.at),
+        ...(activity.kind === 'join' ? { joined: true, done: false, lastJoinIndex: activity.index } : {}),
+        ...(activity.kind === 'done' ? { joined: false, done: true } : {}),
+        ...(activity.kind === 'say' ? { sayCount: previous.sayCount + 1 } : {}),
+    };
+    let replaceAttention;
+    if (activity.kind === 'listen' || activity.kind === 'ignore') {
+        const existing = facts.outgoing.find((item) => sameName(item.target, activity.target));
+        if (existing?.kind !== activity.kind) {
+            replaceAttention = { listener: participant.name, target: activity.target, kind: activity.kind, sinceIndex: activity.index };
+        }
+    }
+    return {
+        activity, participant, audience,
+        ...(activity.kind === 'done' ? { removeListeningOf: participant.name } : {}),
+        ...(replaceAttention === undefined ? {} : { replaceAttention }),
+    };
+}
+export function landingFacts(read, activity) {
+    return {
+        actor: activity.actor === undefined ? undefined : read.participant(activity.actor),
+        standing: activity.kind === 'say' ? read.roster().filter((item) => item.joined) : [],
+        incoming: activity.kind === 'say' ? read.incomingAttention(activity.actor) : [],
+        outgoing: activity.kind === 'listen' || activity.kind === 'ignore' ? read.attention(activity.actor) : [],
+        replyAuthor: activity.kind === 'say' && activity.reply !== undefined ? read.activity(activity.reply)?.actor : undefined,
+    };
+}
+/** Driver-owned methods validate rows/writes and track changes; the domain owns allocation. */
+export function wrapSquareWrite(read, writes) {
+    const { applyLanding, ...mutations } = writes;
+    return Object.assign({}, read, mutations, {
+        land(activity) {
+            const index = read.header().nextActIndex;
+            if (!Number.isSafeInteger(index) || index < 0 || index >= Number.MAX_SAFE_INTEGER) {
+                throw new SquareError('invalid_args', 'Square activity index is exhausted.');
+            }
+            const stored = { ...activity, index };
+            applyLanding(deriveLanding(stored, landingFacts(read, stored)));
+            return read.activity(index);
+        },
+    });
+}