@dxos/echo 0.10.0 → 0.11.1

package/dist/lib/chunk-Annotation.mjs

@@ -0,0 +1,221 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { a as isEntity, b as getDictionary$1, i as update$1, n as get$1, r as set$1, t as snapshotForComparison, v as Dictionary$1, x as setDictionary$1, y as Key$1 } from "./chunk-atom-snapshot.mjs";
+import { $ as ReferenceAnnotation, B as FormLayoutAnnotationId, D as DEFAULT_LAYOUT_NAME, Et as setDescriptionWithSchema, F as FormInlineAnnotation, G as HiddenAnnotation, J as IconFromRefAnnotation, L as FormInputAnnotation, N as FormCreateAnnotation, O as DescriptionAnnotation, Ot as setLabelWithSchema, P as FormCreateAnnotationId, U as GeneratorAnnotation, V as FormOrderedAnnotation, W as GeneratorAnnotationId, Y as LabelAnnotation, bt as getTypeAnnotation, dt as getFromAst$1, et as ReferenceAnnotationId, ht as getLabelWithSchema, j as FieldLookupAnnotationId, lt as getDescriptionWithSchema, nt as TypeAnnotation, q as IconAnnotation, wt as makeUserAnnotation, xt as getTypeIdentifierAnnotation, z as FormLayoutAnnotation } from "./chunk-Database.mjs";
+import { g as subscribe } from "./chunk-ref.mjs";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { assertArgument } from "@dxos/invariant";
+import * as Atom from "@effect-atom/atom/Atom";
+import * as Data from "effect/Data";
+//#region src/internal/Annotation/atoms.ts
+/**
+* Atom family for an annotation value on an entity instance.
+* Mirrors the object-property atom family: re-emits a fresh reference whenever the entity changes
+* (so an in-place array mutation is observed) and dedupes primitive values via `!==`.
+*/
+var annotationFamily = Atom.family((target) => Atom.family((annotation) => {
+	const read = () => Option.map(get$1(target, annotation), snapshotForComparison);
+	return Atom.make((get) => {
+		let previous = read();
+		const unsubscribe = subscribe(target, () => {
+			const next = read();
+			if (!sameOption(previous, next)) {
+				previous = next;
+				get.setSelf(next);
+			}
+		});
+		get.addFinalizer(() => unsubscribe());
+		return previous;
+	}).pipe(Atom.keepAlive);
+}));
+/**
+* Atom family for a single key of a record-valued annotation on an entity instance.
+* Keyed by a value-equal `Data.tuple([target, annotation, key])` so nested families are avoided.
+*/
+var annotationPropertyFamily = Atom.family(([target, annotation, key]) => {
+	const read = () => get$1(target, annotation).pipe(Option.map((value) => snapshotForComparison(value[key])), Option.getOrUndefined);
+	return Atom.make((get) => {
+		let previous = read();
+		const unsubscribe = subscribe(target, () => {
+			const next = read();
+			if (next !== previous) {
+				previous = next;
+				get.setSelf(next);
+			}
+		});
+		get.addFinalizer(() => unsubscribe());
+		return previous;
+	}).pipe(Atom.keepAlive);
+});
+/** Equal when both empty, or both present with the same (snapshotted) value. */
+var sameOption = (a, b) => Option.isNone(a) || Option.isNone(b) ? Option.isNone(a) && Option.isNone(b) : a.value === b.value;
+/**
+* Reactive atom for an annotation value on an entity instance. Emits a shallow snapshot (a fresh
+* reference for objects/arrays) so dependent atoms recompute on change. Mirrors {@link makeProperty}.
+*/
+var makeAtom = (target, annotation) => {
+	assertArgument(isEntity(target), "target", "Must be a reactive ECHO entity");
+	return annotationFamily(target)(annotation);
+};
+/**
+* Reactive atom for a single key of a record-valued annotation on an entity instance.
+*/
+var makeProperty = (target, annotation, key) => {
+	assertArgument(isEntity(target), "target", "Must be a reactive ECHO entity");
+	return annotationPropertyFamily(Data.tuple(target, annotation, key));
+};
+//#endregion
+//#region src/Annotation.ts
+var Annotation_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_LAYOUT_NAME: () => DEFAULT_LAYOUT_NAME,
+	DescriptionAnnotation: () => DescriptionAnnotation,
+	Dictionary: () => Dictionary,
+	FieldLookupAnnotationId: () => FieldLookupAnnotationId,
+	FormCreateAnnotation: () => FormCreateAnnotation,
+	FormCreateAnnotationId: () => FormCreateAnnotationId,
+	FormInlineAnnotation: () => FormInlineAnnotation,
+	FormInputAnnotation: () => FormInputAnnotation,
+	FormLayoutAnnotation: () => FormLayoutAnnotation,
+	FormLayoutAnnotationId: () => FormLayoutAnnotationId,
+	FormOrderedAnnotation: () => FormOrderedAnnotation,
+	GeneratorAnnotation: () => GeneratorAnnotation,
+	GeneratorAnnotationId: () => GeneratorAnnotationId,
+	HiddenAnnotation: () => HiddenAnnotation,
+	IconAnnotation: () => IconAnnotation,
+	IconFromRefAnnotation: () => IconFromRefAnnotation,
+	Key: () => Key,
+	LabelAnnotation: () => LabelAnnotation,
+	ReferenceAnnotation: () => ReferenceAnnotation,
+	ReferenceAnnotationId: () => ReferenceAnnotationId,
+	TypeAnnotation: () => TypeAnnotation,
+	TypeId: () => TypeId,
+	atom: () => atom,
+	atomProperty: () => atomProperty,
+	buildDictionary: () => buildDictionary,
+	get: () => get,
+	getDescriptionWithSchema: () => getDescriptionWithSchema,
+	getDictionary: () => getDictionary,
+	getFromAst: () => getFromAst,
+	getLabelWithSchema: () => getLabelWithSchema,
+	getTypeAnnotation: () => getTypeAnnotation,
+	getTypeIdentifierAnnotation: () => getTypeIdentifierAnnotation,
+	make: () => make,
+	set: () => set,
+	setDescriptionWithSchema: () => setDescriptionWithSchema,
+	setDictionary: () => setDictionary,
+	setLabelWithSchema: () => setLabelWithSchema,
+	update: () => update
+});
+var TypeId = "~@dxos/echo/Annotation";
+var Key = Key$1;
+/**
+* Create a new schema annotation.
+* Annotation can be assigned both to fields and to the schema itself.
+* Annotation is serialized with the schema.
+*
+* @example
+* ```ts
+* const ColorAnnotation = Annotation.make({
+*   id: 'org.dxos.annotation.color',
+*   schema: Schema.String,
+* });
+*
+* const schema = Schema.String.annotations(ColorAnnotation.set('red'));
+* ```
+*/
+var make = makeUserAnnotation;
+/**
+* Get the value of an annotation from an entity instance or snapshot.
+* For schema-level reads use the annotation instance method (e.g. `ColorAnnotation.get(schema)`).
+* For getting an annotation value from a dictionary, use `getDictionary`.
+*
+* The value is read-only (schema types are readonly by default): to mutate an annotation (including
+* in-place array splices) use `Annotation.update` or `Annotation.set`, which open a change transaction.
+* A read-only return is sound regardless of context — the reactive proxy rejects mutation outside an
+* `Obj.update`.
+*/
+var get = Function.dual(2, (target, annotation) => {
+	return get$1(target, annotation);
+});
+/**
+* Set the value of an annotation on an entity instance.
+* For schema-level writes use the annotation instance method (e.g. `ColorAnnotation.set('red')`).
+* For setting an annotation value on a dictionary, use `setDictionary`.
+*/
+var set = Function.dual(3, (target, annotation, value) => {
+	return set$1(target, annotation, value);
+});
+/**
+* Mutate an existing annotation value in place via a callback, wrapping the mutation in a change
+* transaction (like `Obj.update`). The result is validated against the annotation's schema. Use when
+* only an annotation needs to change; to mutate it alongside other changes (unvalidated), call
+* `Annotation.get` inside an existing `Obj.update` instead. No-op when absent.
+*/
+var update = (target, annotation, mutator) => update$1(target, annotation, mutator);
+var getFromAst = Function.dual(2, (ast, annotation) => {
+	return getFromAst$1(ast, annotation);
+});
+/**
+* Reactive atom for an annotation value on an entity instance.
+* Fires only when the annotation value changes (mirrors `Obj.atom`, scoped to one annotation).
+*/
+var atom = makeAtom;
+/**
+* Reactive atom for a single key of a record-valued annotation on an entity instance.
+* Reactivity is scoped to that key, and the value type is preserved (mirrors `Obj.atomProperty`).
+*/
+var atomProperty = makeProperty;
+/**
+* Set of annotation values.
+*
+* Can be used inside an object/relation schema:
+*
+* ```ts
+* const Person = Schema.Struct({
+*   name: Schema.String,
+*   extensions: Annotation.Dictionary,
+* });
+* ```
+*/
+var Dictionary = Dictionary$1;
+/**
+* Get the value of an annotation from a Dictionary.
+*/
+var getDictionary = Function.dual(2, (values, annotation) => {
+	return getDictionary$1(values, annotation);
+});
+/**
+* Set the value of an annotation in a Dictionary.
+*
+* Can also be used within Obj.update callback:
+*
+* ```ts
+* Obj.update(obj, (obj) => {
+*   Annotation.setDictionary(obj.annotations, ColorAnnotation, 'red');
+* });
+* ```
+*/
+var setDictionary = Function.dual(3, (values, annotation, value) => {
+	return setDictionary$1(values, annotation, value);
+});
+/**
+* Build a dictionary by mutating it in a callback.
+*
+* @example
+* ```ts
+* const dictionary = Annotation.buildDictionary((dictionary) => {
+*   Annotation.setDictionary(dictionary, ColorAnnotation, 'red');
+*   Annotation.setDictionary(dictionary, SizeAnnotation, '10px');
+* });
+* ```
+*/
+var buildDictionary = (build) => {
+	const dictionary = Schema.encodeSync(Dictionary)({});
+	build(dictionary);
+	return dictionary;
+};
+//#endregion
+export { atom as a, get as c, make as d, set as f, TypeId as i, getDictionary as l, update as m, Dictionary as n, atomProperty as o, setDictionary as p, Key as r, buildDictionary as s, Annotation_exports as t, getFromAst as u };
+
+//# sourceMappingURL=chunk-Annotation.mjs.map

