@dxos/echo 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/dist/lib/neutral/chunk-XL5OYQ4X.mjs

@@ -0,0 +1,354 @@
+import {
+  isRef
+} from "./chunk-GMAUO3CE.mjs";
+import {
+  getDXN,
+  prettyFilter
+} from "./chunk-LLK3YB3N.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-4U7YKZUA.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Filter.ts
+var Filter_exports = {};
+__export(Filter_exports, {
+  and: () => and,
+  between: () => between,
+  childOf: () => childOf,
+  contains: () => contains,
+  created: () => created,
+  eq: () => eq,
+  everything: () => everything,
+  foreignKeys: () => foreignKeys,
+  fromAst: () => fromAst,
+  gt: () => gt,
+  gte: () => gte,
+  id: () => id,
+  in: () => in$,
+  is: () => is,
+  lt: () => lt,
+  lte: () => lte,
+  neq: () => neq,
+  not: () => not,
+  nothing: () => nothing,
+  or: () => or,
+  pretty: () => pretty,
+  props: () => props,
+  tag: () => tag,
+  text: () => text,
+  type: () => type,
+  typeDXN: () => typeDXN,
+  typename: () => typename,
+  updated: () => updated
+});
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument } from "@dxos/invariant";
+import { DXN, ObjectId } from "@dxos/keys";
+var FilterClass = class _FilterClass {
+  ast;
+  static "variance" = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Filter" = _FilterClass.variance;
+};
+var is = (value2) => {
+  return typeof value2 === "object" && value2 !== null && "~Filter" in value2;
+};
+var fromAst = (ast) => {
+  return new FilterClass(ast);
+};
+var everything = () => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    props: {}
+  });
+};
+var nothing = () => {
+  return new FilterClass({
+    type: "not",
+    filter: {
+      type: "object",
+      typename: null,
+      props: {}
+    }
+  });
+};
+var id = (...ids) => {
+  assertArgument(ids.every((id2) => ObjectId.isValid(id2)), "ids", "ids must be valid");
+  if (ids.length === 0) {
+    return nothing();
+  }
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    id: ids,
+    props: {}
+  });
+};
+var type = (schema, props2) => {
+  if (Schema.isSchema(schema) && SchemaAST.isUnion(schema.ast)) {
+    const typenames = schema.ast.types.map((type2) => getTypeDXNFromSpecifier(Schema.make(type2)));
+    return new FilterClass({
+      type: "or",
+      filters: typenames.map((typename2) => ({
+        type: "object",
+        typename: typename2.toString(),
+        props: {}
+      }))
+    });
+  }
+  const dxn = getTypeDXNFromSpecifier(schema);
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    ...propsFilterToAst(props2 ?? {})
+  });
+};
+var typename = (typename2) => {
+  assertArgument(!typename2.startsWith("dxn:"), "typename", "Typename must no be qualified");
+  return new FilterClass({
+    type: "object",
+    typename: DXN.fromTypename(typename2).toString(),
+    props: {}
+  });
+};
+var typeDXN = (dxn) => {
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    props: {}
+  });
+};
+var tag = (tag2) => {
+  return new FilterClass({
+    type: "tag",
+    tag: tag2
+  });
+};
+var props = (props2) => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    ...propsFilterToAst(props2)
+  });
+};
+var text = (text2, options) => {
+  return new FilterClass({
+    type: "text-search",
+    text: text2,
+    searchKind: options?.type
+  });
+};
+var foreignKeys = (schema, keys) => {
+  const dxn = getTypeDXNFromSpecifier(schema);
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    props: {},
+    foreignKeys: keys
+  });
+};
+var eq = (value2) => {
+  if (!isRef(value2) && typeof value2 === "object" && value2 !== null) {
+    throw new TypeError("Cannot use object as a value for eq filter");
+  }
+  return new FilterClass({
+    type: "compare",
+    operator: "eq",
+    value: isRef(value2) ? value2.noInline().encode() : value2
+  });
+};
+var neq = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "neq",
+    value: value2
+  });
+};
+var gt = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "gt",
+    value: value2
+  });
+};
+var gte = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "gte",
+    value: value2
+  });
+};
+var lt = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "lt",
+    value: value2
+  });
+};
+var lte = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "lte",
+    value: value2
+  });
+};
+var in$ = (...values) => {
+  return new FilterClass({
+    type: "in",
+    values
+  });
+};
+var contains = (value2) => {
+  return new FilterClass({
+    type: "contains",
+    value: value2
+  });
+};
+var between = (from, to) => {
+  return new FilterClass({
+    type: "range",
+    from,
+    to
+  });
+};
+var _toUnixMs = (date) => typeof date === "number" ? date : date.getTime();
+var _timeRangeFilter = (field, range) => {
+  const filters = [];
+  if (range.after != null) {
+    filters.push(new FilterClass({
+      type: "timestamp",
+      field,
+      operator: "gte",
+      value: _toUnixMs(range.after)
+    }));
+  }
+  if (range.before != null) {
+    filters.push(new FilterClass({
+      type: "timestamp",
+      field,
+      operator: "lte",
+      value: _toUnixMs(range.before)
+    }));
+  }
+  if (filters.length === 0) {
+    return everything();
+  }
+  return filters.length === 1 ? filters[0] : and(...filters);
+};
+var updated = (range) => _timeRangeFilter("updatedAt", range);
+var created = (range) => _timeRangeFilter("createdAt", range);
+var childOf = (parents, options) => {
+  const items = Array.isArray(parents) ? parents : [
+    parents
+  ];
+  const dxns = items.map((item) => {
+    if (isRef(item)) {
+      return item.dxn.toString();
+    }
+    return getDXN(item).toString();
+  });
+  return new FilterClass({
+    type: "child-of",
+    parents: dxns,
+    transitive: options?.transitive ?? true
+  });
+};
+var not = (filter) => {
+  return new FilterClass({
+    type: "not",
+    filter: filter.ast
+  });
+};
+var and = (...filters) => {
+  return new FilterClass({
+    type: "and",
+    filters: filters.map((f) => f.ast)
+  });
+};
+var or = (...filters) => {
+  return new FilterClass({
+    type: "or",
+    filters: filters.map((f) => f.ast)
+  });
+};
+var propsFilterToAst = (predicates) => {
+  let idFilter;
+  if ("id" in predicates) {
+    assertArgument(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
+    idFilter = typeof predicates.id === "string" ? [
+      predicates.id
+    ] : predicates.id;
+    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
+  }
+  return {
+    id: idFilter,
+    props: Object.fromEntries(Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [
+      prop,
+      processPredicate(predicate)
+    ]))
+  };
+};
+var processPredicate = (predicate) => {
+  return Match.value(predicate).pipe(
+    Match.withReturnType(),
+    Match.when(is, (predicate2) => predicate2.ast),
+    // TODO(wittjosiah): Add support for array predicates.
+    Match.when(Array.isArray, (_predicate) => {
+      throw new Error("Array predicates are not yet supported.");
+    }),
+    Match.when((predicate2) => !isRef(predicate2) && typeof predicate2 === "object" && predicate2 !== null, (predicate2) => {
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value2]) => [
+        key,
+        processPredicate(value2)
+      ]));
+      return {
+        type: "object",
+        typename: null,
+        props: nestedProps
+      };
+    }),
+    Match.orElse((value2) => eq(value2).ast)
+  );
+};
+var pretty = (filter) => prettyFilter(filter.ast);
+
+export {
+  is,
+  fromAst,
+  everything,
+  nothing,
+  id,
+  type,
+  typename,
+  typeDXN,
+  tag,
+  props,
+  text,
+  foreignKeys,
+  eq,
+  neq,
+  gt,
+  gte,
+  lt,
+  lte,
+  in$,
+  contains,
+  between,
+  updated,
+  created,
+  childOf,
+  not,
+  and,
+  or,
+  pretty,
+  Filter_exports
+};
+//# sourceMappingURL=chunk-XL5OYQ4X.mjs.map

