@mszr/idb-dux 1.0.0

package/dist/esm/schema/namespace.js

@@ -0,0 +1,34 @@
+import { i as officialI } from '@instantdb/core';
+/**
+ * The namespace constructor — the single home for everything that describes
+ * a namespace: its fields, its singular name, and its rule params.
+ *
+ * @example
+ *   workspaces: i.namespace({
+ *     fields: { name: i.string().indexed() },
+ *     ruleParams: { inviteCode: i.string() },
+ *   }),
+ */
+function namespace(config) {
+    const def = officialI.entity(config.fields);
+    Object.defineProperty(def, '$dux', {
+        value: { singular: config.singular, ruleParams: config.ruleParams },
+        enumerable: false,
+    });
+    return def;
+}
+/**
+ * dux's authoring dialect: `i.namespace` plus the official field builders.
+ * There is no `i.entity` / `i.schema` / `i.graph` — one dialect, one
+ * vocabulary; the builders themselves are the official implementations.
+ */
+export const i = {
+    namespace,
+    string: officialI.string,
+    number: officialI.number,
+    boolean: officialI.boolean,
+    date: officialI.date,
+    json: officialI.json,
+    any: officialI.any,
+};
+//# sourceMappingURL=namespace.js.map

package/dist/esm/schema/namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../../src/schema/namespace.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,IAAI,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAsEhD;;;;;;;;;GASG;AACH,SAAS,SAAS,CAKhB,MAAwD;IAMxD,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,MAAmB,CAItD,CAAA;IACD,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE;QACjC,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE;QACnE,UAAU,EAAE,KAAK;KAClB,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,CAAC,GAAG;IACf,SAAS;IACT,MAAM,EAAE,SAAS,CAAC,MAAM;IACxB,MAAM,EAAE,SAAS,CAAC,MAAM;IACxB,OAAO,EAAE,SAAS,CAAC,OAAO;IAC1B,IAAI,EAAE,SAAS,CAAC,IAAI;IACpB,IAAI,EAAE,SAAS,CAAC,IAAI;IACpB,GAAG,EAAE,SAAS,CAAC,GAAG;CACnB,CAAA","sourcesContent":["import type { AttrsDefs, DataAttrDef, EntityDef as EntityDefType } from '@instantdb/core'\nimport { i as officialI } from '@instantdb/core'\n\n/**\n * The dux metadata a namespace declaration carries into `defineSchema`,\n * where it is hoisted onto the schema's own (non-enumerable) `$dux` meta.\n */\nexport interface IdbNamespaceMeta<\n  Singular extends string | undefined = string | undefined,\n  RuleParams extends AttrsDefs | undefined = AttrsDefs | undefined,\n> {\n  readonly singular: Singular\n  readonly ruleParams: RuleParams\n}\n\n/**\n * What `i.namespace()` returns: a real official `EntityDef` (so the schema's\n * enumerable projection stays exactly what Instant's tooling consumes), with\n * the dux metadata riding along non-enumerably under `$dux`.\n */\nexport type IdbNamespaceDef<\n  Fields extends AttrsDefs = AttrsDefs,\n  Singular extends string | undefined = string | undefined,\n  RuleParams extends AttrsDefs | undefined = AttrsDefs | undefined,\n> = EntityDefType<Fields, {}, void> & {\n  readonly $dux: IdbNamespaceMeta<Singular, RuleParams>\n}\n\n/**\n * The constraint for `defineSchema`'s `namespaces` block. Deliberately the\n * official* `EntityDef` shape, without the `$dux` slot: a generic constraint\n * doubles as the contextual type of the config literal, and a contextual\n * `$dux: IdbNamespaceMeta<any, any>` would poison `i.namespace`'s inference\n * (literal singulars widen, ruleParams collapse to `any`). The meta is\n * extracted conditionally where it's needed instead.\n */\nexport type IdbNamespacesDef = Record<string, EntityDefType<any, any, any>>\n\n/**\n * The validation arm for `fields`/`ruleParams`: non-builder members carry\n * the diagnostic on the offending key; valid members contribute nothing.\n */\ntype ValidFieldBuilders<F> = {\n  [K in keyof F]: F[K] extends DataAttrDef<any, any, any, any>\n    ? unknown\n    : `QERR_SCHEMA_FIELD_INVALID: ${K & string} must be a field builder (i.string(), i.number(), …)`\n}\n\n/**\n * `Fields` and `RuleParams` are deliberately unconstrained: a generic's\n * constraint becomes the contextual type of the matching config property, and\n * an `AttrsDefs` context degrades unchained builder calls (a bare\n * `i.string()`) to `DataAttrDef<any, …>`. Validation rides in a parallel\n * intersection arm instead, and the return type re-tightens via `Extract`.\n */\nexport interface IdbNamespaceConfig<Fields, Singular, RuleParams> {\n  /**\n   * The singular form of the namespace name — the single source of truth for\n   * auto-singularization of `$only`/`$at` result keys. Defaults to the\n   * built-in English algorithm when omitted.\n   */\n  singular?: Singular\n  /** The namespace's local data attributes. */\n  fields: Fields & ValidFieldBuilders<Fields>\n  /**\n   * The namespace's rule params, declared once and typed end-to-end: in the\n   * tx chain, in query options, and in perms.\n   */\n  ruleParams?: RuleParams & ValidFieldBuilders<RuleParams>\n}\n\n/**\n * The namespace constructor — the single home for everything that describes\n * a namespace: its fields, its singular name, and its rule params.\n *\n * @example\n *   workspaces: i.namespace({\n *     fields: { name: i.string().indexed() },\n *     ruleParams: { inviteCode: i.string() },\n *   }),\n */\nfunction namespace<\n  Fields,\n  const Singular extends string | undefined = undefined,\n  RuleParams = undefined,\n>(\n  config: IdbNamespaceConfig<Fields, Singular, RuleParams>,\n): IdbNamespaceDef<\n  Extract<Fields, AttrsDefs>,\n  Singular,\n  Extract<RuleParams, AttrsDefs | undefined>\n> {\n  const def = officialI.entity(config.fields as AttrsDefs) as IdbNamespaceDef<\n    Extract<Fields, AttrsDefs>,\n    Singular,\n    Extract<RuleParams, AttrsDefs | undefined>\n  >\n  Object.defineProperty(def, '$dux', {\n    value: { singular: config.singular, ruleParams: config.ruleParams },\n    enumerable: false,\n  })\n  return def\n}\n\n/**\n * dux's authoring dialect: `i.namespace` plus the official field builders.\n * There is no `i.entity` / `i.schema` / `i.graph` — one dialect, one\n * vocabulary; the builders themselves are the official implementations.\n */\nexport const i = {\n  namespace,\n  string: officialI.string,\n  number: officialI.number,\n  boolean: officialI.boolean,\n  date: officialI.date,\n  json: officialI.json,\n  any: officialI.any,\n}\n"]}

package/dist/esm/schema/register.d.ts

