@agentshouse/mdruntime 0.1.0-c8ca66ac9e99d → 0.1.0-c8e865ef64c82

package/dist/queue.js

@@ -0,0 +1,450 @@
+import { changeSet, mergeChangeSets } from './change-set.js';
+import { leaving as leavingIn, partnerOf } from './change.js';
+import { composedOf, definitionsAt } from './collection.js';
+import { declared } from './declaration.js';
+import { runtimeError } from './failure.js';
+import { roomDraftRevision } from './identity.js';
+import { landed, movedBy, overlayOf, replaying, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
+import { returnedBy, returnedInto } from './room-draft.js';
+import { documentKey } from './rows.js';
+import { stepped } from './turn.js';
+export function withdrawable(states) {
+    return (batch) => {
+        const state = states.get(batch.id);
+        return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
+    };
+}
+export async function sliceAt(store, record, view, queue, extra = [], moved = []) {
+    const local = await store.open();
+    const needed = new Set([...touchedBy(queue), ...extra]);
+    const movedPaths = [...new Set([...movedBy(queue, record.locator), ...moved])];
+    if (movedPaths.length > 0) {
+        for (const { path } of await local.referrers(record.key, view, movedPaths)) {
+            needed.add(path);
+        }
+    }
+    const paths = [...needed];
+    return stepped(slicing(await local.entries(record.key, view, paths), paths));
+}
+async function landedWhole(store, record, batch, confirmedLayer, current) {
+    if (!landed(batch, confirmedLayer, store.composed(record), current))
+        return false;
+    const partner = partnerOf(batch, record.locator);
+    if (partner === null)
+        return true;
+    const other = await store.replica(partner);
+    const half = other?.queue.find((one) => one.id === batch.id);
+    if (other === undefined || half === undefined)
+        return false;
+    return landed(half, await sliceAt(store, other.record, 'confirmed', [half]), store.composed(other.record));
+}
+async function returnedDrafts(store, locator, work, leaving, composition) {
+    const written = new Map();
+    for (const { batch, returned } of leaving) {
+        if (returned === null || batch.between?.destination.room === locator)
+            continue;
+        for (const saved of work.states.get(batch.id)?.drafts ?? []) {
+            const existing = written.get(saved.path) ?? (await store.draft(locator, saved.path));
+            const parts = returnedInto(existing?.parts, saved.parts, composition === undefined ? undefined : definitionsAt(composition, saved.path));
+            written.set(saved.path, parts === null
+                ? { ...existing, returned }
+                : { locator, path: saved.path, revision: roomDraftRevision(), parts, returned });
+        }
+    }
+    return written;
+}
+function unheldComposition({ store, presence }, locator) {
+    const model = presence.unheldModel(locator);
+    const listed = presence.room(locator);
+    if (model === null || listed === undefined)
+        return undefined;
+    return store.composed({ model, declaration: declared(listed) });
+}
+async function carriedBack(runtime, locator, unlanded, written) {
+    const { store } = runtime;
+    const back = new Map();
+    const taken = [];
+    for (const batch of unlanded) {
+        const between = batch.between;
+        if (between === undefined)
+            continue;
+        const source = between.source.room;
+        const destination = between.destination.room;
+        const local = await store.open();
+        const arrived = (await local.pending(destination, batch.id)).state?.drafts ?? [];
+        for (const { path: to } of arrived) {
+            const record = await store.draft(destination, to);
+            const path = between.moves.find((move) => move.to === to)?.path;
+            if (record === undefined || path === undefined)
+                continue;
+            const [into, key] = source === locator ? [written, path] : [back, documentKey(source, path)];
+            const existing = into.get(key) ?? (await store.draft(source, path));
+            const held = await store.record(source);
+            const composition = held === undefined ? unheldComposition(runtime, source) : store.composed(held);
+            const parts = returnedInto(existing?.parts, record.parts, composition === undefined ? undefined : definitionsAt(composition, path));
+            if (parts === null)
+                continue;
+            taken.push({ locator: destination, path: to });
+            into.set(key, {
+                locator: source,
+                path,
+                revision: roomDraftRevision(),
+                parts,
+                returned: existing?.returned ?? null,
+            });
+        }
+    }
+    const records = [...back.values()];
+    const elsewhere = taken.filter((one) => one.locator !== locator);
+    const rooms = new Set([...records, ...elsewhere].map((one) => one.locator));
+    return {
+        taken: taken.filter((one) => one.locator === locator).map(({ path }) => path),
+        writes: [...rooms].map((room) => ({
+            locator: room,
+            roomDrafts: records.filter((record) => record.locator === room),
+            consumedRoomDrafts: elsewhere.filter((one) => one.locator === room).map(({ path }) => path),
+        })),
+        changes: [...rooms].map((room) => changeSet(room, {
+            drafts: [...records, ...elsewhere]
+                .filter((one) => one.locator === room)
+                .map(({ path }) => path),
+        })),
+    };
+}
+function confirmedAgain(store, locator) {
+    store.installs.change(locator, (held) => ({
+        ...held,
+        confirmations: held.confirmations + 1,
+    }));
+}
+function replayed(store, record, confirmedLayer, queue) {
+    return stepped(replaying(confirmedLayer, queue, record.locator, store.composed(record)));
+}
+async function overlayDiff(record, before, visible, touched) {
+    const kept = before !== undefined && before.record.key === record.key ? before.overlaid : new Set();
+    return {
+        overlay: {
+            set: await stepped(overlayOf(visible, touched)),
+            cleared: [...kept].filter((path) => !touched.has(path)),
+        },
+        touched,
+    };
+}
+function unsent(state, batch, locator) {
+    if (state === undefined)
+        return false;
+    return !leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch);
+}
+async function together(runtime, local, settlements) {
+    const settled = new Set(settlements.map(({ locator }) => locator));
+    const all = [...settlements];
+    for (let wave = settlements; wave.length > 0;) {
+        const partnered = new Map();
+        for (const { locator, left } of wave) {
+            for (const batch of left) {
+                const partner = partnerOf(batch, locator);
+                if (partner === null ||
+                    settled.has(partner) ||
+                    !unsent((await local.pending(partner, batch.id)).state, batch, partner)) {
+                    continue;
+                }
+                partnered.set(partner, [...(partnered.get(partner) ?? []), batch]);
+            }
+        }
+        const partners = [];
+        for (const [partner, batches] of partnered) {
+            settled.add(partner);
+            partners.push(await unpairing(runtime, local, partner, batches));
+        }
+        all.push(...partners);
+        wave = partners;
+    }
+    const answer = await local.commit({
+        rooms: all.flatMap(({ commit }) => commit.rooms),
+        writes: all.flatMap(({ commit }) => commit.writes),
+    });
+    return mergeChangeSets(all.map((one) => one.apply(answer)));
+}
+async function settlement(runtime, local, locator, work, record, queue, settling = {}) {
+    const { store, localSaves } = runtime;
+    const before = work.replica;
+    const view = settling.view ?? 'confirmed';
+    const previousQueue = work.queue;
+    const overrides = settling.changes;
+    const read = await sliceAt(store, record, view, queue, [
+        ...(before !== undefined && before.record.key === record.key ? before.overlaid : []),
+        ...(overrides?.set.map(({ path }) => path) ?? []),
+        ...(overrides?.removed ?? []),
+    ]);
+    const confirmedLayer = overrides === undefined
+        ? read
+        : await stepped(slicingWith(read, overrides.set, overrides.removed));
+    const composition = store.composed(record);
+    const shown = queue.filter((batch) => {
+        const held = store.landed.of(locator, batch.id);
+        return (held !== undefined &&
+            Object.entries(held).some(([path, revision]) => confirmedLayer.revisions[path] !== revision));
+    });
+    const unshown = queue.filter((batch) => !shown.includes(batch));
+    const { withdrawn, kept } = await stepped(standing(confirmedLayer, unshown, withdrawable(work.states), localSaves, locator, composition));
+    const founded = kept.filter((batch) => !unshown.includes(batch));
+    const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
+    const unqueued = shown.map((batch) => ({ batch, landed: true }));
+    for (const batch of withdrawn) {
+        unqueued.push({ batch, landed: await landedWhole(store, record, batch, confirmedLayer) });
+    }
+    const returning = [
+        ...[...unqueued].reverse().map(({ batch, landed: held }) => ({
+            batch,
+            returned: localSaves || held ? null : returnedBy(),
+        })),
+        ...(settling.leaving ?? []),
+    ];
+    const written = await returnedDrafts(store, locator, work, returning, composition);
+    const carried = await carriedBack(runtime, locator, [
+        ...[...unqueued].reverse().flatMap(({ batch, landed: held }) => (held ? [] : [batch])),
+        ...(settling.leaving ?? []).flatMap(({ batch, returned }) => returned === null ? [] : [batch]),
+    ], written);
+    const replayedLayer = await replayed(store, record, confirmedLayer, kept);
+    const { overlay } = await overlayDiff(record, before, replayedLayer.visible, replayedLayer.touched);
+    const commit = {
+        rooms: [
+            {
+                locator,
+                key: record.key,
+                record: storedRecord(record),
+                roots: record.declaration.typedSelection?.roots ?? [],
+                composed: composedOf(composition),
+                ...settling.commit,
+                ...(overrides === undefined
+                    ? {}
+                    : { confirmed: { set: overrides.set, removed: overrides.removed } }),
+                overlay,
+            },
+        ],
+        writes: [
+            {
+                locator,
+                queue: kept,
+                stored: previousQueue,
+                founded,
+                roomDrafts: [...written.values()],
+                consumedRoomDrafts: carried.taken,
+            },
+            ...carried.writes,
+        ],
+    };
+    const staying = new Set(kept.map((batch) => batch.id));
+    return {
+        locator,
+        left: previousQueue.filter((batch) => !staying.has(batch.id)),
+        commit,
+        apply: (answer) => {
+            for (const batch of previousQueue) {
+                if (!staying.has(batch.id))
+                    store.landed.drop(locator, batch.id);
+            }
+            const drafts = [...written.keys(), ...carried.taken];
+            const changed = answer.changed[locator];
+            if (settling.commit?.published !== undefined ||
+                settling.commit?.refreshed === true ||
+                overrides !== undefined) {
+                confirmedAgain(store, locator);
+            }
+            return mergeChangeSets([
+                changeSet(locator, {
+                    documents: changed === undefined ? [] : changed,
+                    room: settling.room,
+                    queue: queueChanged,
+                    drafts,
+                    unindexed: answer.indexed[locator] === false,
+                    due: kept.length > 0 && settling.refused !== true,
+                }),
+                ...carried.changes,
+            ]);
+        },
+    };
+}
+async function unpairing(runtime, local, locator, batches) {
+    const { store, localSaves } = runtime;
+    const ids = new Set(batches.map(({ id }) => id));
+    const leaving = batches.map((batch) => ({
+        batch,
+        returned: !localSaves && leavingIn(batch, locator) ? returnedBy() : null,
+    }));
+    const work = await store.work(locator);
+    const current = work.replica;
+    if (current !== undefined) {
+        return settlement(runtime, local, locator, work, current.record, current.queue.filter((one) => !ids.has(one.id)), { leaving });
+    }
+    const queue = work.queue.filter((one) => !ids.has(one.id));
+    const written = await returnedDrafts(store, locator, work, leaving, unheldComposition(runtime, locator));
+    const carried = await carriedBack(runtime, locator, leaving.flatMap(({ batch, returned }) => (returned === null ? [] : [batch])), written);
+    return {
+        locator,
+        left: batches,
+        commit: {
+            rooms: [],
+            writes: [
+                {
+                    locator,
+                    queue,
+                    stored: work.queue,
+                    roomDrafts: [...written.values()],
+                    consumedRoomDrafts: carried.taken,
+                },
+                ...carried.writes,
+            ],
+        },
+        apply() {
+            return mergeChangeSets([
+                changeSet(locator, {
+                    queue: true,
+                    drafts: [...written.keys(), ...carried.taken],
+                    due: queue.length > 0,
+                }),
+                ...carried.changes,
+            ]);
+        },
+    };
+}
+async function orphaned(local) {
+    const { queued, moving } = await local.moving();
+    const halves = new Map();
+    for (const { locator, batch, state } of moving) {
+        const partner = partnerOf(batch, locator);
+        if (partner === null || queued.get(partner)?.includes(batch.id) === true)
+            continue;
+        if (unsent(state, batch, locator))
+            halves.set(locator, [...(halves.get(locator) ?? []), batch]);
+    }
+    return halves;
+}
+async function sweep(runtime, local) {
+    if (!runtime.socket.continuing())
+        return;
+    const halves = await orphaned(local);
+    if (halves.size === 0)
+        return;
+    const settlements = [];
+    for (const [locator, batches] of halves) {
+        settlements.push(await unpairing(runtime, local, locator, batches));
+    }
+    void runtime.store.changed(await together(runtime, local, settlements));
+}
+async function settled(runtime, local, settlements, steps) {
+    const set = await together(runtime, local, settlements);
+    for (const step of steps)
+        step();
+    void runtime.store.changed(set);
+    await sweep(runtime, local);
+}
+export function settle(runtime, locators, decide) {
+    const { store } = runtime;
+    return store.exclusive(async () => {
+        const local = await store.open();
+        const held = new Map();
+        for (const locator of locators)
+            held.set(locator, await store.work(locator));
+        const decided = await decide(held);
+        if (decided.length === 0)
+            return;
+        const settlements = [];
+        for (const { locator, record, accepted, adopted, installed, refused } of decided) {
+            const work = held.get(locator) ?? (await store.work(locator));
+            settlements.push(await settlement(runtime, local, locator, work, record, work.queue.filter((batch) => batch.id !== accepted), {
+                room: true,
+                view: installed?.refreshed === true ? 'refreshed' : 'confirmed',
+                ...(installed === undefined ? {} : { commit: installed }),
+                ...(adopted === undefined ? {} : { changes: adopted }),
+                ...(refused === undefined ? {} : { refused }),
+            }));
+        }
+        await settled(runtime, local, settlements, decided.flatMap(({ after }) => (after === undefined ? [] : [after])));
+    });
+}
+export function answered(runtime, locator, head, answer) {
+    const { store, socket } = runtime;
+    return store.exclusive(async () => {
+        if (!socket.continuing())
+            return;
+        const local = await store.open();
+        const work = await store.work(locator);
+        const current = work.replica;
+        if (current === undefined || !current.queue.some((batch) => batch.id === head.id))
+            return;
+        const confirmedLayer = await sliceAt(store, current.record, 'confirmed', [head]);
+        const held = answer.kind === 'conflicted' &&
+            (await landedWhole(store, current.record, head, confirmedLayer, answer.affected));
+        if (held &&
+            partnerOf(head, locator) === null &&
+            !landed(head, confirmedLayer, store.composed(current.record))) {
+            store.landed.hold(locator, head.id, Object.fromEntries([...touchedBy([head])].map((path) => [path, confirmedLayer.revisions[path]])));
+            return;
+        }
+        const returned = {
+            kind: answer.kind,
+            code: answer.code,
+            fields: answer.fields,
+            retryable: answer.retryable,
+        };
+        await settled(runtime, local, [
+            await settlement(runtime, local, locator, work, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [{ batch: head, returned: held ? null : returned }] }),
+        ], []);
+    });
+}
+export function unpair(runtime) {
+    return runtime.store.durably((local) => sweep(runtime, local));
+}
+export async function append(runtime, appending) {
+    const { plan, files, held, after } = appending;
+    if (plan.kind === 'refused')
+        return { outcome: 'refused', ...plan.refusal };
+    const { store } = runtime;
+    const local = await store.open();
+    const rooms = [];
+    const writes = [];
+    for (const { locator, queue, saved, consumed, carried } of plan.rooms) {
+        const { replica, confirmed } = held.get(locator);
+        const { record } = replica;
+        const replayedLayer = await replayed(store, record, confirmed, queue);
+        const { overlay } = await overlayDiff(record, replica, replayedLayer.visible, replayedLayer.touched);
+        rooms.push({
+            locator,
+            key: record.key,
+            roots: record.declaration.typedSelection?.roots ?? [],
+            composed: composedOf(store.composed(record)),
+            overlay,
+        });
+        writes.push({
+            locator,
+            queue,
+            stored: replica.queue,
+            saved,
+            consumedRoomDrafts: consumed,
+            roomDrafts: carried,
+        });
+    }
+    let answer;
+    try {
+        answer = await local.commit({ rooms, writes, files, whole: true });
+    }
+    catch {
+        return { outcome: 'refused', code: 'durable-write', retryable: true };
+    }
+    const lost = answer.fenced ?? plan.rooms.find(({ locator }) => runtime.presence.lost(locator))?.locator;
+    if (lost !== undefined)
+        throw runtimeError('unknown-room', `Unknown Room ${lost}`);
+    const [saving] = plan.rooms;
+    await Promise.all([
+        store.changed(mergeChangeSets(plan.rooms.map(({ locator, consumed, carried }) => changeSet(locator, {
+            documents: answer.changed[locator] ?? [],
+            queue: true,
+            drafts: [...consumed, ...carried.map(({ path }) => path)],
+            unindexed: answer.indexed[locator] === false,
+            due: locator === saving?.locator,
+        })))),
+        after?.(),
+    ]);
+    return { outcome: 'saved', identifier: plan.identifier };
+}

