@raf-query/core 0.11.0 → 0.12.0

package/dist/controls.mjs

@@ -1,69 +0,0 @@
-import { fulfilled, pending } from "./thenable.mjs";
-import { returnsEffectUnsafe } from "./query.mjs";
-import { Effect, Result } from "effect";
-//#region src/controls.ts
-/**
-* What a framework binding's `useQuery` returns next to the data: the
-* observer's result with Promise commands, and the types every binding
-* shares. The React, Svelte and Vue packages build their reads on this.
-*/
-/**
-* {@link ThrowsOnError} at runtime, for bindings: a read of `query` throws
-* when `throwOnError` (the call's, else the client's) is `true`, or when its
-* `queryFn` returns a promise or plain value, whose error isn't typed. A
-* query whose `queryFn` hasn't run yet follows `throwOnError`.
-*/
-function throwsOnError(query, throwOnError) {
-	return throwOnError || returnsEffectUnsafe(query) === false;
-}
-const commands = /* @__PURE__ */ new WeakMap();
-/** One stable Promise function per command Effect, so identities track the query's. */
-function commandFor(effect) {
-	let command = commands.get(effect);
-	if (!command) {
-		command = () => Effect.runPromise(effect);
-		commands.set(effect, command);
-	}
-	return command;
-}
-/**
-* `result`, with the observer's command Effects as Promise functions. Reads
-* of every other property go through to `result`, so a tracked result
-* (`QueryObserver.trackResult`) stays tracked. For bindings.
-*/
-function promiseControls(result) {
-	return new Proxy(result, { get: (target, name, receiver) => {
-		if (name === "fetchNextPage" || name === "fetchPreviousPage" || name === "refetch") return commandFor(target[name]);
-		return Reflect.get(target, name, receiver);
-	} });
-}
-/**
-* One `Result` thenable per data thenable, so readers see a stable identity
-* across re-renders the same way they do for the data promise.
-*/
-const resultThenables = /* @__PURE__ */ new WeakMap();
-/**
-* A thenable that fulfills with a `Result` when `promise` settles, for reads
-* that don't throw (`throwOnError: false`). Settled already when `promise`
-* is, and the same thenable for the same `promise`. For bindings.
-*/
-function resultThenable(promise) {
-	const cached = resultThenables.get(promise);
-	if (cached) return cached;
-	let next;
-	if (promise.status === "fulfilled") next = fulfilled(Result.succeed(promise.value));
-	else if (promise.status === "rejected") next = fulfilled(Result.fail(promise.reason));
-	else {
-		const deferred = pending();
-		promise.then((value) => {
-			deferred.resolve(Result.succeed(value));
-		}, (error) => {
-			deferred.resolve(Result.fail(error));
-		});
-		next = deferred.promise;
-	}
-	resultThenables.set(promise, next);
-	return next;
-}
-//#endregion
-export { promiseControls, resultThenable, throwsOnError };

package/dist/hydration.d.mts