@@ -0,0 +1,37 @@
+import type { InstantUnknownSchemaDef } from '@instantdb/core';
+import type { IdbSchema, IdbSchemaDef } from './defineSchema.js';
+/**
+ * Tell dux your schema once — every `Idb*` type utility and the exported `q`
+ * then default to it, project-wide:
+ *
+ * ```ts
+ * // instant.schema.ts
+ * export const schema = defineSchema({ ... })
+ *
+ * declare module '@mszr/idb-dux' {
+ *   interface IdbRegister { schema: typeof schema }
+ * }
+ * ```
+ *
+ * Registration supplies types, not values — factories that need the schema
+ * object (`defineDb`, `init`, `definePerms(schema)`) still receive it
+ * explicitly.
+ */
+export interface IdbRegister {
+}
+/** The fallback when no schema is registered: untyped namespaces, default options. */
+export type IdbUnknownSchema = IdbSchemaDef<InstantUnknownSchemaDef['entities'], InstantUnknownSchemaDef['rooms'], {
+    readonly namespaces: Record<string, {
+        singular: undefined;
+        ruleParams: undefined;
+    }>;
+    readonly linkSingulars: Record<string, Record<string, never>>;
+    readonly options: {
+        readonly singularize: 'auto';
+    };
+}>;
+/** The registered schema, or `IdbUnknownSchema` when nothing is registered. */
+export type IdbRegisteredSchema = IdbRegister extends {
+    schema: infer S;
+} ? S extends IdbSchema ? S : IdbUnknownSchema : IdbUnknownSchema;
+//# sourceMappingURL=register.d.ts.map

package/dist/esm/schema/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/schema/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,WAAW;CAAG;AAE/B,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,GAAG,YAAY,CACzC,uBAAuB,CAAC,UAAU,CAAC,EACnC,uBAAuB,CAAC,OAAO,CAAC,EAChC;IACE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,SAAS,CAAC;QAAC,UAAU,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACnF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC7D,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CACnD,CACF,CAAA;AAED,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG,WAAW,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACrE,CAAC,SAAS,SAAS,GACjB,CAAC,GACD,gBAAgB,GAClB,gBAAgB,CAAA"}

package/dist/esm/schema/register.js

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

package/dist/esm/schema/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../src/schema/register.ts"],"names":[],"mappings":"","sourcesContent":["import type { InstantUnknownSchemaDef } from '@instantdb/core'\nimport type { IdbSchema, IdbSchemaDef } from './defineSchema.js'\n\n/**\n * Tell dux your schema once — every `Idb*` type utility and the exported `q`\n * then default to it, project-wide:\n *\n * ```ts\n * // instant.schema.ts\n * export const schema = defineSchema({ ... })\n *\n * declare module '@mszr/idb-dux' {\n *   interface IdbRegister { schema: typeof schema }\n * }\n * ```\n *\n * Registration supplies types, not values — factories that need the schema\n * object (`defineDb`, `init`, `definePerms(schema)`) still receive it\n * explicitly.\n */\nexport interface IdbRegister {}\n\n/** The fallback when no schema is registered: untyped namespaces, default options. */\nexport type IdbUnknownSchema = IdbSchemaDef<\n  InstantUnknownSchemaDef['entities'],\n  InstantUnknownSchemaDef['rooms'],\n  {\n    readonly namespaces: Record<string, { singular: undefined, ruleParams: undefined }>\n    readonly linkSingulars: Record<string, Record<string, never>>\n    readonly options: { readonly singularize: 'auto' }\n  }\n>\n\n/** The registered schema, or `IdbUnknownSchema` when nothing is registered. */\nexport type IdbRegisteredSchema = IdbRegister extends { schema: infer S }\n  ? S extends IdbSchema\n    ? S\n    : IdbUnknownSchema\n  : IdbUnknownSchema\n"]}

package/dist/esm/schema/singularize.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The default English singularization algorithm, shipped twice from one rule
+ * set: `singularize` (runtime) and `Singularize<>` (type space). The two must
+ * never disagree — their equivalence is locked by a word-list test that runs
+ * both planes over the same fixtures.
+ *
+ * The algorithm is deliberately small and predictable: a short irregulars
+ * table plus ordered suffix rules. Anything it gets wrong is declared
+ * explicitly in the schema (`singular` on a namespace or link label), which
+ * always wins over the algorithm.
+ */
+/** Words the suffix rules would mangle. One source for both planes. */
+declare const IRREGULARS: {
+    readonly people: "person";
+    readonly children: "child";
+    readonly men: "man";
+    readonly women: "woman";
+    readonly feet: "foot";
+    readonly teeth: "tooth";
+    readonly geese: "goose";
+    readonly mice: "mouse";
+    readonly movies: "movie";
+    readonly cookies: "cookie";
+    readonly caches: "cache";
+    readonly statuses: "status";
+    readonly buses: "bus";
+    readonly quizzes: "quiz";
+    readonly heroes: "hero";
+};
+type Irregulars = typeof IRREGULARS;
+/**
+ * The ordered rules, in type space. Mirrors `singularize` exactly:
+ *
+ * 1. irregulars table
+ * 2. `…ies` → `…y` (stems of 2+ chars only, so `ties` → `tie`, not `ty`)
+ * 3. `…sses` / `…zzes` / `…ches` / `…shes` / `…xes` → strip `es`
+ * 4. `…ss` → unchanged (`class` is already singular)
+ * 5. `…s` → strip `s`
+ * 6. anything else → unchanged
+ */
+export type Singularize<Word extends string> = Word extends keyof Irregulars ? Irregulars[Word] : Word extends `${infer C1}${infer C2}${infer Rest}ies` ? `${C1}${C2}${Rest}y` : Word extends `${infer Stem}sses` ? `${Stem}ss` : Word extends `${infer Stem}zzes` ? `${Stem}zz` : Word extends `${infer Stem}ches` ? `${Stem}ch` : Word extends `${infer Stem}shes` ? `${Stem}sh` : Word extends `${infer Stem}xes` ? `${Stem}x` : Word extends `${string}ss` ? Word : Word extends `${infer Stem}s` ? Stem : Word;
+/** The same ordered rules, at runtime. Mirrors `Singularize<>` exactly. */
+export declare function singularize(word: string): string;
+export {};
+//# sourceMappingURL=singularize.d.ts.map

package/dist/esm/schema/singularize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singularize.d.ts","sourceRoot":"","sources":["../../../src/schema/singularize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uEAAuE;AACvE,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;CAgB2B,CAAA;AAE3C,KAAK,UAAU,GAAG,OAAO,UAAU,CAAA;AAEnC;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,SAAS,MAAM,IAAI,IAAI,SAAS,MAAM,UAAU,GACxE,UAAU,CAAC,IAAI,CAAC,GAChB,IAAI,SAAS,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,IAAI,KAAK,GACnD,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,GACpB,IAAI,SAAS,GAAG,MAAM,IAAI,MAAM,GAAG,GAAG,IAAI,IAAI,GAC5C,IAAI,SAAS,GAAG,MAAM,IAAI,MAAM,GAAG,GAAG,IAAI,IAAI,GAC5C,IAAI,SAAS,GAAG,MAAM,IAAI,MAAM,GAAG,GAAG,IAAI,IAAI,GAC5C,IAAI,SAAS,GAAG,MAAM,IAAI,MAAM,GAAG,GAAG,IAAI,IAAI,GAC5C,IAAI,SAAS,GAAG,MAAM,IAAI,KAAK,GAAG,GAAG,IAAI,GAAG,GAC1C,IAAI,SAAS,GAAG,MAAM,IAAI,GAAG,IAAI,GAC/B,IAAI,SAAS,GAAG,MAAM,IAAI,GAAG,GAAG,IAAI,GAClC,IAAI,CAAA;AAExB,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYhD"}

