@dxos/echo 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

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

@@ -0,0 +1,43 @@
+import {
+  Ref,
+  RefArray,
+  getSchemaReference
+} from "./chunk-PP4DNUZU.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Ref.ts
+var Ref_exports = {};
+__export(Ref_exports, {
+  Array: () => Array,
+  Ref: () => Ref2,
+  fromDXN: () => fromDXN,
+  isRef: () => isRef,
+  isRefType: () => isRefType,
+  make: () => make
+});
+import * as Option from "effect/Option";
+import * as SchemaAST from "effect/SchemaAST";
+var Ref2 = Ref;
+var Array = RefArray;
+var isRef = Ref.isRef;
+var make = Ref.make;
+var fromDXN = Ref.fromDXN;
+var isRefType = (ast) => {
+  return SchemaAST.getAnnotation(ast, SchemaAST.JSONSchemaAnnotationId).pipe(Option.flatMap((jsonSchema) => "$id" in jsonSchema ? Option.some(jsonSchema) : Option.none()), Option.flatMap((jsonSchema) => {
+    const { typename } = getSchemaReference(jsonSchema) ?? {};
+    return typename ? Option.some(true) : Option.some(false);
+  }), Option.getOrElse(() => false));
+};
+
+export {
+  Ref2 as Ref,
+  Array,
+  isRef,
+  make,
+  fromDXN,
+  isRefType,
+  Ref_exports
+};
+//# sourceMappingURL=chunk-QXF3LGN2.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport type * as Entity from './Entity';\nimport * as internal from './internal';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\n\n/**\n * Instance type for a reference.\n *\n * Reference can point to any object or relation.\n * References are lazy loaded.\n *\n * `ref.dxn` is the DXN of the referenced object.\n *\n * @example\n * ```ts\n * const taskRef: Ref<Task> = Ref.make(task);\n *\n * await taskRef.load(); // Returns Promise<Task>\n * yield* Database.load(taskRef); // Effectful version.\n *\n * database.makeRef(dxn); // Create a ref from a DXN.\n * ```\n */\nexport type Ref<T> = internal.Ref<T>;\nexport type Unknown = internal.Ref<Obj.Unknown>;\n\n/**\n * Factory function to create a Ref schema for the given target schema.\n * Use this in schema definitions to declare reference fields.\n *\n * @example\n * ```ts\n * const Task = Schema.Struct({\n *   assignee: Ref.Ref(Person),  // Creates a Ref schema\n * }).pipe(Type.object({ typename: 'Task', version: '0.1.0' }));\n * ```\n */\nexport const Ref: <S extends Schema.Schema.Any>(schema: S) => RefSchema<Schema.Schema.Type<S>> = internal.Ref;\n\nexport const Array = internal.RefArray;\n\n/**\n * TypeScript type for a Ref schema.\n * This is the type of the SCHEMA itself, not the runtime ref instance.\n * For the instance type, use `Ref.Ref<T>` from the Ref module.\n *\n * @example\n * ```ts\n * // Schema type annotation (rarely needed, usually inferred):\n * const refSchema: Ref.RefSchema<typeof Task> = Ref.Ref(Task);\n *\n * // Instance type annotation (use Ref.Ref instead):\n * const refInstance: Ref.Ref<Task> = Ref.make(task);\n * ```\n */\n// TODO(dmaretskyi): Investigate if we can remove this type.\n//                   Post DX-836 it will become just `Schema.Schema<Ref.Ref<T>>`.\n//                   NOTE: This could be Type.Ref<T> instead, but since it going to be removed, it's better to keep it here, self-contained.\nexport interface RefSchema<T extends Entity.Unknown> extends internal.RefSchema<T> {}\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Unknown> = R extends internal.Ref<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = internal.RefResolver;\n\nexport const isRef: (value: unknown) => value is Unknown = internal.Ref.isRef;\n\nexport const make = internal.Ref.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept DXN.\nexport const fromDXN = internal.Ref.fromDXN;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = internal.getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],
+  "mappings": ";;;;;;;;;;AAAA;;;aAAAA;EAAA;;;;;AAIA,YAAYC,YAAY;AAExB,YAAYC,eAAe;AAuCpB,IAAMC,OAA6FA;AAEnG,IAAMC,QAAiBC;AA+BvB,IAAMC,QAAuDH,IAAIG;AAEjE,IAAMC,OAAgBJ,IAAII;AAG1B,IAAMC,UAAmBL,IAAIK;AAG7B,IAAMC,YAAY,CAACC,QAAAA;AACxB,SAAiBC,wBAAqCD,KAAeE,gCAAsB,EAAEC,KACpFC,eAAQ,CAACC,eAAgB,SAASA,aAAoBC,YAAKD,UAAAA,IAAqBE,YAAI,CAAA,GACpFH,eAAQ,CAACC,eAAAA;AACd,UAAM,EAAEG,SAAQ,IAAcC,mBAAmBJ,UAAAA,KAAe,CAAC;AACjE,WAAOG,WAAkBF,YAAK,IAAA,IAAeA,YAAK,KAAA;EACpD,CAAA,GACOI,iBAAU,MAAM,KAAA,CAAA;AAE3B;",
+  "names": ["Ref", "Option", "SchemaAST", "Ref", "Array", "RefArray", "isRef", "make", "fromDXN", "isRefType", "ast", "getAnnotation", "JSONSchemaAnnotationId", "pipe", "flatMap", "jsonSchema", "some", "none", "typename", "getSchemaReference", "getOrElse"]
+}

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