package/dist/lib/chunk-Annotation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-Annotation.mjs","names":[],"sources":["../../src/internal/Annotation/atoms.ts","../../src/Annotation.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Atom from '@effect-atom/atom/Atom';\nimport * as Data from 'effect/Data';\nimport * as Option from 'effect/Option';\n\nimport { assertArgument } from '@dxos/invariant';\n\nimport type * as Annotation from '../../Annotation';\nimport type * as Entity from '../../Entity';\nimport { snapshotForComparison } from '../common/atom-snapshot';\nimport { subscribe } from '../common/proxy/reactive';\nimport { isEntity } from '../Entity';\nimport { get as getAnnotation } from './entity-dictionary';\n\n/**\n * Atom family for an annotation value on an entity instance.\n * Mirrors the object-property atom family: re-emits a fresh reference whenever the entity changes\n * (so an in-place array mutation is observed) and dedupes primitive values via `!==`.\n */\nconst annotationFamily = Atom.family((target: Entity.Unknown) =>\n  Atom.family(<T>(annotation: Annotation.Annotation<T>): Atom.Atom<Option.Option<T>> => {\n    const read = (): Option.Option<T> => Option.map(getAnnotation(target, annotation), snapshotForComparison);\n\n    return Atom.make<Option.Option<T>>((get) => {\n      let previous = read();\n\n      const unsubscribe = subscribe(target, () => {\n        const next = read();\n        if (!sameOption(previous, next)) {\n          previous = next;\n          get.setSelf(next);\n        }\n      });\n      get.addFinalizer(() => unsubscribe());\n\n      return previous;\n    }).pipe(Atom.keepAlive);\n  }),\n);\n\n/**\n * Atom family for a single key of a record-valued annotation on an entity instance.\n * Keyed by a value-equal `Data.tuple([target, annotation, key])` so nested families are avoided.\n */\nconst annotationPropertyFamily = Atom.family(\n  ([target, annotation, key]: readonly [\n    Entity.Unknown,\n    Annotation.Annotation<Record<string, any>>,\n    string,\n  ]): Atom.Atom<any> => {\n    const read = (): unknown =>\n      getAnnotation(target, annotation).pipe(\n        Option.map((value) => snapshotForComparison(value[key])),\n        Option.getOrUndefined,\n      );\n\n    return Atom.make<unknown>((get) => {\n      let previous = read();\n\n      const unsubscribe = subscribe(target, () => {\n        const next = read();\n        if (next !== previous) {\n          previous = next;\n          get.setSelf(next);\n        }\n      });\n      get.addFinalizer(() => unsubscribe());\n\n      return previous;\n    }).pipe(Atom.keepAlive);\n  },\n);\n\n/** Equal when both empty, or both present with the same (snapshotted) value. */\nconst sameOption = <T>(a: Option.Option<T>, b: Option.Option<T>): boolean =>\n  Option.isNone(a) || Option.isNone(b) ? Option.isNone(a) && Option.isNone(b) : a.value === b.value;\n\n/**\n * Reactive atom for an annotation value on an entity instance. Emits a shallow snapshot (a fresh\n * reference for objects/arrays) so dependent atoms recompute on change. Mirrors {@link makeProperty}.\n */\nexport const makeAtom = <T>(\n  target: Entity.Unknown,\n  annotation: Annotation.Annotation<T>,\n): Atom.Atom<Option.Option<T>> => {\n  assertArgument(isEntity(target), 'target', 'Must be a reactive ECHO entity');\n  return annotationFamily(target)(annotation);\n};\n\n/**\n * Reactive atom for a single key of a record-valued annotation on an entity instance.\n */\nexport const makeProperty = <V>(\n  target: Entity.Unknown,\n  annotation: Annotation.Annotation<Record<string, V>>,\n  key: string,\n): Atom.Atom<V | undefined> => {\n  assertArgument(isEntity(target), 'target', 'Must be a reactive ECHO entity');\n  // The flattened family key is a single concrete tuple type, so the generic `V` is erased at the\n  // family boundary and recovered here; no typed alternative exists for a per-call-generic family.\n  return annotationPropertyFamily(\n    Data.tuple(target, annotation as Annotation.Annotation<Record<string, any>>, key),\n  ) as Atom.Atom<V | undefined>;\n};\n","//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nexport {\n  DEFAULT_LAYOUT_NAME,\n  DescriptionAnnotation,\n  FieldLookupAnnotationId,\n  FormCreateAnnotation,\n  FormCreateAnnotationId,\n  FormInlineAnnotation,\n  FormInputAnnotation,\n  FormLayoutAnnotation,\n  FormLayoutAnnotationId,\n  type FormLayoutMap,\n  FormOrderedAnnotation,\n  GeneratorAnnotation,\n  GeneratorAnnotationId,\n  type GeneratorAnnotationValue,\n  HiddenAnnotation,\n  IconAnnotation,\n  IconFromRefAnnotation,\n  LabelAnnotation,\n  ReferenceAnnotation,\n  ReferenceAnnotationId,\n  type ReferenceAnnotationValue,\n  TypeAnnotation,\n  getDescriptionWithSchema,\n  getLabelWithSchema,\n  getTypeAnnotation,\n  getTypeIdentifierAnnotation,\n  setDescriptionWithSchema,\n  setLabelWithSchema,\n} from './internal/Annotation';\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport * as Types from 'effect/Types';\n\nimport * as Entity from './Entity';\nimport * as internalAnnotations from './internal/Annotation';\nimport * as annotationAtoms from './internal/Annotation/atoms';\n\nexport const TypeId = '~@dxos/echo/Annotation' as const;\nexport type TypeId = typeof TypeId;\n\n// TODO(dmaretskyi): Reconcile different get/set styles: mutate in-place, return.\n// TODO(dmaretskyi): Reconcile Annotation methods vs static functions.\n// TODO(dmaretskyi): Reconcile Annotation.Key vs DXN -- work-out approach to versioning.\n\n/**\n * Annotation is a typed property that can be assigned to a schema or an entity instance.\n */\nexport interface Annotation<T> {\n  [TypeId]: {\n    _Type: T;\n  };\n\n  // TODO(dmaretskyi): Make this a DXN?\n  /**\n   * Unique fully-qualified identifier for the annotation.\n   * @example \"org.dxos.annotation.color\"\n   */\n  readonly key: Key;\n\n  /**\n   * Schema of the annotation value.\n   */\n  readonly schema: Schema.Schema<T, unknown, never>;\n\n  /**\n   * Get the annotation value from an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — to read an annotation off a `Type.Type`\n   * entity, unwrap it first with `Type.getSchema(entity)`. This keeps the\n   * annotation pipeline single-shaped and forces annotations to live on the\n   * source schema, not on the post-construction Type entity.\n   */\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  /**\n   * Get the annotation value from the AST.\n   */\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  /**\n   * Set the annotation on an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — annotations must be applied to the\n   * source schema BEFORE wrapping it with `Type.makeObject` / `Type.makeRelation`.\n   * In a pipe, place every `Annotation.X.set(...)` before the `Type.make...` step.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\nexport const Key = internalAnnotations.Key;\nexport type Key = Schema.Schema.Type<typeof Key>;\n\ninterface MakeProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n/**\n * Create a new schema annotation.\n * Annotation can be assigned both to fields and to the schema itself.\n * Annotation is serialized with the schema.\n *\n * @example\n * ```ts\n * const ColorAnnotation = Annotation.make({\n *   id: 'org.dxos.annotation.color',\n *   schema: Schema.String,\n * });\n *\n * const schema = Schema.String.annotations(ColorAnnotation.set('red'));\n * ```\n */\nexport const make: <T>(props: MakeProps<T>) => Annotation<T> = internalAnnotations.makeUserAnnotation;\n\n/**\n * Get the value of an annotation from an entity instance or snapshot.\n * For schema-level reads use the annotation instance method (e.g. `ColorAnnotation.get(schema)`).\n * For getting an annotation value from a dictionary, use `getDictionary`.\n *\n * The value is read-only (schema types are readonly by default): to mutate an annotation (including\n * in-place array splices) use `Annotation.update` or `Annotation.set`, which open a change transaction.\n * A read-only return is sound regardless of context — the reactive proxy rejects mutation outside an\n * `Obj.update`.\n */\nexport const get: {\n  <T>(annotation: Annotation<T>): (target: Entity.Unknown | Entity.Snapshot) => Option.Option<T>;\n  <T>(target: Entity.Unknown | Entity.Snapshot, annotation: Annotation<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(annotation: Annotation<T>) => (target: Entity.Unknown | Entity.Snapshot) => Option.Option<T>,\n  <T>(target: Entity.Unknown | Entity.Snapshot, annotation: Annotation<T>) => Option.Option<T>\n>(2, (target, annotation) => {\n  return internalAnnotations.get(target, annotation);\n});\n\n/**\n * Set the value of an annotation on an entity instance.\n * For schema-level writes use the annotation instance method (e.g. `ColorAnnotation.set('red')`).\n * For setting an annotation value on a dictionary, use `setDictionary`.\n */\nexport const set: {\n  <T>(annotation: Annotation<T>, value: T): (target: Entity.Mutable<Entity.Unknown>) => void;\n  <T>(target: Entity.Mutable<Entity.Unknown>, annotation: Annotation<T>, value: T): void;\n} = Function.dual<\n  <T>(annotation: Annotation<T>, value: T) => (target: Entity.Mutable<Entity.Unknown>) => void,\n  <T>(target: Entity.Mutable<Entity.Unknown>, annotation: Annotation<T>, value: T) => void\n>(3, (target, annotation, value) => {\n  return internalAnnotations.set(target, annotation, value);\n});\n\n/**\n * Mutate an existing annotation value in place via a callback, wrapping the mutation in a change\n * transaction (like `Obj.update`). The result is validated against the annotation's schema. Use when\n * only an annotation needs to change; to mutate it alongside other changes (unvalidated), call\n * `Annotation.get` inside an existing `Obj.update` instead. No-op when absent.\n */\nexport const update = <T>(\n  target: Entity.Unknown,\n  annotation: Annotation<T>,\n  mutator: (value: Entity.Mutable<T>) => void,\n): void => internalAnnotations.update(target, annotation, mutator);\n\nexport const getFromAst: {\n  <T>(annotation: Annotation<T>): (ast: SchemaAST.AST) => Option.Option<T>;\n  <T>(ast: SchemaAST.AST, annotation: Annotation<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(annotation: Annotation<T>) => (ast: SchemaAST.AST) => Option.Option<T>,\n  <T>(ast: SchemaAST.AST, annotation: Annotation<T>) => Option.Option<T>\n>(2, (ast, annotation) => {\n  return internalAnnotations.getFromAst(ast, annotation);\n});\n\n/**\n * Reactive atom for an annotation value on an entity instance.\n * Fires only when the annotation value changes (mirrors `Obj.atom`, scoped to one annotation).\n */\nexport const atom = annotationAtoms.makeAtom;\n\n/**\n * Reactive atom for a single key of a record-valued annotation on an entity instance.\n * Reactivity is scoped to that key, and the value type is preserved (mirrors `Obj.atomProperty`).\n */\nexport const atomProperty = annotationAtoms.makeProperty;\n\n/**\n * Set of annotation values.\n *\n * Can be used inside an object/relation schema:\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n *   extensions: Annotation.Dictionary,\n * });\n * ```\n */\nexport const Dictionary = internalAnnotations.Dictionary;\nexport interface Dictionary extends Schema.Schema.Type<typeof Dictionary> {}\n\n/**\n * Get the value of an annotation from a Dictionary.\n */\nexport const getDictionary: {\n  <T>(annotation: Annotation<T>): (values: Dictionary) => Option.Option<T>;\n  <T>(values: Dictionary, annotation: Annotation<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(annotation: Annotation<T>) => (values: Dictionary) => Option.Option<T>,\n  <T>(values: Dictionary, annotation: Annotation<T>) => Option.Option<T>\n>(2, (values, annotation) => {\n  return internalAnnotations.getDictionary(values, annotation);\n});\n\n/**\n * Set the value of an annotation in a Dictionary.\n *\n * Can also be used within Obj.update callback:\n *\n * ```ts\n * Obj.update(obj, (obj) => {\n *   Annotation.setDictionary(obj.annotations, ColorAnnotation, 'red');\n * });\n * ```\n */\nexport const setDictionary: {\n  <T>(annotation: Annotation<T>, value: T): (values: Dictionary) => void;\n  <T>(values: Types.Mutable<Dictionary>, annotation: Annotation<T>, value: T): void;\n} = Function.dual<\n  <T>(annotation: Annotation<T>, value: T) => (values: Dictionary) => void,\n  <T>(values: Types.Mutable<Dictionary>, annotation: Annotation<T>, value: T) => void\n>(3, (values, annotation, value) => {\n  return internalAnnotations.setDictionary(values, annotation, value);\n});\n\n/**\n * Build a dictionary by mutating it in a callback.\n *\n * @example\n * ```ts\n * const dictionary = Annotation.buildDictionary((dictionary) => {\n *   Annotation.setDictionary(dictionary, ColorAnnotation, 'red');\n *   Annotation.setDictionary(dictionary, SizeAnnotation, '10px');\n * });\n * ```\n */\nexport const buildDictionary = (build: (dictionary: Types.Mutable<Dictionary>) => void): Dictionary => {\n  const dictionary = Schema.encodeSync(Dictionary)({});\n  build(dictionary);\n  return dictionary;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAsBA,IAAM,mBAAmB,KAAK,QAAQ,WACpC,KAAK,QAAW,eAAsE;CACpF,MAAM,aAA+B,OAAO,IAAI,MAAc,QAAQ,UAAU,GAAG,qBAAqB;CAExG,OAAO,KAAK,MAAwB,QAAQ;EAC1C,IAAI,WAAW,KAAK;EAEpB,MAAM,cAAc,UAAU,cAAc;GAC1C,MAAM,OAAO,KAAK;GAClB,IAAI,CAAC,WAAW,UAAU,IAAI,GAAG;IAC/B,WAAW;IACX,IAAI,QAAQ,IAAI;GAClB;EACF,CAAC;EACD,IAAI,mBAAmB,YAAY,CAAC;EAEpC,OAAO;CACT,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS;AACxB,CAAC,CACH;;;;;AAMA,IAAM,2BAA2B,KAAK,QACnC,CAAC,QAAQ,YAAY,SAIA;CACpB,MAAM,aACJ,MAAc,QAAQ,UAAU,CAAC,CAAC,KAChC,OAAO,KAAK,UAAU,sBAAsB,MAAM,IAAI,CAAC,GACvD,OAAO,cACT;CAEF,OAAO,KAAK,MAAe,QAAQ;EACjC,IAAI,WAAW,KAAK;EAEpB,MAAM,cAAc,UAAU,cAAc;GAC1C,MAAM,OAAO,KAAK;GAClB,IAAI,SAAS,UAAU;IACrB,WAAW;IACX,IAAI,QAAQ,IAAI;GAClB;EACF,CAAC;EACD,IAAI,mBAAmB,YAAY,CAAC;EAEpC,OAAO;CACT,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS;AACxB,CACF;;AAGA,IAAM,cAAiB,GAAqB,MAC1C,OAAO,OAAO,CAAC,KAAK,OAAO,OAAO,CAAC,IAAI,OAAO,OAAO,CAAC,KAAK,OAAO,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE;;;;;AAM9F,IAAa,YACX,QACA,eACgC;CAChC,eAAe,SAAS,MAAM,GAAG,UAAU,gCAAgC;CAC3E,OAAO,iBAAiB,MAAM,CAAC,CAAC,UAAU;AAC5C;;;;AAKA,IAAa,gBACX,QACA,YACA,QAC6B;CAC7B,eAAe,SAAS,MAAM,GAAG,UAAU,gCAAgC;CAG3E,OAAO,yBACL,KAAK,MAAM,QAAQ,YAA0D,GAAG,CAClF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3DA,IAAa,SAAS;AAkDtB,IAAa,MAAM;;;;;;;;;;;;;;;;AAuBnB,IAAa,OAAkD;;;;;;;;;;;AAY/D,IAAa,MAGT,SAAS,KAGX,IAAI,QAAQ,eAAe;CAC3B,OAAO,MAAwB,QAAQ,UAAU;AACnD,CAAC;;;;;;AAOD,IAAa,MAGT,SAAS,KAGX,IAAI,QAAQ,YAAY,UAAU;CAClC,OAAO,MAAwB,QAAQ,YAAY,KAAK;AAC1D,CAAC;;;;;;;AAQD,IAAa,UACX,QACA,YACA,YACS,SAA2B,QAAQ,YAAY,OAAO;AAEjE,IAAa,aAGT,SAAS,KAGX,IAAI,KAAK,eAAe;CACxB,OAAO,aAA+B,KAAK,UAAU;AACvD,CAAC;;;;;AAMD,IAAa,OAAO;;;;;AAMpB,IAAa,eAAe;;;;;;;;;;;;;AAc5B,IAAa,aAAa;;;;AAM1B,IAAa,gBAGT,SAAS,KAGX,IAAI,QAAQ,eAAe;CAC3B,OAAO,gBAAkC,QAAQ,UAAU;AAC7D,CAAC;;;;;;;;;;;;AAaD,IAAa,gBAGT,SAAS,KAGX,IAAI,QAAQ,YAAY,UAAU;CAClC,OAAO,gBAAkC,QAAQ,YAAY,KAAK;AACpE,CAAC;;;;;;;;;;;;AAaD,IAAa,mBAAmB,UAAuE;CACrG,MAAM,aAAa,OAAO,WAAW,UAAU,CAAC,CAAC,CAAC,CAAC;CACnD,MAAM,UAAU;CAChB,OAAO;AACT"}