@mszr/idb-dux 1.0.0

package/dist/esm/vue/overlay/db.js

@@ -0,0 +1,101 @@
+import { InstantError } from '@instantdb/core';
+/**
+ * The enhanced db — the only public client surface. A thin overlay over the
+ * vendored baseline ([dux-spec-vue.md §1]): hooks compose baseline hooks and
+ * reshape through the pure `shapeResult`, never forking the baseline. SSR
+ * resilience comes from the baseline guards; shaping and the result pattern
+ * are added here.
+ */
+import { computed, toValue } from 'vue';
+import { resultKeys, shapeResult, shapingSchema, toWireQuery } from '../../query/index.js';
+import { typedTx } from '../../tx/index.js';
+import { makeDynamicResult, makeResult } from './result.js';
+import { rooms as overlayRooms } from './rooms/index.js';
+export class IdbClient {
+    /** The schema-typed tx chain — shared machinery with `/admin` ([root §5]). */
+    tx = typedTx();
+    /** Rooms hooks — stateful ones return the result pattern ([§6]). */
+    rooms = overlayRooms;
+    #baseline;
+    #schema;
+    constructor(baseline, schema) {
+        this.#baseline = baseline;
+        this.#schema = shapingSchema(schema);
+    }
+    // ----- pass-throughs to the baseline -----
+    get auth() {
+        return this.#baseline.auth;
+    }
+    get storage() {
+        return this.#baseline.storage;
+    }
+    get streams() {
+        return this.#baseline.streams;
+    }
+    transact = (chunks) => this.#baseline.transact(chunks);
+    getAuth = () => this.#baseline.getAuth();
+    getLocalId = (name) => this.#baseline.getLocalId(name);
+    room = ((type, id) => this.#baseline.room(type, id));
+    // ----- the data plane -----
+    /**
+     * Subscribe to a query. Destructure top-level scopes directly — full
+     * shaping ($only/$at/$as/$m, array normalization, singularization) per the
+     * root spec, plus the result pattern. A factory returning `null` pauses.
+     */
+    useQuery = (query, opts) => {
+        const duxQuery = computed(() => toValue(query));
+        const base = this.#baseline.useQuery((() => {
+            const q = duxQuery.value;
+            return q ? toWireQuery(q) : null;
+        }), opts);
+        const shaped = computed(() => {
+            const q = duxQuery.value;
+            return q ? shapeResult(base.data.value, q, this.#schema) : {};
+        });
+        return makeDynamicResult({ isLoading: base.isLoading, error: base.error, pageInfo: base.pageInfo }, key => computed(() => shaped.value[key]));
+    };
+    /** Imperative one-shot with identical shaping — plain shaped data, no refs. */
+    queryOnce = async (query, opts) => {
+        const { data } = await this.#baseline.queryOnce(toWireQuery(query), opts);
+        return shapeResult(data, query, this.#schema);
+    };
+    /** The data plane, paginated — same shaping, plus `loadNextPage`. */
+    useInfiniteQuery = (query, opts) => {
+        const duxQuery = computed(() => toValue(query));
+        const base = this.#baseline.useInfiniteQuery((() => {
+            const q = duxQuery.value;
+            return q ? toWireQuery(q) : null;
+        }), opts);
+        const shaped = computed(() => {
+            const q = duxQuery.value;
+            return q ? shapeResult(base.data.value, q, this.#schema) : {};
+        });
+        return makeDynamicResult({ isLoading: base.isLoading, error: base.error, canLoadNextPage: base.canLoadNextPage }, key => computed(() => shaped.value[key]), { loadNextPage: base.loadNextPage });
+    };
+    // ----- auth, connection, identity -----
+    useAuth = () => {
+        const { isLoading, user, error } = this.#baseline.useAuth();
+        // dux types `user` as IdbAuthUser | undefined — fold the official null.
+        const userRef = computed(() => user.value ?? undefined);
+        return makeResult({ isLoading, user: userRef, error });
+    };
+    useUser(opts) {
+        const { user } = this.useAuth();
+        return computed(() => {
+            if (!user.value && opts?.requireUser) {
+                throw new InstantError('useUser({ requireUser: true }) must be used behind an auth gate');
+            }
+            return user.value;
+        });
+    }
+    useConnectionStatus = () => {
+        const status = this.#baseline.useConnectionStatus();
+        return makeResult({ status });
+    };
+    useLocalId = (name) => {
+        const localId = this.#baseline.useLocalId(name);
+        return makeResult({ localId });
+    };
+}
+void resultKeys; // exported utility; kept available for tooling
+//# sourceMappingURL=db.js.map