@@ -1,84 +0,0 @@
-import { QueryKey } from "./key.mjs";
-import { QueryFactory, QueryMeta } from "./options.mjs";
-import { Query, query_d_exports } from "./query.mjs";
-import "./entry.mjs";
-import "./cache.mjs";
-import { Cause, Effect, Scope, Stream } from "effect";
-//#region src/hydration.d.ts
-/** What a dehydrated pending query's promise resolves to. */
-export interface DehydratedResult {
-  readonly data?: unknown;
-  /** When the sender got `data` (ms since epoch). */
-  readonly updatedAt: number;
-}
-/**
- * One cache entry in transit. Settled entries carry `data`; entries still
- * loading their first data carry the request's `promise`, so the receiving
- * cache resumes it instead of fetching again.
- */
-export interface DehydratedQuery {
-  readonly data?: unknown;
-  /** Whether the sender's `queryFn` returned an Effect, when it ran there. */
-  readonly effect?: boolean;
-  readonly key: QueryKey;
-  /** The query's `meta`, for receivers that haven't called its factory. */
-  readonly meta?: QueryMeta;
-  readonly promise?: Promise<DehydratedResult>;
-  /** When `data` was fetched; `0` while pending. */
-  readonly updatedAt: number;
-}
-export interface DehydratedState {
-  readonly queries: ReadonlyArray<DehydratedQuery>;
-}
-/** The cache now, then entries as they start or settle. */
-export interface DehydratedStream {
-  /** The entries to send first. */
-  readonly initial: DehydratedState;
-  /**
-   * Later entries, in batches. Ends once the scope `dehydrateStream` ran in
-   * closes, after a last batch of what changed before. One consumer only.
-   */
-  readonly updates: Stream.Stream<DehydratedState>;
-}
-export interface DehydrateOptions {
-  /**
-   * Which entries to send. Default: entries with data or a request in
-   * flight ({@link canDehydrate}).
-   */
-  readonly filter?: (query: Query) => boolean;
-  /**
-   * Send a pending query's rejection as-is. By default the receiving side
-   * gets a {@link RedactedError}, so server errors don't leak into the page;
-   * its error boundary can still retry on the client.
-   */
-  readonly keepErrors?: boolean;
-  /**
-   * Hashes of entries sent already, shared by every dehydration of one
-   * transfer (e.g. one request). Those entries are skipped, and the ones
-   * sent are added.
-   */
-  readonly sent?: Set<string>;
-  /** Transform data before it is serialized. */
-  readonly serializeData?: (data: unknown) => unknown;
-}
-export interface HydrateOptions {
-  /** Reverse `serializeData`. */
-  readonly deserializeData?: (data: unknown) => unknown;
-}
-declare const RedactedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
-  readonly _tag: "RedactedError";
-} & Readonly<A>;
-/**
- * What a dehydrated pending query rejects with when its request failed and
- * `keepErrors` is off: the receiving side learns which query failed, not why.
- */
-export declare class RedactedError extends RedactedError_base<{
-  readonly hash: string;
-}> {
-  get message(): string;
-}
-/** The default dehydrate filter: entries with data or a request in flight. */
-export declare function canDehydrate<TFactory extends QueryFactory>(query: Query<TFactory>): boolean;
-/** Snapshot one entry for transfer. */
-export declare function dehydrateQuery<TFactory extends QueryFactory>(query: Query<TFactory>, options?: DehydrateOptions): Effect.Effect<DehydratedQuery>;
-//#endregion

package/dist/hydration.mjs