package/dist/lib/neutral/chunk-XL5OYQ4X.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Filter.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport type * as Obj from './Obj';\nimport * as Ref from './Ref';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Covariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\nexport type Props<T> = {\n  // Predicate or a value as a shorthand for `eq`.\n  [K in keyof T & string]?: Filter<T[K]> | T[K];\n};\n\nexport type Any = Filter<any>;\n\nexport type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\nclass FilterClass implements Any {\n  private static 'variance': Any['~Filter'] = {} as Any['~Filter'];\n\n  constructor(public readonly ast: QueryAST.Filter) {}\n\n  '~Filter' = FilterClass.variance;\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Filter' in value;\n};\n\n/** Construct a filter from an ast. */\nexport const fromAst = (ast: QueryAST.Filter): Any => {\n  return new FilterClass(ast);\n};\n\n/**\n * Filter that matches all objects.\n */\n// TODO(dmaretskyi): `Entity.Any` would be more type-safe, but causes annoying errors in existing code\nexport const everything = (): FilterClass => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n  });\n};\n\n/**\n * Filter that matches no objects.\n */\nexport const nothing = (): FilterClass => {\n  return new FilterClass({\n    type: 'not',\n    filter: {\n      type: 'object',\n      typename: null,\n      props: {},\n    },\n  });\n};\n\n/*\n * Filter by ObjectId.\n */\nexport const id = (...ids: ObjectId[]): Any => {\n  assertArgument(\n    ids.every((id) => ObjectId.isValid(id)),\n    'ids',\n    'ids must be valid',\n  );\n\n  if (ids.length === 0) {\n    return nothing();\n  }\n\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    id: ids,\n    props: {},\n  });\n};\n\n/**\n * Filter by type.\n */\nexport const type = <S extends Schema.Schema.All>(\n  schema: S | string,\n  props?: Props<Schema.Schema.Type<S>>,\n): Filter<Schema.Schema.Type<S>> => {\n  if (Schema.isSchema(schema) && SchemaAST.isUnion(schema.ast)) {\n    const typenames = schema.ast.types.map((type) => internal.getTypeDXNFromSpecifier(Schema.make(type)));\n    return new FilterClass({\n      type: 'or',\n      filters: typenames.map((typename) => ({\n        type: 'object',\n        typename: typename.toString(),\n        props: {},\n      })),\n    });\n  }\n\n  const dxn = internal.getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    ...propsFilterToAst(props ?? {}),\n  });\n};\n\n/**\n * Filter by non-qualified typename.\n */\nexport const typename = (typename: string): Any => {\n  assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');\n  return new FilterClass({\n    type: 'object',\n    typename: DXN.fromTypename(typename).toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by fully qualified type DXN.\n */\nexport const typeDXN = (dxn: DXN): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by tag.\n */\nexport const tag = (tag: string): Any => {\n  return new FilterClass({\n    type: 'tag',\n    tag,\n  });\n};\n\n/**\n * Filter by properties.\n */\nexport const props = <T>(props: Props<T>): Filter<T> => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    ...propsFilterToAst(props),\n  });\n};\n\nexport type TextSearchOptions = {\n  // TODO(dmaretskyi): Hybrid search.\n  type?: 'full-text' | 'vector';\n};\n\n/**\n * Full-text or vector search.\n */\nexport const text = (\n  // TODO(dmaretskyi): Consider passing a vector here, but really the embedding should be done on the query-executor side.\n  text: string,\n  options?: TextSearchOptions,\n): Any => {\n  return new FilterClass({\n    type: 'text-search',\n    text,\n    searchKind: options?.type,\n  });\n};\n\n/**\n * Filter by foreign keys.\n */\nexport const foreignKeys = <S extends Schema.Schema.All>(\n  schema: S | string,\n  keys: ForeignKey[],\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = internal.getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n    foreignKeys: keys,\n  });\n};\n\n/**\n * Predicate for property to be equal to the provided value.\n */\nexport const eq = <T>(value: T): Filter<T | undefined> => {\n  if (!Ref.isRef(value) && typeof value === 'object' && value !== null) {\n    throw new TypeError('Cannot use object as a value for eq filter');\n  }\n\n  return new FilterClass({\n    type: 'compare',\n    operator: 'eq',\n    value: Ref.isRef(value) ? value.noInline().encode() : value,\n  });\n};\n\n/**\n * Predicate for property to be not equal to the provided value.\n */\nexport const neq = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'neq',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than the provided value.\n */\nexport const gt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than or equal to the provided value.\n */\nexport const gte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than the provided value.\n */\nexport const lt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than or equal to the provided value.\n */\nexport const lte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided array.\n * @param values - Values to check against.\n */\nconst in$ = <T>(...values: T[]): Filter<T> => {\n  return new FilterClass({\n    type: 'in',\n    values,\n  });\n};\nexport { in$ as in };\n\n/**\n * Predicate for an array property to contain the provided value.\n * @param value - Value to check against.\n */\nexport const contains = <T>(value: T): Filter<readonly T[] | undefined> => {\n  return new FilterClass({\n    type: 'contains',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided range.\n * @param from - Start of the range (inclusive).\n * @param to - End of the range (exclusive).\n */\nexport const between = <T>(from: T, to: T): Filter<T> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\ntype TimeRange = { after?: Date | number; before?: Date | number };\n\nconst _toUnixMs = (date: Date | number): number => (typeof date === 'number' ? date : date.getTime());\n\nconst _timeRangeFilter = (field: 'updatedAt' | 'createdAt', range: TimeRange): Any => {\n  const filters: Any[] = [];\n  if (range.after != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: _toUnixMs(range.after) }));\n  }\n  if (range.before != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: _toUnixMs(range.before) }));\n  }\n  if (filters.length === 0) {\n    return everything();\n  }\n  return filters.length === 1 ? filters[0] : and(...filters);\n};\n\n/**\n * Filter objects by updatedAt timestamp.\n */\nexport const updated = (range: TimeRange): Any => _timeRangeFilter('updatedAt', range);\n\n/**\n * Filter objects by createdAt timestamp.\n */\nexport const created = (range: TimeRange): Any => _timeRangeFilter('createdAt', range);\n\nexport type ChildOfOptions = {\n  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */\n  transitive?: boolean;\n};\n\n/**\n * Filter objects that are children of the specified parent(s).\n * Accepts ECHO objects, Refs, or arrays of either.\n * Refs are resolved to DXNs without loading; objects use {@link Obj.getDXN}.\n * With transitive=true (default), also matches grandchildren and beyond.\n */\nexport const childOf = (\n  parents: Obj.Unknown | Ref.Unknown | readonly (Obj.Unknown | Ref.Unknown)[],\n  options?: ChildOfOptions,\n): Any => {\n  const items = Array.isArray(parents) ? parents : [parents];\n  const dxns = items.map((item) => {\n    if (Ref.isRef(item)) {\n      return item.dxn.toString();\n    }\n    return internal.getDXN(item).toString();\n  });\n  return new FilterClass({\n    type: 'child-of',\n    parents: dxns,\n    transitive: options?.transitive ?? true,\n  });\n};\n\n/**\n * Negate the filter.\n */\nexport const not = <F extends Any>(filter: F): Filter<Type<F>> => {\n  return new FilterClass({\n    type: 'not',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Combine filters with a logical AND.\n */\nexport const and = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'and',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n/**\n * Combine filters with a logical OR.\n */\nexport const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'or',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n// TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n\nconst propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly ObjectId[] | undefined;\n  if ('id' in predicates) {\n    assertArgument(\n      typeof predicates.id === 'string' || Array.isArray(predicates.id),\n      'predicates.id',\n      'invalid id filter',\n    );\n    idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;\n    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);\n  }\n\n  return {\n    id: idFilter,\n    props: Object.fromEntries(\n      Object.entries(predicates)\n        .filter(([prop, _value]) => prop !== 'id')\n        .map(([prop, predicate]) => [prop, processPredicate(predicate)]),\n    ) as Record<string, QueryAST.Filter>,\n  };\n};\n\nconst processPredicate = (predicate: any): QueryAST.Filter => {\n  return Match.value(predicate).pipe(\n    Match.withReturnType<QueryAST.Filter>(),\n    Match.when(is, (predicate) => predicate.ast),\n    // TODO(wittjosiah): Add support for array predicates.\n    Match.when(Array.isArray, (_predicate) => {\n      throw new Error('Array predicates are not yet supported.');\n    }),\n    Match.when(\n      (predicate: any) => !Ref.isRef(predicate) && typeof predicate === 'object' && predicate !== null,\n      (predicate) => {\n        const nestedProps = Object.fromEntries(\n          Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]),\n        );\n\n        return {\n          type: 'object',\n          typename: null,\n          props: nestedProps,\n        };\n      },\n    ),\n    Match.orElse((value) => eq(value).ast),\n  );\n};\n\n/**\n * Returns a human-readable string representation of a Filter AST.\n */\nexport const pretty = (filter: Any): string => internal.prettyFilter(filter.ast);\n"],
+  "mappings": "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",
+  "names": ["Match", "Schema", "SchemaAST", "assertArgument", "DXN", "ObjectId", "FilterClass", "ast", "variance", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "schema", "isSchema", "isUnion", "typenames", "types", "map", "getTypeDXNFromSpecifier", "make", "filters", "toString", "dxn", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "text", "options", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "_toUnixMs", "date", "getTime", "_timeRangeFilter", "field", "range", "filters", "after", "push", "operator", "before", "length", "everything", "and", "updated", "created", "childOf", "parents", "options", "items", "Array", "isArray", "dxns", "map", "item", "isRef", "dxn", "toString", "getDXN", "transitive", "not", "filter", "ast", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "nestedProps", "key", "typename", "orElse", "eq", "pretty", "prettyFilter"]
+}