package/dist/reach.d.ts

@@ -1,18 +1,27 @@
-import type { ReferrerScope } from './adapter.js';
-import type { MdRuntime, RuntimeTopic } from './connection.js';
+import type { AppRoom } from './listing.js';
+import type { ReadinessPort } from './preparation.js';
+import type { MdRuntime, RuntimeTopic } from './surface.js';
 import type { Plan, PlanReach, QueryResult } from './query.js';
+import type { Readiness } from './readiness.js';
 import type { SearchResult } from './search.js';
 export type ReachedDocument = {
     readonly room: string;
     readonly path: string;
 };
+export type ReachedArea = {
+    readonly room: string;
+    readonly path: string;
+    readonly open: readonly string[];
+};
 export type PortReach = {
     readonly rooms: readonly string[];
     readonly documents: readonly ReachedDocument[];
+    readonly areas?: readonly ReachedArea[];
     readonly conversations: boolean;
 };
 export type Deliver = (message: unknown) => void;
-export type Watch = (topic: RuntimeTopic, input: readonly unknown[], deliver: Deliver) => () => void;
+export type Fail = (error: unknown) => void;
+export type Watch = (topic: RuntimeTopic, input: readonly unknown[], deliver: Deliver, fail: Fail) => () => void;
 export type RuntimeView = {
     md: MdRuntime;
     watch: Watch;
@@ -21,11 +30,16 @@ export type NarrowedView = RuntimeView & {
     narrow(reach: PortReach | null): void;
 };
 export type Reachable = RuntimeView & {
-    plan(input: unknown, reach: PortReach | null): Plan;
+    plan(input: unknown, reach: PortReach | null): Promise<Plan>;
     query(plan: Plan): Promise<QueryResult>;
-    watchPlan(plan: Plan, deliver: (message: unknown) => void): () => void;
+    watchPlan(plan: Plan, deliver: Deliver, fail: Fail): () => void;
     search(input: unknown, reach: PortReach | null): Promise<SearchResult>;
-    referrerScope(referrer: unknown): ReferrerScope | null;
+    watchReadiness(port: ReadinessPort, reach: PortReach | null, deliver: (readiness: Readiness) => void): () => void;
+    locked(room: string): Promise<boolean>;
+    lockedRooms(): Promise<readonly string[]>;
+    watchLocks(notify: () => void): () => void;
+    located(room: string, path: string, destination: string): Promise<ReachedDocument | null>;
+    room(locator: string): Promise<AppRoom | undefined>;
 };
 export declare function holds(reach: PortReach | null, room: string): boolean;
 export declare function governs(reach: PortReach | null, room: {
@@ -38,5 +52,5 @@ export declare function governs(reach: PortReach | null, room: {
     readonly selection: boolean;
 };
 export declare function planReach(reach: PortReach | null): PlanReach | null;
-export declare function narrowed(runtime: Reachable, given: PortReach | null): NarrowedView;
+export declare function narrowed(runtime: Reachable, given: PortReach | null, port: ReadinessPort): NarrowedView;
 //# sourceMappingURL=reach.d.ts.map

package/dist/reach.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reach.d.ts","sourceRoot":"","sources":["../src/reach.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAW,SAAS,EAAe,YAAY,EAAc,MAAM,iBAAiB,CAAC;AAajG,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAU/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAEjD,MAAM,MAAM,KAAK,GAAG,CAClB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,OAAO,EAAE,OAAO,KACb,MAAM,IAAI,CAAC;AAEhB,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAE1D,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG;IAAE,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAAA;CAAE,CAAC;AAEnF,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IACpC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC;IACpD,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACxC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACvE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACvE,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,aAAa,GAAG,IAAI,CAAC;CACxD,CAAC;AAyBF,wBAAgB,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMpE;AAMD,wBAAgB,OAAO,CACrB,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,IAAI,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE;QAAE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;CAAE,GAC/F;IAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAU/D;AA2BD,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CASnE;AA8ED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,YAAY,CA4KlF"}
+{"version":3,"file":"reach.d.ts","sourceRoot":"","sources":["../src/reach.ts"],"names":[],"mappings":"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"}