package/dist/esm/schema/singularize.js

@@ -0,0 +1,44 @@
+/**
+ * The default English singularization algorithm, shipped twice from one rule
+ * set: `singularize` (runtime) and `Singularize<>` (type space). The two must
+ * never disagree — their equivalence is locked by a word-list test that runs
+ * both planes over the same fixtures.
+ *
+ * The algorithm is deliberately small and predictable: a short irregulars
+ * table plus ordered suffix rules. Anything it gets wrong is declared
+ * explicitly in the schema (`singular` on a namespace or link label), which
+ * always wins over the algorithm.
+ */
+/** Words the suffix rules would mangle. One source for both planes. */
+const IRREGULARS = {
+    people: 'person',
+    children: 'child',
+    men: 'man',
+    women: 'woman',
+    feet: 'foot',
+    teeth: 'tooth',
+    geese: 'goose',
+    mice: 'mouse',
+    movies: 'movie',
+    cookies: 'cookie',
+    caches: 'cache',
+    statuses: 'status',
+    buses: 'bus',
+    quizzes: 'quiz',
+    heroes: 'hero',
+};
+/** The same ordered rules, at runtime. Mirrors `Singularize<>` exactly. */
+export function singularize(word) {
+    if (word in IRREGULARS)
+        return IRREGULARS[word];
+    if (word.endsWith('ies') && word.length >= 5)
+        return `${word.slice(0, -3)}y`;
+    if (/(?:ss|zz|ch|sh|x)es$/.test(word))
+        return word.slice(0, -2);
+    if (word.endsWith('ss'))
+        return word;
+    if (word.endsWith('s'))
+        return word.slice(0, -1);
+    return word;
+}
+//# sourceMappingURL=singularize.js.map

package/dist/esm/schema/singularize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singularize.js","sourceRoot":"","sources":["../../../src/schema/singularize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uEAAuE;AACvE,MAAM,UAAU,GAAG;IACjB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,OAAO;IACjB,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,OAAO;IACb,MAAM,EAAE,OAAO;IACf,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE,OAAO;IACf,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,MAAM;IACf,MAAM,EAAE,MAAM;CAC2B,CAAA;AA2B3C,2EAA2E;AAC3E,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,IAAI,IAAI,UAAU;QACpB,OAAO,UAAU,CAAC,IAAwB,CAAC,CAAA;IAC7C,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC;QAC1C,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA;IAChC,IAAI,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC;QACnC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QACrB,OAAO,IAAI,CAAA;IACb,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC1B,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["/**\n * The default English singularization algorithm, shipped twice from one rule\n * set: `singularize` (runtime) and `Singularize<>` (type space). The two must\n * never disagree — their equivalence is locked by a word-list test that runs\n * both planes over the same fixtures.\n *\n * The algorithm is deliberately small and predictable: a short irregulars\n * table plus ordered suffix rules. Anything it gets wrong is declared\n * explicitly in the schema (`singular` on a namespace or link label), which\n * always wins over the algorithm.\n */\n\n/** Words the suffix rules would mangle. One source for both planes. */\nconst IRREGULARS = {\n  people: 'person',\n  children: 'child',\n  men: 'man',\n  women: 'woman',\n  feet: 'foot',\n  teeth: 'tooth',\n  geese: 'goose',\n  mice: 'mouse',\n  movies: 'movie',\n  cookies: 'cookie',\n  caches: 'cache',\n  statuses: 'status',\n  buses: 'bus',\n  quizzes: 'quiz',\n  heroes: 'hero',\n} as const satisfies Record<string, string>\n\ntype Irregulars = typeof IRREGULARS\n\n/**\n * The ordered rules, in type space. Mirrors `singularize` exactly:\n *\n * 1. irregulars table\n * 2. `…ies` → `…y` (stems of 2+ chars only, so `ties` → `tie`, not `ty`)\n * 3. `…sses` / `…zzes` / `…ches` / `…shes` / `…xes` → strip `es`\n * 4. `…ss` → unchanged (`class` is already singular)\n * 5. `…s` → strip `s`\n * 6. anything else → unchanged\n */\nexport type Singularize<Word extends string> = Word extends keyof Irregulars\n  ? Irregulars[Word]\n  : Word extends `${infer C1}${infer C2}${infer Rest}ies`\n    ? `${C1}${C2}${Rest}y`\n    : Word extends `${infer Stem}sses` ? `${Stem}ss`\n      : Word extends `${infer Stem}zzes` ? `${Stem}zz`\n        : Word extends `${infer Stem}ches` ? `${Stem}ch`\n          : Word extends `${infer Stem}shes` ? `${Stem}sh`\n            : Word extends `${infer Stem}xes` ? `${Stem}x`\n              : Word extends `${string}ss` ? Word\n                : Word extends `${infer Stem}s` ? Stem\n                  : Word\n\n/** The same ordered rules, at runtime. Mirrors `Singularize<>` exactly. */\nexport function singularize(word: string): string {\n  if (word in IRREGULARS)\n    return IRREGULARS[word as keyof Irregulars]\n  if (word.endsWith('ies') && word.length >= 5)\n    return `${word.slice(0, -3)}y`\n  if (/(?:ss|zz|ch|sh|x)es$/.test(word))\n    return word.slice(0, -2)\n  if (word.endsWith('ss'))\n    return word\n  if (word.endsWith('s'))\n    return word.slice(0, -1)\n  return word\n}\n"]}

package/dist/esm/schema/types.d.ts

