@mszr/idb-dux 1.0.0

package/dist/commonjs/schema/defineSchema.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineSchema = defineSchema;
+const core_1 = require("@instantdb/core");
+// ==========
+// defineSchema
+/**
+ * The schema authority: namespaces, fields, links, rooms, ruleParams,
+ * options — the single home for everything that describes your data.
+ *
+ * Returns an actual official `InstantSchemaDef` instance (CLI push and the
+ * platform API consume it as-is); dux metadata rides along non-enumerably.
+ *
+ * @example
+ *   export const schema = defineSchema({
+ *     namespaces: {
+ *       tasks: i.namespace({
+ *         fields: { title: i.string().indexed() },
+ *       }),
+ *     },
+ *   })
+ *
+ *   declare module '@mszr/idb-dux' {
+ *     interface IdbRegister { schema: typeof schema }
+ *   }
+ */
+function defineSchema(config) {
+    const links = config.links ?? {};
+    // The official schema constructor builds the enriched entity defs and the
+    // canonical instance; dux only prepares official-dialect inputs for it, so
+    // the projection matches `i.schema` output by construction.
+    const schema = core_1.i.schema({
+        entities: config.namespaces,
+        links: stripDialect(links),
+        rooms: config.rooms ?? {},
+    });
+    Object.defineProperty(schema, '$dux', {
+        value: {
+            namespaces: Object.fromEntries(Object.entries(config.namespaces).map(([name, def]) => [
+                name,
+                def.$dux
+                    ?? { singular: undefined, ruleParams: undefined },
+            ])),
+            linkSingulars: collectLinkSingulars(links),
+            options: { singularize: config.options?.singularize ?? 'auto' },
+        },
+        enumerable: false,
+    });
+    return schema;
+}
+/** Remove dux-only keys so `schema.links` is wire-clean official dialect. */
+function stripDialect(links) {
+    return Object.fromEntries(Object.entries(links).map(([name, { forward, reverse }]) => {
+        const { singular: _f, ...forwardRest } = forward;
+        const { singular: _r, ...reverseRest } = reverse;
+        return [name, { forward: forwardRest, reverse: reverseRest }];
+    }));
+}
+/** Hoist declared label singulars into `$dux.linkSingulars[namespace][label]`. */
+function collectLinkSingulars(links) {
+    const result = {};
+    for (const { forward, reverse } of Object.values(links)) {
+        for (const side of [forward, reverse]) {
+            if (side.singular === undefined)
+                continue;
+            const labels = (result[side.on] ??= {});
+            labels[side.label] = side.singular;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=defineSchema.js.map

package/dist/commonjs/schema/defineSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineSchema.js","sourceRoot":"","sources":["../../../src/schema/defineSchema.ts"],"names":[],"mappings":";;AA2JA,oCA2CC;AA7LD,0CAAgD;AA2HhD,aAAa;AACb,eAAe;AAEf;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,YAAY,CAM1B,MAA0D;IAM1D,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAK,EAAY,CAAA;IAE3C,0EAA0E;IAC1E,2EAA2E;IAC3E,4DAA4D;IAC5D,MAAM,MAAM,GAAG,QAAS,CAAC,MAAM,CAAC;QAC9B,QAAQ,EAAE,MAAM,CAAC,UAAU;QAC3B,KAAK,EAAE,YAAY,CAAC,KAAK,CAAkB;QAC3C,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,EAAE;KAC1B,CAAC,CAAA;IAEF,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE;QACpC,KAAK,EAAE;YACL,UAAU,EAAE,MAAM,CAAC,WAAW,CAC5B,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;gBACrD,IAAI;gBACH,GAAgC,CAAC,IAAI;uBACnC,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE;aAClD,CAAC,CACH;YACD,aAAa,EAAE,oBAAoB,CAAC,KAAK,CAAC;YAC1C,OAAO,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,OAAO,EAAE,WAAW,IAAI,MAAM,EAAE;SAChE;QACD,UAAU,EAAE,KAAK;KAClB,CAAC,CAAA;IAEF,OAAO,MAIN,CAAA;AACH,CAAC;AAED,6EAA6E;AAC7E,SAAS,YAAY,CAAC,KAAuB;IAC3C,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE;QACzD,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAA;QAChD,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAA;QAChD,OAAO,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAA;IAC/D,CAAC,CAAC,CACH,CAAA;AACH,CAAC;AAED,kFAAkF;AAClF,SAAS,oBAAoB,CAC3B,KAAuB;IAEvB,MAAM,MAAM,GAA2C,EAAE,CAAA;IACzD,KAAK,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACxD,KAAK,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;YACtC,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;gBAC7B,SAAQ;YACV,MAAM,MAAM,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAA;YACvC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAA;QACpC,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC","sourcesContent":["import type {\n  CardinalityKind,\n  EntitiesWithLinks,\n  InstantSchemaDef as InstantSchemaDefType,\n  LinksDef,\n  RoomsDef,\n} from '@instantdb/core'\nimport type { IdbNamespaceDef, IdbNamespaceMeta, IdbNamespacesDef } from './namespace.js'\nimport type { Expand } from './util.js'\nimport { i as officialI } from '@instantdb/core'\n\n// ==========\n// links\n\ninterface IdbLinkSide<On extends string> {\n  on: On\n  label: string\n  has: CardinalityKind\n  /**\n   * The singular form of this label — governs the output key when `$only`/\n   * `$at` is applied to the nested link. Defaults to the built-in English\n   * algorithm when omitted. Stripped from the wire projection.\n   */\n  singular?: string\n  onDelete?: 'cascade'\n}\n\nexport interface IdbLinkDef<On extends string> {\n  forward: IdbLinkSide<On> & { required?: boolean }\n  reverse: IdbLinkSide<On>\n}\n\nexport type IdbLinksDef<Namespaces> = Record<\n  string,\n  IdbLinkDef<keyof Namespaces & string>\n>\n\n// ==========\n// options\n\nexport interface IdbSchemaOptions {\n  /**\n   * How `$only`/`$at` result keys are singularized, inherited by every dux\n   * init from the schema:\n   *\n   * - `'auto'` (default) — the schema's `singular` if declared, otherwise the\n   *   built-in English algorithm\n   * - `'explicit'` — the schema's `singular` if declared, otherwise the key\n   *   stays as-is (`$as` required for unregistered plurals)\n   * - `'off'` — never singularize; keys keep their names (`$as` to rename)\n   */\n  singularize?: 'auto' | 'off' | 'explicit'\n}\n\ninterface ResolveOptions<Options extends IdbSchemaOptions> {\n  singularize: Options['singularize'] extends 'off' | 'explicit'\n    ? Options['singularize']\n    : 'auto'\n}\n\n// ==========\n// schema meta\n\n/** The loose shape of a schema's `$dux` meta — the constraint side. */\nexport interface IdbSchemaMetaShape {\n  readonly namespaces: Record<string, IdbNamespaceMeta>\n  /** namespace → link label → declared singular (declared labels only). */\n  readonly linkSingulars: Record<string, Record<string, string>>\n  readonly options: { readonly singularize: 'auto' | 'off' | 'explicit' }\n}\n\ntype SideSingulars<Links, NS, Dir extends 'forward' | 'reverse'> = {\n  [K in keyof Links as Links[K] extends Record<Dir, { on: NS, label: infer L extends string, singular: string }>\n    ? L\n    : never]: Links[K] extends Record<Dir, { singular: infer Sg extends string }>\n    ? Sg\n    : never\n}\n\ntype LinkSingularsOf<Namespaces, Links> = {\n  [NS in keyof Namespaces]: Expand<\n    SideSingulars<Links, NS, 'forward'> & SideSingulars<Links, NS, 'reverse'>\n  >\n}\n\ntype MetaOfNamespace<Def> = Def extends { readonly $dux: infer Meta extends IdbNamespaceMeta }\n  ? Meta\n  : IdbNamespaceMeta<undefined, undefined>\n\n/** The computed `$dux` meta of a schema, as `defineSchema` derives it. */\nexport interface IdbSchemaMeta<\n  Namespaces extends IdbNamespacesDef,\n  Links,\n  Options extends IdbSchemaOptions,\n> {\n  readonly namespaces: { [K in keyof Namespaces]: MetaOfNamespace<Namespaces[K]> }\n  readonly linkSingulars: LinkSingularsOf<Namespaces, Links>\n  readonly options: ResolveOptions<Options>\n}\n\n// ==========\n// the schema type\n\n/**\n * Every dux schema: a real official `InstantSchemaDef` instance whose\n * enumerable projection is exactly what Instant's tooling consumes, with dux\n * metadata riding along non-enumerably under `$dux`. The official rename is\n * `IdbSchema` — this is the parameterized form behind it.\n */\nexport type IdbSchemaDef<\n  Entities extends Record<string, any>,\n  Rooms extends RoomsDef,\n  Meta extends IdbSchemaMetaShape,\n> = InstantSchemaDefType<Entities, LinksDef<any>, Rooms> & {\n  readonly $dux: Meta\n}\n\n/** The schema type — what `defineSchema` returns, loosely. */\nexport type IdbSchema = IdbSchemaDef<any, any, IdbSchemaMetaShape>\n\nexport interface IdbSchemaConfig<\n  Namespaces extends IdbNamespacesDef,\n  Links extends IdbLinksDef<Namespaces>,\n  Rooms extends RoomsDef,\n  Options extends IdbSchemaOptions,\n> {\n  namespaces: Namespaces\n  links?: Links\n  rooms?: Rooms\n  options?: Options\n}\n\n// ==========\n// defineSchema\n\n/**\n * The schema authority: namespaces, fields, links, rooms, ruleParams,\n * options — the single home for everything that describes your data.\n *\n * Returns an actual official `InstantSchemaDef` instance (CLI push and the\n * platform API consume it as-is); dux metadata rides along non-enumerably.\n *\n * @example\n *   export const schema = defineSchema({\n *     namespaces: {\n *       tasks: i.namespace({\n *         fields: { title: i.string().indexed() },\n *       }),\n *     },\n *   })\n *\n *   declare module '@mszr/idb-dux' {\n *     interface IdbRegister { schema: typeof schema }\n *   }\n */\nexport function defineSchema<\n  Namespaces extends IdbNamespacesDef,\n  const Links extends IdbLinksDef<Namespaces> = {},\n  Rooms extends RoomsDef = {},\n  const Options extends IdbSchemaOptions = {},\n>(\n  config: IdbSchemaConfig<Namespaces, Links, Rooms, Options>,\n): IdbSchemaDef<\n  EntitiesWithLinks<Namespaces, Links>,\n  Rooms,\n  IdbSchemaMeta<Namespaces, Links, Options>\n> {\n  const links = config.links ?? ({} as Links)\n\n  // The official schema constructor builds the enriched entity defs and the\n  // canonical instance; dux only prepares official-dialect inputs for it, so\n  // the projection matches `i.schema` output by construction.\n  const schema = officialI.schema({\n    entities: config.namespaces,\n    links: stripDialect(links) as LinksDef<any>,\n    rooms: config.rooms ?? {},\n  })\n\n  Object.defineProperty(schema, '$dux', {\n    value: {\n      namespaces: Object.fromEntries(\n        Object.entries(config.namespaces).map(([name, def]) => [\n          name,\n          (def as Partial<IdbNamespaceDef>).$dux\n          ?? { singular: undefined, ruleParams: undefined },\n        ]),\n      ),\n      linkSingulars: collectLinkSingulars(links),\n      options: { singularize: config.options?.singularize ?? 'auto' },\n    },\n    enumerable: false,\n  })\n\n  return schema as unknown as IdbSchemaDef<\n    EntitiesWithLinks<Namespaces, Links>,\n    Rooms,\n    IdbSchemaMeta<Namespaces, Links, Options>\n  >\n}\n\n/** Remove dux-only keys so `schema.links` is wire-clean official dialect. */\nfunction stripDialect(links: IdbLinksDef<any>): IdbLinksDef<any> {\n  return Object.fromEntries(\n    Object.entries(links).map(([name, { forward, reverse }]) => {\n      const { singular: _f, ...forwardRest } = forward\n      const { singular: _r, ...reverseRest } = reverse\n      return [name, { forward: forwardRest, reverse: reverseRest }]\n    }),\n  )\n}\n\n/** Hoist declared label singulars into `$dux.linkSingulars[namespace][label]`. */\nfunction collectLinkSingulars(\n  links: IdbLinksDef<any>,\n): Record<string, Record<string, string>> {\n  const result: Record<string, Record<string, string>> = {}\n  for (const { forward, reverse } of Object.values(links)) {\n    for (const side of [forward, reverse]) {\n      if (side.singular === undefined)\n        continue\n      const labels = (result[side.on] ??= {})\n      labels[side.label] = side.singular\n    }\n  }\n  return result\n}\n"]}

package/dist/commonjs/schema/fields.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Schema-derived field and link helpers, shared by the query and tx layers.
+ * Internal — the public surface exposes them only through `Idb*` types.
+ *
+ * Field-subset keys are detected by inferring the relevant `DataAttrDef`
+ * type param (core's UniqueKeys/IndexedKeys pattern) — `IsUnique`/`IsIndexed`
+ * are not structural properties, so assignability tests cannot see them.
+ */
+import type { DataAttrDef } from '@instantdb/core';
+import type { IdbSchema } from './defineSchema.js';
+export type AttrsOf<S extends IdbSchema, NS extends string> = S['entities'][NS]['attrs'];
+export type LinksOf<S extends IdbSchema, NS extends string> = S['entities'][NS]['links'];
+export type FieldKeys<S extends IdbSchema, NS extends string> = keyof AttrsOf<S, NS> & string;
+export type LinkLabels<S extends IdbSchema, NS extends string> = keyof LinksOf<S, NS> & string;
+export type LinkTarget<S extends IdbSchema, NS extends string, L extends string> = LinksOf<S, NS>[L] extends {
+    entityName: infer T extends string;
+} ? T : never;
+export type LinkCardinality<S extends IdbSchema, NS extends string, L extends string> = LinksOf<S, NS>[L] extends {
+    cardinality: infer C;
+} ? C : never;
+export type AttrValue<A> = A extends DataAttrDef<infer V, any, any, any> ? V : never;
+/** The wire form of a field value — `i.date()` fields travel as string | number. */
+export type WireValue<V> = V extends Date ? string | number | Date : V;
+export type IndexedFieldKeys<S extends IdbSchema, NS extends string> = {
+    [K in keyof AttrsOf<S, NS>]: AttrsOf<S, NS>[K] extends DataAttrDef<any, any, infer I, any> ? I extends true ? K & string : never : never;
+}[keyof AttrsOf<S, NS>];
+export type UniqueFieldKeys<S extends IdbSchema, NS extends string> = {
+    [K in keyof AttrsOf<S, NS>]: AttrsOf<S, NS>[K] extends DataAttrDef<any, any, any, infer U> ? U extends true ? K & string : never : never;
+}[keyof AttrsOf<S, NS>];
+export type PrimitiveFieldKeys<S extends IdbSchema, NS extends string> = {
+    [K in keyof AttrsOf<S, NS>]: AttrsOf<S, NS>[K] extends DataAttrDef<infer V, any, any, any> ? [V] extends [string | number | boolean] ? K & string : never : never;
+}[keyof AttrsOf<S, NS>];
+//# sourceMappingURL=fields.d.ts.map

package/dist/commonjs/schema/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../src/schema/fields.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAElD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;AACxF,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;AAExF,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAA;AAC7F,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAA;AAE9F,MAAM,MAAM,UAAU,CACpB,CAAC,SAAS,SAAS,EACnB,EAAE,SAAS,MAAM,EACjB,CAAC,SAAS,MAAM,IACd,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAA;AAEhF,MAAM,MAAM,eAAe,CACzB,CAAC,SAAS,SAAS,EACnB,EAAE,SAAS,MAAM,EACjB,CAAC,SAAS,MAAM,IACd,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAA;AAElE,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEpF,oFAAoF;AACpF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,CAAC,CAAA;AAEtE,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI;KACpE,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,GACtF,CAAC,SAAS,IAAI,GACZ,CAAC,GAAG,MAAM,GACV,KAAK,GACP,KAAK;CACV,CAAC,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;AAEvB,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI;KACnE,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,GACtF,CAAC,SAAS,IAAI,GACZ,CAAC,GAAG,MAAM,GACV,KAAK,GACP,KAAK;CACV,CAAC,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;AAEvB,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,SAAS,EAAE,EAAE,SAAS,MAAM,IAAI;KACtE,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GACtF,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACnC,CAAC,GAAG,MAAM,GACV,KAAK,GACT,KAAK;CACV,CAAC,MAAM,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA"}

package/dist/commonjs/schema/fields.js

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

package/dist/commonjs/schema/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sourceRoot":"","sources":["../../../src/schema/fields.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Schema-derived field and link helpers, shared by the query and tx layers.\n * Internal — the public surface exposes them only through `Idb*` types.\n *\n * Field-subset keys are detected by inferring the relevant `DataAttrDef`\n * type param (core's UniqueKeys/IndexedKeys pattern) — `IsUnique`/`IsIndexed`\n * are not structural properties, so assignability tests cannot see them.\n */\nimport type { DataAttrDef } from '@instantdb/core'\nimport type { IdbSchema } from './defineSchema.js'\n\nexport type AttrsOf<S extends IdbSchema, NS extends string> = S['entities'][NS]['attrs']\nexport type LinksOf<S extends IdbSchema, NS extends string> = S['entities'][NS]['links']\n\nexport type FieldKeys<S extends IdbSchema, NS extends string> = keyof AttrsOf<S, NS> & string\nexport type LinkLabels<S extends IdbSchema, NS extends string> = keyof LinksOf<S, NS> & string\n\nexport type LinkTarget<\n  S extends IdbSchema,\n  NS extends string,\n  L extends string,\n> = LinksOf<S, NS>[L] extends { entityName: infer T extends string } ? T : never\n\nexport type LinkCardinality<\n  S extends IdbSchema,\n  NS extends string,\n  L extends string,\n> = LinksOf<S, NS>[L] extends { cardinality: infer C } ? C : never\n\nexport type AttrValue<A> = A extends DataAttrDef<infer V, any, any, any> ? V : never\n\n/** The wire form of a field value — `i.date()` fields travel as string | number. */\nexport type WireValue<V> = V extends Date ? string | number | Date : V\n\nexport type IndexedFieldKeys<S extends IdbSchema, NS extends string> = {\n  [K in keyof AttrsOf<S, NS>]: AttrsOf<S, NS>[K] extends DataAttrDef<any, any, infer I, any>\n    ? I extends true\n      ? K & string\n      : never\n    : never\n}[keyof AttrsOf<S, NS>]\n\nexport type UniqueFieldKeys<S extends IdbSchema, NS extends string> = {\n  [K in keyof AttrsOf<S, NS>]: AttrsOf<S, NS>[K] extends DataAttrDef<any, any, any, infer U>\n    ? U extends true\n      ? K & string\n      : never\n    : never\n}[keyof AttrsOf<S, NS>]\n\nexport type PrimitiveFieldKeys<S extends IdbSchema, NS extends string> = {\n  [K in keyof AttrsOf<S, NS>]: AttrsOf<S, NS>[K] extends DataAttrDef<infer V, any, any, any>\n    ? [V] extends [string | number | boolean]\n        ? K & string\n        : never\n    : never\n}[keyof AttrsOf<S, NS>]\n"]}

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

@@ -0,0 +1,9 @@
+export type { IdbLinkDef, IdbLinksDef, IdbSchema, IdbSchemaConfig, IdbSchemaDef, IdbSchemaMeta, IdbSchemaMetaShape, IdbSchemaOptions, } from './defineSchema.js';
+export { defineSchema } from './defineSchema.js';
+export type { IdbNamespaceConfig, IdbNamespaceDef, IdbNamespaceMeta, IdbNamespacesDef, } from './namespace.js';
+export { i } from './namespace.js';
+export type { IdbRegister, IdbRegisteredSchema, IdbUnknownSchema, } from './register.js';
+export { singularize } from './singularize.js';
+export type { Singularize } from './singularize.js';
+export type { IdbEntity, IdbEntityWithLinks, IdbNamespaceName, IdbRoomName, IdbRoomPresence, IdbRooms, IdbRoomTopics, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,WAAW,EACX,SAAS,EACT,eAAe,EACf,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,CAAC,EAAE,MAAM,gBAAgB,CAAA;AAClC,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,QAAQ,EACR,aAAa,GACd,MAAM,YAAY,CAAA"}

package/dist/commonjs/schema/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.singularize = exports.i = exports.defineSchema = void 0;
+var defineSchema_js_1 = require("./defineSchema.js");
+Object.defineProperty(exports, "defineSchema", { enumerable: true, get: function () { return defineSchema_js_1.defineSchema; } });
+var namespace_js_1 = require("./namespace.js");
+Object.defineProperty(exports, "i", { enumerable: true, get: function () { return namespace_js_1.i; } });
+var singularize_js_1 = require("./singularize.js");
+Object.defineProperty(exports, "singularize", { enumerable: true, get: function () { return singularize_js_1.singularize; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":";;;AAUA,qDAAgD;AAAvC,+GAAA,YAAY,OAAA;AAOrB,+CAAkC;AAAzB,iGAAA,CAAC,OAAA;AAMV,mDAA8C;AAArC,6GAAA,WAAW,OAAA","sourcesContent":["export type {\n  IdbLinkDef,\n  IdbLinksDef,\n  IdbSchema,\n  IdbSchemaConfig,\n  IdbSchemaDef,\n  IdbSchemaMeta,\n  IdbSchemaMetaShape,\n  IdbSchemaOptions,\n} from './defineSchema.js'\nexport { defineSchema } from './defineSchema.js'\nexport type {\n  IdbNamespaceConfig,\n  IdbNamespaceDef,\n  IdbNamespaceMeta,\n  IdbNamespacesDef,\n} from './namespace.js'\nexport { i } from './namespace.js'\nexport type {\n  IdbRegister,\n  IdbRegisteredSchema,\n  IdbUnknownSchema,\n} from './register.js'\nexport { singularize } from './singularize.js'\nexport type { Singularize } from './singularize.js'\nexport type {\n  IdbEntity,\n  IdbEntityWithLinks,\n  IdbNamespaceName,\n  IdbRoomName,\n  IdbRoomPresence,\n  IdbRooms,\n  IdbRoomTopics,\n} from './types.js'\n"]}

package/dist/commonjs/schema/namespace.d.ts

@@ -0,0 +1,82 @@
+import type { AttrsDefs, DataAttrDef, EntityDef as EntityDefType } from '@instantdb/core';
+/**
+ * The dux metadata a namespace declaration carries into `defineSchema`,
+ * where it is hoisted onto the schema's own (non-enumerable) `$dux` meta.
+ */
+export interface IdbNamespaceMeta<Singular extends string | undefined = string | undefined, RuleParams extends AttrsDefs | undefined = AttrsDefs | undefined> {
+    readonly singular: Singular;
+    readonly ruleParams: RuleParams;
+}
+/**
+ * What `i.namespace()` returns: a real official `EntityDef` (so the schema's
+ * enumerable projection stays exactly what Instant's tooling consumes), with
+ * the dux metadata riding along non-enumerably under `$dux`.
+ */
+export type IdbNamespaceDef<Fields extends AttrsDefs = AttrsDefs, Singular extends string | undefined = string | undefined, RuleParams extends AttrsDefs | undefined = AttrsDefs | undefined> = EntityDefType<Fields, {}, void> & {
+    readonly $dux: IdbNamespaceMeta<Singular, RuleParams>;
+};
+/**
+ * The constraint for `defineSchema`'s `namespaces` block. Deliberately the
+ * official* `EntityDef` shape, without the `$dux` slot: a generic constraint
+ * doubles as the contextual type of the config literal, and a contextual
+ * `$dux: IdbNamespaceMeta<any, any>` would poison `i.namespace`'s inference
+ * (literal singulars widen, ruleParams collapse to `any`). The meta is
+ * extracted conditionally where it's needed instead.
+ */
+export type IdbNamespacesDef = Record<string, EntityDefType<any, any, any>>;
+/**
+ * The validation arm for `fields`/`ruleParams`: non-builder members carry
+ * the diagnostic on the offending key; valid members contribute nothing.
+ */
+type ValidFieldBuilders<F> = {
+    [K in keyof F]: F[K] extends DataAttrDef<any, any, any, any> ? unknown : `QERR_SCHEMA_FIELD_INVALID: ${K & string} must be a field builder (i.string(), i.number(), …)`;
+};
+/**
+ * `Fields` and `RuleParams` are deliberately unconstrained: a generic's
+ * constraint becomes the contextual type of the matching config property, and
+ * an `AttrsDefs` context degrades unchained builder calls (a bare
+ * `i.string()`) to `DataAttrDef<any, …>`. Validation rides in a parallel
+ * intersection arm instead, and the return type re-tightens via `Extract`.
+ */
+export interface IdbNamespaceConfig<Fields, Singular, RuleParams> {
+    /**
+     * The singular form of the namespace name — the single source of truth for
+     * auto-singularization of `$only`/`$at` result keys. Defaults to the
+     * built-in English algorithm when omitted.
+     */
+    singular?: Singular;
+    /** The namespace's local data attributes. */
+    fields: Fields & ValidFieldBuilders<Fields>;
+    /**
+     * The namespace's rule params, declared once and typed end-to-end: in the
+     * tx chain, in query options, and in perms.
+     */
+    ruleParams?: RuleParams & ValidFieldBuilders<RuleParams>;
+}
+/**
+ * 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() },
+ *   }),
+ */
+declare function namespace<Fields, const Singular extends string | undefined = undefined, RuleParams = undefined>(config: IdbNamespaceConfig<Fields, Singular, RuleParams>): IdbNamespaceDef<Extract<Fields, AttrsDefs>, Singular, Extract<RuleParams, AttrsDefs | undefined>>;
+/**
+ * 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 declare const i: {
+    namespace: typeof namespace;
+    string: <StringEnum extends string = string>() => DataAttrDef<StringEnum, true, false>;
+    number: () => DataAttrDef<number, true, false>;
+    boolean: () => DataAttrDef<boolean, true, false>;
+    date: () => DataAttrDef<Date, true, false>;
+    json: <T = any>() => DataAttrDef<T, true, false>;
+    any: () => DataAttrDef<any, true, false>;
+};
+export {};
+//# sourceMappingURL=namespace.d.ts.map

package/dist/commonjs/schema/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../../src/schema/namespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAGzF;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAC/B,QAAQ,SAAS,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,EACxD,UAAU,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS;IAEhE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAChC;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,CACzB,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,QAAQ,SAAS,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,EACxD,UAAU,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,IAC9D,aAAa,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG;IACpC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;CACtD,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;AAE3E;;;GAGG;AACH,KAAK,kBAAkB,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GACxD,OAAO,GACP,8BAA8B,CAAC,GAAG,MAAM,sDAAsD;CACnG,CAAA;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU;IAC9D;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAA;IAC3C;;;OAGG;IACH,UAAU,CAAC,EAAE,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAA;CACzD;AAED;;;;;;;;;GASG;AACH,iBAAS,SAAS,CAChB,MAAM,EACN,KAAK,CAAC,QAAQ,SAAS,MAAM,GAAG,SAAS,GAAG,SAAS,EACrD,UAAU,GAAG,SAAS,EAEtB,MAAM,EAAE,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,GACvD,eAAe,CAChB,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1B,QAAQ,EACR,OAAO,CAAC,UAAU,EAAE,SAAS,GAAG,SAAS,CAAC,CAC3C,CAWA;AAED;;;;GAIG;AACH,eAAO,MAAM,CAAC;;;;;;;;CAQb,CAAA"}

package/dist/commonjs/schema/namespace.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i = void 0;
+const core_1 = require("@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 = core_1.i.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.
+ */
+exports.i = {
+    namespace,
+    string: core_1.i.string,
+    number: core_1.i.number,
+    boolean: core_1.i.boolean,
+    date: core_1.i.date,
+    json: core_1.i.json,
+    any: core_1.i.any,
+};
+//# sourceMappingURL=namespace.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../../src/schema/namespace.ts"],"names":[],"mappings":";;;AACA,0CAAgD;AAsEhD;;;;;;;;;GASG;AACH,SAAS,SAAS,CAKhB,MAAwD;IAMxD,MAAM,GAAG,GAAG,QAAS,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;AACU,QAAA,CAAC,GAAG;IACf,SAAS;IACT,MAAM,EAAE,QAAS,CAAC,MAAM;IACxB,MAAM,EAAE,QAAS,CAAC,MAAM;IACxB,OAAO,EAAE,QAAS,CAAC,OAAO;IAC1B,IAAI,EAAE,QAAS,CAAC,IAAI;IACpB,IAAI,EAAE,QAAS,CAAC,IAAI;IACpB,GAAG,EAAE,QAAS,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/commonjs/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/commonjs/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/commonjs/schema/register.js

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

package/dist/commonjs/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/commonjs/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/commonjs/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/commonjs/schema/singularize.js

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

@@ -0,0 +1 @@
+{"version":3,"file":"singularize.js","sourceRoot":"","sources":["../../../src/schema/singularize.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AA+CH,kCAYC;AAzDD,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,SAAgB,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/commonjs/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/commonjs/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/commonjs/schema/types.js

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

package/dist/commonjs/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/commonjs/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/commonjs/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/commonjs/schema/util.js

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

package/dist/commonjs/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/commonjs/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/commonjs/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/commonjs/tx/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookup = exports.id = exports.typedTx = void 0;
+var typedTx_js_1 = require("./typedTx.js");
+Object.defineProperty(exports, "typedTx", { enumerable: true, get: function () { return typedTx_js_1.typedTx; } });
+// `id` and `lookup` keep their official names — values are unprefixed at the
+// boundary; `lookup` remains available for direct use beside dot-path links.
+var core_1 = require("@instantdb/core");
+Object.defineProperty(exports, "id", { enumerable: true, get: function () { return core_1.id; } });
+Object.defineProperty(exports, "lookup", { enumerable: true, get: function () { return core_1.lookup; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tx/index.ts"],"names":[],"mappings":";;;AAAA,2CAAsC;AAA7B,qGAAA,OAAO,OAAA;AAYhB,6EAA6E;AAC7E,6EAA6E;AAC7E,wCAA4C;AAAnC,0FAAA,EAAE,OAAA;AAAE,8FAAA,MAAM,OAAA","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/commonjs/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