@@ -0,0 +1,97 @@
+import {
+  EchoObjectSchema,
+  EchoRelationSchema,
+  EchoSchema,
+  PersistentSchema,
+  isMutable
+} from "./chunk-PP4DNUZU.mjs";
+import {
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypeAnnotation
+} from "./chunk-F7KMHDPJ.mjs";
+import {
+  EntityKind,
+  SchemaKindId
+} from "./chunk-4KG6IGL4.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Type.ts
+var Type_exports = {};
+__export(Type_exports, {
+  PersistentType: () => PersistentType,
+  RuntimeType: () => RuntimeType,
+  getDXN: () => getDXN,
+  getMeta: () => getMeta,
+  getTypename: () => getTypename,
+  getVersion: () => getVersion,
+  isMutable: () => isMutable2,
+  isObjectSchema: () => isObjectSchema,
+  isRelationSchema: () => isRelationSchema,
+  object: () => object,
+  relation: () => relation
+});
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
+var RuntimeType = EchoSchema;
+var object = EchoObjectSchema;
+var PersistentType = PersistentSchema;
+var relation = EchoRelationSchema;
+var isObjectSchema = (schema) => {
+  return schema[SchemaKindId] === EntityKind.Object;
+};
+var isRelationSchema = (schema) => {
+  return schema[SchemaKindId] === EntityKind.Relation;
+};
+var getDXN = (schema) => {
+  return getSchemaDXN(schema);
+};
+var getTypename = (schema) => {
+  const typename = getSchemaTypename(schema);
+  invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
+    F: __dxlog_file,
+    L: 227,
+    S: void 0,
+    A: [
+      "typeof typename === 'string' && !typename.startsWith('dxn:')",
+      "'Invalid typename'"
+    ]
+  });
+  return typename;
+};
+var getVersion = (schema) => {
+  const version = getSchemaVersion(schema);
+  invariant(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
+    F: __dxlog_file,
+    L: 237,
+    S: void 0,
+    A: [
+      "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
+      "'Invalid version'"
+    ]
+  });
+  return version;
+};
+var isMutable2 = isMutable;
+var getMeta = (schema) => {
+  return getTypeAnnotation(schema);
+};
+
+export {
+  RuntimeType,
+  object,
+  PersistentType,
+  relation,
+  isObjectSchema,
+  isRelationSchema,
+  getDXN,
+  getTypename,
+  getVersion,
+  isMutable2 as isMutable,
+  getMeta,
+  Type_exports
+};
+//# sourceMappingURL=chunk-T4MPQJ7X.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Type.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type EncodedReference } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { type DXN } from '@dxos/keys';\nimport { type ToMutable } from '@dxos/util';\n\nimport type * as EntityModule from './Entity';\nimport * as internal from './internal';\nimport type * as ObjModule from './Obj';\nimport type * as RelationModule from './Relation';\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport const RuntimeType = internal.EchoSchema;\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport type RuntimeType = internal.EchoSchema;\n\n//\n// Internal types (not exported)\n//\n\n/**\n * Type that marks a schema as an ECHO schema.\n * The value indicates the entity kind (Object or Relation).\n */\ntype EchoSchemaKind<K extends internal.EntityKind = internal.EntityKind> = {\n  readonly [internal.SchemaKindId]: K;\n};\n\n//\n// Obj - Runtime schema for any ECHO object\n//\n\n/**\n * TypeScript type for an ECHO object schema.\n * `T` is the instance type produced by the schema.\n * `Fields` is the optional struct fields type for introspection.\n *\n * @example\n * ```ts\n * const PersonSchema: Type.Obj<Person> = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'Person', version: '0.1.0' }));\n *\n * // Access fields for introspection:\n * Object.keys(PersonSchema.fields); // ['name']\n * ```\n */\nexport interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Object>,\n    Schema.AnnotableClass<\n      Obj<T, Fields>,\n      EntityModule.OfKind<typeof EntityModule.Kind.Object> & T,\n      Schema.Simplify<ObjModule.BaseObjJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO object schema.\n * Accepts both static schemas (created with Type.object()) and EchoSchema.\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isObjectSchema() for runtime type guards.\n */\ntype ObjectSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO object schema.\n * Accepts both static schemas (Type.object()) and mutable schemas (EchoSchema).\n */\nexport type AnyObj = ObjectSchemaBase;\n\n/**\n * Factory function to create an ECHO object schema.\n * Adds object metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'example.com/type/Person', version: '0.1.0' }));\n * ```\n */\nexport const object: {\n  (opts: internal.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;\n} = internal.EchoObjectSchema as any;\n\n//\n// PersistentType (Schema stored in database)\n//\n\nexport const PersistentType: Obj<internal.PersistentSchema> = internal.PersistentSchema as any;\n\nexport interface PersistentType extends Schema.Schema.Type<typeof PersistentType> {}\n\n/**\n * TypeScript type for an ECHO relation schema.\n * `T` is the instance type produced by the schema (excluding source/target).\n * `Source` and `Target` are the endpoint types.\n * `Fields` is the optional struct fields type for introspection.\n */\nexport interface Relation<T, Source, Target, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Relation>,\n    Schema.AnnotableClass<\n      Relation<T, Source, Target, Fields>,\n      EntityModule.OfKind<typeof EntityModule.Kind.Relation> & RelationModule.Endpoints<Source, Target> & T,\n      Schema.Simplify<RelationModule.BaseRelationJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO relation schema.\n * Accepts static schemas (created with Type.relation()).\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isRelationSchema() for runtime type guards.\n */\ntype RelationSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO relation schema.\n * Accepts static schemas (Type.relation()).\n */\nexport type AnyRelation = RelationSchemaBase;\n\n/**\n * Factory function to create an ECHO relation schema.\n * Adds relation metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const WorksFor = Schema.Struct({\n *   role: Schema.String,\n * }).pipe(Type.relation({\n *   typename: 'example.com/type/WorksFor',\n *   version: '0.1.0',\n *   source: Person,\n *   target: Company,\n * }));\n * ```\n */\nexport const relation: {\n  <SourceSchema extends Schema.Schema.AnyNoContext, TargetSchema extends Schema.Schema.AnyNoContext>(\n    opts: internal.EchoRelationSchemaOptions<SourceSchema, TargetSchema>,\n  ): <Self extends Schema.Schema.Any>(\n    self: Self,\n  ) => Relation<Schema.Schema.Type<Self>, Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>>;\n} = internal.EchoRelationSchema as any;\n\n/**\n * Type alias for any ECHO entity schema (object or relation).\n * Use this in type annotations for schema parameters.\n */\nexport type AnyEntity = AnyObj | AnyRelation;\n\n/**\n * Type guard to check if a schema is an object schema.\n * NOTE: This checks SCHEMAS, not instances. Use Obj.isObject for instances.\n */\nexport const isObjectSchema = (schema: AnyEntity): schema is AnyObj => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Object;\n};\n\n/**\n * Type guard to check if a schema is a relation schema.\n * NOTE: This checks SCHEMAS, not instances. Use Relation.isRelation for instances.\n */\nexport const isRelationSchema = (schema: AnyEntity): schema is AnyRelation => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * Type that represents any Ref schema (with unknown target type).\n * This is a schema type, not an instance type.\n */\nexport type AnyRef = Schema.Schema<internal.Ref<any>, EncodedReference>;\n\n//\n// Schema utility functions\n//\n\n/**\n * Gets the full DXN of the schema.\n * Will include the version if it's a `type` DXN.\n * @example \"dxn:example.com/type/Person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: AnyEntity): DXN | undefined => {\n  return internal.getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `example.com/type/Person`.\n */\nexport const getTypename = (schema: AnyEntity): string => {\n  const typename = internal.getSchemaTypename(schema);\n  invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');\n  return typename;\n};\n\n/**\n * Gets the version of the schema.\n * @example 0.1.0\n */\nexport const getVersion = (schema: AnyEntity): string => {\n  const version = internal.getSchemaVersion(schema);\n  invariant(typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/), 'Invalid version');\n  return version;\n};\n\n/**\n * @returns True if the schema is mutable.\n */\nexport const isMutable = internal.isMutable;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = internal.TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: AnyEntity): Meta | undefined => {\n  return internal.getTypeAnnotation(schema);\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;mBAAAA;EAAA;;;;;AAOA,SAASC,iBAAiB;;AAYnB,IAAMC,cAAuBC;AAmF7B,IAAMC,SAEAC;AAMN,IAAMC,iBAA0DC;AA4DhE,IAAMC,WAMAC;AAYN,IAAMC,iBAAiB,CAACC,WAAAA;AAC7B,SAAQA,OAAwBC,YAAY,MAAeC,WAAWC;AACxE;AAMO,IAAMC,mBAAmB,CAACJ,WAAAA;AAC/B,SAAQA,OAAwBC,YAAY,MAAeC,WAAWG;AACxE;AAkBO,IAAMC,SAAS,CAACN,WAAAA;AACrB,SAAgBO,aAAaP,MAAAA;AAC/B;AAMO,IAAMQ,cAAc,CAACR,WAAAA;AAC1B,QAAMS,WAAoBC,kBAAkBV,MAAAA;AAC5CW,YAAU,OAAOF,aAAa,YAAY,CAACA,SAASG,WAAW,MAAA,GAAS,oBAAA;;;;;;;;;AACxE,SAAOH;AACT;AAMO,IAAMI,aAAa,CAACb,WAAAA;AACzB,QAAMc,UAAmBC,iBAAiBf,MAAAA;AAC1CW,YAAU,OAAOG,YAAY,YAAYA,QAAQE,MAAM,iBAAA,GAAoB,mBAAA;;;;;;;;;AAC3E,SAAOF;AACT;AAKO,IAAMG,aAAqBA;AAU3B,IAAMC,UAAU,CAAClB,WAAAA;AACtB,SAAgBmB,kBAAkBnB,MAAAA;AACpC;",
+  "names": ["isMutable", "invariant", "RuntimeType", "EchoSchema", "object", "EchoObjectSchema", "PersistentType", "PersistentSchema", "relation", "EchoRelationSchema", "isObjectSchema", "schema", "SchemaKindId", "EntityKind", "Object", "isRelationSchema", "Relation", "getDXN", "getSchemaDXN", "getTypename", "typename", "getSchemaTypename", "invariant", "startsWith", "getVersion", "version", "getSchemaVersion", "match", "isMutable", "getMeta", "getTypeAnnotation"]
+}

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

