@astrosheep/square 0.3.86 → 0.3.88

package/dist/plugins/opencode/delivery.js

@@ -1,60 +1,63 @@
-import { nameKey } from '../../model.js';
-import { nativePendingPreview, observeSessionPending, sessionInbox } from '../../inbox.js';
-import { hostLedgerForEnv } from '../../registry.js';
-import { openSquare } from '../../open-square.js';
-import { closeOpenSquare } from '../../open-square.js';
-import { presentationSuppressesWake, projectPresentationEvidence } from '../../square-projections.js';
-import { presentPending } from '../../presentation-operations.js';
+import { createHash } from 'node:crypto';
+import { createArtifactPort } from '../../artifact.js';
 import { deliverPending } from '../../delivery-operations.js';
-import { createWakeTransport } from '../../notifications.js';
-import { publishWakeRoute } from '../../routes.js';
+import { nativePendingPreview, observeSessionPending, projectSessionSeats } from '../../inbox.js';
+import { automaticWakeEligible, presentationBlocksWake } from '../../delivery.js';
+import { sameBody } from '../../model.js';
 import { formatActivityId, parseActivityId } from '../../square-core.js';
+import { indexedSquareEntries } from '../../square-index.js';
+import { asSeatRef } from '../../seats.js';
+import { presentPending } from '../../presentation-operations.js';
 import { createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
 const routeKind = 'opencode-server';
-const key = (location, participant, index) => `${location}\0${nameKey(participant)}\0${index}`;
-/** The one native pending preview: the audience/catch/epoch fence before send and inside presentation. */
-function preview(facts, owner, index) {
-    return nativePendingPreview(facts, { location: owner.location, routeKind, sessionId: owner.session, participant: owner.participant, actIndex: index, epoch: owner.epoch, address: { sessionId: owner.session }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+const bodyFor = (sessionId) => ({ channel: 'opencode', session: sessionId });
+const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
+function preview(facts, location, seat, index) {
+    return nativePendingPreview(facts, {
+        location, routeKind, sessionId: seat.body.session, participant: seat.participant,
+        actIndex: index, address: { sessionId: seat.body.session }, now: Date.now(),
+    });
+}
+export async function indexedOpenCodeSessions(env) {
+    return [...new Set((await indexedSquareEntries({ channel: 'opencode' }, env)).map((entry) => entry.body.session))];
+}
+export async function discoverOpenCodeSeats(sessionId, env, signal) {
+    return projectSessionSeats({ body: bodyFor(sessionId), env }, signal);
+}
+function sameSeat(left, right) {
+    return left !== undefined && left.generation === right.generation && sameBody(left.body, right.body);
 }
-function createOpenCodeWakeTransport(target, env, lifetime) {
-    const ledger = hostLedgerForEnv(env);
+function createOpenCodeWakeTransport(target, lifetime) {
     return {
-        probe: async (route) => !lifetime.aborted && route.kind === routeKind && route.sessionId === target.sessionId && route.address.sessionId === target.sessionId,
+        probe: async (route) => !lifetime.aborted && route.kind === routeKind
+            && route.sessionId === target.sessionId && 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
+                || !sameBody(request.seat.body, bodyFor(target.sessionId))
+                || 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 deadline = Date.now() + timeoutMs;
-            // Start the native call under the ownership fence, but await it OUTSIDE: prompt may
-            // enter our context hook synchronously and that hook needs the same ownership lock.
-            const started = await ledger.withClaimLock(async () => {
-                if (signal.aborted || request.route.sessionId !== target.sessionId || !request.claimToken
-                    || !await (beforeSend?.() ?? Promise.resolve(true)))
-                    return undefined;
-                const owner = (await ledger.listPresence({ location: request.location, participant: request.participant, session: target.sessionId }))
-                    .find((binding) => binding.channel === 'opencode' && binding.epoch === request.route.epoch);
-                const index = parseActivityId(request.activity);
-                if (!owner || index === undefined)
-                    return undefined;
-                const square = await openSquare(owner.location, { hostLedger: ledger, env, signal });
-                try {
-                    const { value: prepared } = await square.artifact.read((facts) => preview(facts, owner, index), signal);
-                    if (!prepared)
-                        return undefined;
-                    const row = { location: owner.location, participant: owner.participant, session: target.sessionId,
-                        activity: request.activity, kind: 'wake', outcome: 'dispatching', routeKind, attemptN: request.attemptN, claimToken: request.claimToken,
-                        nativeDelivery: { harness: 'opencode', epoch: owner.epoch ?? 0, inputId: createNativeInputId(), payload: prepared.payload } };
-                    if (!await ledger.prepareNativeWake(row) || !await (beforeSend?.() ?? Promise.resolve(true)) || signal.aborted
-                        || (await square.artifact.read((facts) => preview(facts, owner, index)?.payload, signal)).value !== prepared.payload)
-                        return undefined;
-                    return { sending: sendNativeText(target, prepared.payload, { inputId: row.nativeDelivery.inputId, delivery: 'steer',
-                            timeoutMs: Math.max(1, deadline - Date.now()), signal }) };
-                }
-                finally {
-                    await closeOpenSquare(square);
-                }
-            }, signal);
-            if (!started)
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention, binding or local delivery generation changed before send.' };
-            const result = await started.sending;
+            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')
@@ -63,109 +66,161 @@ function createOpenCodeWakeTransport(target, env, lifetime) {
         },
     };
 }
-/** Only the matching prepared primary context authorizes presentation, never admission. */
+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 ledger = hostLedgerForEnv(env);
-    await ledger.withClaimLock(async () => {
+    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 rows = (await ledger.listEvidence({ kind: 'wake', session: sessionId })).filter((row) => row.nativeDelivery?.harness === 'opencode' && !!row.claimToken && ['dispatching', 'unknown', 'accepted'].includes(row.outcome));
-        for (const row of rows) {
-            if (signal.aborted || !messages.some((message) => message.id === row.nativeDelivery.inputId && message.role === 'user'
-                && message.content.every((part) => part.type === 'text' && typeof part.text === 'string')
-                && message.content.map((part) => part.text).join('') === row.nativeDelivery.payload))
-                continue;
-            const owner = (await ledger.listPresence({ location: row.location, participant: row.participant, session: sessionId }))
-                .find((binding) => binding.channel === 'opencode' && binding.epoch === row.nativeDelivery.epoch);
-            const index = parseActivityId(row.activity);
-            if (!owner || index === undefined)
-                continue;
-            const square = await openSquare(row.location, { hostLedger: ledger, env, signal });
-            try {
-                const { value: prepared } = await square.artifact.read((facts) => preview(facts, owner, index), signal);
-                if (!prepared || prepared.payload !== row.nativeDelivery.payload)
-                    continue;
-                const prior = await projectPresentationEvidence({ hostLedger: ledger, location: row.location, participant: row.participant, sessionId, activity: row.activity });
-                if (presentationSuppressesWake(prior))
-                    continue;
-                await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId,
-                    activity: row.activity, sink: { present() { } }, markSeen: !prepared.clipped, signal,
-                    current: (facts) => !signal.aborted && preview(facts, owner, index)?.payload === row.nativeDelivery.payload });
-            }
-            finally {
-                await closeOpenSquare(square);
+        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), 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;
+                    },
+                });
             }
         }
-    }, signal);
+        finally {
+            await artifact.close();
+        }
+    }
 }
