@agentshouse/kit 0.1.0-alpha.26 → 0.1.0-alpha.28

package/src/worker.js

@@ -20,7 +20,9 @@ import { localRequest, reconcileInbound } from "./inbound.js";
 import { localFiles } from "./local-files.js";
 import { answerText, answerYaml, editRefusal } from "./mcp.js";
 import { inheritedEnvironment } from "./command.js";
+import { sourceEntries } from "./google/entries.js";
 import { watchKitWork } from "./kit-work-stream.js";
+import { coalescedTask, residentWake } from "./tasks.js";
 import {
   applyWorkingCopies,
   deliverWorkingCopies,
@@ -38,10 +40,8 @@ import {
   MCP_REQUEST_BODY_MAX_BYTES,
   PROVIDER_CONTINUATION_UNAVAILABLE,
   WORKER_COMMAND_BATCH_MAX,
-  WORKER_COMMAND_POLL_MS,
   WORKER_EXIT_GRACE_MS,
   WORKER_EXIT_POLL_MS,
-  WORKER_HEARTBEAT_MS,
   WORKER_INHERITED_ENVIRONMENT,
   WORKER_SUPERVISION_POLL_MS,
   WORKING_COPY_INDEX_METHOD,
@@ -74,7 +74,6 @@ import {
   reportInteractionOutcome,
   toolMutations,
   reportRunOutcome,
-  reportSessionHeartbeat,
   releaseControl,
   reportSessions,
   serveResident,
@@ -99,6 +98,7 @@ import {
 
 const LAUNCHER_MAIN = fileURLToPath(new URL("launcher-main.js", import.meta.url));
 const RESIDENT_INTERVAL_MS = 30_000;
+const PASS_REACHES = ["commands", "runs"];
 
 async function dispatchSeal(context, bound) {
   try {
@@ -132,9 +132,7 @@ async function pendingCommands(context, kinds = ["stop"]) {
   try {
     return await acquireCommands(context.session, WORKER_COMMAND_BATCH_MAX, kinds);
   } catch (refusal) {
-    if (houseFailed(refusal) || context.session.refused === true) {
-      return { stops: [], answers: [], interrupts: [] };
-    }
+    if (houseFailed(refusal) || context.session.refused === true) return null;
     throw refusal;
   }
 }
@@ -155,14 +153,6 @@ async function settleInterrupt(context, interrupt, outcome) {
   }
 }
 
-async function reportHeartbeat(context, bound) {
-  try {
-    await reportSessionHeartbeat(context.session, bound.session);
-  } catch (refusal) {
-    if (!(refusal instanceof KitRefusal)) throw refusal;
-  }
-}
-
 function retryFiles(context) {
   if (context.retrying !== undefined) return;
   context.retrying = retryConversationFiles(context)
@@ -185,40 +175,32 @@ async function settleFiles(context) {
 }
 
 async function supervise(context, bound, bridge) {
-  const terminal = bridge.departed;
-  let live = true;
-  terminal.then(() => {
-    live = false;
-  });
-  let commanded = Date.now() + WORKER_COMMAND_POLL_MS;
-  let pulsed = Date.now() + WORKER_HEARTBEAT_MS;
-  while (live) {
-    await Promise.race([terminal, delay(WORKER_SUPERVISION_POLL_MS)]);
-    if (!live) return null;
+  const departed = new AbortController();
+  bridge.departed.then(() => departed.abort());
+  const waiting = AbortSignal.any([context.signal, departed.signal]);
+  let owed = false;
+  for (;;) {
+    const commanded = (await context.commands.wait(WORKER_SUPERVISION_POLL_MS, waiting)) || owed;
+    if (departed.signal.aborted) return null;
+    if (context.signal.aborted) throw new KitRefusal("kit_command_cancelled");
     await context.update?.announce();
-    if (Date.now() >= commanded) {
-      commanded = Date.now() + WORKER_COMMAND_POLL_MS;
+    if (commanded) {
       const polled = await pendingCommands(context, ["stop", "interrupt", "answer"]);
-      for (const answer of polled.answers) {
+      owed = polled === null && context.session.refused !== true;
+      for (const answer of polled?.answers ?? []) {
         if (answer.session === bound.session) bridge.answered(answer);
       }
-      for (const interrupt of polled.interrupts) {
+      for (const interrupt of polled?.interrupts ?? []) {
         if (interrupt.session !== bound.session || interrupt.run !== bound.run) continue;
         if (!bridge.interrupt(interrupt)) {
           await settleInterrupt(context, interrupt.interrupt, "nothing_to_interrupt");
         }
       }
-      const stop = polled.stops.find((command) => command.run === bound.run);
+      const stop = polled?.stops.find((command) => command.run === bound.run);
       if (stop !== undefined) return stop;
     }
-    if (Date.now() >= pulsed) {
-      pulsed = Date.now() + WORKER_HEARTBEAT_MS;
-      retryFiles(context);
-      await reportHeartbeat(context, bound);
-    }
     if (!(await sessionPresent(context.runtime, bound.tmux))) return null;
   }
-  return null;
 }
 
 async function grantExitGrace(runtime, handle) {
@@ -430,6 +412,7 @@ async function superviseBound(context, bound, opened, start) {
   } finally {
     try {
       try {
+        retryFiles(context);
         await settleFiles(context);
         for (const interaction of bridge.unsettledInteractions()) {
           await settleInteraction(context, interaction, "expired");
@@ -725,7 +708,7 @@ async function reconcile(context) {
   }
   const bindings = await readBindings(context.directory);
   if (bindings.length === 0) return { run: null, stopped, unresolved };
-  const commands = (await pendingCommands(context)).stops;
+  const commands = (await pendingCommands(context))?.stops ?? [];
   const carried = [];
   for (const binding of bindings) {
     if (binding.reported !== null) {
@@ -809,7 +792,7 @@ function unlessDraining(context, act) {
   return context.update?.requested ? null : act();
 }
 
-async function workerPass(context, dependencies, baseConfiguration) {
+async function workerPass(context, dependencies, baseConfiguration, reach) {
   const { session, signal } = context;
   const reconciled = await reconcile(context);
   if (reconciled.run !== null || reconciled.unresolved.length > 0 || context.update?.requested) {
@@ -840,6 +823,7 @@ async function workerPass(context, dependencies, baseConfiguration) {
   }
   const resumption = await unlessDraining(context, () => acquireOneResumption(session));
   if (resumption !== null) return { ...reconciled, run: await superviseResumption(context, resumption) };
+  if (reach !== "runs") return reconciled;
   const assignment = await unlessDraining(context, () => acquireOneRun(session));
   if (assignment === null) return reconciled;
   return { ...reconciled, run: await superviseAssignment(context, assignment) };
@@ -863,6 +847,7 @@ async function workerContext(options, dependencies, resident = false) {
     directory: options.directory,
     home: dependencies.home ?? homedir(),
     files: { originals: [], failures: [] },
+    commands: residentWake(),
     epochReport: null,
     agentRefresh: Promise.resolve(),
     configurationPath: options.configuration,
@@ -907,7 +892,7 @@ function queueAgentRefresh(context, dependencies, signal, configuration, pointer
   return refreshed;
 }
 
-async function controlledPass(context, dependencies, configuration, signal) {
+async function controlledPass(context, dependencies, configuration, signal, reach = "runs") {
   context.signal = signal;
   context.session.signal = signal;
   await reconcileSkillSet({
@@ -917,7 +902,7 @@ async function controlledPass(context, dependencies, configuration, signal) {
   });
   context.busy = true;
   try {
-    return await afterEpochReport(context, () => workerPass(context, dependencies, configuration));
+    return await afterEpochReport(context, () => workerPass(context, dependencies, configuration, reach));
   } finally {
     context.busy = false;
     if (context.deferredRemoval) context.onIdle?.();
@@ -928,8 +913,23 @@ export async function runWorkers(options, dependencies = {}) {
   const { context, tmux } = await workerContext(options, dependencies);
   const { session, runtime } = context;
   const supervised = await maintainControl(session, async (signal) => {
-    await reportedWorkingCopies(applyWorkingCopies, context, signal);
-    return controlledPass(context, dependencies, context.configuration, signal);
+    const watcher = new AbortController();
+    const commanded = (subject) => {
+      if (subject === null || subject === "commands") context.commands.notify();
+    };
+    const watching = (dependencies.watchKitWork ?? watchKitWork)(
+      session,
+      AbortSignal.any([signal, watcher.signal]),
+      { available: commanded, changed: () => {} },
+      dependencies,
+    ).catch((error) => reported(`control stream ended: ${error?.code ?? error?.message ?? error}`));
+    try {
+      await reportedWorkingCopies(applyWorkingCopies, context, signal);
+      return await controlledPass(context, dependencies, context.configuration, signal);
+    } finally {
+      watcher.abort();
+      await watching;
+    }
   }, session.signal);
   return {
     tmux,
@@ -950,65 +950,11 @@ function reported(line) {
 }
 
 async function reportedWorkingCopies(act, context, signal) {
-  for (const refused of (await act(context, signal)).refused) {
+  const outcome = await act(context, signal);
+  for (const refused of outcome.refused) {
     reported(`working copy ${refused.path} refused: ${refused.code}`);
   }
-}
-
-function coalescedTask(signal, fail, work) {
-  let pending = false;
-  let task = null;
-  const trigger = () => {
-    pending = true;
-    if (task !== null) return;
-    task = (async () => {
-      while (pending && !signal.aborted) {
-        pending = false;
-        await work();
-      }
-    })()
-      .catch((error) => {
-        if (signal.aborted) return;
-        fail(error);
-      })
-      .finally(() => {
-        task = null;
-        if (pending && !signal.aborted) trigger();
-      });
-  };
-  return { trigger, idle: () => task === null, settled: () => task };
-}
-
-function residentWake() {
-  let pending = false;
-  let release = null;
-  return {
-    notify() {
-      pending = true;
-      release?.();
-    },
-    async wait(milliseconds, signal) {
-      if (pending) {
-        pending = false;
-        return;
-      }
-      const pause = new AbortController();
-      try {
-        await Promise.race([
-          new Promise((resolve) => {
-            release = resolve;
-          }),
-          delay(milliseconds, undefined, { signal: AbortSignal.any([signal, pause.signal]) }),
-        ]);
-      } catch (error) {
-        if (!signal.aborted) throw error;
-      } finally {
-        release = null;
-        pending = false;
-        pause.abort();
-      }
-    },
-  };
+  return outcome;
 }
 
 function residentUpdate(context, wake) {
@@ -1078,6 +1024,7 @@ export async function runResident(options, dependencies = {}) {
   const wake = residentWake();
   const update = residentUpdate(context, wake);
   context.update = update;
+  let sources = null;
   const served = await serveResident(
     session,
     context.directory,
@@ -1087,6 +1034,8 @@ export async function runResident(options, dependencies = {}) {
       pushWorkingCopy({ directory: context.directory, session }, request, ownerCaller(session), signal).catch(
         (error) => ({ refused: true, text: formatCommandError(error) }),
       ),
+    (source) =>
+      sources === null ? Promise.reject(new KitRefusal("kit_resident_unavailable")) : sources.capture(source),
   );
   const serve = async (signal) => {
     context.busy = true;
@@ -1143,50 +1092,111 @@ export async function runResident(options, dependencies = {}) {
       context.startLogins(needsLogin);
     });
     const unavailable = (error) => reported(`working copies unavailable: ${error?.message ?? error}`);
-    const copies = coalescedTask(signal, unavailable, () =>
-      reportedWorkingCopies(applyWorkingCopies, context, signal),
+    const changed = () => {
+      if (!update.requested) deliveries.trigger();
+    };
+    const behind = (outcome) => {
+      if (!outcome.behind) return;
+      controlSleep(interval, signal).then(changed, () => {});
+    };
+    const copies = coalescedTask(signal, unavailable, async () =>
+      behind(await reportedWorkingCopies(applyWorkingCopies, context, signal)),
     );
-    const deliveries = coalescedTask(signal, unavailable, () =>
-      reportedWorkingCopies(deliverWorkingCopies, context, signal),
+    const deliveries = coalescedTask(signal, unavailable, async () =>
+      behind(await reportedWorkingCopies(deliverWorkingCopies, context, signal)),
     );
+    sources = sourceEntries({
+      session: context.session,
+      directory: context.directory,
+      dependencies,
+      signal: AbortSignal.any([signal, watcher.signal]),
+      now: session.now,
+      draining: () => update.requested,
+      unavailable: (error) => reported(`google sources unavailable: ${error?.message ?? error}`),
+    });
+    await sources.start();
     const pointer = () => {
       if (!update.requested) agentRefresh.trigger();
     };
+    let passOwed = null;
+    let deferred = null;
+    let retrying = null;
+    const higher = (reach, than) =>
+      PASS_REACHES.indexOf(reach) > PASS_REACHES.indexOf(than) ? reach : than;
+    const owe = (reach) => {
+      passOwed = higher(reach, passOwed);
+      wake.notify();
+    };
+    const defer = (reach) => {
+      deferred = higher(reach, deferred);
+      if (retrying !== null) return;
+      retrying = new AbortController();
+      controlSleep(interval, AbortSignal.any([signal, retrying.signal])).then(() => {
+        retrying = null;
+        const owed = deferred;
+        deferred = null;
+        owe(owed);
+      }, () => {});
+    };
+    const settle = (reach) => {
+      retrying?.abort();
+      retrying = null;
+      if (higher(deferred, reach) !== reach) owe(deferred);
+      deferred = null;
+    };
     const available = (subject) => {
+      if (subject === null || subject === "runs") owe("runs");
+      if (subject === null || subject === "commands") {
+        context.commands.notify();
+        owe("commands");
+      }
       if (update.requested) return;
-      if (subject !== "working_copy") agentRefresh.trigger();
-      if (subject !== "agents") copies.trigger();
+      if (subject === null || subject === "agents") agentRefresh.trigger();
+      if (subject === null || subject === "working_copy") copies.trigger();
+      if (subject === null || subject === "sources") sources.reconcile();
     };
     context.onIdle = pointer;
     context.workingCopiesApplied = copies.settled;
-    if (!update.requested) copies.trigger();
     const watching = (dependencies.watchKitWork ?? watchKitWork)(
       context.session,
       AbortSignal.any([signal, watcher.signal]),
-      available,
+      { available, changed },
       dependencies,
     ).catch(fail);
     try {
       while (!signal.aborted) {
         if (failure !== null) throw failure;
-        if (!session.refused) {
+        if (passOwed !== null && !session.refused) {
+          const reach = passOwed;
+          passOwed = null;
           const configuration = await readConfiguration(options.configuration);
-          await controlledPass(context, dependencies, configuration, signal).catch((error) => {
-            if (!session.refused) throw error;
-          });
+          const passed = await controlledPass(context, dependencies, configuration, signal, reach).catch(
+            (error) => {
+              if (!session.refused) throw error;
+              return null;
+            },
+          );
+          if ((passed?.run ?? null) !== null) owe(reach);
+          if ((passed?.unresolved.length ?? 0) > 0) defer(reach);
+          else if (passed !== null) settle(reach);
         }
-        if (session.refused || update.requested) {
+        const draining = session.refused || update.requested;
+        if (draining) {
           const sessions = await heldSessions(context);
           if (sessions.length > 0) update.answer({ ready: false, sessions });
           else if (
             session.refused ||
-            (!served.serving() && logins.size === 0 && agentRefresh.idle() && copies.idle() && deliveries.idle())
+            (!served.serving() &&
+              logins.size === 0 &&
+              agentRefresh.idle() &&
+              copies.idle() &&
+              deliveries.idle() &&
+              sources.idle())
           ) {
             return;
           }
         }
-        await wake.wait(interval, signal);
-        if (!update.requested && !session.refused) deliveries.trigger();
+        if (session.refused || passOwed === null) await wake.wait(draining ? interval : Infinity, signal);
       }
     } finally {
       watcher.abort();
@@ -1194,6 +1204,7 @@ export async function runResident(options, dependencies = {}) {
       await agentRefresh.settled();
       await copies.settled();
       await deliveries.settled();
+      await sources.settled();
       for (const running of logins.values()) running.controller.abort();
       await Promise.all([...logins.values()].map((running) => running.task));
       await context.agentRefresh;
@@ -1219,7 +1230,7 @@ export async function runResident(options, dependencies = {}) {
       await wake.wait(interval, options.signal);
     }
     update.quiesce();
-    while (!options.signal.aborted) await wake.wait(interval, options.signal);
+    while (!options.signal.aborted) await wake.wait(Infinity, options.signal);
     throw new KitRefusal("kit_command_cancelled");
   } finally {
     await served.close();

package/src/working-copy.js

@@ -23,6 +23,7 @@ import { readNote, writeNote, writeText } from "./state.js";
 import { bootstrapBundle, discoveryOf, door, withSession } from "./sync.js";
 import { isGeneratedProvenance, sidecarPath, structuredOrReplace } from "./sync-library.js";
 import { locate, removeReplicaFile, writeReplicaFile } from "./sync-state.js";
+import { exclusively } from "./tasks.js";
 
 const COMMITTER_NAME = "House Kit";
 const COMMITTER_EMAIL = "house-kit@localhost";
@@ -366,21 +367,6 @@ async function heldCopies(directory) {
   return held.filter((copy) => copy !== null);
 }
 
-const turns = new Map();
-
-function exclusively(path, work) {
-  const turn = (turns.get(path) ?? Promise.resolve()).then(work);
-  const settled = turn.then(
-    () => undefined,
-    () => undefined,
-  );
-  turns.set(path, settled);
-  void settled.then(() => {
-    if (turns.get(path) === settled) turns.delete(path);
-  });
-  return turn;
-}
-
 function received(scope, read, parents) {
   const files = read.files.filter((file) => file.writable);
   return { message: `House ${housePath(scope)} at position ${read.position}`, parents, files, whole: true };
@@ -511,7 +497,7 @@ async function deliver(context, path, authority, signal) {
   let copy = await readCopy(path);
   if (copy?.active && JSON.stringify(copy.received.declared) !== JSON.stringify(declaration(authority))) {
     await writeCopy(context.directory, await receive(context, copy, scopeOf(copy), signal), signal);
-    return;
+    return false;
   }
   while (
     copy?.active &&
@@ -522,24 +508,26 @@ async function deliver(context, path, authority, signal) {
     try {
       view = await enumerated(context, copy, since, signal);
     } catch (error) {
-      if (error.code === "replica_behind") return;
+      if (error.code === "replica_behind") return true;
       if (error.code !== "position_expired") throw error;
       await writeCopy(context.directory, await receive(context, copy, scopeOf(copy), signal), signal);
-      return;
+      return false;
     }
-    if (view.position === since.position) return;
+    if (view.position === since.position) return false;
     copy = await incorporated(copy, view, authority, signal);
     await writeCopy(context.directory, copy, signal);
   }
+  return false;
 }
 
 async function delivering(context, signal) {
   const copies = (await heldCopies(context.directory)).filter((copy) => copy.active);
-  if (copies.length === 0) return { refused: [], lost: false };
+  if (copies.length === 0) return { refused: [], lost: false, behind: false };
   const prefixes = copies.flatMap((copy) => selectedPrefixes(scopeOf(copy)));
   const discovery = discoveryOf(await door(context.session, KIT_DOOR_DISCOVER_PATH, { prefixes }, signal));
   const refused = [];
   let lost = false;
+  let behind = false;
   for (const copy of copies) {
     const at = housePath(scopeOf(copy));
     const authority = discovery.authorities.find((entry) => entry?.room_ref === copy.room_ref);
@@ -553,18 +541,24 @@ async function delivering(context, signal) {
     }
     const path = copyPath(context.directory, copy);
     try {
-      await exclusively(path, () => deliver(context, path, authority, signal));
+      if (await exclusively(path, () => deliver(context, path, authority, signal))) behind = true;
     } catch (error) {
       if (!scopeRefused(error)) throw error;
       refused.push({ path: at, code: error.code });
     }
   }
-  return { refused, lost };
+  return { refused, lost, behind };
+}
+
+function deliveredOutcome(refused, behind) {
+  return behind ? { refused, behind } : { refused };
 }
 
 export async function deliverWorkingCopies(context, signal) {
   const delivered = await delivering(context, signal);
-  return delivered.lost ? applyWorkingCopies(context, signal) : { refused: delivered.refused };
+  return delivered.lost
+    ? applyWorkingCopies(context, signal)
+    : deliveredOutcome(delivered.refused, delivered.behind);
 }
 
 export async function applyWorkingCopies(context, signal) {
@@ -596,7 +590,8 @@ export async function applyWorkingCopies(context, signal) {
       refused.push({ path: housePath(scope), code: error.code });
     }
   }
-  return { refused: [...refused, ...(await delivering(context, signal)).refused] };
+  const delivered = await delivering(context, signal);
+  return deliveredOutcome([...refused, ...delivered.refused], delivered.behind);
 }
 
 export async function workingCopyPaths(directory) {

package/src/google/declared.js

@@ -1,146 +0,0 @@
-import { ITEM_BODY_MAX_BYTES } from "../contract.js";
-import { KitRefusal } from "../refusal.js";
-import { googleJson } from "./gateway.js";
-
-function valueAt(value, path) {
-  let current = value;
-  for (const segment of path.split(".")) {
-    if (current === null || current === undefined || typeof current !== "object") return undefined;
-    current = current[segment];
-  }
-  return current;
-}
-
-function requiredText(value, declaration) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new KitRefusal("google_provider_response_invalid", declaration);
-  }
-  return value;
-}
-
-function optionalText(value, declaration) {
-  if (value === undefined || value === null) return null;
-  return requiredText(value, declaration);
-}
-
-function cursorOf(value) {
-  if (value === null) return { pageToken: null, checkpoint: null };
-  let cursor;
-  try {
-    cursor = JSON.parse(value);
-  } catch {
-    throw new KitRefusal("google_checkpoint_invalid", "declared service");
-  }
-  if (
-    typeof cursor !== "object" ||
-    cursor === null ||
-    (cursor.pageToken !== null && typeof cursor.pageToken !== "string") ||
-    (cursor.checkpoint !== null && typeof cursor.checkpoint !== "string")
-  ) {
-    throw new KitRefusal("google_checkpoint_invalid", "declared service");
-  }
-  return cursor;
-}
-
-function composedBody(item, paths) {
-  const parts = paths.map((path) => valueAt(item, path));
-  if (parts.some((part) => !["string", "number", "boolean"].includes(typeof part))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared body");
-  }
-  const body = parts.map((part) => `${part}`).join("\n\n");
-  if (Buffer.byteLength(body, "utf8") > ITEM_BODY_MAX_BYTES) {
-    throw new KitRefusal("google_provider_response_invalid", "declared body");
-  }
-  return body;
-}
-
-function normalizedItem(service, item) {
-  const fields = service.declaration.fields;
-  const observedAt = requiredText(valueAt(item, fields.observedAt), "declared observed time");
-  if (Number.isNaN(Date.parse(observedAt))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared observed time");
-  }
-  const container = requiredText(valueAt(item, fields.container), "declared container");
-  const nativeVersion =
-    fields.nativeVersion === null
-      ? null
-      : optionalText(valueAt(item, fields.nativeVersion), "declared native version");
-  const providerModifiedAt =
-    fields.providerModifiedAt === null
-      ? null
-      : optionalText(
-          valueAt(item, fields.providerModifiedAt),
-          "declared provider modification time",
-        );
-  if (providerModifiedAt !== null && Number.isNaN(Date.parse(providerModifiedAt))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared provider modification time");
-  }
-  return {
-    namespace: `google/${service.service}`,
-    nativeObjectId: requiredText(valueAt(item, fields.nativeId), "declared native id"),
-    nativeVersion,
-    providerModifiedAt:
-      providerModifiedAt === null ? null : new Date(providerModifiedAt).toISOString(),
-    observedAt: new Date(observedAt).toISOString(),
-    body: composedBody(item, fields.body),
-    author:
-      fields.author === null
-        ? null
-        : optionalText(valueAt(item, fields.author), "declared author"),
-    url:
-      fields.url === null ? null : optionalText(valueAt(item, fields.url), "declared url"),
-    attachments: [],
-    container: `google/${service.service}/${container}`,
-  };
-}
-
-export async function declaredPage(options, dependencies = {}) {
-  const declared = options.service.declaration;
-  const cursor = cursorOf(options.cursor);
-  const url = new URL(declared.path, `https://${declared.host}`);
-  for (const [name, value] of Object.entries(declared.query)) url.searchParams.set(name, value);
-  url.searchParams.set(declared.pageSize, `${options.limit}`);
-  if (cursor.pageToken !== null) {
-    url.searchParams.set(declared.pageToken.request, cursor.pageToken);
-  }
-  if (cursor.checkpoint !== null) {
-    url.searchParams.set(declared.pageToken.checkpointRequest, cursor.checkpoint);
-  }
-  const answer = await googleJson(
-    {
-      directory: options.directory,
-      instance: options.instance,
-      client: options.client,
-      requiredScopes: declared.scopes,
-      url: url.toString(),
-      signal: options.signal,
-    },
-    dependencies,
-  );
-  const entries = valueAt(answer, declared.items);
-  if (!Array.isArray(entries) || entries.length > options.limit) {
-    throw new KitRefusal("google_provider_response_invalid", "declared items");
-  }
-  const pageToken = valueAt(answer, declared.pageToken.response);
-  let next;
-  if (pageToken !== undefined && pageToken !== null) {
-    next = {
-      pageToken: requiredText(pageToken, "declared page token"),
-      checkpoint: cursor.checkpoint,
-    };
-  } else {
-    next = {
-      pageToken: null,
-      checkpoint: requiredText(
-        valueAt(answer, declared.pageToken.checkpointResponse),
-        "declared checkpoint",
-      ),
-    };
-  }
-  return {
-    items: entries.map((entry) => normalizedItem(options.service, entry)),
-    dropped: [],
-    cursor: JSON.stringify(next),
-    more: pageToken !== undefined && pageToken !== null,
-  };
-}

package/src/google/id.js

@@ -1 +0,0 @@
-export const GOOGLE_DRIVE_ID = /^[A-Za-z0-9_-]{1,512}$/;

package/src/instance/google.js

@@ -1 +0,0 @@
-export const GOOGLE_OAUTH_CLIENT = Object.freeze({"id":"911965338518-867gdvuddb7kdkjo3qvpv6gds369alb7.apps.googleusercontent.com","secret":"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"});