@@ -1,148 +0,0 @@
-import { entryOf, isDisabled, resume, revalidate, setData } from "./entry.mjs";
-import { getUnsafe, metaUnsafe, returnsEffectUnsafe } from "./query.mjs";
-import { Data, Effect, Queue, Stream } from "effect";
-//#region src/hydration.ts
-/**
-* What a dehydrated pending query rejects with when its request failed and
-* `keepErrors` is off: the receiving side learns which query failed, not why.
-*/
-var RedactedError = class extends Data.TaggedError("RedactedError") {
-	get message() {
-		return `Query ${this.hash} failed`;
-	}
-};
-const noop = () => {};
-const identity = (value) => value;
-/** The default dehydrate filter: entries with data or a request in flight. */
-function canDehydrate(query) {
-	const state = getUnsafe(query);
-	return state.hasData || state.isFetching;
-}
-function dehydrateUnsafe(query, options) {
-	const sent = dehydrateState(query, options);
-	const effect = returnsEffectUnsafe(query);
-	return effect === void 0 ? sent : {
-		...sent,
-		effect
-	};
-}
-/** {@link dehydrateUnsafe} without `effect`. */
-function dehydrateState(query, options) {
-	const state = getUnsafe(query);
-	const serialize = options.serializeData ?? identity;
-	const meta = metaUnsafe(query);
-	const sent = meta === void 0 ? { key: query.key } : {
-		key: query.key,
-		meta
-	};
-	if (state.hasData) return {
-		...sent,
-		data: serialize(state.data),
-		updatedAt: state.updatedAt
-	};
-	const promise = state.promise.then((data) => ({
-		data: serialize(data),
-		updatedAt: getUnsafe(query).updatedAt
-	}), (error) => {
-		throw options.keepErrors ? error : new RedactedError({ hash: query.hash });
-	});
-	promise.catch(noop);
-	return {
-		...sent,
-		promise,
-		updatedAt: 0
-	};
-}
-/** Snapshot one entry for transfer. */
-function dehydrateQuery(query, options = {}) {
-	return Effect.sync(() => dehydrateUnsafe(query, options));
-}
-/** Dehydrate the entries `options` selects, recording them in `options.sent`. */
-function dehydrateEntries(queries, options) {
-	const filter = options.filter ?? canDehydrate;
-	const sent = options.sent;
-	const dehydrated = [];
-	for (const query of queries) if (!sent?.has(query.hash) && !isDisabled(entryOf(query)) && filter(query)) {
-		sent?.add(query.hash);
-		dehydrated.push(dehydrateUnsafe(query, options));
-	}
-	return { queries: dehydrated };
-}
-/**
-* Snapshots `queries()` and subscribes in the same synchronous step, so no
-* change falls between the two. Changed entries are collected for a
-* microtask, so entries that settle together share a batch, and the batch is
-* handed to the reader before that microtask ends: ahead of the Suspense
-* boundaries React resumes for those entries.
-*/
-const dehydrateStream = /*#__PURE__*/ Effect.fnUntraced(function* (queries, subscribe, options) {
-	const sent = options.sent ?? /* @__PURE__ */ new Set();
-	const send = {
-		...options,
-		sent
-	};
-	const queue = yield* Queue.unbounded();
-	let batch;
-	const flush = () => {
-		const changed = batch;
-		batch = void 0;
-		if (!changed) return;
-		const state = dehydrateEntries(changed.values(), send);
-		if (state.queries.length > 0) {
-			Queue.offerUnsafe(queue, state);
-			Queue.flushUnsafe(queue);
-		}
-	};
-	yield* Effect.acquireRelease(Effect.sync(() => subscribe((event) => {
-		if (event.type === "removed" || sent.has(event.query.hash)) return;
-		if (!batch) {
-			batch = /* @__PURE__ */ new Map();
-			queueMicrotask(flush);
-		}
-		batch.set(event.query.hash, event.query);
-	})), (unsubscribe) => Effect.sync(() => {
-		flush();
-		unsubscribe();
-		Queue.endUnsafe(queue);
-	}));
-	return {
-		initial: dehydrateEntries(queries(), send),
-		updates: Stream.fromQueue(queue)
-	};
-});
-/**
-* Take the sender's data if it's newer than the entry's. An entry that keeps
-* its own (the sender's is older, as in a router's cached payload) was asked
-* for again, so it revalidates if stale, as `prefetch` would.
-*/
-function takeNewer(entry, data, updatedAt) {
-	const current = entry.state;
-	if (!current.hasData || current.updatedAt < updatedAt) setData(entry, data, updatedAt);
-	else revalidate(entry);
-}
-/**
-* Write dehydrated entries into a cache. Existing entries only take newer
-* data. A pending entry the cache has nothing for resumes the sender's
-* request. One that has data, or a request of its own, waits for the
-* sender's instead of fetching again, and then takes whichever is newer;
-* if the sender's failed, it revalidates.
-*/
-function hydrateEntries(entryFor, state, options) {
-	const deserialize = options.deserializeData ?? identity;
-	for (const query of state.queries) {
-		const entry = entryFor(query.key);
-		if (!entry.options && query.meta !== void 0) entry.hydratedMeta = query.meta;
-		entry.returnsEffect ??= query.effect;
-		if (query.updatedAt > 0) takeNewer(entry, deserialize(query.data), query.updatedAt);
-		else if (query.promise) {
-			const result = Promise.resolve(query.promise).then((sent) => ({
-				data: deserialize(sent.data),
-				updatedAt: sent.updatedAt
-			}));
-			if (!entry.state.hasData && !entry.inFlight) resume(entry, result);
-			else result.then((sent) => takeNewer(entry, sent.data, sent.updatedAt), () => revalidate(entry));
-		} else revalidate(entry);
-	}
-}
-//#endregion
-export { RedactedError, canDehydrate, dehydrateEntries, dehydrateQuery, dehydrateStream, hydrateEntries };

