@firsthandjs/data 0.9.1 → 0.10.1

package/dist/index.dev.js

@@ -4,7 +4,6 @@ import {
   effect,
   isRendering,
   onCleanup,
-  untrack,
   useContext
 } from "@firsthandjs/core";
 
@@ -57,85 +56,91 @@ function readable(value) {
 
 // packages/data/src/store.ts
 function createData(options = {}) {
-  const held = /* @__PURE__ */ new Set();
-  const remember = options.remember ?? 6e4;
-  let recent = [];
-  const now = () => Date.now();
+  const state = {
+    options,
+    held: /* @__PURE__ */ new Set(),
+    recent: [],
+    remember: options.remember ?? 6e4
+  };
   return {
     storage: options.storage,
-    missed: (entry, tags) => {
-      if (remember === 0 || recent.length === 0) {
-        return false;
-      }
-      const since = now() - remember;
-      recent = recent.filter((one) => one.at >= since);
-      return recent.some(
-        // Younger than this resource's last answer, and about what it has just
-        // said it is about. A resource that has answered *since* the
-        // invalidation has already taken it into account.
-        (one) => one.at > entry.answeredAt && anyTagMatches(one.patterns, tags)
-      );
-    },
+    missed: (entry, tags) => missed(state, entry, tags),
     settled: (tags) => {
-      if (recent.length === 0) {
-        return;
-      }
-      recent = recent.filter((one) => !anyTagMatches(one.patterns, tags));
-    },
-    settle: async (passes = 10) => {
-      for (let pass = 0; pass < passes; pass++) {
-        const waiting = [];
-        for (const entry of held) {
-          if (entry.inflight !== null) {
-            waiting.push(entry.inflight);
-          }
-        }
-        if (waiting.length === 0) {
-          return;
-        }
-        await Promise.all(waiting);
-      }
+      settled(state, tags);
     },
+    settle: (passes = 10) => settle(state, passes),
     hold: (entry) => {
-      held.add(entry);
-      return () => held.delete(entry);
-    },
-    invalidate: async (...patterns) => {
-      const waiting = [];
-      for (const cache of options.caches ?? []) {
-        cache.forgetTagged(patterns);
-      }
-      if (remember > 0) {
-        recent.push({ patterns, at: now() });
-      }
-      for (const entry of [...held]) {
-        if (entry.controller !== null) {
-          entry.pending.push(...patterns);
-        }
-        if (!anyTagMatches(patterns, entry.tags)) {
-          continue;
-        }
-        devQuery("invalidated", entry.name ?? "(call site)", entry.tags);
-        waiting.push(entry.run(true));
-      }
-      await Promise.all(waiting);
+      state.held.add(entry);
+      return () => state.held.delete(entry);
     },
+    invalidate: (...patterns) => invalidate(state, patterns),
     clear: () => {
-      recent = [];
-      for (const entry of [...held]) {
-        entry.controller?.abort();
-        held.delete(entry);
-      }
-      try {
-        options.storage?.clear?.();
-      } catch {
-      }
+      clear(state);
     },
     get size() {
-      return held.size;
+      return state.held.size;
     }
   };
 }
+function missed(state, entry, tags) {
+  if (state.remember === 0 || state.recent.length === 0) {
+    return false;
+  }
+  const since = Date.now() - state.remember;
+  state.recent = state.recent.filter((one) => one.at >= since);
+  return state.recent.some((one) => one.at > entry.answeredAt && anyTagMatches(one.patterns, tags));
+}
+function settled(state, tags) {
+  if (state.recent.length === 0) {
+    return;
+  }
+  state.recent = state.recent.filter((one) => !anyTagMatches(one.patterns, tags));
+}
+async function settle(state, passes) {
+  for (let pass = 0; pass < passes; pass++) {
+    const waiting = [];
+    for (const entry of state.held) {
+      if (entry.inflight !== null) {
+        waiting.push(entry.inflight);
+      }
+    }
+    if (waiting.length === 0) {
+      return;
+    }
+    await Promise.all(waiting);
+  }
+}
+async function invalidate(state, patterns) {
+  const waiting = [];
+  for (const cache of state.options.caches ?? []) {
+    cache.forgetTagged(patterns);
+  }
+  if (state.remember > 0) {
+    state.recent.push({ patterns, at: Date.now() });
+  }
+  for (const entry of [...state.held]) {
+    if (entry.controller !== null) {
+      entry.pending.push(...patterns);
+    }
+    if (!anyTagMatches(patterns, entry.tags)) {
+      continue;
+    }
+    devQuery("invalidated", entry.name ?? "(call site)", entry.tags);
+    waiting.push(entry.run(true));
+  }
+  await Promise.all(waiting);
+}
+function clear(state) {
+  state.recent = [];
+  for (const entry of [...state.held]) {
+    entry.controller?.abort();
+    state.held.delete(entry);
+  }
+  try {
+    state.options.storage?.clear?.();
+  } catch {
+  }
+}
 function createHeld(store, name) {
   const entry = {
     data: signal(void 0),
@@ -208,187 +213,143 @@ function useResource(load, options = {}) {
   const entry = createHeld(store, options.persist);
   const release = store.hold(entry);
   devQuery("created", options.persist ?? "(call site)", []);
-  entry.run = (force) => {
-    if (entry.disposed) {
-      return Promise.resolve(void 0);
-    }
+  const loading = { entry, store, persist: options.persist };
+  entry.run = (force) => runOnce(loading, load, force);
+  seedFromStorage(entry, store, options.persist);
+  startLoading(entry);
+  onCleanup(() => {
+    entry.disposed = true;
     entry.controller?.abort();
-    const controller = new AbortController();
-    entry.controller = controller;
-    entry.pending = [];
-    entry.superseded = false;
-    entry.loading.value = true;
-    if (entry.data.peek() === void 0) {
-      entry.status.value = "loading";
-    }
-    let forced = force;
-    let asked = false;
-    const declare = (...next) => {
-      entry.tags = next;
-      if (!forced && store.missed(entry, next)) {
-        forced = true;
-        if (asked) {
-          entry.superseded = true;
-        }
-      }
-      if (entry.pending.length > 0 && anyTagMatches(entry.pending, next)) {
-        entry.superseded = true;
-      }
-    };
-    const request = {
-      signal: controller.signal,
-      get force() {
-        asked = true;
-        return forced;
-      },
-      // Read after `tags()` by a cache that keeps them, which is every client
-      // in this project: they declare first and look in their cache second.
-      get declared() {
-        return entry.tags;
-      },
-      tags: declare
-    };
-    const context = {
-      signal: controller.signal,
-      get force() {
-        asked = true;
-        return forced;
-      },
-      request,
-      tags: declare
-    };
-    const running = load(context).then(async (value) => {
-      if (controller.signal.aborted || entry.disposed) {
-        return void 0;
-      }
-      entry.controller = null;
-      succeed(entry, value);
-      if (!entry.superseded) {
-        store.settled(entry.tags);
-      }
-      if (options.persist !== void 0) {
-        try {
-          store.storage?.write?.(options.persist, value);
-        } catch {
-        }
-      }
-      if (entry.superseded) {
-        entry.superseded = false;
-        return entry.run(true);
-      }
-      return value;
-    }).catch((error) => {
-      if (controller.signal.aborted || entry.disposed) {
-        return void 0;
-      }
-      entry.controller = null;
-      fail(entry, error);
+    devQuery("dropped", options.persist ?? "(call site)", entry.tags);
+    release();
+  });
+  return expose(entry, release);
+}
+function runOnce(loading, load, force) {
+  const { entry, store } = loading;
+  if (entry.disposed) {
+    return Promise.resolve(void 0);
+  }
+  entry.controller?.abort();
+  const controller = new AbortController();
+  entry.controller = controller;
+  entry.pending = [];
+  entry.superseded = false;
+  entry.loading.value = true;
+  if (entry.data.peek() === void 0) {
+    entry.status.value = "loading";
+  }
+  const running = load(contextFor(entry, store, controller, force)).then(async (value) => answered(loading, controller, value)).catch((error) => {
+    if (controller.signal.aborted || entry.disposed) {
       return void 0;
-    });
-    entry.inflight = running;
-    void running.then(() => {
-      if (entry.inflight === running) {
-        entry.inflight = null;
-      }
-    });
-    return running;
-  };
-  const persist = options.persist;
-  const storage = store.storage;
-  if (persist !== void 0 && storage?.read !== void 0) {
-    let stored;
+    }
+    entry.controller = null;
+    fail(entry, error);
+    return void 0;
+  });
+  entry.inflight = running;
+  void running.then(() => {
+    if (entry.inflight === running) {
+      entry.inflight = null;
+    }
+  });
+  return running;
+}
+async function answered(loading, controller, value) {
+  const { entry, store, persist } = loading;
+  if (controller.signal.aborted || entry.disposed) {
+    return void 0;
+  }
+  entry.controller = null;
+  succeed(entry, value);
+  if (!entry.superseded) {
+    store.settled(entry.tags);
+  }
+  if (persist !== void 0) {
     try {
-      stored = storage.read(persist);
+      store.storage?.write?.(persist, value);
     } catch {
-      stored = void 0;
-    }
-    if (isThenable(stored)) {
-      void (async () => {
-        try {
-          seed(entry, await stored);
-        } catch {
-        }
-      })();
-    } else {
-      seed(entry, stored);
     }
   }
-  if (isRendering()) {
-    if (entry.data.peek() === void 0) {
-      void entry.run(false);
-    } else {
-      entry.loading.value = false;
+  if (entry.superseded) {
+    entry.superseded = false;
+    return entry.run(true);
+  }
+  return value;
+}
+function seedFromStorage(entry, store, persist) {
+  const storage = store.storage;
+  if (persist === void 0 || storage?.read === void 0) {
+    return;
+  }
+  let stored;
+  try {
+    stored = storage.read(persist);
+  } catch {
+    stored = void 0;
+  }
+  if (!isThenable(stored)) {
+    seed(entry, stored);
+    return;
+  }
+  void (async () => {
+    try {
+      seed(entry, await stored);
+    } catch {
     }
-  } else {
+  })();
+}
+function startLoading(entry) {
+  if (!isRendering()) {
     effect(() => {
       void entry.run(false);
     });
+    return;
+  }
+  if (entry.data.peek() === void 0) {
+    void entry.run(false);
+  } else {
+    entry.loading.value = false;
   }
-  onCleanup(() => {
-    entry.disposed = true;
-    entry.controller?.abort();
-    devQuery("dropped", options.persist ?? "(call site)", entry.tags);
-    release();
-  });
-  return expose(entry, release);
 }
-function useAction(run) {
-  const store = useData();
-  const entry = createHeld(store, void 0);
-  let controller = null;
-  onCleanup(() => {
-    entry.disposed = true;
-    controller?.abort();
-  });
-  return {
-    data: entry.data,
-    error: entry.error,
-    status: entry.status,
-    running: entry.loading,
-    run: async (input) => {
-      controller?.abort();
-      controller = new AbortController();
-      const current = controller;
-      let invalidating = [];
-      entry.loading.value = true;
-      entry.status.value = "loading";
-      try {
-        const invalidates = (...tags) => {
-          invalidating = tags;
-        };
-        const result = await untrack(
-          () => run(input, {
-            signal: current.signal,
-            invalidates,
-            // An action changes something, so nothing it sends may be
-            // answered out of a cache (`force`) or kept in one (`mutating`).
-            // `tags` is the store's invalidation, so a client that knows what
-            // a mutation changed — a document with `@invalidates` — reports it
-            // without the call site repeating it.
-            request: {
-              signal: current.signal,
-              force: true,
-              mutating: true,
-              tags: invalidates
-            }
-          })
-        );
-        if (current.signal.aborted || entry.disposed) {
-          return void 0;
-        }
-        succeed(entry, result);
-        if (invalidating.length > 0) {
-          await store.invalidate(...invalidating);
-        }
-        return result;
-      } catch (error) {
-        if (current.signal.aborted || entry.disposed) {
-          return void 0;
-        }
-        fail(entry, error);
-        return void 0;
+function contextFor(entry, store, controller, force) {
+  let forced = force;
+  let asked = false;
+  const declare = (...next) => {
+    entry.tags = next;
+    if (!forced && store.missed(entry, next)) {
+      forced = true;
+      if (asked) {
+        entry.superseded = true;
       }
     }
+    if (entry.pending.length > 0 && anyTagMatches(entry.pending, next)) {
+      entry.superseded = true;
+    }
+  };
+  const why = () => {
+    asked = true;
+    return forced;
+  };
+  const request = {
+    signal: controller.signal,
+    get force() {
+      return why();
+    },
+    // Read after `tags()` by a cache that keeps them, which is every client in
+    // this project: they declare first and look in their cache second.
+    get declared() {
+      return entry.tags;
+    },
+    tags: declare
+  };
+  return {
+    signal: controller.signal,
+    get force() {
+      return why();
+    },
+    request,
+    tags: declare
   };
 }
 function fromObservable(source, options = {}) {
@@ -429,6 +390,66 @@ async function void_(promise) {
   return void 0;
 }
 
+// packages/data/src/action.ts
+import { onCleanup as onCleanup2, untrack } from "@firsthandjs/core";
+function useAction(run) {
+  const store = useData();
+  const entry = createHeld(store, void 0);
+  const holder = { controller: null, invalidating: [] };
+  onCleanup2(() => {
+    entry.disposed = true;
+    holder.controller?.abort();
+  });
+  return {
+    data: entry.data,
+    error: entry.error,
+    status: entry.status,
+    running: entry.loading,
+    run: (input) => once(entry, store, holder, () => run(input, contextFor2(holder)))
+  };
+}
+function contextFor2(holder) {
+  const current = holder.controller;
+  const invalidates = (...tags) => {
+    holder.invalidating = tags;
+  };
+  return {
+    signal: current.signal,
+    invalidates,
+    request: {
+      signal: current.signal,
+      force: true,
+      mutating: true,
+      tags: invalidates
+    }
+  };
+}
+async function once(entry, store, holder, body) {
+  holder.controller?.abort();
+  holder.controller = new AbortController();
+  const current = holder.controller;
+  holder.invalidating = [];
+  entry.loading.value = true;
+  entry.status.value = "loading";
+  try {
+    const result = await untrack(body);
+    if (current.signal.aborted || entry.disposed) {
+      return void 0;
+    }
+    succeed(entry, result);
+    if (holder.invalidating.length > 0) {
+      await store.invalidate(...holder.invalidating);
+    }
+    return result;
+  } catch (error) {
+    if (current.signal.aborted || entry.disposed) {
+      return void 0;
+    }
+    fail(entry, error);
+    return void 0;
+  }
+}
+
 // packages/data/src/cache.ts
 function stableKey(value) {
   if (value === void 0) {
@@ -447,142 +468,151 @@ function stableKey(value) {
   return `{${entries.map(([name, held]) => `${name}:${stableKey(held)}`).join(",")}}`;
 }
 function createCacheClient(options = {}) {
-  const ttl = options.ttl ?? 0;
-  const max = options.max ?? 100;
-  const now = options.now ?? (() => Date.now());
-  const entries = /* @__PURE__ */ new Map();
-  const drop = (key) => {
-    const entry = entries.get(key);
-    entry?.controller?.abort();
-    entries.delete(key);
-  };
-  const put = (key, value) => {
-    keep(key, {
-      value,
-      tags: [],
-      expires: ttl === 0 ? Infinity : now() + ttl,
-      inflight: null,
-      controller: null,
-      waiting: 0
-    });
+  const store = {
+    ttl: options.ttl ?? 0,
+    max: options.max ?? 100,
+    now: options.now ?? (() => Date.now()),
+    // Insertion order is the eviction order, and a read moves an entry to the
+    // end: a `Map` already keeps that order, so there is no list to maintain.
+    entries: /* @__PURE__ */ new Map()
   };
-  const keep = (key, entry) => {
-    entries.delete(key);
-    entries.set(key, entry);
-    if (entries.size > max) {
-      for (const oldest of entries.keys()) {
-        drop(oldest);
-        break;
-      }
-    }
+  const write = (key, value) => {
+    put(store, key, value);
   };
   return {
     get size() {
-      return entries.size;
-    },
-    dump: () => {
-      const out = {};
-      for (const [key, entry] of entries) {
-        if (entry.inflight === null) {
-          out[key] = entry.value;
-        }
-      }
-      return out;
+      return store.entries.size;
     },
+    dump: () => dump(store),
     seed: (values) => {
       for (const key in values) {
-        put(key, values[key]);
-      }
-    },
-    settle: async (passes = 10) => {
-      for (let pass = 0; pass < passes; pass++) {
-        const waiting = [];
-        for (const entry of entries.values()) {
-          if (entry.inflight !== null) {
-            waiting.push(entry.inflight);
-          }
-        }
-        if (waiting.length === 0) {
-          return;
-        }
-        await Promise.all(waiting.map(async (one) => one.catch(() => void 0)));
+        write(key, values[key]);
       }
     },
+    settle: (passes = 10) => settle2(store, passes),
     peek: (key) => {
-      const entry = entries.get(key);
-      if (entry === void 0 || entry.expires <= now()) {
-        return void 0;
-      }
-      return entry.value;
+      const entry = store.entries.get(key);
+      return entry === void 0 || entry.expires <= store.now() ? void 0 : entry.value;
     },
-    write: put,
+    write,
     forget: (key) => {
-      if (key === void 0) {
-        for (const held of [...entries.keys()]) {
-          drop(held);
-        }
-        return;
+      for (const held of key === void 0 ? [...store.entries.keys()] : [key]) {
+        drop(store, held);
       }
-      drop(key);
     },
     forgetTagged: (patterns) => {
-      for (const [key, entry] of [...entries]) {
+      for (const [key, entry] of [...store.entries]) {
         if (entry.tags.length > 0 && anyTagMatches(patterns, entry.tags)) {
-          drop(key);
+          drop(store, key);
         }
       }
     },
-    read: (key, produce) => async (request) => {
-      if (request.mutating === true) {
-        return await produce(request);
-      }
-      const held = entries.get(key);
-      if (request.force) {
-        drop(key);
-      } else if (held !== void 0) {
-        if (held.inflight !== null) {
-          return await share(held, request);
-        }
-        if (held.expires > now()) {
-          keep(key, held);
-          return held.value;
-        }
-        entries.delete(key);
+    read: (key, produce) => async (request) => read(store, key, produce, request)
+  };
+}
+function drop(store, key) {
+  const entry = store.entries.get(key);
+  entry?.controller?.abort();
+  store.entries.delete(key);
+}
+function keep(store, key, entry) {
+  store.entries.delete(key);
+  store.entries.set(key, entry);
+  if (store.entries.size > store.max) {
+    for (const oldest of store.entries.keys()) {
+      drop(store, oldest);
+      break;
+    }
+  }
+}
+function put(store, key, value) {
+  keep(store, key, {
+    value,
+    tags: [],
+    expires: store.ttl === 0 ? Infinity : store.now() + store.ttl,
+    inflight: null,
+    controller: null,
+    waiting: 0
+  });
+}
+function dump(store) {
+  const out = {};
+  for (const [key, entry] of store.entries) {
+    if (entry.inflight === null) {
+      out[key] = entry.value;
+    }
+  }
+  return out;
+}
+async function settle2(store, passes) {
+  for (let pass = 0; pass < passes; pass++) {
+    const waiting = [];
+    for (const entry of store.entries.values()) {
+      if (entry.inflight !== null) {
+        waiting.push(entry.inflight);
       }
-      const controller = new AbortController();
-      const entry = {
-        value: void 0,
-        // What the request has been declared to be about by now. A client
-        // declares before it looks here, which is what makes this possible.
-        tags: request.declared ?? [],
-        expires: 0,
-        inflight: null,
-        controller,
-        waiting: 0
-      };
-      const run = produce({ signal: controller.signal, force: request.force }).then((value) => {
-        if (entries.get(key) === entry) {
-          if (ttl === 0) {
-            entries.delete(key);
-          } else {
-            entry.value = value;
-            entry.expires = now() + ttl;
-            entry.inflight = null;
-            entry.controller = null;
-          }
-        }
-        return value;
-      }).catch((error) => {
-        if (entries.get(key) === entry) {
-          entries.delete(key);
-        }
-        throw error;
-      });
-      entry.inflight = run;
-      keep(key, entry);
-      return await share(entry, request);
     }
+    if (waiting.length === 0) {
+      return;
+    }
+    await Promise.all(waiting.map(async (one) => one.catch(() => void 0)));
+  }
+}
+async function read(store, key, produce, request) {
+  if (request.mutating === true) {
+    return await produce(request);
+  }
+  const held = store.entries.get(key);
+  if (request.force) {
+    drop(store, key);
+  } else if (held !== void 0) {
+    if (held.inflight !== null) {
+      return await share(held, request);
+    }
+    if (held.expires > store.now()) {
+      keep(store, key, held);
+      return held.value;
+    }
+    store.entries.delete(key);
+  }
+  return await start(store, key, produce, request);
+}
+async function start(store, key, produce, request) {
+  const controller = new AbortController();
+  const entry = {
+    value: void 0,
+    // What the request has been declared to be about by now. A client declares
+    // before it looks here, which is what makes this possible.
+    tags: request.declared ?? [],
+    expires: 0,
+    inflight: null,
+    controller,
+    waiting: 0
   };
+  const run = produce({ signal: controller.signal, force: request.force }).then((value) => {
+    if (store.entries.get(key) === entry) {
+      settleEntry(store, key, entry, value);
+    }
+    return value;
+  }).catch((error) => {
+    if (store.entries.get(key) === entry) {
+      store.entries.delete(key);
+    }
+    throw error;
+  });
+  entry.inflight = run;
+  keep(store, key, entry);
+  return await share(entry, request);
+}
+function settleEntry(store, key, entry, value) {
+  if (store.ttl === 0) {
+    store.entries.delete(key);
+    return;
+  }
+  entry.value = value;
+  entry.expires = store.now() + store.ttl;
+  entry.inflight = null;
+  entry.controller = null;
 }
 async function share(entry, request) {
   entry.waiting += 1;
@@ -632,30 +662,44 @@ var ESCAPES = {
   "\u2029": "\\u2029"
 };
 
-// packages/data/src/document.ts
-var DIRECTIVE = /^@(tag|invalidates)\b/;
-var OPERATION = /\b(query|mutation|subscription)\b[^\S\n]*([A-Za-z_]\w*)?/;
-var NAME = /^[_A-Za-z][_0-9A-Za-z]*/;
+// packages/data/src/errors.ts
 var FirsthandDirectiveError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "FirsthandDirectiveError";
   }
 };
-function endOfString(source, start) {
-  if (source.startsWith('"""', start)) {
-    const close = source.indexOf('"""', start + 3);
+var FirsthandHttpError = class extends Error {
+  constructor(status, url, body) {
+    super(`HTTP ${String(status)} for ${url}`);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+    this.name = "FirsthandHttpError";
+  }
+  status;
+  url;
+  body;
+};
+
+// packages/data/src/document.ts
+var DIRECTIVE = /^@(tag|invalidates)\b/;
+var OPERATION = /\b(query|mutation|subscription)\b[^\S\n]*([A-Za-z_]\w*)?/;
+var NAME = /^[_A-Za-z][_0-9A-Za-z]*/;
+function endOfString(source, start2) {
+  if (source.startsWith('"""', start2)) {
+    const close = source.indexOf('"""', start2 + 3);
     return close === -1 ? source.length : close + 3;
   }
-  let at = start + 1;
+  let at = start2 + 1;
   while (at < source.length && source[at] !== '"') {
     at += source[at] === "\\" ? 2 : 1;
   }
   return at + 1;
 }
-function endOfArguments(source, start) {
+function endOfArguments(source, start2) {
   let depth = 0;
-  let at = start;
+  let at = start2;
   while (at < source.length) {
     const character = source[at];
     if (character === '"') {
@@ -672,7 +716,7 @@ function endOfArguments(source, start) {
     }
     at++;
   }
-  throw new FirsthandDirectiveError(`unclosed arguments in ${source.slice(start, start + 40)}`);
+  throw new FirsthandDirectiveError(`unclosed arguments in ${source.slice(start2, start2 + 40)}`);
 }
 function unquote(quoted, directive) {
   try {
@@ -704,9 +748,9 @@ function parseArguments(raw, directive) {
     }
     at++;
     skipIgnored();
-    const read = readValue(raw, directive, at);
-    vars[name[0]] = read.value;
-    at = read.next;
+    const read2 = readValue(raw, directive, at);
+    vars[name[0]] = read2.value;
+    at = read2.next;
     skipIgnored();
   }
   return vars;
@@ -747,24 +791,14 @@ function readValue(raw, directive, at) {
   return { value: { literal: Number.isNaN(asNumber) ? text : asNumber }, next };
 }
 function scan(source) {
-  const tags = [];
-  const invalidates = [];
+  const into = { tags: [], invalidates: [] };
   let stripped = "";
   let at = 0;
   let kept = 0;
   while (at < source.length) {
-    const character = source[at];
-    if (character === '"') {
-      at = endOfString(source, at);
-      continue;
-    }
-    if (character === "#") {
-      const newline = source.indexOf("\n", at);
-      at = newline === -1 ? source.length : newline;
-      continue;
-    }
-    if (character !== "@") {
-      at++;
+    const skipped = skipPast(source, at);
+    if (skipped !== null) {
+      at = skipped;
       continue;
     }
     const directive = DIRECTIVE.exec(source.slice(at));
@@ -772,26 +806,7 @@ function scan(source) {
       at++;
       continue;
     }
-    let end = at + directive[0].length;
-    let args = "";
-    let probe = end;
-    while (probe < source.length && /\s/.test(source[probe])) {
-      probe++;
-    }
-    if (source[probe] === "(") {
-      const close = endOfArguments(source, probe);
-      args = source.slice(probe + 1, close - 1);
-      end = close;
-    }
-    const vars = parseArguments(args, directive[1]);
-    const named = vars["name"];
-    if (named === void 0 || !("literal" in named) || typeof named.literal !== "string") {
-      throw new FirsthandDirectiveError(
-        `@${directive[1]} needs a literal name, as in @${directive[1]}(name: "user", id: $id)`
-      );
-    }
-    delete vars["name"];
-    (directive[1] === "tag" ? tags : invalidates).push({ name: named.literal, vars });
+    const end = takeDirective(source, at, directive, into);
     let from = at;
     while (from > kept && /\s/.test(source[from - 1])) {
       from--;
@@ -800,7 +815,42 @@ function scan(source) {
     kept = end;
     at = end;
   }
-  return { tags, invalidates, stripped: stripped + source.slice(kept) };
+  return { ...into, stripped: stripped + source.slice(kept) };
+}
+function skipPast(source, at) {
+  const character = source[at];
+  if (character === '"') {
+    return endOfString(source, at);
+  }
+  if (character === "#") {
+    const newline = source.indexOf("\n", at);
+    return newline === -1 ? source.length : newline;
+  }
+  return character === "@" ? null : at + 1;
+}
+function takeDirective(source, at, directive, into) {
+  const kind = directive[1];
+  let end = at + directive[0].length;
+  let args = "";
+  let probe = end;
+  while (probe < source.length && /\s/.test(source[probe])) {
+    probe++;
+  }
+  if (source[probe] === "(") {
+    const close = endOfArguments(source, probe);
+    args = source.slice(probe + 1, close - 1);
+    end = close;
+  }
+  const vars = parseArguments(args, kind);
+  const named = vars["name"];
+  if (named === void 0 || !("literal" in named) || typeof named.literal !== "string") {
+    throw new FirsthandDirectiveError(
+      `@${kind} needs a literal name, as in @${kind}(name: "user", id: $id)`
+    );
+  }
+  delete vars["name"];
+  (kind === "tag" ? into.tags : into.invalidates).push({ name: named.literal, vars });
+  return end;
 }
 function parseGraphQL(source) {
   const { tags, invalidates, stripped } = scan(source);
@@ -832,18 +882,6 @@ function resolveTags(templates, variables) {
 
 // packages/data/src/http.ts
 import { untrack as untrack2 } from "@firsthandjs/core";
-var FirsthandHttpError = class extends Error {
-  constructor(status, url, body) {
-    super(`HTTP ${String(status)} for ${url}`);
-    this.status = status;
-    this.url = url;
-    this.body = body;
-    this.name = "FirsthandHttpError";
-  }
-  status;
-  url;
-  body;
-};
 function resolve(options, url, init) {
   const target = /^[a-z]+:\/\//i.test(url) ? url : `${options.baseUrl ?? ""}${url}`;
   const { json: payload, cacheKey: _key, ...rest } = init;
@@ -876,17 +914,26 @@ async function send(options, url, init, request) {
   }
   return parsed;
 }
+function cacheKeyFor(options, init, target, merged) {
+  if (init.cacheKey === false) {
+    return void 0;
+  }
+  const method = (merged.method ?? "GET").toUpperCase();
+  const named = typeof init.cacheKey === "string" ? init.cacheKey : method === "GET" || method === "HEAD" ? `${method} ${target}` : void 0;
+  if (named === void 0) {
+    return void 0;
+  }
+  const scope = options.scope === void 0 ? merged.headers.get("authorization") ?? "" : untrack2(options.scope);
+  return `${scope}\0${named}`;
+}
 function createFetchClient(options = {}) {
   const cache = options.cache === void 0 || options.cache === false ? void 0 : "read" in options.cache ? options.cache : createCacheClient(options.cache);
   const client = {
     cache,
     request: (url, init = {}) => async (request) => {
       const [target, merged] = resolve(options, url, init);
-      const method = (merged.method ?? "GET").toUpperCase();
-      const scope = options.scope === void 0 ? merged.headers.get("authorization") ?? "" : untrack2(options.scope);
-      const named = typeof init.cacheKey === "string" ? init.cacheKey : method === "GET" || method === "HEAD" ? `${method} ${target}` : void 0;
-      const key = named === void 0 ? void 0 : `${scope}\0${named}`;
-      if (cache === void 0 || init.cacheKey === false || key === void 0 || // An action. Even a `cacheKey` does not put its answer in here: the
+      const key = cacheKeyFor(options, init, target, merged);
+      if (cache === void 0 || key === void 0 || // An action. Even a `cacheKey` does not put its answer in here: the
       // call site asked for a key, not for its writes to be remembered.
       request.mutating === true) {
         return await send(options, target, merged, request);