@@ -0,0 +1,39 @@
+import type { LinkAttrDef, PresenceOf, ResolveAttrs, RoomsOf, TopicsOf } from '@instantdb/core';
+import type { IdbSchema } from './defineSchema.js';
+import type { IdbRegisteredSchema } from './register.js';
+import type { Expand } from './util.js';
+/** A namespace name in the schema. */
+export type IdbNamespaceName<S extends IdbSchema = IdbRegisteredSchema> = keyof S['entities'] & string;
+/**
+ * The bare entity: `id` + fields only. Links live *between* entities, so the
+ * plain entity has none — `IdbEntityWithLinks` adds them, queries shape them.
+ */
+export type IdbEntity<NS extends IdbNamespaceName<S>, S extends IdbSchema = IdbRegisteredSchema> = Expand<{
+    id: string;
+} & ResolveAttrs<S['entities'], NS, false>>;
+/**
+ * The entity plus every link label, one hop, cardinality-aware
+ * (`Entity[]` or `Entity | undefined`), fields-only inside — deeper shapes
+ * are what queries are for.
+ */
+export type IdbEntityWithLinks<NS extends IdbNamespaceName<S>, S extends IdbSchema = IdbRegisteredSchema> = Expand<{
+    id: string;
+} & ResolveAttrs<S['entities'], NS, false> & {
+    [L in keyof S['entities'][NS]['links']]: S['entities'][NS]['links'][L] extends LinkAttrDef<infer Cardinality, infer Target> ? Target extends IdbNamespaceName<S> ? Cardinality extends 'one' ? IdbEntity<Target, S> | undefined : IdbEntity<Target, S>[] : never : never;
+}>;
+/**
+ * Every room defined in the schema's `rooms` block, keyed by room name —
+ * the schema-rooted extractor (official `RoomsOf`). Schema is the unmarked
+ * root domain, so room shapes read straight off your schema.
+ */
+export type IdbRooms<S extends IdbSchema = IdbRegisteredSchema> = RoomsOf<S>;
+/** A room name in the schema. */
+export type IdbRoomName<S extends IdbSchema = IdbRegisteredSchema> = keyof IdbRooms<S> & string;
+/**
+ * The presence shape of a room (official `PresenceOf`) — what `usePresence`
+ * peers and `db.rooms.getPresence` are typed against.
+ */
+export type IdbRoomPresence<RoomType extends IdbRoomName<S>, S extends IdbSchema = IdbRegisteredSchema> = PresenceOf<S, RoomType>;
+/** The topics map of a room (official `TopicsOf`). */
+export type IdbRoomTopics<RoomType extends IdbRoomName<S>, S extends IdbSchema = IdbRegisteredSchema> = TopicsOf<S, RoomType>;
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/schema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC,sCAAsC;AACtC,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,IAClE,MAAM,CAAC,CAAC,UAAU,CAAC,GAAG,MAAM,CAAA;AAEhC;;;GAGG;AACH,MAAM,MAAM,SAAS,CACnB,EAAE,SAAS,gBAAgB,CAAC,CAAC,CAAC,EAC9B,CAAC,SAAS,SAAS,GAAG,mBAAmB,IACvC,MAAM,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC,CAAA;AAEnE;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAC5B,EAAE,SAAS,gBAAgB,CAAC,CAAC,CAAC,EAC9B,CAAC,SAAS,SAAS,GAAG,mBAAmB,IACvC,MAAM,CACR;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG;KACvD,CAAC,IAAI,MAAM,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,WAAW,CACxF,MAAM,WAAW,EACjB,MAAM,MAAM,CACb,GACG,MAAM,SAAS,gBAAgB,CAAC,CAAC,CAAC,GAChC,WAAW,SAAS,KAAK,GACvB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,GAChC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GACxB,KAAK,GACP,KAAK;CACV,CACF,CAAA;AAKD;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;AAE5E,iCAAiC;AACjC,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,IAC7D,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAA;AAE9B;;;GAGG;AACH,MAAM,MAAM,eAAe,CACzB,QAAQ,SAAS,WAAW,CAAC,CAAC,CAAC,EAC/B,CAAC,SAAS,SAAS,GAAG,mBAAmB,IACvC,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAA;AAE3B,sDAAsD;AACtD,MAAM,MAAM,aAAa,CACvB,QAAQ,SAAS,WAAW,CAAC,CAAC,CAAC,EAC/B,CAAC,SAAS,SAAS,GAAG,mBAAmB,IACvC,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAA"}

package/dist/esm/schema/types.js

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

package/dist/esm/schema/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/schema/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { LinkAttrDef, PresenceOf, ResolveAttrs, RoomsOf, TopicsOf } from '@instantdb/core'\nimport type { IdbSchema } from './defineSchema.js'\nimport type { IdbRegisteredSchema } from './register.js'\nimport type { Expand } from './util.js'\n\n/** A namespace name in the schema. */\nexport type IdbNamespaceName<S extends IdbSchema = IdbRegisteredSchema>\n  = keyof S['entities'] & string\n\n/**\n * The bare entity: `id` + fields only. Links live *between* entities, so the\n * plain entity has none — `IdbEntityWithLinks` adds them, queries shape them.\n */\nexport type IdbEntity<\n  NS extends IdbNamespaceName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = Expand<{ id: string } & ResolveAttrs<S['entities'], NS, false>>\n\n/**\n * The entity plus every link label, one hop, cardinality-aware\n * (`Entity[]` or `Entity | undefined`), fields-only inside — deeper shapes\n * are what queries are for.\n */\nexport type IdbEntityWithLinks<\n  NS extends IdbNamespaceName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = Expand<\n  { id: string } & ResolveAttrs<S['entities'], NS, false> & {\n    [L in keyof S['entities'][NS]['links']]: S['entities'][NS]['links'][L] extends LinkAttrDef<\n      infer Cardinality,\n      infer Target\n    >\n      ? Target extends IdbNamespaceName<S>\n        ? Cardinality extends 'one'\n          ? IdbEntity<Target, S> | undefined\n          : IdbEntity<Target, S>[]\n        : never\n      : never\n  }\n>\n\n// ==========\n// room type extractors\n\n/**\n * Every room defined in the schema's `rooms` block, keyed by room name —\n * the schema-rooted extractor (official `RoomsOf`). Schema is the unmarked\n * root domain, so room shapes read straight off your schema.\n */\nexport type IdbRooms<S extends IdbSchema = IdbRegisteredSchema> = RoomsOf<S>\n\n/** A room name in the schema. */\nexport type IdbRoomName<S extends IdbSchema = IdbRegisteredSchema>\n  = keyof IdbRooms<S> & string\n\n/**\n * The presence shape of a room (official `PresenceOf`) — what `usePresence`\n * peers and `db.rooms.getPresence` are typed against.\n */\nexport type IdbRoomPresence<\n  RoomType extends IdbRoomName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = PresenceOf<S, RoomType>\n\n/** The topics map of a room (official `TopicsOf`). */\nexport type IdbRoomTopics<\n  RoomType extends IdbRoomName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = TopicsOf<S, RoomType>\n"]}

package/dist/esm/schema/util.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Flatten a computed object type (mapped-type intersections, alias chains)
+ * into a plain `{ key: value }` shape — both for exact type equality and for
+ * readable editor hovers.
+ */
+export type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+/** Collapse a union of object types into their intersection. */
+export type UnionToIntersection<U> = (U extends any ? (member: U) => void : never) extends (member: infer I) => void ? I : never;
+//# sourceMappingURL=util.d.ts.map

package/dist/esm/schema/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/schema/util.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAA;AAE5E,gEAAgE;AAChE,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CACnC,CAAC,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,KAAK,CAC5C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,GAC/B,CAAC,GACD,KAAK,CAAA"}

package/dist/esm/schema/util.js

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

package/dist/esm/schema/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../src/schema/util.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Flatten a computed object type (mapped-type intersections, alias chains)\n * into a plain `{ key: value }` shape — both for exact type equality and for\n * readable editor hovers.\n */\nexport type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never\n\n/** Collapse a union of object types into their intersection. */\nexport type UnionToIntersection<U> = (\n  U extends any ? (member: U) => void : never\n) extends (member: infer I) => void\n  ? I\n  : never\n"]}