package/dist/esm/vue/overlay/db.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","sourceRoot":"","sources":["../../../../src/vue/overlay/db.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ComputedRef, MaybeRefOrGetter } from 'vue'\nimport type { IdbQueryData, IdbQueryOptions, IdbValidQuery } from '../../query/index.js'\nimport type { IdbSchema } from '../../schema/defineSchema.js'\nimport type { IdbRegisteredSchema } from '../../schema/register.js'\nimport type { IdbTx, IdbTxChunkInput } from '../../tx/index.js'\nimport type { InstantDuxDatabase } from '../baseline/index.js'\nimport type {\n  IdbAuthResult,\n  IdbAuthUser,\n  IdbConnectionResult,\n  IdbInfiniteQueryResult,\n  IdbLocalIdResult,\n  IdbQueryResult,\n  IdbUserOptions,\n} from './types.js'\nimport { InstantError } from '@instantdb/core'\n/**\n * The enhanced db — the only public client surface. A thin overlay over the\n * vendored baseline ([dux-spec-vue.md §1]): hooks compose baseline hooks and\n * reshape through the pure `shapeResult`, never forking the baseline. SSR\n * resilience comes from the baseline guards; shaping and the result pattern\n * are added here.\n */\nimport { computed, toValue } from 'vue'\nimport { resultKeys, shapeResult, shapingSchema, toWireQuery } from '../../query/index.js'\nimport { typedTx } from '../../tx/index.js'\nimport { makeDynamicResult, makeResult } from './result.js'\nimport { rooms as overlayRooms } from './rooms/index.js'\n\n/** A query input: a query, a ref/getter of one, or a factory returning null to pause. */\ntype QueryInput<Q> = MaybeRefOrGetter<Q | null>\n\nexport class IdbClient<S extends IdbSchema = IdbRegisteredSchema> {\n  /** The schema-typed tx chain — shared machinery with `/admin` ([root §5]). */\n  public readonly tx: IdbTx<S> = typedTx<S>()\n  /** Rooms hooks — stateful ones return the result pattern ([§6]). */\n  public readonly rooms = overlayRooms\n\n  readonly #baseline: InstantDuxDatabase<S>\n  readonly #schema: IdbSchema\n\n  constructor(baseline: InstantDuxDatabase<S>, schema: IdbSchema | undefined) {\n    this.#baseline = baseline\n    this.#schema = shapingSchema(schema)\n  }\n\n  // ----- pass-throughs to the baseline -----\n\n  get auth() {\n    return this.#baseline.auth\n  }\n\n  get storage() {\n    return this.#baseline.storage\n  }\n\n  get streams() {\n    return this.#baseline.streams\n  }\n\n  transact = (chunks: IdbTxChunkInput<S> | IdbTxChunkInput<S>[]) =>\n    this.#baseline.transact(chunks as any)\n\n  getAuth = (): Promise<IdbAuthUser | null> => this.#baseline.getAuth()\n  getLocalId = (name: string): Promise<string> => this.#baseline.getLocalId(name)\n\n  room = ((type?: any, id?: any) => this.#baseline.room(type, id)) as\n    InstantDuxDatabase<S>['room']\n\n  // ----- the data plane -----\n\n  /**\n   * Subscribe to a query. Destructure top-level scopes directly — full\n   * shaping ($only/$at/$as/$m, array normalization, singularization) per the\n   * root spec, plus the result pattern. A factory returning `null` pauses.\n   */\n  useQuery = <const Q extends IdbValidQuery<Q, S>>(\n    query: QueryInput<Q>,\n    opts?: MaybeRefOrGetter<IdbQueryOptions<S> | null | undefined>,\n  ): IdbQueryResult<Q, S> => {\n    const duxQuery = computed(() => toValue(query) as Record<string, any> | null)\n    const base = this.#baseline.useQuery(\n      (() => {\n        const q = duxQuery.value\n        return q ? toWireQuery(q) : null\n      }) as any,\n      opts as any,\n    )\n    const shaped = computed(() => {\n      const q = duxQuery.value\n      return q ? shapeResult(base.data.value, q, this.#schema) : {}\n    })\n    return makeDynamicResult(\n      { isLoading: base.isLoading, error: base.error, pageInfo: base.pageInfo },\n      key => computed(() => shaped.value[key]),\n    )\n  }\n\n  /** Imperative one-shot with identical shaping — plain shaped data, no refs. */\n  queryOnce = async <const Q extends IdbValidQuery<Q, S>>(\n    query: Q,\n    opts?: IdbQueryOptions<S>,\n  ): Promise<IdbQueryData<Q, S>> => {\n    const { data } = await this.#baseline.queryOnce(\n      toWireQuery(query as Record<string, any>) as any,\n      opts as any,\n    )\n    return shapeResult(data, query as Record<string, any>, this.#schema) as IdbQueryData<Q, S>\n  }\n\n  /** The data plane, paginated — same shaping, plus `loadNextPage`. */\n  useInfiniteQuery = <const Q extends IdbValidQuery<Q, S>>(\n    query: QueryInput<Q>,\n    opts?: MaybeRefOrGetter<IdbQueryOptions<S> | undefined>,\n  ): IdbInfiniteQueryResult<Q, S> => {\n    const duxQuery = computed(() => toValue(query) as Record<string, any> | null)\n    const base = this.#baseline.useInfiniteQuery(\n      (() => {\n        const q = duxQuery.value\n        return q ? toWireQuery(q) : null\n      }) as any,\n      opts as any,\n    )\n    const shaped = computed(() => {\n      const q = duxQuery.value\n      return q ? shapeResult(base.data.value, q, this.#schema) : {}\n    })\n    return makeDynamicResult(\n      { isLoading: base.isLoading, error: base.error, canLoadNextPage: base.canLoadNextPage },\n      key => computed(() => shaped.value[key]),\n      { loadNextPage: base.loadNextPage },\n    )\n  }\n\n  // ----- auth, connection, identity -----\n\n  useAuth = (): IdbAuthResult => {\n    const { isLoading, user, error } = this.#baseline.useAuth()\n    // dux types `user` as IdbAuthUser | undefined — fold the official null.\n    const userRef = computed(() => user.value ?? undefined)\n    return makeResult({ isLoading, user: userRef, error })\n  }\n\n  /**\n   * The user-centric projection. `requireUser: true` types `user` present and\n   * throws at access when there's none; the default leaves it optional.\n   */\n  useUser(opts: { requireUser: true }): ComputedRef<IdbAuthUser>\n  useUser(opts?: IdbUserOptions): ComputedRef<IdbAuthUser | undefined>\n  useUser(opts?: IdbUserOptions): ComputedRef<IdbAuthUser | undefined> {\n    const { user } = this.useAuth()\n    return computed(() => {\n      if (!user.value && opts?.requireUser) {\n        throw new InstantError(\n          'useUser({ requireUser: true }) must be used behind an auth gate',\n        )\n      }\n      return user.value\n    })\n  }\n\n  useConnectionStatus = (): IdbConnectionResult => {\n    const status = this.#baseline.useConnectionStatus()\n    return makeResult({ status })\n  }\n\n  useLocalId = (name: MaybeRefOrGetter<string>): IdbLocalIdResult => {\n    const localId = this.#baseline.useLocalId(name)\n    return makeResult({ localId })\n  }\n}\n\nvoid resultKeys // exported utility; kept available for tooling\n"]}

package/dist/esm/vue/overlay/defineDb.d.ts

@@ -0,0 +1,34 @@
+import type { IdbSchema } from '../../schema/defineSchema.js';
+import type { IdbRegisteredSchema } from '../../schema/register.js';
+import type { IdbClientConfig } from './types.js';
+import { IdbClient } from './db.js';
+/**
+ * Build the db eagerly — for apps whose config is available at module load.
+ *
+ * The client is `markRaw`'d: it is a stable handle, not reactive state (its
+ * reactivity lives in the refs its hooks return), so it must never be wrapped
+ * in a reactive proxy. Storing it in a Pinia store or `reactive()` is the
+ * normal case, and a proxy would break the pass-through getters (`auth`,
+ * `storage`, `streams`) — reading a private field through a proxy throws. This
+ * makes the client proxy-safe with zero userland ceremony.
+ */
+export declare function init<S extends IdbSchema = IdbRegisteredSchema>(config: IdbClientConfig<S>): IdbClient<S>;
+/** `defineDb` options: the schema, a lazy `getAppId`, and the rest of config. */
+export type IdbDefineDbOptions<S extends IdbSchema> = Omit<IdbClientConfig<S>, 'appId'> & {
+    /** Resolved on first use (framework runtime config, env indirection, …). */
+    getAppId: () => string;
+};
+/**
+ * Returns a factory: the first call resolves config and creates the db;
+ * subsequent calls return the same instance. No framework-wide singleton —
+ * global state stays the app's responsibility.
+ *
+ * @example
+ *   export const useDb = defineDb({
+ *     schema,
+ *     getAppId: () => useRuntimeConfig().public.instantAppId,
+ *     firstPartyPath: '/api/idb',
+ *   })
+ */
+export declare function defineDb<S extends IdbSchema = IdbRegisteredSchema>(options: IdbDefineDbOptions<S>): () => IdbClient<S>;
+//# sourceMappingURL=defineDb.d.ts.map

package/dist/esm/vue/overlay/defineDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineDb.d.ts","sourceRoot":"","sources":["../../../../src/vue/overlay/defineDb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAQjD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,EAC5D,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GACzB,SAAS,CAAC,CAAC,CAAC,CAGd;AAED,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,SAAS,IAAI,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG;IACxF,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,EAChE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC7B,MAAM,SAAS,CAAC,CAAC,CAAC,CAQpB"}

package/dist/esm/vue/overlay/defineDb.js

@@ -0,0 +1,44 @@
+/**
+ * Setup — `init` (eager) and `defineDb` (memoized lazy factory). `defineDb`
+ * gives first-class support to the app-id-resolves-at-runtime pattern instead
+ * of a hand-rolled lazy-init-and-memoize dance ([dux-spec-vue.md §2]).
+ */
+import { markRaw } from 'vue';
+import { init as baselineInit } from '../baseline/index.js';
+import { IdbClient } from './db.js';
+/**
+ * Build the db eagerly — for apps whose config is available at module load.
+ *
+ * The client is `markRaw`'d: it is a stable handle, not reactive state (its
+ * reactivity lives in the refs its hooks return), so it must never be wrapped
+ * in a reactive proxy. Storing it in a Pinia store or `reactive()` is the
+ * normal case, and a proxy would break the pass-through getters (`auth`,
+ * `storage`, `streams`) — reading a private field through a proxy throws. This
+ * makes the client proxy-safe with zero userland ceremony.
+ */
+export function init(config) {
+    const baseline = baselineInit(config);
+    return markRaw(new IdbClient(baseline, config.schema));
+}
+/**
+ * Returns a factory: the first call resolves config and creates the db;
+ * subsequent calls return the same instance. No framework-wide singleton —
+ * global state stays the app's responsibility.
+ *
+ * @example
+ *   export const useDb = defineDb({
+ *     schema,
+ *     getAppId: () => useRuntimeConfig().public.instantAppId,
+ *     firstPartyPath: '/api/idb',
+ *   })
+ */
+export function defineDb(options) {
+    let instance;
+    const { getAppId, ...config } = options;
+    return () => {
+        if (!instance)
+            instance = init({ ...config, appId: getAppId() });
+        return instance;
+    };
+}
+//# sourceMappingURL=defineDb.js.map

package/dist/esm/vue/overlay/defineDb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineDb.js","sourceRoot":"","sources":["../../../../src/vue/overlay/defineDb.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAC7B,OAAO,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC;;;;;;;;;GASG;AACH,MAAM,UAAU,IAAI,CAClB,MAA0B;IAE1B,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAa,CAAC,CAAA;IAC5C,OAAO,OAAO,CAAC,IAAI,SAAS,CAAI,QAAe,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;AAClE,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACtB,OAA8B;IAE9B,IAAI,QAAkC,CAAA;IACtC,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAA;IACvC,OAAO,GAAG,EAAE;QACV,IAAI,CAAC,QAAQ;YACX,QAAQ,GAAG,IAAI,CAAI,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAwB,CAAC,CAAA;QAC5E,OAAO,QAAQ,CAAA;IACjB,CAAC,CAAA;AACH,CAAC","sourcesContent":["import type { IdbSchema } from '../../schema/defineSchema.js'\nimport type { IdbRegisteredSchema } from '../../schema/register.js'\nimport type { IdbClientConfig } from './types.js'\n/**\n * Setup — `init` (eager) and `defineDb` (memoized lazy factory). `defineDb`\n * gives first-class support to the app-id-resolves-at-runtime pattern instead\n * of a hand-rolled lazy-init-and-memoize dance ([dux-spec-vue.md §2]).\n */\nimport { markRaw } from 'vue'\nimport { init as baselineInit } from '../baseline/index.js'\nimport { IdbClient } from './db.js'\n\n/**\n * Build the db eagerly — for apps whose config is available at module load.\n *\n * The client is `markRaw`'d: it is a stable handle, not reactive state (its\n * reactivity lives in the refs its hooks return), so it must never be wrapped\n * in a reactive proxy. Storing it in a Pinia store or `reactive()` is the\n * normal case, and a proxy would break the pass-through getters (`auth`,\n * `storage`, `streams`) — reading a private field through a proxy throws. This\n * makes the client proxy-safe with zero userland ceremony.\n */\nexport function init<S extends IdbSchema = IdbRegisteredSchema>(\n  config: IdbClientConfig<S>,\n): IdbClient<S> {\n  const baseline = baselineInit(config as any)\n  return markRaw(new IdbClient<S>(baseline as any, config.schema))\n}\n\n/** `defineDb` options: the schema, a lazy `getAppId`, and the rest of config. */\nexport type IdbDefineDbOptions<S extends IdbSchema> = Omit<IdbClientConfig<S>, 'appId'> & {\n  /** Resolved on first use (framework runtime config, env indirection, …). */\n  getAppId: () => string\n}\n\n/**\n * Returns a factory: the first call resolves config and creates the db;\n * subsequent calls return the same instance. No framework-wide singleton —\n * global state stays the app's responsibility.\n *\n * @example\n *   export const useDb = defineDb({\n *     schema,\n *     getAppId: () => useRuntimeConfig().public.instantAppId,\n *     firstPartyPath: '/api/idb',\n *   })\n */\nexport function defineDb<S extends IdbSchema = IdbRegisteredSchema>(\n  options: IdbDefineDbOptions<S>,\n): () => IdbClient<S> {\n  let instance: IdbClient<S> | undefined\n  const { getAppId, ...config } = options\n  return () => {\n    if (!instance)\n      instance = init<S>({ ...config, appId: getAppId() } as IdbClientConfig<S>)\n    return instance\n  }\n}\n"]}

package/dist/esm/vue/overlay/result.d.ts

@@ -0,0 +1,29 @@
+import type { Ref } from 'vue';
+/** The flat ref bag a hook produces (`{ isLoading, error, todos, … }`). */
+export type RefsBag = Record<string, Ref<any>>;
+type Unref<R> = R extends Ref<infer V> ? V : never;
+/** `.state` — getter projection over the refs, `.value`-free and read-only. */
+export type StateOf<Refs> = {
+    readonly [K in keyof Refs]: Unref<Refs[K]>;
+};
+/** The full result: top-level refs (spread in), plus `.refs` and `.state`. */
+export type IdbResult<Refs> = Refs & {
+    refs: Refs;
+    state: StateOf<Refs>;
+};
+/**
+ * Wrap a hook's flat ref bag into the result pattern. The refs are spread to
+ * the top level, exposed again under `.refs`, and projected read-only under a
+ * raw `.state`.
+ */
+export declare function makeResult<Refs extends RefsBag>(refs: Refs): IdbResult<Refs>;
+/**
+ * The result pattern for hooks whose key set is *dynamic* (query scopes
+ * depend on the query, which can change at runtime). `staticRefs` are always
+ * present (`isLoading`, `error`, …); any other accessed key is resolved
+ * through `scopeRef`, which the builder memoizes. Destructuring, `.refs`
+ * passthrough, and the raw `.state` projection all work over arbitrary keys.
+ */
+export declare function makeDynamicResult<Static extends RefsBag>(staticRefs: Static, scopeRef: (key: string) => Ref<any>, extras?: Record<string, unknown>): any;
+export {};
+//# sourceMappingURL=result.d.ts.map

package/dist/esm/vue/overlay/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../../src/vue/overlay/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAiB9B,2EAA2E;AAC3E,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;AAE9C,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAQlD,+EAA+E;AAC/E,MAAM,MAAM,OAAO,CAAC,IAAI,IAAI;IAC1B,QAAQ,EAAE,CAAC,IAAI,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAA;AAED,8EAA8E;AAC9E,MAAM,MAAM,SAAS,CAAC,IAAI,IAAI,IAAI,GAAG;IACnC,IAAI,EAAE,IAAI,CAAA;IACV,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACrB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,SAAS,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAc5E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,SAAS,OAAO,EACtD,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,EACnC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACnC,GAAG,CA8CL"}

package/dist/esm/vue/overlay/result.js

@@ -0,0 +1,71 @@
+/**
+ * The refs+state primitive — one shape, every stateful hook ([conventions §3],
+ * [dux-spec-vue.md §3]). A result serves three reading styles over one
+ * reactive source:
+ *
+ * - **top-level refs** for destructuring and watch sources,
+ * - **`.refs`** for composable passthrough,
+ * - **`.state`** for `.value`-free script reads.
+ *
+ * `state` is a `markRaw` plain object with getters over the underlying refs:
+ * Pinia won't try to hydrate it, writing a property fails at the property
+ * level, and Vue effects still track because each getter reads a reactive
+ * source.
+ */
+import { markRaw } from 'vue';
+/**
+ * Wrap a hook's flat ref bag into the result pattern. The refs are spread to
+ * the top level, exposed again under `.refs`, and projected read-only under a
+ * raw `.state`.
+ */
+export function makeResult(refs) {
+    const state = markRaw(Object.defineProperties({}, Object.fromEntries(Object.keys(refs).map(key => [
+        key,
+        { get: () => refs[key].value, enumerable: true },
+    ]))));
+    return { ...refs, refs, state };
+}
+/**
+ * The result pattern for hooks whose key set is *dynamic* (query scopes
+ * depend on the query, which can change at runtime). `staticRefs` are always
+ * present (`isLoading`, `error`, …); any other accessed key is resolved
+ * through `scopeRef`, which the builder memoizes. Destructuring, `.refs`
+ * passthrough, and the raw `.state` projection all work over arbitrary keys.
+ */
+export function makeDynamicResult(staticRefs, scopeRef, extras = {}) {
+    const cache = new Map();
+    const refFor = (key) => {
+        if (key in staticRefs)
+            return staticRefs[key];
+        if (typeof key !== 'string')
+            return undefined;
+        let ref = cache.get(key);
+        if (!ref) {
+            ref = scopeRef(key);
+            cache.set(key, ref);
+        }
+        return ref;
+    };
+    const refs = new Proxy({}, {
+        get: (_t, key) => refFor(key),
+        has: () => true,
+    });
+    const state = markRaw(new Proxy({}, {
+        get: (_t, key) => refFor(key)?.value,
+        has: () => true,
+        set: () => false, // writing a state property fails at the property level
+    }));
+    return new Proxy({}, {
+        get: (_t, key) => {
+            if (key === 'refs')
+                return refs;
+            if (key === 'state')
+                return state;
+            if (key in extras)
+                return extras[key]; // passthrough methods (e.g. loadNextPage)
+            return refFor(key);
+        },
+        has: () => true,
+    });
+}
+//# sourceMappingURL=result.js.map

package/dist/esm/vue/overlay/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../../../src/vue/overlay/result.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAwB7B;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAuB,IAAU;IACzD,MAAM,KAAK,GAAG,OAAO,CACnB,MAAM,CAAC,gBAAgB,CACrB,EAAE,EACF,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,GAAG;QACH,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAE,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE;KAClD,CAAC,CACH,CACF,CACe,CAAA;IAElB,OAAO,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;AACjC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAAkB,EAClB,QAAmC,EACnC,SAAkC,EAAE;IAEpC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAA;IACzC,MAAM,MAAM,GAAG,CAAC,GAAW,EAAwB,EAAE;QACnD,IAAI,GAAG,IAAI,UAAU;YACnB,OAAO,UAAU,CAAC,GAAG,CAAC,CAAA;QACxB,IAAI,OAAO,GAAG,KAAK,QAAQ;YACzB,OAAO,SAAS,CAAA;QAClB,IAAI,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACxB,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAA;YACnB,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;QACrB,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC,CAAA;IAED,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,EAAa,EAAE;QACpC,GAAG,EAAE,CAAC,EAAE,EAAE,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC;QACrC,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;KAChB,CAAC,CAAA;IAEF,MAAM,KAAK,GAAG,OAAO,CACnB,IAAI,KAAK,CACP,EAAE,EACF;QACE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK;QAC5C,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;QACf,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,uDAAuD;KAC1E,CACF,CACF,CAAA;IAED,OAAO,IAAI,KAAK,CACd,EAAE,EACF;QACE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAW,EAAE,EAAE;YACvB,IAAI,GAAG,KAAK,MAAM;gBAChB,OAAO,IAAI,CAAA;YACb,IAAI,GAAG,KAAK,OAAO;gBACjB,OAAO,KAAK,CAAA;YACd,IAAI,GAAG,IAAI,MAAM;gBACf,OAAO,MAAM,CAAC,GAAG,CAAC,CAAA,CAAC,0CAA0C;YAC/D,OAAO,MAAM,CAAC,GAAG,CAAC,CAAA;QACpB,CAAC;QACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;KAChB,CACF,CAAA;AACH,CAAC","sourcesContent":["import type { Ref } from 'vue'\n/**\n * The refs+state primitive — one shape, every stateful hook ([conventions §3],\n * [dux-spec-vue.md §3]). A result serves three reading styles over one\n * reactive source:\n *\n * - **top-level refs** for destructuring and watch sources,\n * - **`.refs`** for composable passthrough,\n * - **`.state`** for `.value`-free script reads.\n *\n * `state` is a `markRaw` plain object with getters over the underlying refs:\n * Pinia won't try to hydrate it, writing a property fails at the property\n * level, and Vue effects still track because each getter reads a reactive\n * source.\n */\nimport { markRaw } from 'vue'\n\n/** The flat ref bag a hook produces (`{ isLoading, error, todos, … }`). */\nexport type RefsBag = Record<string, Ref<any>>\n\ntype Unref<R> = R extends Ref<infer V> ? V : never\n\n// The type-level helpers don't constrain to `RefsBag`: a named ref-bag\n// interface (e.g. `AuthRefs`) has no string index signature and so wouldn't\n// satisfy `Record<string, Ref>`, even though every member is a `Ref`. They\n// map over `keyof Refs` directly instead; `makeResult` keeps the runtime\n// constraint where call sites pass object literals.\n\n/** `.state` — getter projection over the refs, `.value`-free and read-only. */\nexport type StateOf<Refs> = {\n  readonly [K in keyof Refs]: Unref<Refs[K]>\n}\n\n/** The full result: top-level refs (spread in), plus `.refs` and `.state`. */\nexport type IdbResult<Refs> = Refs & {\n  refs: Refs\n  state: StateOf<Refs>\n}\n\n/**\n * Wrap a hook's flat ref bag into the result pattern. The refs are spread to\n * the top level, exposed again under `.refs`, and projected read-only under a\n * raw `.state`.\n */\nexport function makeResult<Refs extends RefsBag>(refs: Refs): IdbResult<Refs> {\n  const state = markRaw(\n    Object.defineProperties(\n      {},\n      Object.fromEntries(\n        Object.keys(refs).map(key => [\n          key,\n          { get: () => refs[key]!.value, enumerable: true },\n        ]),\n      ),\n    ),\n  ) as StateOf<Refs>\n\n  return { ...refs, refs, state }\n}\n\n/**\n * The result pattern for hooks whose key set is *dynamic* (query scopes\n * depend on the query, which can change at runtime). `staticRefs` are always\n * present (`isLoading`, `error`, …); any other accessed key is resolved\n * through `scopeRef`, which the builder memoizes. Destructuring, `.refs`\n * passthrough, and the raw `.state` projection all work over arbitrary keys.\n */\nexport function makeDynamicResult<Static extends RefsBag>(\n  staticRefs: Static,\n  scopeRef: (key: string) => Ref<any>,\n  extras: Record<string, unknown> = {},\n): any {\n  const cache = new Map<string, Ref<any>>()\n  const refFor = (key: string): Ref<any> | undefined => {\n    if (key in staticRefs)\n      return staticRefs[key]\n    if (typeof key !== 'string')\n      return undefined\n    let ref = cache.get(key)\n    if (!ref) {\n      ref = scopeRef(key)\n      cache.set(key, ref)\n    }\n    return ref\n  }\n\n  const refs = new Proxy({} as RefsBag, {\n    get: (_t, key: string) => refFor(key),\n    has: () => true,\n  })\n\n  const state = markRaw(\n    new Proxy(\n      {},\n      {\n        get: (_t, key: string) => refFor(key)?.value,\n        has: () => true,\n        set: () => false, // writing a state property fails at the property level\n      },\n    ),\n  )\n\n  return new Proxy(\n    {},\n    {\n      get: (_t, key: string) => {\n        if (key === 'refs')\n          return refs\n        if (key === 'state')\n          return state\n        if (key in extras)\n          return extras[key] // passthrough methods (e.g. loadNextPage)\n        return refFor(key)\n      },\n      has: () => true,\n    },\n  )\n}\n"]}

package/dist/esm/vue/overlay/rooms/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The rooms overlay: the baseline room hooks keep their official names and
+ * semantics; the stateful ones (`usePresence`, `useTypingIndicator`) gain the
+ * result pattern, the rest pass through unchanged ([dux-spec-vue.md §6]).
+ *
+ * The wrappers re-declare the baseline generics rather than forwarding
+ * `Parameters<typeof …>`: a spread-args signature collapses the generics to
+ * their constraints, which erases per-room presence/topic typing (`keys` and
+ * `peers` resolve against `never`). Re-declaring keeps `keys`,
+ * `initialPresence`, and the resulting `peers`/`active` typed against the
+ * room's schema.
+ */
+import type { PresenceOpts, RoomSchemaShape } from '@instantdb/core';
+import type { InstantDuxRoom, TypingIndicatorOpts } from '../../baseline/index.js';
+import { usePublishTopic, useSyncPresence, useTopicEffect } from '../../baseline/index.js';
+declare function usePresence<RoomSchema extends RoomSchemaShape, RoomType extends keyof RoomSchema, Keys extends keyof RoomSchema[RoomType]['presence']>(room: InstantDuxRoom<any, RoomSchema, RoomType>, opts?: PresenceOpts<RoomSchema[RoomType]['presence'], Keys>): {
+    peers: import("vue").ShallowRef<{
+        [peerId: string]: Pick<RoomSchema[RoomType]["presence"], Keys> & {
+            peerId: string;
+        };
+    }>;
+    isLoading: import("vue").ShallowRef<boolean>;
+    user: import("vue").ShallowRef<(Pick<RoomSchema[RoomType]["presence"], Keys> & {
+        peerId: string;
+    }) | undefined>;
+    error: import("vue").ShallowRef<string | undefined>;
+} & {
+    refs: {
+        peers: import("vue").ShallowRef<{
+            [peerId: string]: Pick<RoomSchema[RoomType]["presence"], Keys> & {
+                peerId: string;
+            };
+        }>;
+        isLoading: import("vue").ShallowRef<boolean>;
+        user: import("vue").ShallowRef<(Pick<RoomSchema[RoomType]["presence"], Keys> & {
+            peerId: string;
+        }) | undefined>;
+        error: import("vue").ShallowRef<string | undefined>;
+    };
+    state: import("../result.js").StateOf<{
+        peers: import("vue").ShallowRef<{
+            [peerId: string]: Pick<RoomSchema[RoomType]["presence"], Keys> & {
+                peerId: string;
+            };
+        }>;
+        isLoading: import("vue").ShallowRef<boolean>;
+        user: import("vue").ShallowRef<(Pick<RoomSchema[RoomType]["presence"], Keys> & {
+            peerId: string;
+        }) | undefined>;
+        error: import("vue").ShallowRef<string | undefined>;
+    }>;
+} & {
+    publishPresence: (data: Partial<RoomSchema[RoomType]["presence"]>) => void;
+};
+declare function useTypingIndicator<RoomSchema extends RoomSchemaShape, RoomType extends keyof RoomSchema>(room: InstantDuxRoom<any, RoomSchema, RoomType>, inputName: string, opts?: TypingIndicatorOpts): {
+    active: import("vue").Ref<RoomSchema[RoomType]["presence"][], RoomSchema[RoomType]["presence"][]>;
+} & {
+    refs: {
+        active: import("vue").Ref<RoomSchema[RoomType]["presence"][], RoomSchema[RoomType]["presence"][]>;
+    };
+    state: import("../result.js").StateOf<{
+        active: import("vue").Ref<RoomSchema[RoomType]["presence"][], RoomSchema[RoomType]["presence"][]>;
+    }>;
+} & {
+    setActive: (active: boolean) => void;
+    inputProps: {
+        onKeydown: (e: KeyboardEvent) => void;
+        onBlur: () => void;
+    };
+};
+export declare const rooms: {
+    useTopicEffect: typeof useTopicEffect;
+    usePublishTopic: typeof usePublishTopic;
+    usePresence: typeof usePresence;
+    useSyncPresence: typeof useSyncPresence;
+    useTypingIndicator: typeof useTypingIndicator;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/vue/overlay/rooms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/vue/overlay/rooms/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAClF,OAAO,EAGL,eAAe,EACf,eAAe,EACf,cAAc,EACf,MAAM,yBAAyB,CAAA;AAGhC,iBAAS,WAAW,CAClB,UAAU,SAAS,eAAe,EAClC,QAAQ,SAAS,MAAM,UAAU,EACjC,IAAI,SAAS,MAAM,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,EAEnD,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,CAAC,EAC/C,IAAI,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc5D;AAED,iBAAS,kBAAkB,CACzB,UAAU,SAAS,eAAe,EAClC,QAAQ,SAAS,MAAM,UAAU,EAEjC,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,CAAC,EAC/C,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;EAI3B;AAED,eAAO,MAAM,KAAK;;;;;;CAMjB,CAAA"}

package/dist/esm/vue/overlay/rooms/index.js

@@ -0,0 +1,25 @@
+import { usePresence as baselineUsePresence, useTypingIndicator as baselineUseTypingIndicator, usePublishTopic, useSyncPresence, useTopicEffect, } from '../../baseline/index.js';
+import { makeResult } from '../result.js';
+function usePresence(room, opts) {
+    const handle = baselineUsePresence(room, opts);
+    // user/error are optional on the presence-response shape, but the baseline
+    // always creates their refs; assert them present for the result bag.
+    return Object.assign(makeResult({
+        peers: handle.peers,
+        isLoading: handle.isLoading,
+        user: handle.user,
+        error: handle.error,
+    }), { publishPresence: handle.publishPresence });
+}
+function useTypingIndicator(room, inputName, opts) {
+    const { active, setActive, inputProps } = baselineUseTypingIndicator(room, inputName, opts);
+    return Object.assign(makeResult({ active }), { setActive, inputProps });
+}
+export const rooms = {
+    useTopicEffect,
+    usePublishTopic,
+    usePresence,
+    useSyncPresence,
+    useTypingIndicator,
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/vue/overlay/rooms/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/vue/overlay/rooms/index.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,WAAW,IAAI,mBAAmB,EAClC,kBAAkB,IAAI,0BAA0B,EAChD,eAAe,EACf,eAAe,EACf,cAAc,GACf,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC,SAAS,WAAW,CAKlB,IAA+C,EAC/C,IAA2D;IAE3D,MAAM,MAAM,GAAG,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IAC9C,2EAA2E;IAC3E,qEAAqE;IACrE,OAAO,MAAM,CAAC,MAAM,CAClB,UAAU,CAAC;QACT,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,IAAI,EAAE,MAAM,CAAC,IAAK;QAClB,KAAK,EAAE,MAAM,CAAC,KAAM;KACrB,CAAC,EACF,EAAE,eAAe,EAAE,MAAM,CAAC,eAAe,EAAE,CAC5C,CAAA;AACH,CAAC;AAED,SAAS,kBAAkB,CAIzB,IAA+C,EAC/C,SAAiB,EACjB,IAA0B;IAE1B,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,0BAA0B,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAA;IAC3F,OAAO,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAA;AACzE,CAAC;AAED,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,cAAc;IACd,eAAe;IACf,WAAW;IACX,eAAe;IACf,kBAAkB;CACnB,CAAA","sourcesContent":["/**\n * The rooms overlay: the baseline room hooks keep their official names and\n * semantics; the stateful ones (`usePresence`, `useTypingIndicator`) gain the\n * result pattern, the rest pass through unchanged ([dux-spec-vue.md §6]).\n *\n * The wrappers re-declare the baseline generics rather than forwarding\n * `Parameters<typeof …>`: a spread-args signature collapses the generics to\n * their constraints, which erases per-room presence/topic typing (`keys` and\n * `peers` resolve against `never`). Re-declaring keeps `keys`,\n * `initialPresence`, and the resulting `peers`/`active` typed against the\n * room's schema.\n */\nimport type { PresenceOpts, RoomSchemaShape } from '@instantdb/core'\nimport type { InstantDuxRoom, TypingIndicatorOpts } from '../../baseline/index.js'\nimport {\n  usePresence as baselineUsePresence,\n  useTypingIndicator as baselineUseTypingIndicator,\n  usePublishTopic,\n  useSyncPresence,\n  useTopicEffect,\n} from '../../baseline/index.js'\nimport { makeResult } from '../result.js'\n\nfunction usePresence<\n  RoomSchema extends RoomSchemaShape,\n  RoomType extends keyof RoomSchema,\n  Keys extends keyof RoomSchema[RoomType]['presence'],\n>(\n  room: InstantDuxRoom<any, RoomSchema, RoomType>,\n  opts?: PresenceOpts<RoomSchema[RoomType]['presence'], Keys>,\n) {\n  const handle = baselineUsePresence(room, opts)\n  // user/error are optional on the presence-response shape, but the baseline\n  // always creates their refs; assert them present for the result bag.\n  return Object.assign(\n    makeResult({\n      peers: handle.peers,\n      isLoading: handle.isLoading,\n      user: handle.user!,\n      error: handle.error!,\n    }),\n    { publishPresence: handle.publishPresence },\n  )\n}\n\nfunction useTypingIndicator<\n  RoomSchema extends RoomSchemaShape,\n  RoomType extends keyof RoomSchema,\n>(\n  room: InstantDuxRoom<any, RoomSchema, RoomType>,\n  inputName: string,\n  opts?: TypingIndicatorOpts,\n) {\n  const { active, setActive, inputProps } = baselineUseTypingIndicator(room, inputName, opts)\n  return Object.assign(makeResult({ active }), { setActive, inputProps })\n}\n\nexport const rooms = {\n  useTopicEffect,\n  usePublishTopic,\n  usePresence,\n  useSyncPresence,\n  useTypingIndicator,\n}\n"]}

package/dist/esm/vue/overlay/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The `/vue` overlay's public types: the config rename, the result-pattern
+ * shapes per domain, and the auth/connection renames. Every stateful hook
+ * returns `Idb<Domain>Result` with `-Data`/`-State`/`-Refs` subparts
+ * ([conventions §3]).
+ */
+import type { ConnectionStatus, InstantConfig, User } from '@instantdb/core';
+import type { Ref } from 'vue';
+import type { IdbQueryData, IdbQueryPageInfo } from '../../query/index.js';
+import type { IdbSchema } from '../../schema/defineSchema.js';
+import type { IdbRegisteredSchema } from '../../schema/register.js';
+import type { IdbResult, StateOf } from './result.js';
+/**
+ * `init`/`defineDb` config — everything core supports, including `devtool`
+ * and `apiURI`/`websocketURI` (self-hosting). `i.date()` fields are typed as
+ * the wire format everywhere, so `useDateObjects` stays off.
+ */
+export type IdbClientConfig<S extends IdbSchema = IdbRegisteredSchema> = Omit<InstantConfig<S, false>, 'useDateObjects' | 'schema'> & {
+    schema?: S;
+};
+/** The authenticated user (official `User`). */
+export type IdbAuthUser = User;
+/** Connection status union (official `ConnectionStatus`). */
+export type IdbConnectionStatus = ConnectionStatus;
+type QueryRefs<Q, S extends IdbSchema> = {
+    isLoading: Ref<boolean>;
+    error: Ref<{
+        message: string;
+    } | undefined>;
+    pageInfo: Ref<IdbQueryPageInfo<Q> | undefined>;
+} & {
+    [K in keyof IdbQueryData<Q, S>]: Ref<IdbQueryData<Q, S>[K]>;
+};
+export type IdbQueryResultRefs<Q, S extends IdbSchema = IdbRegisteredSchema> = QueryRefs<Q, S>;
+export type IdbQueryResultData<Q, S extends IdbSchema = IdbRegisteredSchema> = IdbQueryData<Q, S>;
+export type IdbQueryResultState<Q, S extends IdbSchema = IdbRegisteredSchema> = StateOf<QueryRefs<Q, S>>;
+export type IdbQueryResult<Q, S extends IdbSchema = IdbRegisteredSchema> = IdbResult<QueryRefs<Q, S>>;
+type InfiniteRefs<Q, S extends IdbSchema> = {
+    isLoading: Ref<boolean>;
+    error: Ref<{
+        message: string;
+    } | undefined>;
+    canLoadNextPage: Ref<boolean>;
+} & {
+    [K in keyof IdbQueryData<Q, S>]: Ref<IdbQueryData<Q, S>[K]>;
+};
+export type IdbInfiniteQueryResult<Q, S extends IdbSchema = IdbRegisteredSchema> = IdbResult<InfiniteRefs<Q, S>> & {
+    loadNextPage: () => void;
+};
+interface AuthRefs {
+    isLoading: Ref<boolean>;
+    user: Ref<IdbAuthUser | undefined>;
+    error: Ref<{
+        message: string;
+    } | undefined>;
+}
+export type IdbAuthResultRefs = AuthRefs;
+export type IdbAuthResultState = StateOf<AuthRefs>;
+export type IdbAuthResult = IdbResult<AuthRefs>;
+interface ConnectionRefs {
+    status: Ref<IdbConnectionStatus>;
+}
+export type IdbConnectionResult = IdbResult<ConnectionRefs>;
+interface LocalIdRefs {
+    localId: Ref<string | null>;
+}
+export type IdbLocalIdResult = IdbResult<LocalIdRefs>;
+export interface IdbUserOptions {
+    /** Type `user` as present and treat a missing user as a dev-time error. */
+    requireUser?: boolean;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/vue/overlay/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/vue/overlay/types.ts"],"names":[],"mappings":"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"}

package/dist/esm/vue/overlay/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/vue/overlay/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/vue/overlay/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The `/vue` overlay's public types: the config rename, the result-pattern\n * shapes per domain, and the auth/connection renames. Every stateful hook\n * returns `Idb<Domain>Result` with `-Data`/`-State`/`-Refs` subparts\n * ([conventions §3]).\n */\nimport type {\n  ConnectionStatus,\n  InstantConfig,\n  User,\n} from '@instantdb/core'\nimport type { Ref } from 'vue'\nimport type { IdbQueryData, IdbQueryPageInfo } from '../../query/index.js'\nimport type { IdbSchema } from '../../schema/defineSchema.js'\nimport type { IdbRegisteredSchema } from '../../schema/register.js'\nimport type { IdbResult, StateOf } from './result.js'\n\n// ==========\n// config + auth/connection renames\n\n/**\n * `init`/`defineDb` config — everything core supports, including `devtool`\n * and `apiURI`/`websocketURI` (self-hosting). `i.date()` fields are typed as\n * the wire format everywhere, so `useDateObjects` stays off.\n */\nexport type IdbClientConfig<S extends IdbSchema = IdbRegisteredSchema> = Omit<\n  InstantConfig<S, false>,\n  'useDateObjects' | 'schema'\n> & { schema?: S }\n\n/** The authenticated user (official `User`). */\nexport type IdbAuthUser = User\n\n/** Connection status union (official `ConnectionStatus`). */\nexport type IdbConnectionStatus = ConnectionStatus\n\n// ==========\n// result-pattern shapes\n\ntype QueryRefs<Q, S extends IdbSchema> = {\n  isLoading: Ref<boolean>\n  error: Ref<{ message: string } | undefined>\n  pageInfo: Ref<IdbQueryPageInfo<Q> | undefined>\n} & {\n  [K in keyof IdbQueryData<Q, S>]: Ref<IdbQueryData<Q, S>[K]>\n}\n\nexport type IdbQueryResultRefs<Q, S extends IdbSchema = IdbRegisteredSchema> = QueryRefs<Q, S>\nexport type IdbQueryResultData<Q, S extends IdbSchema = IdbRegisteredSchema> = IdbQueryData<Q, S>\nexport type IdbQueryResultState<Q, S extends IdbSchema = IdbRegisteredSchema> = StateOf<QueryRefs<Q, S>>\nexport type IdbQueryResult<Q, S extends IdbSchema = IdbRegisteredSchema> = IdbResult<QueryRefs<Q, S>>\n\ntype InfiniteRefs<Q, S extends IdbSchema> = {\n  isLoading: Ref<boolean>\n  error: Ref<{ message: string } | undefined>\n  canLoadNextPage: Ref<boolean>\n} & {\n  [K in keyof IdbQueryData<Q, S>]: Ref<IdbQueryData<Q, S>[K]>\n}\n\nexport type IdbInfiniteQueryResult<Q, S extends IdbSchema = IdbRegisteredSchema>\n  = IdbResult<InfiniteRefs<Q, S>> & { loadNextPage: () => void }\n\ninterface AuthRefs {\n  isLoading: Ref<boolean>\n  user: Ref<IdbAuthUser | undefined>\n  error: Ref<{ message: string } | undefined>\n}\nexport type IdbAuthResultRefs = AuthRefs\nexport type IdbAuthResultState = StateOf<AuthRefs>\nexport type IdbAuthResult = IdbResult<AuthRefs>\n\ninterface ConnectionRefs { status: Ref<IdbConnectionStatus> }\nexport type IdbConnectionResult = IdbResult<ConnectionRefs>\n\ninterface LocalIdRefs { localId: Ref<string | null> }\nexport type IdbLocalIdResult = IdbResult<LocalIdRefs>\n\nexport interface IdbUserOptions {\n  /** Type `user` as present and treat a missing user as a dev-time error. */\n  requireUser?: boolean\n}\n"]}

package/dist/esm/webhooks/defineWebhookHandlers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Authoring webhook handlers as plain object literals with full per-change
+ * narrowing — no helper functions, no schema generics at the call site
+ * (dux-spec-webhooks.md §4).
+ */
+import type { IdbSchema } from '../schema/defineSchema.js';
+import type { IdbRegisteredSchema } from '../schema/register.js';
+import type { IdbWebhookHandlers } from './types.js';
+/**
+ * Define webhook handlers as a plain object literal. Contextual typing narrows
+ * each handler's `change` per namespace and action ({ after } is
+ * `IdbEntity<'ns'>`); pass several maps to merge them.
+ *
+ * Resolution per change matches the official dispatcher: `namespace.action` →
+ * `namespace.$default` → top-level `$default`.
+ *
+ * @example
+ *   export const handlers = defineWebhookHandlers({
+ *     tasks: {
+ *       create: ({ after }) => notifyAssignee(after),
+ *       delete: ({ before }) => audit('task removed', before),
+ *     },
+ *     $default: change => log(change),
+ *   })
+ */
+export declare function defineWebhookHandlers<S extends IdbSchema = IdbRegisteredSchema>(...maps: IdbWebhookHandlers<S>[]): IdbWebhookHandlers<S>;
+//# sourceMappingURL=defineWebhookHandlers.d.ts.map

package/dist/esm/webhooks/defineWebhookHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineWebhookHandlers.d.ts","sourceRoot":"","sources":["../../../src/webhooks/defineWebhookHandlers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,EAC7E,GAAG,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,GAC/B,kBAAkB,CAAC,CAAC,CAAC,CAWvB"}

package/dist/esm/webhooks/defineWebhookHandlers.js

@@ -0,0 +1,30 @@
+/**
+ * Define webhook handlers as a plain object literal. Contextual typing narrows
+ * each handler's `change` per namespace and action ({ after } is
+ * `IdbEntity<'ns'>`); pass several maps to merge them.
+ *
+ * Resolution per change matches the official dispatcher: `namespace.action` →
+ * `namespace.$default` → top-level `$default`.
+ *
+ * @example
+ *   export const handlers = defineWebhookHandlers({
+ *     tasks: {
+ *       create: ({ after }) => notifyAssignee(after),
+ *       delete: ({ before }) => audit('task removed', before),
+ *     },
+ *     $default: change => log(change),
+ *   })
+ */
+export function defineWebhookHandlers(...maps) {
+    const result = {};
+    for (const map of maps) {
+        for (const key of Object.keys(map)) {
+            if (key === '$default')
+                result.$default = map.$default;
+            else
+                result[key] = { ...result[key], ...map[key] };
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=defineWebhookHandlers.js.map

package/dist/esm/webhooks/defineWebhookHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineWebhookHandlers.js","sourceRoot":"","sources":["../../../src/webhooks/defineWebhookHandlers.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAG,IAA6B;IAEhC,MAAM,MAAM,GAAwB,EAAE,CAAA;IACtC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,IAAI,GAAG,KAAK,UAAU;gBACpB,MAAM,CAAC,QAAQ,GAAI,GAA2B,CAAC,QAAQ,CAAA;;gBAEvD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,GAAI,GAA2B,CAAC,GAAG,CAAC,EAAE,CAAA;QAC1E,CAAC;IACH,CAAC;IACD,OAAO,MAA+B,CAAA;AACxC,CAAC","sourcesContent":["/**\n * Authoring webhook handlers as plain object literals with full per-change\n * narrowing — no helper functions, no schema generics at the call site\n * (dux-spec-webhooks.md §4).\n */\nimport type { IdbSchema } from '../schema/defineSchema.js'\nimport type { IdbRegisteredSchema } from '../schema/register.js'\nimport type { IdbWebhookHandlers } from './types.js'\n\n/**\n * Define webhook handlers as a plain object literal. Contextual typing narrows\n * each handler's `change` per namespace and action ({ after } is\n * `IdbEntity<'ns'>`); pass several maps to merge them.\n *\n * Resolution per change matches the official dispatcher: `namespace.action` →\n * `namespace.$default` → top-level `$default`.\n *\n * @example\n *   export const handlers = defineWebhookHandlers({\n *     tasks: {\n *       create: ({ after }) => notifyAssignee(after),\n *       delete: ({ before }) => audit('task removed', before),\n *     },\n *     $default: change => log(change),\n *   })\n */\nexport function defineWebhookHandlers<S extends IdbSchema = IdbRegisteredSchema>(\n  ...maps: IdbWebhookHandlers<S>[]\n): IdbWebhookHandlers<S> {\n  const result: Record<string, any> = {}\n  for (const map of maps) {\n    for (const key of Object.keys(map)) {\n      if (key === '$default')\n        result.$default = (map as Record<string, any>).$default\n      else\n        result[key] = { ...result[key], ...(map as Record<string, any>)[key] }\n    }\n  }\n  return result as IdbWebhookHandlers<S>\n}\n"]}