@cortexkit/antigravity-auth-core 3.0.7 → 3.0.8

package/dist/common-auth-embedded/claustrum/watch.js

@@ -0,0 +1,254 @@
+/**
+ * While a vault watch is healthy, the roster is still read this often: the
+ * watch carries no history, so a lost notice or a silently dead stream is
+ * caught within this period.
+ */
+export const SAFETY_POLL_MS = 5 * 60_000;
+/**
+ * After a watch fails without being accepted, the host polls and tries one
+ * new watch this much later, so a refusing or draining module is never asked
+ * in a tight loop.
+ */
+export const WATCH_RETRY_MS = 5 * 60_000;
+/**
+ * First wait before re-subscribing a watch that closed after it had been
+ * accepted. It doubles for each further close in a row, up to WATCH_RETRY_MS.
+ */
+export const RESUBSCRIBE_BACKOFF_MS = 1_000;
+/**
+ * Tells whether a notice follows the previous one with nothing lost between
+ * them. `seq` restarts at 1 for every watch and `epoch` names the sending
+ * module's process lifetime. A sequence gap (notices are sheddable), a
+ * different epoch (the module restarted) or a notice of an unknown kind all
+ * mean changes may have been missed, so the caller must re-read everything.
+ */
+export class ChangeNoticeReader {
+    #epoch;
+    #seq = 0;
+    /**
+     * Begin a new watch, whose first notice is seq 1 again. The epoch is kept,
+     * so a module restart between two watches still reads as a break.
+     */
+    restart() {
+        this.#seq = 0;
+    }
+    continuous(notice) {
+        const continuous = notice.kind === 'changed' &&
+            notice.seq === this.#seq + 1 &&
+            (this.#epoch === undefined || notice.epoch === this.#epoch);
+        this.#epoch = notice.epoch;
+        this.#seq = notice.seq;
+        return continuous;
+    }
+}
+/**
+ * Runs `read` with at most one call in flight and at most one more queued
+ * behind it, however many requests arrive meanwhile. A request made while a
+ * read is running may have arrived after that read took its snapshot, so it
+ * earns exactly one more read; any further requests share that one.
+ */
+export class CoalescedRead {
+    #read;
+    #onError;
+    #running;
+    #queued = false;
+    constructor(read, onError) {
+        this.#read = read;
+        this.#onError = onError;
+    }
+    /** The read in flight (including its queued follow-up), if any. */
+    get running() {
+        return this.#running;
+    }
+    request() {
+        if (this.#running) {
+            this.#queued = true;
+            return this.#running;
+        }
+        this.#running = (async () => {
+            do {
+                this.#queued = false;
+                try {
+                    await this.#read();
+                }
+                catch (error) {
+                    this.#onError(error);
+                }
+            } while (this.#queued);
+        })().finally(() => {
+            this.#running = undefined;
+        });
+        return this.#running;
+    }
+}
+/**
+ * Keeps one vault `watchScoped` open for a host and runs the host's discovery
+ * when a notice shows the visible account list changed. Discovery runs only
+ * when the notice's view differs from the last discovered roster's view, when
+ * a notice shows a gap or a new epoch, or on the first notice of a watch that
+ * was re-subscribed after a close (the time between two watches was not
+ * observed). It never opens a second watch while one is open.
+ */
+export class ScopedRosterWatch {
+    #options;
+    #reader = new ChangeNoticeReader();
+    #reads;
+    #mode = 'polling';
+    #watch;
+    #timer;
+    #stopped = false;
+    #latestView;
+    #force = false;
+    /**
+     * How many accepted watches in a row have closed; each one doubles the wait
+     * before the next re-subscribe. Reset once a watch stays up five minutes.
+     */
+    #closes = 0;
+    constructor(options) {
+        this.#options = options;
+        this.#reads = new CoalescedRead(async () => {
+            const force = this.#force;
+            this.#force = false;
+            // A read is only ever requested by a notice, which set #latestView.
+            if (force || this.#latestView !== this.#options.view())
+                await this.#options.discover(this.#latestView ?? '');
+        }, (error) => {
+            if (!this.#stopped)
+                this.#options.onError?.(error);
+        });
+    }
+    get mode() {
+        return this.#mode;
+    }
+    start() {
+        if (this.#stopped || this.#watch || this.#timer)
+            return;
+        if (typeof this.#options.client.watchScoped !== 'function') {
+            // A claustrum-client older than 0.12.0: poll exactly as before.
+            this.#setMode('fallback', 'client-without-watch');
+            return;
+        }
+        void this.#open(false);
+    }
+    stop() {
+        if (this.#stopped)
+            return;
+        this.#stopped = true;
+        if (this.#timer)
+            (this.#options.clearTimeoutImpl ?? clearTimeout)(this.#timer);
+        this.#timer = undefined;
+        const watch = this.#watch;
+        this.#watch = undefined;
+        watch?.handle.stop();
+    }
+    #setMode(mode, reason) {
+        if (this.#mode === mode)
+            return;
+        this.#mode = mode;
+        this.#options.logger?.debug('claustrum vault watch', { mode, reason });
+        this.#options.onMode?.(mode);
+    }
+    #later(delay, run) {
+        this.#timer = (this.#options.setTimeoutImpl ?? setTimeout)(() => {
+            this.#timer = undefined;
+            if (!this.#stopped)
+                run();
+        }, delay);
+        this.#timer.unref?.();
+    }
+    async #open(resubscribed) {
+        let token;
+        try {
+            token = await this.#options.enrollmentToken();
+        }
+        catch (error) {
+            if (this.#stopped)
+                return;
+            this.#options.onError?.(error);
+            this.#fallback('token-unreadable');
+            return;
+        }
+        const watchScoped = this.#options.client.watchScoped;
+        if (this.#stopped || this.#watch || !watchScoped)
+            return;
+        this.#reader.restart();
+        // A re-subscribed watch reads on its first notice: changes made while no
+        // watch was open were never announced.
+        this.#force = resubscribed;
+        let watch;
+        let handle;
+        try {
+            handle = watchScoped.call(this.#options.client, (notice) => {
+                if (this.#stopped || !watch || this.#watch !== watch)
+                    return;
+                watch.notices++;
+                if (watch.notices === 1) {
+                    this.#options.onReachable?.();
+                    watch.acceptedAt = (this.#options.now ?? Date.now)();
+                    this.#setMode('watching', 'accepted');
+                }
+                if (!this.#reader.continuous(notice))
+                    this.#force = true;
+                this.#latestView = notice.view;
+                // The read itself decides whether to list, against the roster as
+                // it stands when the read runs.
+                void this.#reads.request();
+            }, { enrollmentToken: token });
+        }
+        catch (error) {
+            this.#options.onError?.(error);
+            this.#fallback('watch-failed');
+            return;
+        }
+        watch = { handle, notices: 0 };
+        this.#watch = watch;
+        this.#setMode('polling', resubscribed ? 'resubscribing' : 'opening');
+        const opened = watch;
+        handle.closed.then((end) => this.#closed(opened, end), (error) => this.#closed(opened, { kind: 'transport_lost', error }));
+    }
+    #closed(watch, end) {
+        if (this.#stopped || this.#watch !== watch)
+            return;
+        this.#watch = undefined;
+        if (end.kind === 'stopped')
+            return;
+        if (end.kind === 'transport_lost')
+            this.#options.onTransportLost?.();
+        if (end.kind === 'unsupported') {
+            // An older vault answers unknown_method: poll exactly as before.
+            this.#setMode('fallback', 'vault-without-watch');
+            return;
+        }
+        if (end.kind === 'refused') {
+            this.#fallback('refused');
+            try {
+                this.#options.onRefused(end.error);
+            }
+            catch (error) {
+                this.#options.onError?.(error);
+            }
+            return;
+        }
+        if (watch.notices > 0) {
+            // An accepted watch that closed (the vault restarted, or a revocation
+            // ended it) gets one new watch. A revocation then shows up as that
+            // watch's refusal.
+            const now = (this.#options.now ?? Date.now)();
+            if (watch.acceptedAt !== undefined &&
+                now - watch.acceptedAt >= SAFETY_POLL_MS)
+                this.#closes = 0;
+            const delay = Math.min(RESUBSCRIBE_BACKOFF_MS * 2 ** Math.min(this.#closes, 16), WATCH_RETRY_MS);
+            this.#closes++;
+            this.#setMode('polling', 'resubscribing');
+            this.#later(delay, () => void this.#open(true));
+            return;
+        }
+        // Zero notices: the watch was never accepted (the vault is draining, or
+        // the connection failed). The client already made one read to learn why.
+        this.#fallback(end.kind);
+    }
+    #fallback(reason) {
+        this.#setMode('fallback', reason);
+        this.#later(WATCH_RETRY_MS, () => void this.#open(false));
+    }
+}

package/dist/common-auth-embedded/fs/private-files.js

@@ -184,19 +184,25 @@ export async function replaceWindowsFile(from, to, options = {}) {
     to = resolve(to);
     const now = options.now ?? (() => performance.now());
     const start = now();
-    const deadline = Math.min(start + 500, options.deadline ?? Infinity);
+    const leaseDeadline = options.deadline ?? Infinity;
+    let retryDeadline;
     const delays = [0, 10, 20, 40, 80, 100];
     let original;
     let attempts = 0;
     for (const delay of delays) {
+        const deadline = Math.min(retryDeadline ?? Infinity, leaseDeadline);
         if (now() >= deadline)
             break;
         if (delay)
             await (options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(Math.min(delay, Math.max(0, deadline - now())));
         if (now() >= deadline)
             break;
+        const fenceStart = now();
         await options.beforeRename?.();
-        if (now() >= deadline)
+        // Ownership checks fence every attempt but do not spend the sharing-retry budget.
+        if (retryDeadline !== undefined)
+            retryDeadline += now() - fenceStart;
+        if (now() >= leaseDeadline)
             break;
         attempts++;
         try {
@@ -212,6 +218,8 @@ export async function replaceWindowsFile(from, to, options = {}) {
                     !detail.reason;
             if (!candidate)
                 break;
+            // Start the retry window only once a rename has actually failed.
+            retryDeadline ??= now() + 500;
         }
     }
     const error = new PrivateFileError(to, 'rename', original ??

package/dist/common-auth-embedded/quota/format.d.ts

@@ -14,6 +14,9 @@ export declare const NO_LIMITS_REPORTED = "no limits reported";
  * `narrow` fits one line per account in a narrow sidebar: `5h 92% · 7d 66%
  * · Fa 98% left`, the account-wide windows plus at most one model-scoped
  * window or the budget (as `cr`), and no stale marker (see `isQuotaStale`).
+ * A reading whose windows belong to named groups and that has no
+ * account-wide window reads up to two groups instead:
+ * `Ge 7d 62% · Ot 7d 48% left`.
  */
 export type QuotaTextForm = 'compact' | 'full' | 'narrow';
 export interface QuotaTextOptions {

package/dist/common-auth-embedded/quota/format.js

@@ -122,6 +122,9 @@ function scopedWindowParts(quota, options) {
         const remainingPercent = clampPercent(limit.remainingPercent ?? 0);
         return {
             scope: limit.scope,
+            ...(limit.windowMinutes === undefined
+                ? {}
+                : { windowMinutes: limit.windowMinutes }),
             part: {
                 kind: 'window',
                 name: quotaWindowName(limit),
@@ -212,6 +215,66 @@ function scopeAbbreviations(scopes) {
     }
     return new Map(scopes.map((scope) => [scope, short(scopeDisplayName(scope))]));
 }
+/** The most groups a grouped narrow line shows. */
+const NARROW_GROUP_LIMIT = 2;
+/**
+ * The names the groups read under in the narrow line, one per listed group:
+ * each label's short name, derived exactly as a model window's is (`Gemini`
+ * → `Ge`, `Other models` → `Ot`, colliding names extended until they
+ * differ), computed over every listed group so a group keeps its name
+ * whichever groups show. A blank label falls back to the group's scope.
+ */
+function groupShortNames(groups) {
+    const labels = groups.map((group) => group.label.trim() || group.scope);
+    const short = scopeAbbreviations(labels);
+    return labels.map((label) => short.get(label) ?? label);
+}
+/**
+ * The narrow line of a reading whose windows belong to named groups and that
+ * has no account-wide window: for each group, its tightest window as
+ * `Ge 7d 62%`, with ` left` once at the end. The tightest window is the
+ * one with least left, compared before rounding; on a tie the first in
+ * display order (the shorter window) wins. At most two groups show: the two
+ * with least left, earlier-listed first on a tie, and always in the order
+ * the reading lists them, so the line does not reorder as the figures move.
+ * A group with no reported window is skipped. Windows outside the listed
+ * groups and the credit budget are left out. Undefined when the rule does
+ * not apply, so the caller uses the ordinary narrow rule.
+ */
+function groupedNarrowPieces(groups, windows) {
+    if (!groups || groups.length === 0)
+        return undefined;
+    const reported = windows.filter(({ part }) => part.kind === 'window');
+    if (reported.some(({ scope }) => scope === ALL_SCOPE))
+        return undefined;
+    const candidates = groups.flatMap((group, listed) => {
+        const inGroup = reported.filter(({ scope }) => scope === group.scope);
+        // `windows` is already in display order, and strictly lower wins, so on
+        // a tie the shorter window keeps the place.
+        const groupTightest = inGroup.reduce((least, window) => least === undefined ||
+            (window.part.remainingPercent ?? 0) < (least.part.remainingPercent ?? 0)
+            ? window
+            : least, undefined);
+        return groupTightest ? [{ group, listed, window: groupTightest }] : [];
+    });
+    if (candidates.length === 0)
+        return undefined;
+    const names = groupShortNames(groups);
+    const left = (candidate) => candidate.window.part.remainingPercent ?? 0;
+    const shown = [...candidates]
+        .sort((a, b) => left(a) - left(b) || a.listed - b.listed)
+        .slice(0, NARROW_GROUP_LIMIT)
+        .sort((a, b) => a.listed - b.listed);
+    return shown.map((candidate, index) => {
+        const { windowMinutes } = candidate.window;
+        const piece = [
+            names[candidate.listed] ?? candidate.group.scope,
+            ...(windowMinutes === undefined ? [] : [lengthName(windowMinutes)]),
+            `${wholePercent(left(candidate))}%`,
+        ].join(' ');
+        return index === shown.length - 1 ? `${piece} left` : piece;
+    });
+}
 /**
  * The narrow form's pieces: every account-wide window as `5h 92%`, then at
  * most one more item, with ` left` added once to the last piece. That item is
@@ -224,10 +287,15 @@ function scopeAbbreviations(scopes) {
  * be chosen; when nothing at all is shown it keeps its compact wording
  * (`credits available`). No age is added; `isQuotaStale` says whether the
  * reading is stale. A window whose reset arrived after the reading keeps its
- * figure, as in the other forms.
+ * figure, as in the other forms. A reading that lists named groups and has no
+ * account-wide window reads one item per group instead (see
+ * `groupedNarrowPieces`).
  */
 function narrowTextParts(quota, options) {
     const { windows } = scopedWindowParts(quota, options);
+    const grouped = groupedNarrowPieces(quota?.groups, windows);
+    if (grouped)
+        return grouped;
     const general = windows.filter(({ part, scope }) => part.kind === 'window' && scope === ALL_SCOPE);
     const scoped = windows.filter(({ part, scope }) => part.kind === 'window' && scope !== ALL_SCOPE);
     const abbreviations = scopeAbbreviations(scoped.map(({ scope }) => scope));

package/dist/common-auth-embedded/quota/index.d.ts

@@ -6,5 +6,5 @@ export type { CreditBudgetCleared, CreditBudgetEntry, CreditBudgetReading, Quota
 export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaMap, } from './map.js';
 export type { ObservedBudget, ObservedPair, ObservedReading, QuotaObservation, } from './merge.js';
 export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from './merge.js';
-export type { ExhaustionReset, ProjectedBudget, ProjectedLimit, ProjectedQuota, } from './projection.js';
+export type { ExhaustionReset, ProjectedBudget, ProjectedLimit, ProjectedQuota, QuotaGroup, } from './projection.js';
 export { budgetExhaustedResetAt, futureResetAt, projectQuota, readsExhausted, } from './projection.js';

package/dist/common-auth-embedded/quota/projection.d.ts

@@ -19,6 +19,15 @@ export interface ProjectedBudget {
     remainingPercent?: number;
     resetsAt?: string;
 }
+/**
+ * A named group of windows, such as antigravity-auth's `Gemini` and
+ * `Other models`: every window stored under `scope` belongs to it, and
+ * `label` is the group's display name.
+ */
+export interface QuotaGroup {
+    scope: string;
+    label: string;
+}
 export interface ProjectedQuota {
     scope: string;
     /** One entry per label: longest known window first, unknown lengths last. */
@@ -31,6 +40,13 @@ export interface ProjectedQuota {
     /** Present only when the stored budget is a reading, not cleared. */
     budget?: ProjectedBudget;
     counters?: Record<string, QuotaCounter>;
+    /**
+     * The named groups the windows belong to, in the order the plugin lists
+     * them. Set only by a plugin whose windows all belong to such groups; the
+     * narrow form then shows one item per group (see `formatQuota`).
+     * `projectQuota` never sets it.
+     */
+    groups?: readonly QuotaGroup[];
 }
 /**
  * Resolves `map` for a request in `scope` (`all` or a model family). A family

package/dist/common-auth-embedded/source-output.json

@@ -1,7 +1,7 @@
 {
   "schema": 1,
   "package": "@cortexkit/common-auth",
-  "version": "0.19.0",
+  "version": "0.21.1",
   "artifactStatus": "published",
   "publicRoots": {
     "./store": {
@@ -37,15 +37,15 @@
       "import": "./dist/pi-slot/index.js"
     }
   },
-  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.19.0.tgz",
-  "tarballSha256": "dd32b53e849a7d98ed861a5f9d3d81645b31169350257ef1732f7827b8684885",
-  "sri": "sha512-p7oy26dBllFF6mkQinsyyqqFP8FKoyVvHyt/aQWEGTljn0AbVRj++Co5Mict4ffQUPrujlQwThilUoPn/AsB8Q==",
-  "canonicalFiles": 133,
-  "canonicalBytes": 766798,
+  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.21.1.tgz",
+  "tarballSha256": "4ff9c514bfa7d539483ce9c25e054267c4dc368a0ce8c7f60c74ddac36613a65",
+  "sri": "sha512-DORasuyhF7FOTiw0kiL1DlIw9aPvMmBsdoxzkXJEIrKvNzUuv2lcOvHkflpot9KcoqPLCRJxyZLtMO+LVN61gw==",
+  "canonicalFiles": 137,
+  "canonicalBytes": 829952,
   "generator": {
     "path": "packages/opencode/scripts/embed-common-auth.ts",
     "version": 3,
-    "sha256": "c701471b1c52e731528039f0ed121c9cfa4328f533fe9023c0a49eecca17ba2b"
+    "sha256": "18d41d6b7a3db681b7873981c03d88bb19691116f96e0a37a11fabc1f63e5977"
   },
   "files": [
     {
@@ -208,36 +208,52 @@
       "outputSha256": "134d4950e10d5cd67fd28dba7af51f67e801e719d40b2824bf48e8dde55a1b7b",
       "transform": "verbatim"
     },
+    {
+      "source": "package/dist/claustrum/availability.d.ts",
+      "output": "claustrum/availability.d.ts",
+      "bytes": 3375,
+      "sourceSha256": "eba8ff78abed434be6194715d214a53322f4414a28e6a7389fe14f8a52b772ac",
+      "outputSha256": "eba8ff78abed434be6194715d214a53322f4414a28e6a7389fe14f8a52b772ac",
+      "transform": "verbatim"
+    },
+    {
+      "source": "package/dist/claustrum/availability.js",
+      "output": "claustrum/availability.js",
+      "bytes": 4107,
+      "sourceSha256": "4bfb03de131ed7d036631a6d6455cc6f465ab7a9ea61575a7378d2f447c7cf67",
+      "outputSha256": "4bfb03de131ed7d036631a6d6455cc6f465ab7a9ea61575a7378d2f447c7cf67",
+      "transform": "verbatim"
+    },
     {
       "source": "package/dist/claustrum/consumer.d.ts",
       "output": "claustrum/consumer.d.ts",
-      "bytes": 7516,
-      "sourceSha256": "5bd8eae33d4d0098376fe5b6d6d0171eb6041ba1d0ae9ef5da40e569a36897bd",
-      "outputSha256": "5bd8eae33d4d0098376fe5b6d6d0171eb6041ba1d0ae9ef5da40e569a36897bd",
+      "bytes": 9037,
+      "sourceSha256": "5d508c6b0e62ada6e60f09f52052fd6ee26fe6dacd626ef4e5e1430bd8535fdb",
+      "outputSha256": "5d508c6b0e62ada6e60f09f52052fd6ee26fe6dacd626ef4e5e1430bd8535fdb",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/consumer.js",
       "output": "claustrum/consumer.js",
-      "bytes": 18272,
-      "sourceSha256": "82726ae5b1f14f5bb3a19d1e9a9d312dd8f8339f837f1efbecd65e8195f3c01c",
-      "outputSha256": "82726ae5b1f14f5bb3a19d1e9a9d312dd8f8339f837f1efbecd65e8195f3c01c",
+      "bytes": 23139,
+      "sourceSha256": "7b97c80964eaffa9f4c4fc3334885ce4c2da80ed330288311d08b0c8c7edca31",
+      "outputSha256": "7b97c80964eaffa9f4c4fc3334885ce4c2da80ed330288311d08b0c8c7edca31",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/custody.d.ts",
       "output": "claustrum/custody.d.ts",
-      "bytes": 10126,
-      "sourceSha256": "053619f193ea68739125624cf1bcb078c78cb38e506c7009894d92c672f88b88",
-      "outputSha256": "053619f193ea68739125624cf1bcb078c78cb38e506c7009894d92c672f88b88",
+      "bytes": 14842,
+      "sourceSha256": "f776af511c7a02f8e5c4cb0361845d1e740eec96244fee5cfa1289d2212dffd9",
+      "outputSha256": "f776af511c7a02f8e5c4cb0361845d1e740eec96244fee5cfa1289d2212dffd9",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/custody.js",
       "output": "claustrum/custody.js",
-      "bytes": 15835,
-      "sourceSha256": "ba5c42a9ad00f66b4e33ae8e810d1b0e8a57c433179dec7c939706c682e49a8f",
-      "outputSha256": "ba5c42a9ad00f66b4e33ae8e810d1b0e8a57c433179dec7c939706c682e49a8f",
+      "bytes": 27016,
+      "sourceSha256": "5d2ead857d6e6384980dace94d308f1f47afe831c82e2b644ab434ffb0bcf151",
+      "outputSha256": "5d2ead857d6e6384980dace94d308f1f47afe831c82e2b644ab434ffb0bcf151",
       "transform": "verbatim"
     },
     {
@@ -259,9 +275,9 @@
     {
       "source": "package/dist/claustrum/errors.d.ts",
       "output": "claustrum/errors.d.ts",
-      "bytes": 1095,
-      "sourceSha256": "ba3dbd69b13c521944bd700b063afaaced9a1312bbfbfcebb8ae8b4f3785c52a",
-      "outputSha256": "ba3dbd69b13c521944bd700b063afaaced9a1312bbfbfcebb8ae8b4f3785c52a",
+      "bytes": 1145,
+      "sourceSha256": "b7533d4c281807224d6d05f4bb7a596006862a6c05dc4462fae02af388054bce",
+      "outputSha256": "b7533d4c281807224d6d05f4bb7a596006862a6c05dc4462fae02af388054bce",
       "transform": "verbatim"
     },
     {
@@ -291,33 +307,33 @@
     {
       "source": "package/dist/claustrum/index.d.ts",
       "output": "claustrum/index.d.ts",
-      "bytes": 2939,
-      "sourceSha256": "cd2f374dec9e06a7962d2c262c08c965213610107ff1f4f972c2c76c35fe8254",
-      "outputSha256": "cd2f374dec9e06a7962d2c262c08c965213610107ff1f4f972c2c76c35fe8254",
+      "bytes": 3613,
+      "sourceSha256": "b8f9cb374e5d5545d50a1521d85e4337d28b17d4b0dabdb3548186675b1c2965",
+      "outputSha256": "b8f9cb374e5d5545d50a1521d85e4337d28b17d4b0dabdb3548186675b1c2965",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/index.js",
       "output": "claustrum/index.js",
-      "bytes": 2141,
-      "sourceSha256": "33dc58809d432ea7bbe3f3d4425fe575589a018854444b63e0874f917981ab19",
-      "outputSha256": "33dc58809d432ea7bbe3f3d4425fe575589a018854444b63e0874f917981ab19",
+      "bytes": 2456,
+      "sourceSha256": "1e2ae0ee6f2754189e846298a1c6ce2dd4a5eb8cb7f9293f6c24f9725b8537be",
+      "outputSha256": "1e2ae0ee6f2754189e846298a1c6ce2dd4a5eb8cb7f9293f6c24f9725b8537be",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/insula.d.ts",
       "output": "claustrum/insula.d.ts",
-      "bytes": 2489,
-      "sourceSha256": "21a92525f04810a15a877e1c1ff9d7cf2fc2eb4ffe8a6aa408db22da6337d30f",
-      "outputSha256": "21a92525f04810a15a877e1c1ff9d7cf2fc2eb4ffe8a6aa408db22da6337d30f",
+      "bytes": 4643,
+      "sourceSha256": "be11868f8d766b8c3dc105b3891743bbec1388005be8d2688d617c95b0194e2a",
+      "outputSha256": "be11868f8d766b8c3dc105b3891743bbec1388005be8d2688d617c95b0194e2a",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/insula.js",
       "output": "claustrum/insula.js",
-      "bytes": 6097,
-      "sourceSha256": "1db6a99b9db96635bbf846e58ab54eaaa1892bf8939801a181741022d47ce428",
-      "outputSha256": "1db6a99b9db96635bbf846e58ab54eaaa1892bf8939801a181741022d47ce428",
+      "bytes": 16715,
+      "sourceSha256": "98ac4011e091b142618b83e3258eda3ccfb40ec75ee0c5a2cbeff89aa1f88003",
+      "outputSha256": "98ac4011e091b142618b83e3258eda3ccfb40ec75ee0c5a2cbeff89aa1f88003",
       "transform": "verbatim"
     },
     {
@@ -352,6 +368,22 @@
       "outputSha256": "e6ac8f59dab51db4756ccbaa89fc73acd213a7a4795fdf5a7c7e4f653455fe94",
       "transform": "verbatim"
     },
+    {
+      "source": "package/dist/claustrum/watch.d.ts",
+      "output": "claustrum/watch.d.ts",
+      "bytes": 5760,
+      "sourceSha256": "54f088f0e6c863d75295721700a423e682bfd4a6735e02a03556b2faa379d991",
+      "outputSha256": "54f088f0e6c863d75295721700a423e682bfd4a6735e02a03556b2faa379d991",
+      "transform": "verbatim"
+    },
+    {
+      "source": "package/dist/claustrum/watch.js",
+      "output": "claustrum/watch.js",
+      "bytes": 9226,
+      "sourceSha256": "6fdd6ed31d349da6cd016ebbd5f283ce595e9fab376a44cc6587cc9a13d8f589",
+      "outputSha256": "6fdd6ed31d349da6cd016ebbd5f283ce595e9fab376a44cc6587cc9a13d8f589",
+      "transform": "verbatim"
+    },
     {
       "source": "package/dist/commands/builtins.d.ts",
       "output": "commands/builtins.d.ts",
@@ -507,9 +539,9 @@
     {
       "source": "package/dist/fs/private-files.js",
       "output": "fs/private-files.js",
-      "bytes": 12025,
-      "sourceSha256": "4b46f7b37c11da02f655a6ca841fa51189ceefffaa4476f4fa7a27f953c54ad4",
-      "outputSha256": "4b46f7b37c11da02f655a6ca841fa51189ceefffaa4476f4fa7a27f953c54ad4",
+      "bytes": 12448,
+      "sourceSha256": "1c8f34202b535d774d8c1a53bd403255f02701760c7378e020756c02c55a97c4",
+      "outputSha256": "1c8f34202b535d774d8c1a53bd403255f02701760c7378e020756c02c55a97c4",
       "transform": "verbatim"
     },
     {
@@ -667,25 +699,25 @@
     {
       "source": "package/dist/quota/format.d.ts",
       "output": "quota/format.d.ts",
-      "bytes": 4260,
-      "sourceSha256": "f76541a2f0e1e04782ee8b61a3d0f6b3ba3c156bc0e57bfcbd427e00baf279b4",
-      "outputSha256": "f76541a2f0e1e04782ee8b61a3d0f6b3ba3c156bc0e57bfcbd427e00baf279b4",
+      "bytes": 4415,
+      "sourceSha256": "293073e9f75e7f15790669f4be8340061566e889259593fcfaf17be9fa4f0a01",
+      "outputSha256": "293073e9f75e7f15790669f4be8340061566e889259593fcfaf17be9fa4f0a01",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/quota/format.js",
       "output": "quota/format.js",
-      "bytes": 12897,
-      "sourceSha256": "69e546dbc935300ff3b01294479844177be3e288626e5edf0341e820a20c5580",
-      "outputSha256": "69e546dbc935300ff3b01294479844177be3e288626e5edf0341e820a20c5580",
+      "bytes": 16323,
+      "sourceSha256": "d4856ea40dc4269f9a6ffa78bee8564ba648170530e8ff71af4cf38ba5f3baaa",
+      "outputSha256": "d4856ea40dc4269f9a6ffa78bee8564ba648170530e8ff71af4cf38ba5f3baaa",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/quota/index.d.ts",
       "output": "quota/index.d.ts",
-      "bytes": 1047,
-      "sourceSha256": "1ed8a3feaf208860182d738c2ba732fbaa61b6613c1e0e14442418a76d743663",
-      "outputSha256": "1ed8a3feaf208860182d738c2ba732fbaa61b6613c1e0e14442418a76d743663",
+      "bytes": 1059,
+      "sourceSha256": "fbb7a865108f98da1f3bb44fba20614a2998ccf5c906b271419b49d37a814214",
+      "outputSha256": "fbb7a865108f98da1f3bb44fba20614a2998ccf5c906b271419b49d37a814214",
       "transform": "verbatim"
     },
     {
@@ -731,9 +763,9 @@
     {
       "source": "package/dist/quota/projection.d.ts",
       "output": "quota/projection.d.ts",
-      "bytes": 2975,
-      "sourceSha256": "65a1b13db0a4d21f8b4136af65888494c6d8a7e117e80879c96f75fc0b763ad9",
-      "outputSha256": "65a1b13db0a4d21f8b4136af65888494c6d8a7e117e80879c96f75fc0b763ad9",
+      "bytes": 3549,
+      "sourceSha256": "2bbf4942bc034f3521c6c35e30446d73de525a099f7ba49c004d160e4dd917ea",
+      "outputSha256": "2bbf4942bc034f3521c6c35e30446d73de525a099f7ba49c004d160e4dd917ea",
       "transform": "verbatim"
     },
     {