package/dist/esm/tx/index.d.ts

@@ -0,0 +1,4 @@
+export { typedTx } from './typedTx.js';
+export type { IdbTx, IdbTxChunk, IdbTxChunkInput, IdbTxCreate, IdbTxLink, IdbTxNamespace, IdbTxRuleParams, IdbTxUpdate, IdbTxUpdateOpts, } from './types.js';
+export { id, lookup } from '@instantdb/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/tx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tx/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,YAAY,EACV,KAAK,EACL,UAAU,EACV,eAAe,EACf,WAAW,EACX,SAAS,EACT,cAAc,EACd,eAAe,EACf,WAAW,EACX,eAAe,GAChB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/esm/tx/index.js

@@ -0,0 +1,5 @@
+export { typedTx } from './typedTx.js';
+// `id` and `lookup` keep their official names — values are unprefixed at the
+// boundary; `lookup` remains available for direct use beside dot-path links.
+export { id, lookup } from '@instantdb/core';
+//# sourceMappingURL=index.js.map

package/dist/esm/tx/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tx/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAYtC,6EAA6E;AAC7E,6EAA6E;AAC7E,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA","sourcesContent":["export { typedTx } from './typedTx.js'\nexport type {\n  IdbTx,\n  IdbTxChunk,\n  IdbTxChunkInput,\n  IdbTxCreate,\n  IdbTxLink,\n  IdbTxNamespace,\n  IdbTxRuleParams,\n  IdbTxUpdate,\n  IdbTxUpdateOpts,\n} from './types.js'\n// `id` and `lookup` keep their official names — values are unprefixed at the\n// boundary; `lookup` remains available for direct use beside dot-path links.\nexport { id, lookup } from '@instantdb/core'\n"]}

package/dist/esm/tx/typedTx.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The typed tx runtime: core's `txInit()` proxy wrapped so `.link()`/
+ * `.unlink()` dot-path keys compile to the official `lookup()` wire form.
+ * Everything else passes through untouched — the chain stays core's chain.
+ */
+import type { IdbSchema } from '../schema/defineSchema.js';
+import type { IdbRegisteredSchema } from '../schema/register.js';
+import type { IdbTx } from './types.js';
+/**
+ * Build the typed tx chain for a schema. Schema-independent at runtime —
+ * all typing is schema-derived; the only runtime behavior added over core
+ * is dot-path `.link` compilation.
+ */
+export declare function typedTx<S extends IdbSchema = IdbRegisteredSchema>(): IdbTx<S>;
+//# sourceMappingURL=typedTx.d.ts.map

package/dist/esm/tx/typedTx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedTx.d.ts","sourceRoot":"","sources":["../../../src/tx/typedTx.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,KAAK,EAAE,MAAM,YAAY,CAAA;AA8CvC;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,mBAAmB,KAAK,KAAK,CAAC,CAAC,CAAC,CAK7E"}

package/dist/esm/tx/typedTx.js

@@ -0,0 +1,51 @@
+import { lookup, txInit } from '@instantdb/core';
+/** `{ 'workspace.inviteCode': code }` → `{ workspace: lookup('inviteCode', code) }` */
+function compileLinkArgs(args) {
+    const out = {};
+    for (const [key, value] of Object.entries(args)) {
+        const dot = key.indexOf('.');
+        if (dot === -1)
+            out[key] = value;
+        else
+            out[key.slice(0, dot)] = lookup(key.slice(dot + 1), value);
+    }
+    return out;
+}
+function wrapChunk(chunk) {
+    return new Proxy(chunk, {
+        get(target, prop) {
+            if (prop === 'link' || prop === 'unlink') {
+                return (args) => wrapChunk(target[prop](compileLinkArgs(args)));
+            }
+            const member = target[prop];
+            if (typeof member === 'function')
+                return (...args) => wrapChunk(member(...args));
+            return member;
+        },
+    });
+}
+function wrapNamespace(namespace) {
+    return new Proxy(namespace, {
+        get(target, prop) {
+            if (prop === 'lookup') {
+                return (attr, value) => wrapChunk(target.lookup(attr, value));
+            }
+            const member = target[prop];
+            return typeof member === 'object' && member !== null
+                ? wrapChunk(member)
+                : member;
+        },
+    });
+}
+/**
+ * Build the typed tx chain for a schema. Schema-independent at runtime —
+ * all typing is schema-derived; the only runtime behavior added over core
+ * is dot-path `.link` compilation.
+ */
+export function typedTx() {
+    const tx = txInit();
+    return new Proxy(tx, {
+        get: (target, ns) => wrapNamespace(target[ns]),
+    });
+}
+//# sourceMappingURL=typedTx.js.map

package/dist/esm/tx/typedTx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedTx.js","sourceRoot":"","sources":["../../../src/tx/typedTx.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAEhD,uFAAuF;AACvF,SAAS,eAAe,CAAC,IAA6B;IACpD,MAAM,GAAG,GAA4B,EAAE,CAAA;IACvC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAChD,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAC5B,IAAI,GAAG,KAAK,CAAC,CAAC;YACZ,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;;YAEhB,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;IAC9D,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,SAAS,SAAS,CAAC,KAAU;IAC3B,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE;QACtB,GAAG,CAAC,MAAM,EAAE,IAAI;YACd,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACzC,OAAO,CAAC,IAA6B,EAAE,EAAE,CACvC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YAClD,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;YAC3B,IAAI,OAAO,MAAM,KAAK,UAAU;gBAC9B,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAA;YAC3D,OAAO,MAAM,CAAA;QACf,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,SAAc;IACnC,OAAO,IAAI,KAAK,CAAC,SAAS,EAAE;QAC1B,GAAG,CAAC,MAAM,EAAE,IAAI;YACd,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,OAAO,CAAC,IAAY,EAAE,KAAc,EAAE,EAAE,CACtC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;YACzC,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;YAC3B,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;gBAClD,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;gBACnB,CAAC,CAAC,MAAM,CAAA;QACZ,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO;IACrB,MAAM,EAAE,GAAG,MAAM,EAAE,CAAA;IACnB,OAAO,IAAI,KAAK,CAAC,EAAY,EAAE;QAC7B,GAAG,EAAE,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,aAAa,CAAE,MAAc,CAAC,EAAE,CAAC,CAAC;KACxD,CAAa,CAAA;AAChB,CAAC","sourcesContent":["/**\n * The typed tx runtime: core's `txInit()` proxy wrapped so `.link()`/\n * `.unlink()` dot-path keys compile to the official `lookup()` wire form.\n * Everything else passes through untouched — the chain stays core's chain.\n */\nimport type { IdbSchema } from '../schema/defineSchema.js'\nimport type { IdbRegisteredSchema } from '../schema/register.js'\nimport type { IdbTx } from './types.js'\nimport { lookup, txInit } from '@instantdb/core'\n\n/** `{ 'workspace.inviteCode': code }` → `{ workspace: lookup('inviteCode', code) }` */\nfunction compileLinkArgs(args: Record<string, unknown>): Record<string, unknown> {\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(args)) {\n    const dot = key.indexOf('.')\n    if (dot === -1)\n      out[key] = value\n    else\n      out[key.slice(0, dot)] = lookup(key.slice(dot + 1), value)\n  }\n  return out\n}\n\nfunction wrapChunk(chunk: any): any {\n  return new Proxy(chunk, {\n    get(target, prop) {\n      if (prop === 'link' || prop === 'unlink') {\n        return (args: Record<string, unknown>) =>\n          wrapChunk(target[prop](compileLinkArgs(args)))\n      }\n      const member = target[prop]\n      if (typeof member === 'function')\n        return (...args: unknown[]) => wrapChunk(member(...args))\n      return member\n    },\n  })\n}\n\nfunction wrapNamespace(namespace: any): any {\n  return new Proxy(namespace, {\n    get(target, prop) {\n      if (prop === 'lookup') {\n        return (attr: string, value: unknown) =>\n          wrapChunk(target.lookup(attr, value))\n      }\n      const member = target[prop]\n      return typeof member === 'object' && member !== null\n        ? wrapChunk(member)\n        : member\n    },\n  })\n}\n\n/**\n * Build the typed tx chain for a schema. Schema-independent at runtime —\n * all typing is schema-derived; the only runtime behavior added over core\n * is dot-path `.link` compilation.\n */\nexport function typedTx<S extends IdbSchema = IdbRegisteredSchema>(): IdbTx<S> {\n  const tx = txInit()\n  return new Proxy(tx as object, {\n    get: (target, ns) => wrapNamespace((target as any)[ns]),\n  }) as IdbTx<S>\n}\n"]}

