@mszr/idb-dux 1.0.0

package/dist/commonjs/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/commonjs/vue/overlay/result.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeResult = makeResult;
+exports.makeDynamicResult = makeDynamicResult;
+/**
+ * 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.
+ */
+const vue_1 = require("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`.
+ */
+function makeResult(refs) {
+    const state = (0, vue_1.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.
+ */
+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 = (0, vue_1.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/commonjs/vue/overlay/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../../../src/vue/overlay/result.ts"],"names":[],"mappings":";;AA4CA,gCAcC;AASD,8CAkDC;AApHD;;;;;;;;;;;;;GAaG;AACH,6BAA6B;AAwB7B;;;;GAIG;AACH,SAAgB,UAAU,CAAuB,IAAU;IACzD,MAAM,KAAK,GAAG,IAAA,aAAO,EACnB,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,SAAgB,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,IAAA,aAAO,EACnB,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/commonjs/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/commonjs/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/commonjs/vue/overlay/rooms/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rooms = void 0;
+const index_js_1 = require("../../baseline/index.js");
+const result_js_1 = require("../result.js");
+function usePresence(room, opts) {
+    const handle = (0, index_js_1.usePresence)(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((0, result_js_1.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 } = (0, index_js_1.useTypingIndicator)(room, inputName, opts);
+    return Object.assign((0, result_js_1.makeResult)({ active }), { setActive, inputProps });
+}
+exports.rooms = {
+    useTopicEffect: index_js_1.useTopicEffect,
+    usePublishTopic: index_js_1.usePublishTopic,
+    usePresence,
+    useSyncPresence: index_js_1.useSyncPresence,
+    useTypingIndicator,
+};
+//# sourceMappingURL=index.js.map

package/dist/commonjs/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,sDAMgC;AAChC,4CAAyC;AAEzC,SAAS,WAAW,CAKlB,IAA+C,EAC/C,IAA2D;IAE3D,MAAM,MAAM,GAAG,IAAA,sBAAmB,EAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IAC9C,2EAA2E;IAC3E,qEAAqE;IACrE,OAAO,MAAM,CAAC,MAAM,CAClB,IAAA,sBAAU,EAAC;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,IAAA,6BAA0B,EAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAA;IAC3F,OAAO,MAAM,CAAC,MAAM,CAAC,IAAA,sBAAU,EAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAA;AACzE,CAAC;AAEY,QAAA,KAAK,GAAG;IACnB,cAAc,EAAd,yBAAc;IACd,eAAe,EAAf,0BAAe;IACf,WAAW;IACX,eAAe,EAAf,0BAAe;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/commonjs/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/commonjs/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/commonjs/vue/overlay/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/commonjs/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/commonjs/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/commonjs/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/commonjs/webhooks/defineWebhookHandlers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineWebhookHandlers = defineWebhookHandlers;
+/**
+ * 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),
+ *   })
+ */
+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/commonjs/webhooks/defineWebhookHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineWebhookHandlers.js","sourceRoot":"","sources":["../../../src/webhooks/defineWebhookHandlers.ts"],"names":[],"mappings":";;AA0BA,sDAaC;AA9BD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,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"]}

package/dist/commonjs/webhooks/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@mszr/idb-dux/webhooks` — webhook handling and management.
+ *
+ * Optional-config `init`, `defineWebhookHandlers`, the pipeline verbs
+ * (`verify`/`fetchPayload`/`dispatch`/`process`/`processNode`), and `manager`.
+ * Admin-free by design: handling needs no admin token.
+ *
+ * Spec: `../../../docs/dux-spec-webhooks.md`.
+ */
+export { IdbApiError, IdbError } from '../errors.js';
+export type { IdbIssue } from '../errors.js';
+export { defineWebhookHandlers } from './defineWebhookHandlers.js';
+export { init } from './init.js';
+export type { IdbWebhook, IdbWebhookAction, IdbWebhookAttempt, IdbWebhookBody, IdbWebhookChange, IdbWebhookConfig, IdbWebhookCreate, IdbWebhookEvent, IdbWebhookEventsPage, IdbWebhookEventStatus, IdbWebhookHandlers, IdbWebhookManager, IdbWebhookNodeOpts, IdbWebhookNodeRequest, IdbWebhookPayload, IdbWebhooks, IdbWebhookStatus, IdbWebhookUpdate, IdbWebhookVerifyOpts, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commonjs/webhooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webhooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACpD,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,YAAY,CAAA"}

package/dist/commonjs/webhooks/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = exports.defineWebhookHandlers = exports.IdbError = exports.IdbApiError = void 0;
+/**
+ * `@mszr/idb-dux/webhooks` — webhook handling and management.
+ *
+ * Optional-config `init`, `defineWebhookHandlers`, the pipeline verbs
+ * (`verify`/`fetchPayload`/`dispatch`/`process`/`processNode`), and `manager`.
+ * Admin-free by design: handling needs no admin token.
+ *
+ * Spec: `../../../docs/dux-spec-webhooks.md`.
+ */
+// The branded error family — `e instanceof IdbError` (verify/fetch can throw).
+var errors_js_1 = require("../errors.js");
+Object.defineProperty(exports, "IdbApiError", { enumerable: true, get: function () { return errors_js_1.IdbApiError; } });
+Object.defineProperty(exports, "IdbError", { enumerable: true, get: function () { return errors_js_1.IdbError; } });
+var defineWebhookHandlers_js_1 = require("./defineWebhookHandlers.js");
+Object.defineProperty(exports, "defineWebhookHandlers", { enumerable: true, get: function () { return defineWebhookHandlers_js_1.defineWebhookHandlers; } });
+var init_js_1 = require("./init.js");
+Object.defineProperty(exports, "init", { enumerable: true, get: function () { return init_js_1.init; } });
+//# sourceMappingURL=index.js.map

package/dist/commonjs/webhooks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/webhooks/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACH,+EAA+E;AAC/E,0CAAoD;AAA3C,wGAAA,WAAW,OAAA;AAAE,qGAAA,QAAQ,OAAA;AAE9B,uEAAkE;AAAzD,iIAAA,qBAAqB,OAAA;AAC9B,qCAAgC;AAAvB,+FAAA,IAAI,OAAA","sourcesContent":["/**\n * `@mszr/idb-dux/webhooks` — webhook handling and management.\n *\n * Optional-config `init`, `defineWebhookHandlers`, the pipeline verbs\n * (`verify`/`fetchPayload`/`dispatch`/`process`/`processNode`), and `manager`.\n * Admin-free by design: handling needs no admin token.\n *\n * Spec: `../../../docs/dux-spec-webhooks.md`.\n */\n// The branded error family — `e instanceof IdbError` (verify/fetch can throw).\nexport { IdbApiError, IdbError } from '../errors.js'\nexport type { IdbIssue } from '../errors.js'\nexport { defineWebhookHandlers } from './defineWebhookHandlers.js'\nexport { init } from './init.js'\nexport type {\n  IdbWebhook,\n  IdbWebhookAction,\n  IdbWebhookAttempt,\n  IdbWebhookBody,\n  IdbWebhookChange,\n  IdbWebhookConfig,\n  IdbWebhookCreate,\n  IdbWebhookEvent,\n  IdbWebhookEventsPage,\n  IdbWebhookEventStatus,\n  IdbWebhookHandlers,\n  IdbWebhookManager,\n  IdbWebhookNodeOpts,\n  IdbWebhookNodeRequest,\n  IdbWebhookPayload,\n  IdbWebhooks,\n  IdbWebhookStatus,\n  IdbWebhookUpdate,\n  IdbWebhookVerifyOpts,\n} from './types.js'\n"]}

package/dist/commonjs/webhooks/init.d.ts

@@ -0,0 +1,13 @@
+import type { IdbSchema } from '../schema/defineSchema.js';
+import type { IdbRegisteredSchema } from '../schema/register.js';
+import type { IdbWebhookConfig, IdbWebhooks } from './types.js';
+/**
+ * Create a webhook handle. Call with no config to handle webhooks; pass
+ * `appId` + `adminToken` to also manage subscriptions.
+ *
+ * @example
+ *   const webhooks = init()
+ *   await webhooks.process(handlers, request) // verify → fetch → dispatch
+ */
+export declare function init<S extends IdbSchema = IdbRegisteredSchema>(config?: IdbWebhookConfig): IdbWebhooks<S>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commonjs/webhooks/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/webhooks/init.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAsB,WAAW,EAAE,MAAM,YAAY,CAAA;AAGnF;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,EAC5D,MAAM,CAAC,EAAE,gBAAgB,GACxB,WAAW,CAAC,CAAC,CAAC,CAkBhB"}

package/dist/commonjs/webhooks/init.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const webhooks_1 = require("@instantdb/webhooks");
+/**
+ * Create a webhook handle. Call with no config to handle webhooks; pass
+ * `appId` + `adminToken` to also manage subscriptions.
+ *
+ * @example
+ *   const webhooks = init()
+ *   await webhooks.process(handlers, request) // verify → fetch → dispatch
+ */
+function init(config) {
+    const wh = new webhooks_1.Webhooks({
+        appId: config?.appId,
+        adminToken: config?.adminToken,
+        apiURI: config?.apiURI,
+    });
+    return {
+        manager: wh.manager,
+        verify: (input, opts) => input instanceof Request
+            ? wh.validateRequest(input, opts)
+            : wh.validate(input.signature, input.body, opts),
+        fetchPayload: body => wh.fetchPayloads(body),
+        dispatch: (handlers, payload) => wh.processPayload(official(handlers), payload),
+        process: (handlers, request, opts) => wh.processRequest(official(handlers), request, opts),
+        processNode: (handlers, req, opts) => wh.processNodeRequest(official(handlers), req, opts),
+    };
+}
+/**
+ * The handler-map seam: a dux handler map *is* an official `WebhookHandlers`
+ * (the compat-target test proves it on a concrete schema). The generic `S`
+ * can't carry that proof through `exactOptionalPropertyTypes`, so the rename is
+ * asserted here, once, at the boundary.
+ */
+function official(handlers) {
+    return handlers;
+}
+//# sourceMappingURL=init.js.map

package/dist/commonjs/webhooks/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../src/webhooks/init.ts"],"names":[],"mappings":";;AAmBA,oBAoBC;AA9BD,kDAA8C;AAE9C;;;;;;;GAOG;AACH,SAAgB,IAAI,CAClB,MAAyB;IAEzB,MAAM,EAAE,GAAG,IAAI,mBAAQ,CAAI;QACzB,KAAK,EAAE,MAAM,EAAE,KAAK;QACpB,UAAU,EAAE,MAAM,EAAE,UAAU;QAC9B,MAAM,EAAE,MAAM,EAAE,MAAM;KACvB,CAAC,CAAA;IAEF,OAAO;QACL,OAAO,EAAE,EAAE,CAAC,OAAO;QACnB,MAAM,EAAE,CAAC,KAA8E,EAAE,IAAI,EAAE,EAAE,CAC/F,KAAK,YAAY,OAAO;YACtB,CAAC,CAAC,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC;YACjC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;QACpD,YAAY,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC;QAC5C,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAC/E,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC;QAC1F,WAAW,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,kBAAkB,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC;KAC3F,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,QAAQ,CACf,QAA+B;IAE/B,OAAO,QAAyC,CAAA;AAClD,CAAC","sourcesContent":["/**\n * Optional-config `init` — composes `@instantdb/webhooks` and renames its\n * verbs at the boundary (dux-spec-webhooks.md §3, §5). Handling needs no\n * config; `appId` + `adminToken` unlock the `manager`.\n */\nimport type { WebhookHandlers } from '@instantdb/webhooks'\nimport type { IdbSchema } from '../schema/defineSchema.js'\nimport type { IdbRegisteredSchema } from '../schema/register.js'\nimport type { IdbWebhookConfig, IdbWebhookHandlers, IdbWebhooks } from './types.js'\nimport { Webhooks } from '@instantdb/webhooks'\n\n/**\n * Create a webhook handle. Call with no config to handle webhooks; pass\n * `appId` + `adminToken` to also manage subscriptions.\n *\n * @example\n *   const webhooks = init()\n *   await webhooks.process(handlers, request) // verify → fetch → dispatch\n */\nexport function init<S extends IdbSchema = IdbRegisteredSchema>(\n  config?: IdbWebhookConfig,\n): IdbWebhooks<S> {\n  const wh = new Webhooks<S>({\n    appId: config?.appId,\n    adminToken: config?.adminToken,\n    apiURI: config?.apiURI,\n  })\n\n  return {\n    manager: wh.manager,\n    verify: (input: Request | { signature: string, body: string | (() => Promise<string>) }, opts) =>\n      input instanceof Request\n        ? wh.validateRequest(input, opts)\n        : wh.validate(input.signature, input.body, opts),\n    fetchPayload: body => wh.fetchPayloads(body),\n    dispatch: (handlers, payload) => wh.processPayload(official(handlers), payload),\n    process: (handlers, request, opts) => wh.processRequest(official(handlers), request, opts),\n    processNode: (handlers, req, opts) => wh.processNodeRequest(official(handlers), req, opts),\n  }\n}\n\n/**\n * The handler-map seam: a dux handler map *is* an official `WebhookHandlers`\n * (the compat-target test proves it on a concrete schema). The generic `S`\n * can't carry that proof through `exactOptionalPropertyTypes`, so the rename is\n * asserted here, once, at the boundary.\n */\nfunction official<S extends IdbSchema>(\n  handlers: IdbWebhookHandlers<S>,\n): WebhookHandlers<S> {\n  return handlers as unknown as WebhookHandlers<S>\n}\n"]}