package/dist/infinite.d.mts

@@ -1,5 +0,0 @@
-import "./options.mjs";
-import { Effect } from "effect";
-//#region src/infinite.d.ts
-export type Direction = "backward" | "forward";
-//#endregion

package/dist/infinite.mjs

@@ -1,103 +0,0 @@
-import { replaceEqualDeep } from "./share.mjs";
-import { Effect, Option, Predicate } from "effect";
-//#region src/infinite.ts
-function isInfiniteData(data) {
-	return Predicate.hasProperty(data, "pages") && Predicate.hasProperty(data, "pageParams") && Array.isArray(data.pages) && Array.isArray(data.pageParams);
-}
-function nextPageParam(options, data) {
-	if (data.pages.length === 0) return;
-	return options.getNextPageParam(data.pages.at(-1), data.pages, data.pageParams.at(-1), data.pageParams);
-}
-function previousPageParam(options, data) {
-	if (data.pages.length === 0 || !options.getPreviousPageParam) return;
-	return options.getPreviousPageParam(data.pages[0], data.pages, data.pageParams[0], data.pageParams);
-}
-function addPage(data, page, pageParam, direction, maxPages) {
-	const forward = direction === "forward";
-	const pages = forward ? [...data.pages, page] : [page, ...data.pages];
-	const pageParams = forward ? [...data.pageParams, pageParam] : [pageParam, ...data.pageParams];
-	if (maxPages === void 0 || pages.length <= maxPages) return {
-		pageParams,
-		pages
-	};
-	return forward ? {
-		pageParams: pageParams.slice(-maxPages),
-		pages: pages.slice(-maxPages)
-	} : {
-		pageParams: pageParams.slice(0, maxPages),
-		pages: pages.slice(0, maxPages)
-	};
-}
-function edgeParam(data, direction) {
-	return direction === "forward" ? data.pageParams.at(-1) : data.pageParams[0];
-}
-/** The page `data` holds for `pageParam`, compared deeply. */
-function pageFor(data, pageParam) {
-	const index = data?.pageParams.findIndex((param) => replaceEqualDeep(param, pageParam) === param) ?? -1;
-	return index === -1 ? Option.none() : Option.some(data?.pages[index]);
-}
-/**
-* `data`, a full refetch's pages, with each page that `latest` replaced
-* after the refetch started reading it: that write is newer than the read.
-* A page written before its read started is read again, and the read wins.
-*/
-function keepWrites(data, readFrom, latest) {
-	let changed = false;
-	const pages = data.pages.map((page, index) => {
-		const pageParam = data.pageParams[index];
-		const read = readFrom.find((entry) => replaceEqualDeep(entry.pageParam, pageParam) === entry.pageParam);
-		const now = pageFor(latest, pageParam);
-		if (!read || Option.isNone(now) || Option.isSome(read.seen) && read.seen.value === now.value) return page;
-		changed = true;
-		return now.value;
-	});
-	return changed ? {
-		pageParams: data.pageParams,
-		pages
-	} : data;
-}
-/**
-* A paged query's request. With a `direction`, adds one page at that end of
-* the entry's data, read again with `latest` once the page loads, so data
-* written meanwhile (`setData`, a live subscription) stays. If that data no
-* longer ends at the page param the request started from, the write
-* replaced the list, and the page is dropped. Without a `direction`, loads
-* from the first page param again: as many pages as `current` has, or
-* `pages` if that's more, stopping at the last page. A page written while
-* the refetch was reading it, or after, stays as written ({@link keepWrites}).
-*/
-const fetchPages = /*#__PURE__*/ Effect.fnUntraced(function* (options, current, request, fetchPage, latest) {
-	const direction = request.direction;
-	if (direction && current) {
-		const pageParam = direction === "forward" ? nextPageParam(options, current) : previousPageParam(options, current);
-		if (pageParam == null) return current;
-		const page = yield* fetchPage(pageParam, direction);
-		const now = latest() ?? current;
-		const startedFrom = edgeParam(current, direction);
-		if (replaceEqualDeep(startedFrom, edgeParam(now, direction)) !== startedFrom) return now;
-		return addPage(now, page, pageParam, direction, options.maxPages);
-	}
-	const count = Math.max(request.pages ?? 1, current?.pages.length ?? 0);
-	let data = {
-		pageParams: [],
-		pages: []
-	};
-	const readFrom = [];
-	let pageParam = current && current.pageParams.length > 0 ? current.pageParams[0] : options.initialPageParam;
-	for (let index = 0; index < count; index++) {
-		if (index > 0) {
-			const next = nextPageParam(options, data);
-			if (next == null) break;
-			pageParam = next;
-		}
-		readFrom.push({
-			pageParam,
-			seen: pageFor(latest(), pageParam)
-		});
-		const page = yield* fetchPage(pageParam, "forward");
-		data = addPage(data, page, pageParam, "forward", options.maxPages);
-	}
-	return keepWrites(data, readFrom, latest());
-});
-//#endregion
-export { fetchPages, isInfiniteData, nextPageParam, previousPageParam };