package/dist/lib/neutral/chunk-YP4SEMT6.mjs

@@ -0,0 +1,36 @@
+import {
+  getSchemaDXN
+} from "./chunk-4U7YKZUA.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Migration.ts
+var Migration_exports = {};
+__export(Migration_exports, {
+  define: () => define
+});
+var define = (options) => {
+  const fromType = getSchemaDXN(options.from);
+  if (!fromType) {
+    throw new Error("Invalid from schema");
+  }
+  const toType = getSchemaDXN(options.to);
+  if (!toType) {
+    throw new Error("Invalid to schema");
+  }
+  return {
+    fromType,
+    toType,
+    fromSchema: options.from,
+    toSchema: options.to,
+    transform: options.transform,
+    onMigration: options.onMigration
+  };
+};
+
+export {
+  define,
+  Migration_exports
+};
+//# sourceMappingURL=chunk-YP4SEMT6.mjs.map

package/dist/lib/neutral/chunk-YP4SEMT6.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Migration.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type DXN } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { getSchemaDXN } from './internal';\n\ntype DefineObjectMigrationOptions<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {\n  from: From;\n  to: To;\n  /**\n   * Pure function that converts the old object data to the new object data.\n   */\n  // TODO(dmaretskyi): `id` should not be a part of the schema.\n  transform: (\n    from: Schema.Schema.Type<From>,\n    context: ObjectMigrationContext,\n  ) => Promise<Omit<Schema.Schema.Type<To>, 'id' | Entity.KindId>>;\n\n  /**\n   * Callback that is called after the object is migrated. Called for every object that is migrated.\n   *\n   * NOTE: Database mutations performed in this callback are not guaranteed to be idempotent.\n   *       If multiple peers run the migration separately, the effects may be applied multiple times.\n   */\n  onMigration: (params: OnMigrateProps<From, To>) => Promise<void>;\n};\n\n/**\n * Context passed to object migration callbacks.\n */\nexport type ObjectMigrationContext = {\n  db: Database.Database;\n};\n\ntype OnMigrateProps<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {\n  before: Schema.Schema.Type<From>;\n  object: Schema.Schema.Type<To>;\n  db: Database.Database;\n};\n\n/**\n * Definition of a migration from one object schema version to another.\n */\nexport type ObjectMigration = {\n  fromType: DXN;\n  toType: DXN;\n  fromSchema: Schema.Schema.AnyNoContext;\n  toSchema: Schema.Schema.AnyNoContext;\n  transform: (from: unknown, context: ObjectMigrationContext) => Promise<unknown>;\n  onMigration: (params: OnMigrateProps<any, any>) => Promise<void>;\n};\n\n/**\n * Define a migration between two object schemas.\n *\n * @example\n * ```ts\n * const migration = Migration.define({\n *   from: ContactV1,\n *   to: ContactV2,\n *   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),\n *   onMigration: async () => {},\n * });\n * ```\n */\nexport const define = <From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromType = getSchemaDXN(options.from);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaDXN(options.to);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema: options.from,\n    toSchema: options.to,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],
+  "mappings": ";;;;;;;;AAAA;;;;AAyEO,IAAMA,SAAS,CACpBC,YAAAA;AAEA,QAAMC,WAAWC,aAAaF,QAAQG,IAAI;AAC1C,MAAI,CAACF,UAAU;AACb,UAAM,IAAIG,MAAM,qBAAA;EAClB;AACA,QAAMC,SAASH,aAAaF,QAAQM,EAAE;AACtC,MAAI,CAACD,QAAQ;AACX,UAAM,IAAID,MAAM,mBAAA;EAClB;AAEA,SAAO;IACLH;IACAI;IACAE,YAAYP,QAAQG;IACpBK,UAAUR,QAAQM;IAClBG,WAAWT,QAAQS;IACnBC,aAAaV,QAAQU;EACvB;AACF;",
+  "names": ["define", "options", "fromType", "getSchemaDXN", "from", "Error", "toType", "to", "fromSchema", "toSchema", "transform", "onMigration"]
+}