package/dist/esm/tx/types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The typed-tx types — one machinery for both runtimes (`db.tx` on the
+ * client, `adminDb.tx` on the admin surface). Types the two places the
+ * official chain goes untyped: `ruleParams` (schema-typed per namespace) and
+ * `.link()` dot-path keys (label completes, unique fields narrow, the value
+ * is typed; compiles to the official `lookup()` form on the wire).
+ */
+import type { CreateParams, DataAttrDef, UpdateParams } from '@instantdb/core';
+import type { IdbSchema } from '../schema/defineSchema.js';
+import type { AttrsOf, AttrValue, LinkCardinality, LinkLabels, LinkTarget, UniqueFieldKeys, WireValue } from '../schema/fields.js';
+import type { IdbRegisteredSchema } from '../schema/register.js';
+import type { IdbNamespaceName } from '../schema/types.js';
+import type { Expand } from '../schema/util.js';
+/** Options for `update`/`merge` — core's `UpdateOpts` (not exported there). */
+export interface IdbTxUpdateOpts {
+    upsert?: boolean | undefined;
+}
+/** The `create` payload — required fields required, optionals optional. */
+export type IdbTxCreate<NS extends IdbNamespaceName<S>, S extends IdbSchema = IdbRegisteredSchema> = CreateParams<S, NS>;
+/** The `update`/`merge`-style payload — everything optional. */
+export type IdbTxUpdate<NS extends IdbNamespaceName<S>, S extends IdbSchema = IdbRegisteredSchema> = UpdateParams<S, NS>;
+type PlainLinkValue<Cardinality> = Cardinality extends 'one' ? string : string | readonly string[];
+type LinkDotPaths<S extends IdbSchema, NS extends string> = {
+    [L in LinkLabels<S, NS>]: `${L}.${UniqueFieldKeys<S, LinkTarget<S, NS, L>>}`;
+}[LinkLabels<S, NS>];
+type LinkDotPathValue<S extends IdbSchema, NS extends string, P> = P extends `${infer L}.${infer F}` ? WireValue<AttrValue<AttrsOf<S, LinkTarget<S, NS, L>>[F]>> : never;
+/**
+ * The `link`/`unlink` payload: plain label keys typed per cardinality, plus
+ * one-hop dot-path keys over the linked namespace's unique fields —
+ * `{ 'workspace.inviteCode': code }` compiles to the official `lookup()`
+ * form on the wire.
+ */
+export type IdbTxLink<NS extends IdbNamespaceName<S>, S extends IdbSchema = IdbRegisteredSchema> = {
+    [L in LinkLabels<S, NS>]?: PlainLinkValue<LinkCardinality<S, NS, L>>;
+} & {
+    [P in LinkDotPaths<S, NS>]?: LinkDotPathValue<S, NS, P>;
+};
+type RequiredRuleParamKeys<RP> = {
+    [K in keyof RP]: RP[K] extends DataAttrDef<any, infer R, any, any> ? R extends true ? K : never : never;
+}[keyof RP];
+type OptionalRuleParamKeys<RP> = {
+    [K in keyof RP]: RP[K] extends DataAttrDef<any, infer R, any, any> ? R extends false ? K : never : never;
+}[keyof RP];
+type RuleParamsShape<RP> = Expand<{
+    [K in RequiredRuleParamKeys<RP>]: WireValue<AttrValue<RP[K]>>;
+} & {
+    [K in OptionalRuleParamKeys<RP>]?: WireValue<AttrValue<RP[K]>>;
+}>;
+/**
+ * The `ruleParams` payload for a namespace, typed from its collocated
+ * declaration in `defineSchema` — unknown keys are TS errors; a namespace
+ * with no declaration accepts none.
+ */
+export type IdbTxRuleParams<NS extends IdbNamespaceName<S>, S extends IdbSchema = IdbRegisteredSchema> = NS extends keyof S['$dux']['namespaces'] ? S['$dux']['namespaces'][NS]['ruleParams'] extends infer RP ? RP extends Record<string, DataAttrDef<any, any, any, any>> ? RuleParamsShape<RP> : Record<string, `QERR_TX_RULE_PARAMS_UNDECLARED: ${NS} declares no ruleParams — declare them in i.namespace({ ruleParams })`> : never : never;
+/**
+ * One tx step. Carries the official `__ops`/`__etype` runtime shape that
+ * `transact()` consumes, so interop holds on both runtimes; dux's own
+ * `transact` types its parameter as `IdbTxChunk` (the official
+ * `TransactionChunk` can't be a *structural supertype* — its method params
+ * are contravariant — which is exactly why the dux chain owns its own
+ * narrower typing rather than re-deriving the official one).
+ */
+export interface IdbTxChunk<S extends IdbSchema = IdbRegisteredSchema, NS extends IdbNamespaceName<S> = IdbNamespaceName<S>> {
+    __ops: any[];
+    __etype: NS;
+    /** Create an entity. Throws if the id already exists. */
+    create: (args: IdbTxCreate<NS, S>) => IdbTxChunk<S, NS>;
+    /** Upsert by default; `{ upsert: false }` for strict update. */
+    update: (args: IdbTxUpdate<NS, S>, opts?: IdbTxUpdateOpts) => IdbTxChunk<S, NS>;
+    /** Link entities — plain ids or dot-path unique-field keys. */
+    link: (args: IdbTxLink<NS, S>) => IdbTxChunk<S, NS>;
+    /** Unlink entities — same payload shape as `link`. */
+    unlink: (args: IdbTxLink<NS, S>) => IdbTxChunk<S, NS>;
+    /** Delete the entity and all of its links. */
+    delete: () => IdbTxChunk<S, NS>;
+    /** Deep-merge into the current value (document-style fields). */
+    merge: (args: {
+        [attribute: string]: any;
+    }, opts?: IdbTxUpdateOpts) => IdbTxChunk<S, NS>;
+    /** Schema-declared rule params for this namespace. */
+    ruleParams: (args: IdbTxRuleParams<NS, S>) => IdbTxChunk<S, NS>;
+}
+export type IdbTxNamespace<S extends IdbSchema, NS extends IdbNamespaceName<S>> = {
+    [id: string]: IdbTxChunk<S, NS>;
+} & {
+    /** Address an entity by a unique attribute instead of its id. */
+    lookup: <K extends UniqueFieldKeys<S, NS>>(attr: K, value: WireValue<AttrValue<AttrsOf<S, NS>[K]>>) => IdbTxChunk<S, NS>;
+};
+/** The typed tx builder — `db.tx` and `adminDb.tx` share this shape. */
+export type IdbTx<S extends IdbSchema = IdbRegisteredSchema> = {
+    [NS in IdbNamespaceName<S>]: IdbTxNamespace<S, NS>;
+};
+/**
+ * A chunk for *any one* namespace — the type `transact`/`debugTransact` accept.
+ * `IdbTxChunk<S>` defaults its `NS` to the full union, whose method params are
+ * contravariant, so a chunk narrowed to one namespace (what `tx.tasks[id]…`
+ * produces) wouldn't be assignable to it. The per-namespace union is: a
+ * `'tasks'` chunk is exactly one of its members.
+ */
+export type IdbTxChunkInput<S extends IdbSchema = IdbRegisteredSchema> = {
+    [NS in IdbNamespaceName<S>]: IdbTxChunk<S, NS>;
+}[IdbNamespaceName<S>];
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/tx/types.d.ts.map

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