package/dist/key.d.mts

@@ -1,18 +0,0 @@
-//#region src/key.d.ts
-/**
- * A query's cache key. Must be JSON-serializable (plain objects, arrays and
- * primitives): it travels inside handles.
- */
-export type QueryKey = ReadonlyArray<unknown>;
-/**
- * Stable string form of a key. Object keys are sorted, so `{ a, b }` and
- * `{ b, a }` hash the same.
- */
-export declare function hashKey(key: QueryKey): string;
-/**
- * Whether `key` starts with `prefix`. Object segments match when every field
- * in the prefix's segment matches, so `["posts", { sort: "new" }]` matches
- * `["posts", { sort: "new", page: 2 }]`.
- */
-export declare function matchesKey(key: QueryKey, prefix: QueryKey): boolean;
-//#endregion

package/dist/key.mjs

@@ -1,36 +0,0 @@
-import { Predicate } from "effect";
-//#region src/key.ts
-function isPlainRecord(value) {
-	if (!Predicate.isObject(value) || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-function sortKeys(_name, value) {
-	if (!isPlainRecord(value)) return value;
-	const sorted = {};
-	for (const name of Object.keys(value).toSorted()) sorted[name] = value[name];
-	return sorted;
-}
-/**
-* Stable string form of a key. Object keys are sorted, so `{ a, b }` and
-* `{ b, a }` hash the same.
-*/
-function hashKey(key) {
-	return JSON.stringify(key, sortKeys);
-}
-function partialMatch(actual, expected) {
-	if (actual === expected) return true;
-	if (Array.isArray(actual) && Array.isArray(expected)) return actual.length === expected.length && expected.every((part, index) => partialMatch(actual[index], part));
-	if (isPlainRecord(actual) && isPlainRecord(expected)) return Object.keys(expected).every((name) => partialMatch(actual[name], expected[name]));
-	return false;
-}
-/**
-* Whether `key` starts with `prefix`. Object segments match when every field
-* in the prefix's segment matches, so `["posts", { sort: "new" }]` matches
-* `["posts", { sort: "new", page: 2 }]`.
-*/
-function matchesKey(key, prefix) {
-	return prefix.length <= key.length && prefix.every((part, index) => partialMatch(key[index], part));
-}
-//#endregion
-export { hashKey, isPlainRecord, matchesKey };

package/dist/listen.mjs

@@ -1,19 +0,0 @@
-import { Effect, Queue, Stream } from "effect";
-//#region src/listen.ts
-/**
-* A stream of what `subscribe` emits. Subscribes in the consuming fiber as
-* soon as the stream starts, so nothing emitted after that is missed
-* (`Stream.callback` subscribes on a forked fiber, a scheduler tick later),
-* and unsubscribes when the stream ends.
-*/
-function listen(subscribe) {
-	return Stream.unwrap(Effect.gen(function* () {
-		const queue = yield* Queue.unbounded();
-		yield* Effect.acquireRelease(Effect.sync(() => subscribe((value) => {
-			Queue.offerUnsafe(queue, value);
-		})), (unsubscribe) => Effect.sync(unsubscribe));
-		return Stream.fromQueue(queue);
-	}));
-}
-//#endregion
-export { listen };

package/dist/notify.mjs

@@ -1,21 +0,0 @@
-//#region src/notify.ts
-let queued;
-/**
-* Calls `listener` in a microtask, once per batch. State changes made while
-* React renders (a fetch started by a read) must not notify subscribers
-* synchronously, and several changes in one turn should re-render once.
-*/
-function scheduleNotify(listener) {
-	if (queued) {
-		queued.add(listener);
-		return;
-	}
-	const batch = /* @__PURE__ */ new Set([listener]);
-	queued = batch;
-	queueMicrotask(() => {
-		queued = void 0;
-		for (const queuedListener of batch) queuedListener();
-	});
-}
-//#endregion
-export { scheduleNotify };

package/dist/observer.d.mts

@@ -1,110 +0,0 @@
-import { QueryKey } from "./key.mjs";
-import { DataOf, QueryFactory } from "./options.mjs";
-import { Thenable } from "./thenable.mjs";
-import { Query, query_d_exports } from "./query.mjs";
-import { Effect, Pipeable, Stream } from "effect";
-declare namespace observer_d_exports {
-  export { Options, QueryObserver, Result$1 as Result, ResultKey, TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult, trackThenable };
-}
-export declare const TypeId = "~@raf-query/core/QueryObserver";
-export type TypeId = typeof TypeId;
-/** How one reader observes its query. */
-export interface Options {
-  /** Refetch on this interval (ms) while subscribed and the page is visible. */
-  readonly refetchInterval?: number;
-  /** Refetch on reconnect while stale. Default: the query's option, else `true`. */
-  readonly refetchOnReconnect?: boolean;
-  /** Refetch on window focus while stale. Default: the query's option, else `true`. */
-  readonly refetchOnWindowFocus?: boolean;
-  /**
-   * What to show while the query has no data yet:
-   * - `"suspend"` (default): the result's promise is the query's pending one.
-   * - `"previous"`: keep the last observed query's data, with `isPrevious`.
-   */
-  readonly whilePending?: "previous" | "suspend";
-}
-/** What a reader sees of its query. Replaced, never mutated, on every change. */
-interface Result$1<TData = unknown> {
-  /** Error of the last failed request. Existing data stays readable. */
-  readonly error: unknown;
-  /** The query's `fetchNextPage`. */
-  readonly fetchNextPage: Effect.Effect<void>;
-  /** The query's `fetchPreviousPage`. */
-  readonly fetchPreviousPage: Effect.Effect<void>;
-  /** Stable string form of the observed query's key. */
-  readonly hash: string;
-  readonly hasNextPage: boolean;
-  readonly hasPreviousPage: boolean;
-  /** Input of the data in `promise`; differs from the query's while `isPrevious`. */
-  readonly input: unknown;
-  /** A request is in flight: first load, new input, or background refetch. */
-  readonly isFetching: boolean;
-  readonly isFetchingNextPage: boolean;
-  readonly isFetchingPreviousPage: boolean;
-  /** No data yet for the observed query. */
-  readonly isPending: boolean;
-  /** `promise` holds a previous query's data (`whilePending: "previous"`). */
-  readonly isPrevious: boolean;
-  /** The data is older than `staleTime`, or was invalidated. */
-  readonly isStale: boolean;
-  /** Key of the data in `promise`; differs from the query's while `isPrevious`. */
-  readonly key: QueryKey;
-  /** Settles with the data to show; see `Query.State.promise`. */
-  readonly promise: Thenable<TData>;
-  /** The query's `refetch`. */
-  readonly refetch: Effect.Effect<void>;
-  /** When the data in `promise` was fetched (ms since epoch); `0` before that. */
-  readonly updatedAt: number;
-}
-export type ResultKey = keyof Result$1;
-/** An observer of a factory's queries; its results hold the factory's {@link DataOf}. */
-export interface QueryObserver<TFactory extends QueryFactory = QueryFactory> extends Pipeable.Pipeable {
-  /** The options set by the latest `make` or {@link setOptionsUnsafe}. */
-  readonly options: Options;
-  /** The observed query. */
-  readonly query: Query<TFactory>;
-  readonly [TypeId]: {
-    readonly _A: (_: never) => DataOf<TFactory>;
-  };
-}
-export declare function isQueryObserver(value: unknown): value is QueryObserver;
-/** Observe `query`. Doesn't subscribe to it until the observer has a listener. */
-export declare function makeUnsafe<TFactory extends QueryFactory>(query: Query<TFactory>, options?: Options): QueryObserver<TFactory>;
-/** {@link makeUnsafe}, as an Effect. */
-export declare function make<TFactory extends QueryFactory>(query: Query<TFactory>, options?: Options): Effect.Effect<QueryObserver<TFactory>>;
-/** The current result. */
-export declare function getUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>): Result$1<DataOf<TFactory>>;
-/** {@link getUnsafe}, as an Effect. */
-export declare function get<TFactory extends QueryFactory>(self: QueryObserver<TFactory>): Effect.Effect<Result$1<DataOf<TFactory>>>;
-/**
- * The result for `query` with `options` right now, without switching to
- * them. Bindings call this during render, before `setOptionsUnsafe` commits.
- */
-export declare function getOptimisticResultUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, query: Query<TFactory>, options: Options): Result$1<DataOf<TFactory>>;
-/** Observe `query` with `options` from now on. */
-export declare function setOptionsUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, query: Query<TFactory>, options: Options): void;
-/** Listen for result changes. The first listener subscribes to the query. */
-export declare function subscribeUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, listener: () => void): () => void;
-/**
- * The current result, then every change listeners are notified of. Counts
- * as a listener while the stream runs, so the query counts as read.
- */
-export declare function changes<TFactory extends QueryFactory>(self: QueryObserver<TFactory>): Stream.Stream<Result$1<DataOf<TFactory>>>;
-/**
- * Wrap `result` so that reading a property marks it tracked. Once any
- * property is tracked, listeners are only notified when a tracked one
- * changes.
- */
-export declare function trackResult<TFactory extends QueryFactory, TResult extends Result$1<DataOf<TFactory>>>(self: QueryObserver<TFactory>, result: TResult): TResult;
-/**
- * Wrap `promise`, the result's or one derived from it, so that reading its
- * `status`, `value` or `reason` marks its settling as tracked. A first load
- * settles its promise in place, without a new promise, so only readers of
- * those fields need to hear about it. The mark is the wrapper's, shared by
- * the observers that hand it out.
- */
-export declare function trackThenable<TFactory extends QueryFactory, TThenable extends Thenable<unknown>>(self: QueryObserver<TFactory>, promise: TThenable): TThenable;
-/** Mark `name` as read, for bindings that track access themselves. */
-export declare function trackProp<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, name: ResultKey): void;
-//#endregion
-export { Result$1 as Result, observer_d_exports };