-/** One existing observer and the existing dispatch owner; no second queue or evidence store. */
+/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
 export async function receiveOpenCodePending(target, env, signal) {
-    const ledger = hostLedgerForEnv(env);
-    const observer = await observeSessionPending(target.sessionId, env);
-    const excluded = new Set();
-    const refreshExclusions = async () => {
-        excluded.clear();
-        const owners = await ledger.listPresence({ session: target.sessionId });
-        for (const row of await ledger.listEvidence({ kind: 'wake', session: target.sessionId })) {
-            const index = parseActivityId(row.activity);
-            const current = owners.some((owner) => owner.location === row.location && nameKey(owner.participant) === nameKey(row.participant) && owner.epoch === row.nativeDelivery?.epoch);
-            if (index !== undefined && (['accepted', 'unknown'].includes(row.outcome) || row.outcome === 'dispatching' && current && row.nativeDelivery?.harness === 'opencode'))
-                excluded.add(key(row.location, row.participant, index));
-        }
-        for (const membership of await sessionInbox(target.sessionId, env, signal)) {
-            const owner = owners.find((binding) => binding.location === membership.squarePath && nameKey(binding.participant) === nameKey(membership.name));
-            for (const note of membership.notifications)
-                if (note.actIndex <= (owner?.cancelledThrough ?? -1))
-                    excluded.add(key(membership.squarePath, membership.name, note.actIndex));
-        }
-    };
-    const transport = createWakeTransport([], ledger, Date.now, { [routeKind]: createOpenCodeWakeTransport(target, env, signal) });
+    const observer = await observeSessionPending(bodyFor(target.sessionId), env);
+    const transport = createOpenCodeWakeTransport(target, signal);
+    let waiting;
     try {
-        await refreshExclusions();
-        let pending = await observer.wait(Infinity, { signal, excludeKeys: excluded });
-        while (!signal.aborted && pending.length > 0) {
-            let armed;
-            const ready = new Promise((resolve) => { armed = resolve; });
-            // Capture the next state edge BEFORE dispatch. Evidence failures alone do not retry.
-            const next = observer.wait(Infinity, { signal, excludeKeys: excluded, skipImmediate: true, onChangeArmed: armed })
-                .catch(() => { armed(false); return []; });
-            if (!await ready || signal.aborted)
+        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 pending) {
-                const square = await openSquare(membership.squarePath, { hostLedger: ledger, env, signal });
+            }
+            for (const membership of await observer.read({ signal })) {
+                const { location, seat } = membership;
+                if (signal.aborted)
+                    return;
+                const artifact = createArtifactPort(location, undefined, signal);
                 try {
-                    for (const note of membership.notifications) {
-                        if (signal.aborted || excluded.has(key(membership.squarePath, membership.name, note.actIndex)))
-                            continue;
-                        await deliverPending({ artifact: square.artifact, hostLedger: ledger, transport, location: square.location, activity: formatActivityId(note.actIndex), now: Date.now() });
+                    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 closeOpenSquare(square);
+                    await artifact.close();
                 }
             }
-            await refreshExclusions();
-            pending = await next;
+            await waiting;
+            waiting = undefined;
         }
     }
+    catch (error) {
+        if (!signal.aborted)
+            throw error;
+    }
     finally {
         observer.close();
+        await waiting?.catch(() => { });
     }
 }