package/dist/esm/tx/types.js

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

package/dist/esm/tx/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/tx/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The typed-tx types — one machinery for both runtimes (`db.tx` on the\n * client, `adminDb.tx` on the admin surface). Types the two places the\n * official chain goes untyped: `ruleParams` (schema-typed per namespace) and\n * `.link()` dot-path keys (label completes, unique fields narrow, the value\n * is typed; compiles to the official `lookup()` form on the wire).\n */\nimport type {\n  CreateParams,\n  DataAttrDef,\n  UpdateParams,\n} from '@instantdb/core'\nimport type { IdbSchema } from '../schema/defineSchema.js'\nimport type {\n  AttrsOf,\n  AttrValue,\n  LinkCardinality,\n  LinkLabels,\n  LinkTarget,\n  UniqueFieldKeys,\n  WireValue,\n} from '../schema/fields.js'\nimport type { IdbRegisteredSchema } from '../schema/register.js'\nimport type { IdbNamespaceName } from '../schema/types.js'\nimport type { Expand } from '../schema/util.js'\n\n// ==========\n// op payloads\n\n/** Options for `update`/`merge` — core's `UpdateOpts` (not exported there). */\nexport interface IdbTxUpdateOpts {\n  upsert?: boolean | undefined\n}\n\n/** The `create` payload — required fields required, optionals optional. */\nexport type IdbTxCreate<\n  NS extends IdbNamespaceName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = CreateParams<S, NS>\n\n/** The `update`/`merge`-style payload — everything optional. */\nexport type IdbTxUpdate<\n  NS extends IdbNamespaceName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = UpdateParams<S, NS>\n\ntype PlainLinkValue<Cardinality> = Cardinality extends 'one'\n  ? string\n  : string | readonly string[]\n\ntype LinkDotPaths<S extends IdbSchema, NS extends string> = {\n  [L in LinkLabels<S, NS>]: `${L}.${UniqueFieldKeys<S, LinkTarget<S, NS, L>>}`\n}[LinkLabels<S, NS>]\n\ntype LinkDotPathValue<\n  S extends IdbSchema,\n  NS extends string,\n  P,\n> = P extends `${infer L}.${infer F}`\n  ? WireValue<AttrValue<AttrsOf<S, LinkTarget<S, NS, L>>[F]>>\n  : never\n\n/**\n * The `link`/`unlink` payload: plain label keys typed per cardinality, plus\n * one-hop dot-path keys over the linked namespace's unique fields —\n * `{ 'workspace.inviteCode': code }` compiles to the official `lookup()`\n * form on the wire.\n */\nexport type IdbTxLink<\n  NS extends IdbNamespaceName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = {\n  [L in LinkLabels<S, NS>]?: PlainLinkValue<LinkCardinality<S, NS, L>>\n} & {\n  [P in LinkDotPaths<S, NS>]?: LinkDotPathValue<S, NS, P>\n}\n\n// ==========\n// ruleParams\n\ntype RequiredRuleParamKeys<RP> = {\n  [K in keyof RP]: RP[K] extends DataAttrDef<any, infer R, any, any>\n    ? R extends true\n      ? K\n      : never\n    : never\n}[keyof RP]\n\ntype OptionalRuleParamKeys<RP> = {\n  [K in keyof RP]: RP[K] extends DataAttrDef<any, infer R, any, any>\n    ? R extends false\n      ? K\n      : never\n    : never\n}[keyof RP]\n\ntype RuleParamsShape<RP> = Expand<\n  { [K in RequiredRuleParamKeys<RP>]: WireValue<AttrValue<RP[K]>> } & {\n    [K in OptionalRuleParamKeys<RP>]?: WireValue<AttrValue<RP[K]>>\n  }\n>\n\n/**\n * The `ruleParams` payload for a namespace, typed from its collocated\n * declaration in `defineSchema` — unknown keys are TS errors; a namespace\n * with no declaration accepts none.\n */\nexport type IdbTxRuleParams<\n  NS extends IdbNamespaceName<S>,\n  S extends IdbSchema = IdbRegisteredSchema,\n> = NS extends keyof S['$dux']['namespaces']\n  ? S['$dux']['namespaces'][NS]['ruleParams'] extends infer RP\n    ? RP extends Record<string, DataAttrDef<any, any, any, any>>\n      ? RuleParamsShape<RP>\n      : Record<\n        string,\n          `QERR_TX_RULE_PARAMS_UNDECLARED: ${NS} declares no ruleParams — declare them in i.namespace({ ruleParams })`\n      >\n    : never\n  : never\n\n// ==========\n// the chain\n\n/**\n * One tx step. Carries the official `__ops`/`__etype` runtime shape that\n * `transact()` consumes, so interop holds on both runtimes; dux's own\n * `transact` types its parameter as `IdbTxChunk` (the official\n * `TransactionChunk` can't be a *structural supertype* — its method params\n * are contravariant — which is exactly why the dux chain owns its own\n * narrower typing rather than re-deriving the official one).\n */\nexport interface IdbTxChunk<\n  S extends IdbSchema = IdbRegisteredSchema,\n  NS extends IdbNamespaceName<S> = IdbNamespaceName<S>,\n> {\n  // The official op tuple (`Op`) is not exported; this stays structurally\n  // assignable to `TransactionChunk.__ops` while remaining inspectable.\n  __ops: any[]\n  __etype: NS\n  /** Create an entity. Throws if the id already exists. */\n  create: (args: IdbTxCreate<NS, S>) => IdbTxChunk<S, NS>\n  /** Upsert by default; `{ upsert: false }` for strict update. */\n  update: (args: IdbTxUpdate<NS, S>, opts?: IdbTxUpdateOpts) => IdbTxChunk<S, NS>\n  /** Link entities — plain ids or dot-path unique-field keys. */\n  link: (args: IdbTxLink<NS, S>) => IdbTxChunk<S, NS>\n  /** Unlink entities — same payload shape as `link`. */\n  unlink: (args: IdbTxLink<NS, S>) => IdbTxChunk<S, NS>\n  /** Delete the entity and all of its links. */\n  delete: () => IdbTxChunk<S, NS>\n  /** Deep-merge into the current value (document-style fields). */\n  merge: (args: { [attribute: string]: any }, opts?: IdbTxUpdateOpts) => IdbTxChunk<S, NS>\n  /** Schema-declared rule params for this namespace. */\n  ruleParams: (args: IdbTxRuleParams<NS, S>) => IdbTxChunk<S, NS>\n}\n\nexport type IdbTxNamespace<\n  S extends IdbSchema,\n  NS extends IdbNamespaceName<S>,\n> = {\n  [id: string]: IdbTxChunk<S, NS>\n} & {\n  /** Address an entity by a unique attribute instead of its id. */\n  lookup: <K extends UniqueFieldKeys<S, NS>>(\n    attr: K,\n    value: WireValue<AttrValue<AttrsOf<S, NS>[K]>>,\n  ) => IdbTxChunk<S, NS>\n}\n\n/** The typed tx builder — `db.tx` and `adminDb.tx` share this shape. */\nexport type IdbTx<S extends IdbSchema = IdbRegisteredSchema> = {\n  [NS in IdbNamespaceName<S>]: IdbTxNamespace<S, NS>\n}\n\n/**\n * A chunk for *any one* namespace — the type `transact`/`debugTransact` accept.\n * `IdbTxChunk<S>` defaults its `NS` to the full union, whose method params are\n * contravariant, so a chunk narrowed to one namespace (what `tx.tasks[id]…`\n * produces) wouldn't be assignable to it. The per-namespace union is: a\n * `'tasks'` chunk is exactly one of its members.\n */\nexport type IdbTxChunkInput<S extends IdbSchema = IdbRegisteredSchema> = {\n  [NS in IdbNamespaceName<S>]: IdbTxChunk<S, NS>\n}[IdbNamespaceName<S>]\n"]}