@@ -0,0 +1,7 @@
+// src/SchemaRegistry.ts
+var SchemaRegistry_exports = {};
+
+export {
+  SchemaRegistry_exports
+};
+//# sourceMappingURL=chunk-T6JEFNP6.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/SchemaRegistry.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Types from 'effect/Types';\n\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Key from './Key';\nimport type * as QueryResult from './QueryResult';\nimport type * as Type from './Type';\n\n// TODO(wittjosiah): Replace w/ Query.Query.\nexport type Query = {\n  /**\n   * Filter by schema ID.\n   * Schema id is a DXN with `echo` or `type` kind.\n   */\n  id?: string | string[];\n\n  /**\n   * Id of the backing ECHO object.\n   */\n  backingObjectId?: Key.ObjectId | Key.ObjectId[];\n\n  /**\n   * One or more typenames to filter by.\n   */\n  typename?: string | string[];\n\n  /**\n   * [Semver Range](https://docs.npmjs.com/cli/v6/using-npm/semver#ranges) for the schema version.\n   */\n  version?: string;\n\n  /**\n   * Where to look for the schema.\n   *\n   * Database schema are stored in the database of the current space.\n   * Runtime schema are registered in the runtime.\n   *\n   * @default ['database']\n   */\n  location?: ('database' | 'runtime')[];\n\n  /**\n   * Include system schemas.\n   * @default false\n   *\n   * The system schema include but are not limited to:\n   *  - dxos.org/type/Schema\n   */\n  includeSystem?: boolean;\n};\n\n/**\n * Input for schema registration.\n * The typename, version and schema mutability metadata is read from the schema annotations.\n *\n * Accepts:\n * - Branded ECHO schemas created with Type.Obj() or Type.Relation()\n * - JSON schema with typename and version\n */\nexport type RegisterSchemaInput =\n  | Type.AnyEntity\n  | {\n      typename: string;\n      version: string;\n      jsonSchema: JsonSchema.JsonSchema;\n      /**\n       * Display name of the schema.\n       */\n      name?: string;\n    };\n\nexport type ExtractQueryResult<Query> = Query extends { location: ('database' | 'runtime')[] }\n  ? Type.AnyEntity\n  : Type.RuntimeType;\n\n// TODO(dmaretskyi): Rename TypeRegistry\nexport interface SchemaRegistry {\n  /**\n   * Checks if the provided schema is registered.\n   */\n  // TODO(burdon): Type?\n  hasSchema(schema: Type.AnyEntity): boolean;\n\n  /**\n   * Registers the provided schema.\n   *\n   * @returns Mutable runtime instances of schemas that were registered.\n   *\n   * The behavior of this method depends on the state of the database.\n   * The general principle is that the schema will be upserted into the space.\n   * If an equivalent schema with the same name and version already exists, the method does nothing.\n   * If a different schema with the same name and version exists, the method throws an error.\n   * If no schema with the same name and version exists, a new schema will be inserted based on semantic versioning rules.\n   */\n  register(input: RegisterSchemaInput[]): Promise<Type.RuntimeType[]>;\n\n  /**\n   *\n   */\n  query<Q extends Types.NoExcessProperties<Query, Q>>(\n    query?: Q & Query,\n  ): QueryResult.QueryResult<ExtractQueryResult<Q>>;\n}\n"],
+  "mappings": ";AAAA;",
+  "names": []
+}

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