package/dist/lib/neutral/chunk-YS6Q3XAD.mjs

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Extension.ts
+var Extension_exports = {};
+__export(Extension_exports, {
+  Key: () => Key,
+  TypeId: () => TypeId,
+  Values: () => Values,
+  get: () => get,
+  make: () => make,
+  set: () => set
+});
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+var TypeId = "~@dxos/echo/Extension";
+var make = (key, valueSchema) => {
+  return {
+    [TypeId]: {},
+    key: Key.make(key),
+    valueSchema
+  };
+};
+var Key = Schema.String.pipe(Schema.brand("~@dxos/echo/ExtensionKey"));
+var Values = Schema.Record({
+  key: Key,
+  value: Schema.Unknown
+});
+var get = Function.dual(2, (values, extension) => {
+  if (!(extension.key in values)) {
+    return Option.none();
+  }
+  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);
+});
+var set = Function.dual(3, (values, extension, value) => {
+  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);
+});
+
+export {
+  TypeId,
+  make,
+  Key,
+  Values,
+  get,
+  set,
+  Extension_exports
+};
+//# sourceMappingURL=chunk-YS6Q3XAD.mjs.map

package/dist/lib/neutral/chunk-YS6Q3XAD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Extension.ts"],
+  "sourcesContent": ["// @import-as-namespace\n//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\n// @import-as-namespace\n\n/**\n * Extensions allow objects to contain typed properties that are not part of the schema.\n */\n\nexport const TypeId = '~@dxos/echo/Extension' as const;\nexport type TypeId = typeof TypeId;\n\nexport interface Extension<T> extends Record<\n  TypeId,\n  {\n    _Type: T;\n  }\n> {\n  readonly [TypeId]: {\n    _Type: T;\n  };\n\n  readonly key: Key;\n  readonly valueSchema: Schema.Schema<T>;\n}\n\n/**\n * Create a new typed extension.\n *\n * ```ts\n * const ColorExtension = Extension.make('color', Schema.String);\n *\n * const obj = Obj.make(Person, {\n *   [Obj.Meta]: { keys: [{ source: 'external', id: '123' }] },\n *   name: 'John',\n *   email: 'john@example.com',\n * });\n *\n * Obj.change(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n *\n * console.log(Extension.get(obj.extensions, ColorExtension)); // 'red'\n * ```\n */\nexport const make = <S extends Schema.Schema.AnyNoContext>(\n  key: string,\n  valueSchema: S,\n): Extension<Schema.Schema.Type<S>> => {\n  return {\n    [TypeId]: {} as any,\n    key: Key.make(key),\n    valueSchema,\n  };\n};\n\n/**\n * Unique identifier for an extension.\n */\n// TODO(dmaretskyi): filter to be fully qualified: (e.g., org.dxos.extension.color)\nexport const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/ExtensionKey'));\nexport type Key = Schema.Schema.Type<typeof Key>;\n\n/**\n * Set of extension 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: Extension.Values,\n * });\n * ```\n */\nexport const Values = Schema.Record({ key: Key, value: Schema.Unknown });\nexport interface Values extends Schema.Schema.Type<typeof Values> {}\n\n/**\n * Get the value of an extension from a set of values.\n */\nexport const get: {\n  <T>(extension: Extension<T>): (values: Values) => Option.Option<T>;\n  <T>(values: Values, extension: Extension<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(extension: Extension<T>) => (values: Values) => Option.Option<T>,\n  <T>(values: Values, extension: Extension<T>) => Option.Option<T>\n>(2, (values, extension) => {\n  if (!(extension.key in values)) {\n    return Option.none();\n  }\n\n  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);\n});\n\n/**\n * Set the value of an extension in a set of values.\n *\n * Can also be used within Obj.change callback:\n *\n * ```ts\n * Obj.change(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n * ```\n */\nexport const set: {\n  <T>(extension: Extension<T>, value: T): (values: Values) => void;\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T): void;\n} = Function.dual<\n  <T>(extension: Extension<T>, value: T) => (values: Values) => void,\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T) => void\n>(3, (values, extension, value) => {\n  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);\n});\n"],
+  "mappings": ";;;;;AAAA;;;;;;;;;AAKA,YAAYA,cAAc;AAC1B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AASjB,IAAMC,SAAS;AAoCf,IAAMC,OAAO,CAClBC,KACAC,gBAAAA;AAEA,SAAO;IACL,CAACH,MAAAA,GAAS,CAAC;IACXE,KAAKE,IAAIH,KAAKC,GAAAA;IACdC;EACF;AACF;AAMO,IAAMC,MAAaC,cAAOC,KAAYC,aAAM,0BAAA,CAAA;AAe5C,IAAMC,SAAgBC,cAAO;EAAEP,KAAKE;EAAKM,OAAcC;AAAQ,CAAA;AAM/D,IAAMC,MAGAC,cAGX,GAAG,CAACC,QAAQC,cAAAA;AACZ,MAAI,EAAEA,UAAUb,OAAOY,SAAS;AAC9B,WAAcE,YAAI;EACpB;AAEA,SAAgBV,cAAKQ,OAAOC,UAAUb,GAAG,GAAUe,yBAAkBF,UAAUZ,WAAW,GAAUe,WAAI;AAC1G,CAAA;AAaO,IAAMC,MAGAN,cAGX,GAAG,CAACC,QAAQC,WAAWL,UAAAA;AACvBI,SAAOC,UAAUb,GAAG,IAAWkB,kBAAWL,UAAUZ,WAAW,EAAEO,KAAAA;AACnE,CAAA;",
+  "names": ["Function", "Option", "Schema", "TypeId", "make", "key", "valueSchema", "Key", "String", "pipe", "brand", "Values", "Record", "value", "Unknown", "get", "dual", "values", "extension", "none", "decodeUnknownSync", "some", "set", "encodeSync"]
+}

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,105 @@
+import {
+  Collection_exports,
+  DXN,
+  Dataset_exports,
+  Hypergraph_exports,
+  QueryAST,
+  View_exports
+} from "./chunk-WOEEIQWU.mjs";
+import {
+  SchemaRegistry_exports
+} from "./chunk-BNCCGLJN.mjs";
+import {
+  Tag_exports
+} from "./chunk-F7EQRJWJ.mjs";
+import {
+  Order_exports
+} from "./chunk-UI6MWK5W.mjs";
+import {
+  Key_exports
+} from "./chunk-ANHVGJI4.mjs";
+import {
+  Migration_exports
+} from "./chunk-YP4SEMT6.mjs";
+import {
+  Extension_exports
+} from "./chunk-YS6Q3XAD.mjs";
+import {
+  Format_exports
+} from "./chunk-GZQTCRJB.mjs";
+import {
+  Relation_exports
+} from "./chunk-2DJT26P7.mjs";
+import {
+  JsonSchema_exports
+} from "./chunk-6ZQHG2VX.mjs";
+import {
+  QueryResult_exports
+} from "./chunk-OMUPQMLR.mjs";
+import {
+  Query_exports
+} from "./chunk-B4NP3BY3.mjs";
+import {
+  Feed_exports
+} from "./chunk-3Y6LSSJR.mjs";
+import {
+  Type_exports
+} from "./chunk-OX5WOJZ2.mjs";
+import {
+  Filter_exports
+} from "./chunk-XL5OYQ4X.mjs";
+import {
+  Obj_exports
+} from "./chunk-LSMJDE57.mjs";
+import {
+  Ref_exports
+} from "./chunk-GMAUO3CE.mjs";
+import {
+  Entity_exports
+} from "./chunk-IKAO54M4.mjs";
+import "./chunk-LLK3YB3N.mjs";
+import "./chunk-LZR62GOA.mjs";
+import "./chunk-SZJKLCFE.mjs";
+import "./chunk-DQYLD2RB.mjs";
+import "./chunk-SRYQFSA4.mjs";
+import {
+  Annotation_exports
+} from "./chunk-WABNQYKV.mjs";
+import {
+  Database_exports
+} from "./chunk-HQSGCJPL.mjs";
+import "./chunk-4U7YKZUA.mjs";
+import "./chunk-TBKX6JQO.mjs";
+import {
+  Err_exports
+} from "./chunk-UBEZSGXY.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  Annotation_exports as Annotation,
+  Collection_exports as Collection,
+  DXN,
+  Database_exports as Database,
+  Dataset_exports as Dataset,
+  Entity_exports as Entity,
+  Err_exports as Err,
+  Extension_exports as Extension,
+  Feed_exports as Feed,
+  Filter_exports as Filter,
+  Format_exports as Format,
+  Hypergraph_exports as Hypergraph,
+  JsonSchema_exports as JsonSchema,
+  Key_exports as Key,
+  Migration_exports as Migration,
+  Obj_exports as Obj,
+  Order_exports as Order,
+  Query_exports as Query,
+  QueryAST,
+  QueryResult_exports as QueryResult,
+  Ref_exports as Ref,
+  Relation_exports as Relation,
+  SchemaRegistry_exports as SchemaRegistry,
+  Tag_exports as Tag,
+  Type_exports as Type,
+  View_exports as View
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}