-export async function publishOpenCodeRoutes(sessionId, env, signal) {
-    const ledger = hostLedgerForEnv(env);
-    return ledger.withClaimLock(async () => {
-        const owners = (await ledger.listPresence({ session: sessionId })).filter((binding) => binding.channel === 'opencode');
-        for (const owner of owners) {
-            const square = await openSquare(owner.location, { hostLedger: ledger, env, signal });
-            try {
-                await publishWakeRoute(square.artifact, { location: owner.location, participant: owner.participant, sessionId, channel: 'opencode',
-                    kind: routeKind, address: { sessionId }, epoch: owner.epoch }, { requireCurrentSession: true });
-            }
-            finally {
-                await closeOpenSquare(square);
-            }
+/** Publish the native address into current artifact seats; the legacy route projection is not read. */
+export async function publishOpenCodeAddress(sessionId, env, signal) {
+    const seats = await discoverOpenCodeSeats(sessionId, env, signal);
+    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 } }));
         }
-        return owners.length > 0;
-    }, signal);
+        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;
+        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, body: seat.body, participant: seat.participant });
+        try {
+            await square.endOwnedSession(seat.participant, sessionId, seat.generation, seat.body);
+        }
+        finally {
+            await square.close();
+        }
+    }
 }

package/dist/plugins/opencode/index.js

@@ -1,11 +1,7 @@
-import { operationEnv } from '../../participant-identity.js';
-import { hostLedgerForEnv } from '../../registry.js';
+import { observeSquareIndex } from '../../square-index.js';
 import { canonicalPath } from '../../canonical-path.js';
-import { openSquare } from '../../open-square.js';
-import { closeOpenSquare } from '../../open-square.js';
-import { Square } from '../../square-api.js';
 import { connectNative } from '../../packages/agent-delivery/src/opencode-native.js';