@@ -0,0 +1,121 @@
+import {
+  MetaId,
+  addTag,
+  change,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMetaChecked,
+  isDeleted,
+  objectToJSON,
+  removeTag,
+  subscribe
+} from "./chunk-PP4DNUZU.mjs";
+import {
+  getEntityKind,
+  getTypeDXN,
+  getTypename
+} from "./chunk-F7KMHDPJ.mjs";
+import {
+  EntityKind,
+  EntityKindSchema,
+  KindId,
+  SnapshotKindId
+} from "./chunk-4KG6IGL4.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Entity.ts
+var Entity_exports = {};
+__export(Entity_exports, {
+  Kind: () => Kind,
+  KindId: () => KindId2,
+  KindSchema: () => KindSchema,
+  Meta: () => Meta,
+  SnapshotKindId: () => SnapshotKindId2,
+  addTag: () => addTag2,
+  change: () => change2,
+  getDXN: () => getDXN2,
+  getDatabase: () => getDatabase2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys2,
+  getKind: () => getKind,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  isDeleted: () => isDeleted2,
+  isEntity: () => isEntity,
+  isSnapshot: () => isSnapshot,
+  removeTag: () => removeTag2,
+  subscribe: () => subscribe2,
+  toJSON: () => toJSON
+});
+var KindId2 = KindId;
+var SnapshotKindId2 = SnapshotKindId;
+var Kind = EntityKind;
+var KindSchema = EntityKindSchema;
+var isEntity = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[KindId2] !== void 0;
+};
+var isSnapshot = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[SnapshotKindId2] !== void 0;
+};
+var getKind = getEntityKind;
+var Meta = MetaId;
+var getDXN2 = (entity) => getDXN(entity);
+var getTypeDXN2 = getTypeDXN;
+var getTypename2 = (entity) => getTypename(entity);
+var getDatabase2 = (entity) => getDatabase(entity);
+function getMeta(entity) {
+  return getMetaChecked(entity);
+}
+var getKeys2 = (entity, source) => getKeys(entity, source);
+var isDeleted2 = (entity) => isDeleted(entity);
+var getLabel2 = (entity) => getLabel(entity);
+var getDescription2 = (entity) => getDescription(entity);
+var toJSON = (entity) => objectToJSON(entity);
+var subscribe2 = (entity, callback) => {
+  return subscribe(entity, callback);
+};
+var change2 = (entity, callback) => {
+  change(entity, callback);
+};
+var addTag2 = (entity, tag) => addTag(entity, tag);
+var removeTag2 = (entity, tag) => removeTag(entity, tag);
+
+export {
+  KindId2 as KindId,
+  SnapshotKindId2 as SnapshotKindId,
+  Kind,
+  KindSchema,
+  isEntity,
+  isSnapshot,
+  getKind,
+  Meta,
+  getDXN2 as getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getTypename2 as getTypename,
+  getDatabase2 as getDatabase,
+  getMeta,
+  getKeys2 as getKeys,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  getDescription2 as getDescription,
+  toJSON,
+  subscribe2 as subscribe,
+  change2 as change,
+  addTag2 as addTag,
+  removeTag2 as removeTag,
+  Entity_exports
+};
+//# sourceMappingURL=chunk-W7OP5HGZ.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Entity.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport type { DXN, ObjectId } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport type * as Relation from './Relation';\n\n// Re-export KindId and SnapshotKindId from internal.\nexport const KindId = internal.KindId;\nexport type KindId = typeof internal.KindId;\nexport const SnapshotKindId = internal.SnapshotKindId;\nexport type SnapshotKindId = typeof internal.SnapshotKindId;\n\n// NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.\n//  However, we generally refer to Obj and Relation instances as \"objects\",\n//  and many API methods accept both Obj.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.\n\nexport const Kind = internal.EntityKind;\nexport type Kind = internal.EntityKind;\nexport const KindSchema = internal.EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n * NOTE: Needed to make `isRelation` and `isObject` checks work.\n */\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Assigns a snapshot kind to an Object or Relation snapshot.\n */\nexport interface SnapshotOfKind<K extends Kind> {\n  readonly [SnapshotKindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Obj or Relation with a specific set of properties.\n */\nexport type Entity<Props> = OfKind<Kind> & Props;\n\n/**\n * Unknown Obj or Relation (reactive).\n */\nexport interface Unknown extends OfKind<Kind> {}\n\n/**\n * Snapshot of an Obj or Relation.\n * Branded with SnapshotKindId instead of KindId.\n */\nexport interface Snapshot extends SnapshotOfKind<Kind> {}\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how typescript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n *\n * This type is very permissive and allows accessing any property on the object.\n * We should move to Obj.Unknown that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\n/**\n * Returns all properties of an object or relation except for the id and kind.\n */\nexport type Properties<T> = Omit<T, 'id' | KindId | Relation.Source | Relation.Target>;\n\n/**\n * Check if a value is an ECHO entity (object or relation).\n * Returns `false` for snapshots.\n */\nexport const isEntity = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[KindId] !== undefined;\n};\n\n/**\n * Check if a value is an ECHO entity snapshot.\n * Returns `false` for entities.\n */\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[SnapshotKindId] !== undefined;\n};\n\n// TODO(dmaretskyi): Type introspection -- move to kind.\nexport const getKind = internal.getEntityKind;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport const Meta: unique symbol = internal.MetaId as any;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport type Meta = typeof Meta;\n\n//\n// Entity-level functions that work on any entity (object or relation).\n// Use these when you don't know or care about the specific entity kind.\n// For kind-specific functions, use Obj.* or Relation.*.\n//\n\n/**\n * JSON representation of an entity.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Get the DXN of an entity (object or relation).\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * Get the DXN of an entity's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the typename of an entity's type.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n/**\n * Get the database an entity belongs to.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): any | undefined => internal.getDatabase(entity);\n\n/**\n * Get the metadata for an entity.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): internal.ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): internal.ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): internal.ObjectMeta | internal.ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * Get foreign keys for an entity from the specified source.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Check if an entity is deleted.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n/**\n * Get the label of an entity.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Get the description of an entity.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Convert an entity to its JSON representation.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n/**\n * Subscribe to changes on an entity (object or relation).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (entity: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(entity, callback);\n};\n\n//\n// Change\n//\n\n/**\n * Used to provide a mutable view of an entity within `Entity.change`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an entity (object or relation) within a change context.\n *\n * Entities are read-only by default. Mutations are batched and notifications fire\n * when the callback completes. Direct mutations outside of `Entity.change` will throw\n * at runtime.\n *\n * @param entity - The echo entity (object or relation) to mutate.\n * @param callback - Receives a mutable view of the entity. All mutations must occur here.\n *\n * @example\n * ```typescript\n * // Mutate within Entity.change\n * Entity.change(entity, (e) => {\n *   e.name = 'Updated';\n *   e.count = 42;\n * });\n *\n * // Direct mutation throws\n * entity.name = 'Bob'; // Error: Cannot modify outside Entity.change()\n * ```\n *\n * Note: For type-specific operations, prefer `Obj.change` or `Relation.change`.\n */\nexport const change = <T extends Unknown>(entity: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(entity, callback);\n};\n\n/**\n * Add a tag to an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;gBAAAA;EAAA;;wBAAAC;EAAA,cAAAC;EAAA,cAAAC;EAAA,cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA;kBAAAC;EAAA;oBAAAC;EAAA,mBAAAC;EAAA,iBAAAC;EAAA;;mBAAAC;EAAA,iBAAAC;EAAA;;AAWO,IAAMC,UAAkBA;AAExB,IAAMC,kBAA0BA;AAOhC,IAAMC,OAAgBC;AAEtB,IAAMC,aAAsBC;AAyD5B,IAAMC,WAAW,CAACC,UAAAA;AACvB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,SAAQA,MAAcP,OAAAA,MAAYQ;AACpC;AAMO,IAAMC,aAAa,CAACF,UAAAA;AACzB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,SAAQA,MAAcN,eAAAA,MAAoBO;AAC5C;AAGO,IAAME,UAAmBC;AAKzB,IAAMC,OAA+BC;AAqBrC,IAAMC,UAAS,CAACC,WAA6CD,OAAOC,MAAAA;AAKpE,IAAMC,cAAsBA;AAK5B,IAAMC,eAAc,CAACF,WAA4DE,YAAYF,MAAAA;AAK7F,IAAMG,eAAc,CAACH,WAAyDG,YAAYH,MAAAA;AAU1F,SAASI,QAAQJ,QAA6C;AACnE,SAAgBK,eAAeL,MAAAA;AACjC;AAKO,IAAMM,WAAU,CAACN,QAA4BO,WAA0CD,QAAQN,QAAQO,MAAAA;AAKvG,IAAMC,aAAY,CAACR,WAAiDQ,UAAUR,MAAAA;AAK9E,IAAMS,YAAW,CAACT,WAA4DS,SAAST,MAAAA;AAKvF,IAAMU,kBAAiB,CAACV,WAA4DU,eAAeV,MAAAA;AAKnG,IAAMW,SAAS,CAACX,WAA8CY,aAAaZ,MAAAA;AAM3E,IAAMa,aAAY,CAACb,QAAiBc,aAAAA;AACzC,SAAgBD,UAAUb,QAAQc,QAAAA;AACpC;AAmCO,IAAMC,UAAS,CAAoBf,QAAWc,aAAAA;AACnDE,EAASD,OAAOf,QAAQc,QAAAA;AAC1B;AAMO,IAAMG,UAAS,CAACjB,QAA0BkB,QAA+BD,OAAOjB,QAAQkB,GAAAA;AAMxF,IAAMC,aAAY,CAACnB,QAA0BkB,QAA+BC,UAAUnB,QAAQkB,GAAAA;",
+  "names": ["KindId", "SnapshotKindId", "addTag", "change", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "subscribe", "KindId", "SnapshotKindId", "Kind", "EntityKind", "KindSchema", "EntityKindSchema", "isEntity", "value", "undefined", "isSnapshot", "getKind", "getEntityKind", "Meta", "MetaId", "getDXN", "entity", "getTypeDXN", "getTypename", "getDatabase", "getMeta", "getMetaChecked", "getKeys", "source", "isDeleted", "getLabel", "getDescription", "toJSON", "objectToJSON", "subscribe", "callback", "change", "internal", "addTag", "tag", "removeTag"]
+}

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