package/dist/esm/vue/baseline/InstantDuxDatabase.d.ts

@@ -0,0 +1,52 @@
+import type { Auth, ConnectionStatus, IInstantDatabase, InstantConfig, InstantCoreDatabase, InstantSchemaDef, InstaQLOptions, InstaQLResponse, PageInfoResponse, RoomSchemaShape, RoomsOf, Storage, Streams, TransactionChunk, User, ValidQuery } from '@instantdb/core';
+import type { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import type { InfiniteQueryResult } from './useInfiniteQuery.js';
+import { InstantDuxRoom } from './InstantDuxRoom.js';
+export interface UseQueryReturn<Schema extends InstantSchemaDef<any, any, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> {
+    isLoading: Ref<boolean>;
+    data: ShallowRef<InstaQLResponse<Schema, Q, UseDates> | undefined>;
+    pageInfo: ShallowRef<PageInfoResponse<Q> | undefined>;
+    error: ShallowRef<{
+        message: string;
+    } | undefined>;
+}
+export interface UseAuthReturn {
+    isLoading: Ref<boolean>;
+    user: ShallowRef<User | null | undefined>;
+    error: ShallowRef<{
+        message: string;
+    } | undefined>;
+}
+export declare class InstantDuxDatabase<Schema extends InstantSchemaDef<any, any, any>, UseDates extends boolean = false, Rooms extends RoomSchemaShape = RoomsOf<Schema>> implements IInstantDatabase<Schema> {
+    tx: import("@instantdb/core").TxChunk<Schema>;
+    auth: Auth;
+    storage: Storage;
+    streams: Streams;
+    core: InstantCoreDatabase<Schema, UseDates>;
+    constructor(core: InstantCoreDatabase<Schema, UseDates>);
+    getLocalId: (name: string) => Promise<string>;
+    transact: (chunks: TransactionChunk<any, any> | TransactionChunk<any, any>[]) => Promise<import("@instantdb/core").TransactionResult>;
+    getAuth(): Promise<User | null>;
+    queryOnce: <Q extends ValidQuery<Q, Schema>>(query: Q, opts?: InstaQLOptions) => Promise<{
+        data: InstaQLResponse<Schema, Q, UseDates>;
+        pageInfo: PageInfoResponse<Q>;
+    }>;
+    useQuery: <Q extends ValidQuery<Q, Schema>>(query: MaybeRefOrGetter<Q | null>, opts?: MaybeRefOrGetter<InstaQLOptions | null | undefined>) => UseQueryReturn<Schema, Q, UseDates>;
+    useInfiniteQuery: <Q extends ValidQuery<Q, Schema>>(query: MaybeRefOrGetter<Q | null>, opts?: MaybeRefOrGetter<InstaQLOptions | undefined>) => InfiniteQueryResult<Schema, Q, UseDates>;
+    useAuth: () => UseAuthReturn;
+    useUser: () => ComputedRef<User>;
+    useConnectionStatus: () => Ref<ConnectionStatus>;
+    useLocalId: (name: MaybeRefOrGetter<string>) => Ref<string | null>;
+    room<RoomType extends string & keyof Rooms>(type?: MaybeRefOrGetter<RoomType | undefined>, id?: MaybeRefOrGetter<string | undefined>): InstantDuxRoom<Schema, Rooms, RoomType>;
+    rooms: {
+        useTopicEffect: typeof import("./InstantDuxRoom.js").useTopicEffect;
+        usePublishTopic: typeof import("./InstantDuxRoom.js").usePublishTopic;
+        usePresence: typeof import("./InstantDuxRoom.js").usePresence;
+        useSyncPresence: typeof import("./InstantDuxRoom.js").useSyncPresence;
+        useTypingIndicator: typeof import("./InstantDuxRoom.js").useTypingIndicator;
+    };
+}
+export declare function init<Schema extends InstantSchemaDef<any, any, any>, UseDates extends boolean = false>(config: Omit<InstantConfig<Schema, UseDates>, 'useDateObjects'> & {
+    useDateObjects?: UseDates;
+}): InstantDuxDatabase<Schema, UseDates>;
+//# sourceMappingURL=InstantDuxDatabase.d.ts.map

package/dist/esm/vue/baseline/InstantDuxDatabase.d.ts.map

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