@mcsherrylabs/pi-meerkat 0.8.0 → 0.11.0

package/installer/runtime-control.mjs

@@ -22,6 +22,29 @@ async function until(description, check) {
   }
   throw new Error(`${description} not ready within ${TIMEOUT / 1000}s: ${reason}; state retained, nothing reset`);
 }
+
+// DevNet catch-up is long (~14k blocks) and progress stays observable. A fixed short deadline
+// would fail a healthy sync, so this waits generously, fails only on STALLED progress, and reports
+// advancement to stderr only. `readProgress` returns null (not observed yet), `{ done: value }`
+// (finished), or `{ progress: scalar }` (still advancing). Progress must be comparable with `<=`;
+// the wait succeeds only on `done`, and fails on a stall or the whole budget expiring.
+async function untilProgress(description, readProgress, { budgetMs = 45 * 60 * 1000, stallMs = 10 * 60 * 1000 } = {}) {
+  const end = Date.now() + budgetMs;
+  let last = null, lastAt = Date.now(), started = false;
+  while (Date.now() < end) {
+    const value = await readProgress();
+    if (value && value.done !== undefined) return value.done;
+    if (value && value.progress !== undefined) {
+      if (!started) { started = true; lastAt = Date.now(); }
+      if (last === null || value.progress > last) { last = value.progress; lastAt = Date.now(); }
+    }
+    if (started && Date.now() - lastAt > stallMs)
+      throw new Error(`${description} stalled (no progress for ${Math.round((Date.now() - lastAt) / 1000)}s at ${last}); state retained, nothing reset`);
+    if (started && last !== null && Date.now() - lastAt > 30_000) process.stderr.write(`[installer] ${description} at ${last}…\n`);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+  throw new Error(`${description} not observed within ${Math.round(budgetMs / 1000)}s (last ${last}); state retained, nothing reset`);
+}
 async function child(command, args, env) {
   await new Promise((resolve, reject) => {
     const proc = spawn(command, args, { env, stdio: ['ignore', 'ignore', 'pipe'] });
@@ -36,8 +59,16 @@ async function child(command, args, env) {
 }
 function parameters() {
   const args = JSON.parse(argument);
-  if (!/^[A-Za-z0-9]{1,50}$/.test(args.nodeId) || !/^[A-Za-z0-9]{1,50}$/.test(args.committeeId) || !/^[A-Za-z0-9]{1,50}$/.test(args.identity) ||
-      !/^meerkat\.[0-9a-f]{24}\.announcements$/.test(args.channel)) throw new Error('invalid saved deployment parameters');
+  if (!/^[A-Za-z0-9]{1,50}$/.test(args.nodeId) || !/^[A-Za-z0-9]{1,50}$/.test(args.identity) ||
+      typeof args.channel !== 'string' || !args.channel) throw new Error('invalid saved deployment parameters');
+  if (args.mode === 'devnet') {
+    if (args.channel !== 'ce.meerkat.announcements') throw new Error('invalid saved devnet channel');
+  } else if (args.mode === 'local') {
+    if (!/^meerkat\.[0-9a-f]{24}\.announcements$/.test(args.channel)) throw new Error('invalid saved local channel');
+    if (!/^[A-Za-z0-9]{1,50}$/.test(args.committeeId)) throw new Error('invalid saved local committee identity');
+  } else {
+    throw new Error('invalid saved installation mode');
+  }
   if (args.binding && (args.binding.nodeId !== args.nodeId || !/^[0-9a-f]{64}$/.test(args.binding.chainId))) throw new Error('invalid saved binding');
   return args;
 }
@@ -129,44 +160,176 @@ async function main() {
     return;
   }
   if (mode === 'node-binding') {
-    const binding = await until('owned processing node', async () => {
-      const value = await json('http://node:8440/api/channel/processor-state');
-      if (!value.processing || !/^[0-9a-f]{64}$/.test(value.binding?.chainId)) throw new Error('processing/genesis observation not ready');
-      if (value.binding.nodeId !== args.nodeId) throw Object.assign(new Error('owned node identity differs; refusing re-pairing'), { permanent: true });
-      if (args.binding && args.binding.chainId !== value.binding.chainId) throw Object.assign(new Error('saved genesis differs; refusing re-pairing'), { permanent: true });
-      return value.binding;
-    });
+    // DevNet followers sync from block 0 (~14k blocks); wait generously and fail on STALL, not a
+    // short fixed deadline. Local is a fresh committee and becomes ready quickly.
+    const chainId = args.mode === 'devnet' ? 'c8925985ae7948d2e608efcf863928d15476c4b561ad773fdca6f0d53d4fea05' : undefined;
+    const reads = async () => {
+      try {
+        const value = await json('http://node:8440/api/channel/processor-state');
+        if (!value.processing || !/^[0-9a-f]{64}$/.test(value.binding?.chainId)) {
+          // Followers report a synced height while catching up; expose it as stalled-detectable progress.
+          try {
+            const status = await json('http://node:8440/status');
+            if (Number.isInteger(status.blockHeight) && status.blockHeight >= 0) return { progress: status.blockHeight };
+          } catch { /* not up yet */ }
+          return null;
+        }
+        if (value.binding.nodeId !== args.nodeId) throw Object.assign(new Error('owned node identity differs; refusing re-pairing'), { permanent: true });
+        if (args.binding && args.binding.chainId !== value.binding.chainId) throw Object.assign(new Error('saved genesis differs; refusing re-pairing'), { permanent: true });
+        if (chainId && value.binding.chainId !== chainId) throw Object.assign(new Error('devnet chain id differs; refusing pairing'), { permanent: true });
+        return { done: value.binding };
+      } catch (e) { if (e?.permanent) throw e; return null; }
+    };
+    const binding = args.mode === 'devnet'
+      ? await untilProgress('devnet follower catch-up/processing readiness', reads)
+      : await until('owned processing node', async () => {
+          const value = await reads();
+          if (value === null) throw new Error('processing/genesis observation not ready');
+          if (value.done === undefined) throw new Error('processing/genesis observation not ready');
+          return value.done;
+        });
     process.stdout.write(JSON.stringify(binding) + '\n');
     return;
   }
   if (!args.binding) throw new Error('missing saved node binding');
   const headers = { 'x-evolver-chain-id': args.binding.chainId, 'x-evolver-node-id': args.binding.nodeId };
   if (mode === 'ready') {
-    await until('Meerkat registry/channel/inbox', async () => {
+    // DevNet's read-only registry must walk the shared channel's full history (~14k blocks of
+    // announcements) before it can serve faithfully; wait on its walk progress, not a fixed deadline.
+    // Local's channel is freshly claimed and walks almost immediately.
+    const check = async () => {
       const summary = await json('http://127.0.0.1:8090/summary', headers);
       await json('http://127.0.0.1:8090/inbox', headers);
       if (summary.channel !== args.channel) throw new Error('registry channel differs');
       const terms = await json(`http://node:8440/api/explorer/channels/${encodeURIComponent(args.channel)}`);
       if (!Array.isArray(terms.owners) || !terms.owners.length || terms.writePolicy !== 'open' || terms.da) throw new Error('registry channel not provisioned with open writes/no DA');
-    });
+      return summary;
+    };
+    if (args.mode === 'devnet') {
+      await untilProgress('devnet registry channel walk/index', async () => {
+        try {
+          const summary = await check();
+          const asOf = Number(summary.asOfRound), tip = Number(summary.tipRound);
+          if (Number.isSafeInteger(asOf) && Number.isSafeInteger(tip) && tip >= 0) {
+            // Fully caught up (asOf >= tip) with everything else already valid via check().
+            return asOf >= tip ? { done: true } : { progress: asOf };
+          }
+          return null;
+        } catch (e) { if (e?.permanent) throw e; return null; }
+      });
+    } else {
+      await until('Meerkat registry/channel/inbox', async () => { await check(); });
+    }
     return;
   }
   if (mode === 'bootstrap') {
     const { resolveUpstreamBin } = await import('../dist/mcp-upstream.js');
     const cli = await resolveUpstreamBin();
-    await child(process.execPath, [cli, '--bootstrap', '--target', 'local', '--identity', args.identity], {
-      PATH: process.env.PATH, HOME: agentDir, EVOLVER_NODE: 'http://node:8440', EVOLVER_FAUCET_URL: 'http://committee:8440',
-      EVOLVER_CONTENT_URL: 'http://node:8450', EVOLVER_MCP_STATE_DIR: agentDir, EVOLVER_BOOTSTRAP_CWD: agentDir,
-    });
+    const devnet = args.mode === 'devnet';
+    const childEnv = {
+      PATH: process.env.PATH, HOME: agentDir, EVOLVER_NODE: 'http://node:8440', EVOLVER_CONTENT_URL: 'http://node:8450',
+      EVOLVER_FAUCET_URL: devnet ? 'https://devnet.mcsherrylabs.com' : 'http://committee:8440',
+      EVOLVER_MCP_STATE_DIR: agentDir, EVOLVER_BOOTSTRAP_CWD: agentDir,
+    };
+    await child(process.execPath, [cli, '--bootstrap', '--target', devnet ? 'devnet' : 'local', '--identity', args.identity], childEnv);
     const config = { version: 1, url: 'http://node:8440', identity: args.identity, tls: { insecure: false },
       meerkat: { contentUrl: 'http://node:8450', keyPath: join(agentDir, `${args.identity}.key`), keyType: 'bls',
-        registryUrl: 'http://127.0.0.1:8090', chainId: args.binding.chainId, nodeId: args.nodeId, channel: args.channel } };
+        registryUrl: 'http://127.0.0.1:8090', chainId: args.binding.chainId, nodeId: args.nodeId, channel: args.channel,
+        controlSocketPath: '/control/control.sock' } };
     let existing;
     try { existing = await loadFacadeConfig(configPath); } catch (e) { if (e.code !== 'ENOENT') throw e; }
     if (existing) { if (JSON.stringify(existing) !== JSON.stringify(config)) throw new Error('unrelated saved facade authority; refusing replacement'); }
     else await saveFacadeConfig(configPath, config);
     return;
   }
+  if (mode === 'claim-channel') {
+    // LOCAL only: the agent identity owns the install's private channel. Claim it ONCE through the
+    // released child's own tools (sign + submit), so the agent key never leaves the child. Read the
+    // terms first; already owned by the agent → done; owned by someone else → refuse; unclaimed →
+    // claim then reconcile by reading (never blind-resend).
+    if (args.mode !== 'local') throw new Error('claim-channel is a local-mode operation only');
+    const { OwnedUpstream } = await import('../dist/mcp-upstream.js');
+    const { claimTxId, submissionResult } = await import('../dist/mcp-announce.js');
+    const facadeConfig = await loadFacadeConfig(configPath);
+    // CHAIN-AGREED view (the local committee), never the processing node: a processing node answers
+    // committed-state reads as of its cursor, so a claim it has not applied yet reads `owners: []`.
+    const termsUrl = () => `http://committee:8440/api/explorer/channels/${encodeURIComponent(args.channel)}`;
+    const readTerms = async () => { const r = await fetch(termsUrl(), { signal: AbortSignal.timeout(10000) }); if (!r.ok) throw new Error(`HTTP ${r.status}`); return r.json(); };
+    const ownersOf = terms => Array.isArray(terms.owners) ? terms.owners : [];
+    // The claim commits asynchronously after submit; poll the terms (up to 180s) so the
+    // reconcile-by-read settles regardless of commit latency, never a single immediate read.
+    const awaitOwned = async () => {
+      const end = Date.now() + 180_000;
+      while (Date.now() < end) {
+        const owners = ownersOf(await readTerms());
+        if (owners.some(o => o.name === args.identity)) return;
+        if (owners.length > 0) throw new Error(`channel ${args.channel} is owned by ${owners.map(o => o.name).join(', ')} — refusing to claim`);
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+      throw new Error(`channel ${args.channel} was not claimed by the agent within 180s — refusing to proceed`);
+    };
+    // Already owned by us (from a prior, possibly crashed, claim) → done, idempotent.
+    if (ownersOf(await readTerms()).some(o => o.name === args.identity)) {
+      process.stderr.write(`[installer] channel ${args.channel} already owned by the agent — nothing to claim\n`);
+      return;
+    }
+    // The processing node refuses submissions (`node_not_ready`) until its own node identity is
+    // established. Wait until the chain-agreed view has that identity before signing anything.
+    const identityEnd = Date.now() + 180_000;
+    for (;;) {
+      const r = await fetch(`http://committee:8440/api/identity/${encodeURIComponent(args.nodeId)}`, { signal: AbortSignal.timeout(10000) }).catch(() => null);
+      if (r?.status === 200) break;
+      if (Date.now() > identityEnd) throw new Error(`node identity ${args.nodeId} not established on chain within 180s; nothing submitted`);
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    // The processing node submits through an admit filter keyed on the AGENT identity (claimed by
+    // the earlier `bootstrap` mode), and in processing mode its applied state is paced by the
+    // facade's own polls — so the agent identity can lag behind the committee's chain-agreed view.
+    // A submission in that window is refused with `unknown_key` (`admitFilter rejected
+    // (UnknownKey)`), which ordered and charged nothing but is final (never blind-resend). Wait for
+    // the processing node itself to report the agent identity before signing, so the claim is
+    // admitted on the first submission instead of racing its apply.
+    const agentIdentityEnd = Date.now() + 180_000;
+    for (;;) {
+      const r = await fetch(`http://node:8440/api/identity/${encodeURIComponent(args.identity)}`, { signal: AbortSignal.timeout(10000) }).catch(() => null);
+      if (r?.status === 200) break;
+      if (Date.now() > agentIdentityEnd) throw new Error(`agent identity ${args.identity} not applied by the processing node within 180s; nothing submitted`);
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    // Sign then submit in ONE owned child session, then reconcile by reading (never blind-resend).
+    // Only `node_not_ready` is retried: it is a definite refusal that ordered and charged nothing.
+    // The child blocks repeat submission within a session, so a retry closes that session and signs
+    // afresh in a new one; the refused transaction was never ordered, so this cannot pay twice.
+    const submitEnd = Date.now() + 180_000;
+    let outcome;
+    for (;;) {
+      const upstream = new OwnedUpstream(facadeConfig);
+      await upstream.connect();
+      try {
+        const txId = claimTxId(await upstream.callTool('evolver_sign_claim_channel', { channel: args.channel, writePolicy: 'open' }), args.channel);
+        try {
+          outcome = submissionResult(await upstream.callTool('evolver_submit', { txId }), txId);
+        } catch (e) {
+          // Submit outcome unknown; reconcile by reading, never resend.
+          process.stderr.write(`[installer] claim submit uncertain (${e instanceof Error ? e.message : String(e)}) — reconciling by reading\n`);
+          outcome = undefined;
+        }
+      } finally {
+        await upstream.close();
+      }
+      if (!(outcome?.kind === 'refused' && outcome.reason === 'node_not_ready') || Date.now() > submitEnd) break;
+      process.stderr.write('[installer] node not ready for submissions yet (nothing ordered or charged) — retrying with a fresh claim\n');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+    // A definite refusal or fine is final: report the chain's own reason, never wait or resend.
+    if (outcome && (outcome.kind === 'refused' || outcome.kind === 'fined'))
+      throw new Error(`channel ${args.channel} claim was ${outcome.kind} by the chain: ${outcome.message}`);
+    if (outcome && outcome.kind !== 'committed')
+      process.stderr.write(`[installer] claim submit outcome ${outcome.kind} — reconciling by reading\n`);
+    await awaitOwned();
+    process.stderr.write(`[installer] channel ${args.channel} claimed (open) by the agent\n`);
+    return;
+  }
   throw new Error('unknown installer runtime operation');
 }
 await main().catch(error => { console.error(error instanceof Error ? error.message : 'installer runtime failed'); process.exitCode = 1; });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mcsherrylabs/pi-meerkat",
-  "version": "0.8.0",
-  "description": "Meerkat zero-parameter local installer, stdio MCP facade and registry tools, with a private pinned Evolver MCP child. Preserves the announcement contract and existing Pi extension.",
+  "version": "0.11.0",
+  "description": "Meerkat zero-parameter DevNet installer (local chain with --local), stdio MCP facade and registry tools, with a private pinned Evolver MCP child. Preserves the announcement contract and existing Pi extension.",
   "bin": {
     "meerkat-mcp": "./dist/mcp-cli.js"
   },
@@ -29,9 +29,9 @@
     "check:plan-two:client": "tsx test/mcp-client-checks.ts"
   },
   "dependencies": {
-    "@mcsherrylabs/evolver-client": "0.22.1",
-    "@mcsherrylabs/evolver-core": "0.1.0",
-    "@mcsherrylabs/evolver-mcp": "0.15.0",
+    "@mcsherrylabs/evolver-client": "0.24.0",
+    "@mcsherrylabs/evolver-core": "0.2.2",
+    "@mcsherrylabs/evolver-mcp": "0.17.0",
     "@modelcontextprotocol/sdk": "1.32.1",
     "typebox": "1.3.32"
   },

package/skills/channel-subscription/SKILL.md

@@ -11,8 +11,8 @@ The shared SDK processor is the node's ONE ordered-stream consumer. Never poll
 ## Subscription management
 
 This extension has no config-file or Docker restart tools. Use the managed MCP
-channel subscribe/unsubscribe/subscriptions tools
-when an operator has paired a private processor control socket with the expected
+channel subscribe/unsubscribe/subscriptions tools on the control socket, which
+the installer provisions automatically on a fresh install against the expected
 node and chain. An unmanaged endpoint cannot be configured by these tools.
 
 Saved choices, including an EMPTY set, override all startup/module defaults.
@@ -26,7 +26,7 @@ Removing its channel parks the module; re-enabling it does not replay old inbox
 
 ## Availability and reads
 
-A channel owner may use `evolver_sign_set_channel_da` to arrange availability through
+A channel owner may use `evolver_sign_channel_da` to arrange availability through
 a DA group containing the NODE identity, not the agent identity. Only the owner may
 change a channel's policy. Without DA, bodies are best effort.
 

package/dist/installer-runtime/dist/src/runtime.js

@@ -1,164 +0,0 @@
-// Meerkat composition root for the shared processor, not a second collector/runtime.
-// All paths/capabilities are operator-fixed here; requests can supply only a channel id.
-import { join } from "node:path";
-import { dockerNodeRestarter, nodeObserver, nodePuller, startControlServer, startProcessor, startReadServer, subscriptionConfig, subscriptionController, } from "@mcsherrylabs/evolver-client/processor";
-import { ensureStateDir } from "./env.js";
-const productionSdk = {
-    dockerNodeRestarter, nodeObserver, nodePuller, startControlServer, startProcessor,
-    startReadServer, subscriptionConfig, subscriptionController,
-};
-export function processorBinding() {
-    return { chainId: process.env.EVOLVER_CHAIN_ID?.trim() ?? "", nodeId: process.env.APP_NODE_ID?.trim() ?? "" };
-}
-export function processorConfigPath(target) {
-    return process.env.EVOLVER_SUBSCRIPTIONS_FILE?.trim() || join(target.stateDir, "subscriptions", "channels.conf");
-}
-export function processorStatePath(target) {
-    return join(target.stateDir, "registry.db");
-}
-export async function startMeerkatProcessor(args, sdk = productionSdk) {
-    const binding = processorBinding();
-    // Synchronous SDK validation of fixed expectations, NOT an online-node startup dependency.
-    const observe = sdk.nodeObserver({ baseUrl: args.target.nodeUrl, binding });
-    const config = sdk.subscriptionConfig(processorConfigPath(args.target));
-    await config.read(); // missing/malformed declaration refuses before opening storage; never reseed
-    let initialized = false;
-    ensureStateDir(args.target);
-    const runtime = await sdk.startProcessor({
-        store: {
-            path: processorStatePath(args.target), binding,
-            modules: args.worker ? [args.worker] : [],
-            limits: { maxEntriesPerChannel: 1000, maxBodyBytes: 64 * 1024 * 1024 },
-        },
-        puller: sdk.nodePuller(args.node), config,
-        // SDK initialization normally attempts setup (which can pace). Defer that attempt until
-        // the caller explicitly paces/runs: service composition binds recovery listeners first.
-        // Every subsequent pace still uses the SDK's verified node/chain/ACTIVE gate.
-        observe: async () => {
-            if (!initialized)
-                throw new Error("Meerkat listeners not started; collection deferred");
-            return observe();
-        },
-        tip: async () => String(await args.node.currentRound()),
-        modules: args.lifecycle ? [args.lifecycle] : [], say: args.say,
-    }).catch(error => {
-        if (error?.name === "ProcessorOwnerLockError") {
-            args.say(error.message);
-            args.say("MANUAL FORCE RECOVERY REQUIRED if the owner has died. Using the SAME Compose project/env/files/volumes: 1) docker compose stop app; stop any other collectors and disable all external automatic restarts. 2) Only when fenced: docker compose run --rm --no-deps app node dist/scripts/recover-owner.js --force. 3) docker compose up -d --no-deps app. For a host-run app, stop it and its supervisor first, then run node dist/scripts/recover-owner.js --force with the SAME target/state environment and restart normally. Ordinary restart or --force-recreate does NOT clear the lock. Never delete database/WAL or reinitialize subscriptions.");
-        }
-        throw error;
-    });
-    initialized = true;
-    return runtime;
-}
-/** Always attempt every release, including when another close fails. */
-export async function closeMeerkat(actions) {
-    const errors = [];
-    for (const action of actions) {
-        try {
-            await action();
-        }
-        catch (error) {
-            errors.push(error);
-        }
-    }
-    if (errors.length)
-        throw new AggregateError(errors, "Meerkat shutdown failed");
-}
-export async function startMeerkatServers(args, sdk = productionSdk) {
-    const servers = [];
-    try {
-        servers.push(await sdk.startReadServer({
-            store: args.runtime.store, port: args.port,
-            host: process.env.PROCESSOR_READ_HOST?.trim() || "127.0.0.1", routes: args.routes, say: args.say,
-        }));
-        const containerName = process.env.EVOLVER_MANAGED_NODE_CONTAINER?.trim();
-        const socketPath = process.env.EVOLVER_PROCESSOR_CONTROL_SOCKET?.trim() || (containerName ? "/control/control.sock" : undefined);
-        const dockerSocket = containerName ? "/var/run/docker.sock" : undefined;
-        if (socketPath || dockerSocket || containerName) {
-            if (!socketPath || !dockerSocket || !containerName)
-                throw new Error("managed control requires explicit control socket, Docker socket and fixed node container");
-            const binding = processorBinding();
-            const controller = sdk.subscriptionController({
-                binding, runtime: args.runtime, config: sdk.subscriptionConfig(processorConfigPath(args.target)),
-                observe: sdk.nodeObserver({ baseUrl: args.target.nodeUrl, binding }),
-                restart: sdk.dockerNodeRestarter({ socketPath: dockerSocket, containerName }),
-            });
-            servers.push(await sdk.startControlServer({ socketPath, mode: 0o660, controller, say: args.say }));
-        }
-        return { port: servers[0].port, close: () => closeMeerkat([...servers].reverse().map(server => () => server.close())) };
-    }
-    catch (error) {
-        try {
-            await closeMeerkat(servers.reverse().map(server => () => server.close()));
-        }
-        catch (cleanup) {
-            throw new AggregateError([error, cleanup], "Meerkat listener startup failed");
-        }
-        throw error;
-    }
-}
-/** One service owner: bind listeners before run/setup, and release the worker on partial bind. */
-export async function startMeerkatService(args, sdk = productionSdk) {
-    const runtime = await startMeerkatProcessor(args, sdk);
-    let servers;
-    try {
-        servers = await startMeerkatServers({ ...args, runtime, routes: args.routes(runtime) }, sdk);
-        runtime.run();
-        let stopping;
-        return { runtime, port: servers.port, stop() {
-                return stopping ??= closeMeerkat([() => servers.close(), () => runtime.stop()]);
-            } };
-    }
-    catch (error) {
-        try {
-            await closeMeerkat([...(servers ? [() => servers.close()] : []), () => runtime.stop()]);
-        }
-        catch (cleanup) {
-            throw new AggregateError([error, cleanup], "Meerkat service startup failed");
-        }
-        throw error;
-    }
-}
-/** Signals and normal/error completion share one cleanup path, including partial async startup. */
-export function meerkatShutdown(signals = process) {
-    let stopping;
-    const releases = [];
-    const stop = () => stopping ??= closeMeerkat([...releases].reverse());
-    const onSignal = () => { void stop().then(() => signals.exit(0), error => { console.error(error); signals.exit(1); }); };
-    signals.once("SIGINT", onSignal);
-    signals.once("SIGTERM", onSignal);
-    return {
-        async own(start, release) {
-            if (stopping)
-                throw new Error("Meerkat stopped during startup");
-            const pending = start();
-            // Register before awaiting so a signal DURING startup waits for and releases its result.
-            releases.push(async () => {
-                let resource;
-                try {
-                    resource = await pending;
-                }
-                catch {
-                    return;
-                } // startup owns its partial cleanup
-                await release(resource);
-            });
-            const resource = await pending;
-            if (stopping) {
-                await stopping;
-                throw new Error("Meerkat stopped during startup");
-            }
-            return resource;
-        },
-        async close() {
-            try {
-                await stop();
-            }
-            finally {
-                signals.removeListener("SIGINT", onSignal);
-                signals.removeListener("SIGTERM", onSignal);
-            }
-        },
-    };
-}