@@ -0,0 +1,42 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Order.ts
+var Order_exports = {};
+__export(Order_exports, {
+  natural: () => natural,
+  property: () => property,
+  rank: () => rank
+});
+var OrderClass = class _OrderClass {
+  ast;
+  static "variance" = {};
+  static is(value) {
+    return typeof value === "object" && value !== null && "~Order" in value;
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Order" = _OrderClass.variance;
+};
+var natural = new OrderClass({
+  kind: "natural"
+});
+var property = (property2, direction) => new OrderClass({
+  kind: "property",
+  property: property2,
+  direction
+});
+var rank = (direction = "desc") => new OrderClass({
+  kind: "rank",
+  direction
+});
+
+export {
+  natural,
+  property,
+  rank,
+  Order_exports
+};
+//# sourceMappingURL=chunk-ZTUBYOGB.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Order.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nexport interface Order<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Order': { value: T };\n\n  ast: QueryAST.Order;\n}\n\nexport type Any = Order<any>;\n\nclass OrderClass implements Order<any> {\n  private static 'variance': Order<any>['~Order'] = {} as Order<any>['~Order'];\n\n  static is(value: unknown): value is Order<any> {\n    return typeof value === 'object' && value !== null && '~Order' in value;\n  }\n\n  constructor(public readonly ast: QueryAST.Order) {}\n\n  '~Order' = OrderClass.variance;\n}\n\nexport const natural: Order<any> = new OrderClass({ kind: 'natural' });\nexport const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order<T> =>\n  new OrderClass({\n    kind: 'property',\n    property,\n    direction,\n  });\n\n/**\n * Order by relevance rank (for FTS/vector search results).\n * Higher rank = better match. Default direction is 'desc' (best matches first).\n */\nexport const rank = <T>(direction: QueryAST.OrderDirection = 'desc'): Order<T> =>\n  new OrderClass({\n    kind: 'rank',\n    direction,\n  });\n"],
+  "mappings": ";;;;;AAAA;;;;;;AAeA,IAAMA,aAAN,MAAMA,YAAAA;;EACJ,OAAe,aAAmC,CAAC;EAEnD,OAAOC,GAAGC,OAAqC;AAC7C,WAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,YAAYA;EACpE;EAEA,YAA4BC,KAAqB;SAArBA,MAAAA;EAAsB;EAElD,WAAWH,YAAWI;AACxB;AAEO,IAAMC,UAAsB,IAAIL,WAAW;EAAEM,MAAM;AAAU,CAAA;AAC7D,IAAMC,WAAW,CAAIA,WAA4BC,cACtD,IAAIR,WAAW;EACbM,MAAM;EACNC,UAAAA;EACAC;AACF,CAAA;AAMK,IAAMC,OAAO,CAAID,YAAqC,WAC3D,IAAIR,WAAW;EACbM,MAAM;EACNE;AACF,CAAA;",
+  "names": ["OrderClass", "is", "value", "ast", "variance", "natural", "kind", "property", "direction", "rank"]
+}