-import { observeOpenCodeContext, publishOpenCodeRoutes, receiveOpenCodePending } from './delivery.js';
+import { cancelOpenCodeDeliveries, endOpenCodeSession, indexedOpenCodeSessions, observeOpenCodeContext, publishOpenCodeAddress, receiveOpenCodePending } from './delivery.js';
 /** Actual OpenCode 2.0.20 server plugin. Harness identity belongs to ctx, never process.env. */
 export default {
     id: 'square',
@@ -13,7 +9,7 @@ export default {
         if (ctx.app.version !== '2.0.20')
             return async () => { };
         const env = { ...process.env };
-        const ledger = hostLedgerForEnv(env);
+        const index = await observeSquareIndex(env);
         const lifetime = new AbortController();
         const receivers = new Map(); // Operational handles only; presence owns membership.
         const directory = await canonicalPath(ctx.location.directory);
@@ -43,7 +39,7 @@ export default {
             return target;
         };
         const reconcile = async (activeSession) => {
-            const candidates = new Set((await ledger.listPresence({})).filter((binding) => binding.channel === 'opencode').map((binding) => binding.session));
+            const candidates = new Set(await indexedOpenCodeSessions(env));
             if (activeSession)
                 candidates.add(activeSession);
             for (const sessionId of candidates) {
@@ -54,8 +50,7 @@ export default {
                     stop(sessionId);
                     continue;
                 }
-                const scopedEnv = operationEnv('opencode', sessionId, env);
-                if (!await publishOpenCodeRoutes(sessionId, scopedEnv, lifetime.signal)) {
+                if (!await publishOpenCodeAddress(sessionId, env, lifetime.signal)) {
                     stop(sessionId);
                     continue;
                 }
@@ -63,7 +58,7 @@ export default {
                     continue;
                 const abort = new AbortController();
                 const signal = AbortSignal.any([lifetime.signal, abort.signal]);
-                const receiver = { abort, settled: false, running: receiveOpenCodePending(target, scopedEnv, signal).catch(() => { }).finally(() => { receiver.settled = true; }) };
+                const receiver = { abort, settled: false, running: receiveOpenCodePending(target, env, signal).catch(() => { }).finally(() => { receiver.settled = true; }) };
                 receivers.set(sessionId, receiver);
             }
             for (const sessionId of receivers.keys())
@@ -75,31 +70,12 @@ export default {
                 return;
             // Stop synchronously; persist the cutoff before allowing reconciliation to start fresh work.
             stop(sessionId);
-            await ledger.withClaimLock(async () => {
-                for (const owner of (await ledger.listPresence({ session: sessionId })).filter((binding) => binding.channel === 'opencode')) {
-                    const square = await openSquare(owner.location, { hostLedger: ledger, env, signal: lifetime.signal });
-                    try {
-                        await ledger.suppressPresence(owner, (await square.artifact.read((facts) => facts.header().nextActIndex - 1, lifetime.signal)).value);
-                    }
-                    finally {
-                        await closeOpenSquare(square);
-                    }
-                }
-            }, lifetime.signal);
+            await cancelOpenCodeDeliveries(sessionId, env, lifetime.signal);
             await reconcile();
         };
         const end = async (sessionId) => {
             stop(sessionId);
-            const memberships = (await ledger.listPresence({ session: sessionId })).filter((binding) => binding.channel === 'opencode');
-            for (const owner of memberships) {
-                const square = await Square.at({ path: owner.location, hostLedger: ledger, env: operationEnv('opencode', sessionId, env) });
-                try {
-                    await square.endOwnedSession(owner.participant, sessionId, owner.epoch);
-                }
-                finally {
-                    await square.close();
-                }
-            }
+            await endOpenCodeSession(sessionId, env, lifetime.signal);
         };
         await ctx.session.hook('prompt', (event) => coordinate(() => reconcile(event.sessionID)));
         await ctx.session.hook('context', async (event) => {
@@ -107,15 +83,13 @@ export default {
             const receiver = receivers.get(event.sessionID);
             if (!receiver || lifetime.signal.aborted)
                 return;
-            await observeOpenCodeContext(event.sessionID, event.messages, operationEnv('opencode', event.sessionID, env), AbortSignal.any([lifetime.signal, receiver.abort.signal])).catch(() => { });
+            await observeOpenCodeContext(event.sessionID, event.messages, env, AbortSignal.any([lifetime.signal, receiver.abort.signal])).catch(() => { });
         });
-        const changes = await ledger.observeChanges();
-        changes.evidence.close(); // Manual joins activate an idle receiver; evidence already has a session observer.
         const presenceLoop = (async () => {
             while (!lifetime.signal.aborted) {
-                const baseline = await changes.presence.read(lifetime.signal);
+                const baseline = await index.read(lifetime.signal);
                 await coordinate(() => reconcile());
-                await changes.presence.changed(baseline, Infinity, lifetime.signal);
+                await index.changed(baseline, Infinity, lifetime.signal);
             }
         })().catch(() => { });
         const eventLoop = (async () => {
@@ -136,7 +110,7 @@ export default {
         // Do not await any native prompt in setup: plugin activation itself is lazy.
         return async () => {
             lifetime.abort();
-            changes.presence.close();
+            index.close();
             const tasks = [presenceLoop, eventLoop, coordinating, ...[...receivers.keys()].map(stop)];
             let timer;
             try {