@dxos/echo 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, type ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as entityInternal from './internal/Entity';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Type from './Type';\n\nexport type Endpoints<Source, Target> = {\n  [Source]: Source;\n  [Target]: Target;\n};\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends internal.AnyEntity, Endpoints<Source, Target>, Entity.OfKind<internal.EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Runtime Effect schema for any ECHO relation.\n * Use for validation, parsing, or as a reference target for collections.\n * A relation has `id`, source, and target fields plus any additional properties.\n *\n * NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Relation)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Relation.isRelation(unknownValue)) { ... }\n * ```\n */\n// TODO(dmaretskyi): Change ObjModule.Any to ObjModule.Unknown to have stricter types.\nexport const Unknown: Type.Relation<Unknown, Obj.Any, Obj.Any> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  // TODO(dmaretskyi): Clean this up.\n  // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.\n  //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.\n  internal.EchoRelationSchema({\n    typename: 'org.dxos.schema.any-relation',\n    version: '0.0.0',\n    source: Obj.Unknown,\n    target: Obj.Unknown,\n  }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Relation<Unknown, Obj.Any, Obj.Any>,\n);\n\n/**\n * Relation type with specific source and target types.\n */\nexport type OfShape<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends internal.AnyEntity, Endpoints<Source, Target> {\n  readonly [Entity.SnapshotKindId]: internal.EntityKind.Relation;\n  readonly id: ObjectId;\n}\n\n/**\n * JSON-encoded properties for relations.\n */\nexport interface BaseRelationJson {\n  id: string;\n  [internal.ATTR_RELATION_SOURCE]: string;\n  [internal.ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> &\n  BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = entityInternal.RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = entityInternal.RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Get relation source type.\n */\nexport type SourceOf<A> = A extends Endpoints<infer S, infer _T> ? S : never;\n\n/**\n * Get relation target type.\n */\nexport type TargetOf<A> = A extends Endpoints<infer _S, infer T> ? T : never;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype MakePropsInternal<T extends Unknown> = {\n  id?: ObjectId;\n  [Meta]?: internal.ObjectMeta;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Entity.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Schema.Schema.Type<S>>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata. (deprecated; use [Obj.Meta] instead)\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.AnyRelation>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === internal.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n  assertArgument(props[internal.ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  let meta: internal.ObjectMeta | undefined = undefined;\n\n  if (props[internal.MetaId] != null) {\n    meta = props[internal.MetaId] as any;\n    delete props[internal.MetaId];\n  }\n\n  const sourceDXN = internal.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[internal.RelationSourceDXNId] = sourceDXN;\n  (props as any)[internal.RelationTargetDXNId] = targetDXN;\n\n  return internal.makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (internal.ATTR_RELATION_SOURCE in value || internal.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[Entity.SnapshotKindId];\n  return kind === internal.EntityKind.Relation;\n};\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)[Entity.SnapshotKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): SourceOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as SourceOf<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): TargetOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as TargetOf<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.change`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.change` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.change` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.change\n * Relation.change(worksFor, (r) => {\n *   r.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.change` for objects.\n */\nexport const change = <T extends Unknown>(relation: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = internal.getSnapshot as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return internal.getValue(rel, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  internal.setValue as any;\n\n//\n// Type\n//\n\n/**\n * Get the DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of ObjectMeta.\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.change` callback.\n */\nexport type Meta = internal.Meta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.change` callback).\n * Returns read-only meta when passed a regular relation 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>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport const isVersion = internal.isVersion;\n\n/**\n * Represent relation version.\n */\nexport type Version = internal.EntityVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "change", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "createJsonPath", "assertArgument", "invariant", "DXN", "assumeType", "Unknown", "Struct", "id", "String", "pipe", "extend", "Record", "key", "value", "EchoRelationSchema", "typename", "version", "source", "target", "schema", "Object", "assign", "SchemaKindId", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "props", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Relation", "ParentId", "undefined", "meta", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "makeObject", "isRelation", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "SnapshotKindId", "isSnapshot", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "getTarget", "change", "callback", "internal", "getSnapshot", "subscribe", "rel", "getValue", "path", "createJsonPath", "setValue", "getDXN", "entity", "getTypeDXN", "getSchema", "getTypename", "getDatabase", "Meta", "getMeta", "getMetaChecked", "getKeys", "deleteKeys", "addTag", "tag", "removeTag", "isDeleted", "getLabel", "setLabel", "label", "getDescription", "setDescription", "description", "toJSON", "objectToJSON", "sortByLabel", "sortByTypename", "sort", "comparators", "VersionTypeId", "isVersion"]
+}

package/dist/lib/neutral/{chunk-YQYMWZAD.mjs → chunk-WYOKA6AE.mjs}

@@ -1,4 +1,4 @@
-// src/internal/types/entity.ts
+// src/internal/common/types/entity.ts
 import * as Schema from "effect/Schema";
 var KindId = "~@dxos/echo/Kind";
 var SchemaKindId = "~@dxos/echo/SchemaKind";
@@ -9,10 +9,10 @@ var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
   return EntityKind2;
 })({});
 var EntityKindSchema = Schema.Enums(EntityKind);
-var ANY_OBJECT_TYPENAME = "dxos.org/schema/AnyObject";
+var ANY_OBJECT_TYPENAME = "org.dxos.schema.any-object";
 var ANY_OBJECT_VERSION = "0.0.0";
 
-// src/internal/annotations/util.ts
+// src/internal/Annotation/util.ts
 import * as SchemaAST from "effect/SchemaAST";
 import { assertArgument } from "@dxos/invariant";
 import { DXN } from "@dxos/keys";
@@ -64,4 +64,4 @@ export {
   unwrapOptional,
   makeTypeJsonSchemaAnnotation
 };
-//# sourceMappingURL=chunk-YQYMWZAD.mjs.map
+//# sourceMappingURL=chunk-WYOKA6AE.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/common/types/entity.ts", "../../../src/internal/Annotation/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'org.dxos.schema.any-object';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../common/types';\n\nexport interface AnnotationHelper<T> {\n  /**\n   * Get the annotation value from the schema.\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 value on the schema.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\n/**\n * Note: only for system annotations.\n */\n// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S) =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AAMvB,IAAKC,aAAAA,0BAAAA,aAAAA;;;SAAAA;;AAKL,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC/ClC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAuBb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAAM;;IAEVC,KAAKR,QAAQS,cAAcC,IAAIC,aAAaX,QAAQY,QAAQ,EAAEC,SAAQ;IACtEC,YAAYd,QAAQG;IACpBY,SAASf,QAAQe;IACjBH,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEc,MAAMhB,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAEU,MAAMhB,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "fromTypename", "typename", "toString", "entityKind", "version", "$ref"]
+}

package/dist/lib/neutral/{chunk-XMIDBDE6.mjs → chunk-YMNSMKKW.mjs}

@@ -3,23 +3,18 @@ import {
   EchoRelationSchema,
   EchoSchema,
   PersistentSchema,
-  Ref,
-  isMutable,
-  toEffectSchema,
-  toJsonSchema
-} from "./chunk-SU2LVM7J.mjs";
+  isMutable
+} from "./chunk-C4JZK4J7.mjs";
 import {
   getSchemaDXN,
   getSchemaTypename,
   getSchemaVersion,
   getTypeAnnotation
-} from "./chunk-CUDIBUM4.mjs";
+} from "./chunk-SEMVAGBM.mjs";
 import {
-  ANY_OBJECT_TYPENAME,
-  ANY_OBJECT_VERSION,
   EntityKind,
   SchemaKindId
-} from "./chunk-YQYMWZAD.mjs";
+} from "./chunk-WYOKA6AE.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -27,12 +22,8 @@ import {
 // src/Type.ts
 var Type_exports = {};
 __export(Type_exports, {
-  Entity: () => Entity,
-  Obj: () => Obj,
   PersistentType: () => PersistentType,
-  Ref: () => Ref2,
-  Relation: () => Relation,
-  RuntimeType: () => EchoSchema,
+  RuntimeType: () => RuntimeType,
   getDXN: () => getDXN,
   getMeta: () => getMeta,
   getTypename: () => getTypename,
@@ -41,52 +32,20 @@ __export(Type_exports, {
   isObjectSchema: () => isObjectSchema,
   isRelationSchema: () => isRelationSchema,
   object: () => object,
-  relation: () => relation,
-  toEffectSchema: () => toEffectSchema,
-  toJsonSchema: () => toJsonSchema
+  relation: () => relation
 });
-import * as Schema from "effect/Schema";
 import { invariant } from "@dxos/invariant";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
-var ObjSchema = Schema.Struct({
-  id: Schema.String
-}).pipe(Schema.extend(Schema.Record({
-  key: Schema.String,
-  value: Schema.Unknown
-})), EchoObjectSchema({
-  typename: ANY_OBJECT_TYPENAME,
-  version: ANY_OBJECT_VERSION
-}));
-var Obj = Object.assign(ObjSchema, {
-  [SchemaKindId]: ObjSchema[SchemaKindId]
-});
+var RuntimeType = EchoSchema;
 var object = EchoObjectSchema;
 var PersistentType = PersistentSchema;
-var RelationSchema = Schema.Struct({
-  id: Schema.String
-}).pipe(Schema.extend(Schema.Record({
-  key: Schema.String,
-  value: Schema.Unknown
-})), EchoRelationSchema({
-  typename: "dxos.org/schema/AnyRelation",
-  version: "0.0.0",
-  source: ObjSchema,
-  target: ObjSchema
-}));
-var Relation = Object.assign(RelationSchema, {
-  [SchemaKindId]: RelationSchema[SchemaKindId]
-});
 var relation = EchoRelationSchema;
-(function(Entity2) {
-  Entity2.Any = Schema.Union(Obj, Relation);
-})(Entity || (Entity = {}));
 var isObjectSchema = (schema) => {
   return schema[SchemaKindId] === EntityKind.Object;
 };
 var isRelationSchema = (schema) => {
   return schema[SchemaKindId] === EntityKind.Relation;
 };
-var Ref2 = Ref;
 var getDXN = (schema) => {
   return getSchemaDXN(schema);
 };
@@ -94,7 +53,7 @@ var getTypename = (schema) => {
   const typename = getSchemaTypename(schema);
   invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
     F: __dxlog_file,
-    L: 463,
+    L: 230,
     S: void 0,
     A: [
       "typeof typename === 'string' && !typename.startsWith('dxn:')",
@@ -107,7 +66,7 @@ var getVersion = (schema) => {
   const version = getSchemaVersion(schema);
   invariant(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
     F: __dxlog_file,
-    L: 473,
+    L: 240,
     S: void 0,
     A: [
       "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
@@ -120,23 +79,19 @@ var isMutable2 = isMutable;
 var getMeta = (schema) => {
   return getTypeAnnotation(schema);
 };
-var Entity;
 
 export {
-  Obj,
+  RuntimeType,
   object,
   PersistentType,
-  Relation,
   relation,
   isObjectSchema,
   isRelationSchema,
-  Ref2 as Ref,
   getDXN,
   getTypename,
   getVersion,
   isMutable2 as isMutable,
   getMeta,
-  Entity,
   Type_exports
 };
-//# sourceMappingURL=chunk-XMIDBDE6.mjs.map
+//# sourceMappingURL=chunk-YMNSMKKW.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Type.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\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 Entity from './Entity';\nimport * as typeInternal from './internal/Type';\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 = typeInternal.EchoSchema;\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport type RuntimeType = typeInternal.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      Entity.OfKind<typeof Entity.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: 'com.example.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<typeInternal.PersistentSchema> = typeInternal.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      Entity.OfKind<typeof Entity.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: 'com.example.type.works-for',\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:com.example.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: `com.example.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 = typeInternal.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;;;;;AASA,SAASC,iBAAiB;;AAanB,IAAMC,cAA2BC;AAmFjC,IAAMC,SAEAC;AAMN,IAAMC,iBAAkEC;AA4DxE,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,aAAyBA;AAU/B,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-YWXWXIE5.mjs

@@ -0,0 +1,34 @@
+import {
+  Ref
+} from "./chunk-43Y5DOS6.mjs";
+
+// src/internal/Ref/ref-array.ts
+import { isNonNullable } from "@dxos/util";
+var RefArray = Object.freeze({
+  /**
+  * @returns all resolved targets.
+  */
+  targets: (refs) => {
+    return refs.map((ref) => ref.target).filter(isNonNullable);
+  },
+  /**
+  * Load all referenced objects.
+  */
+  loadAll: (refs) => {
+    return Promise.all(refs.map((ref) => ref.load()));
+  },
+  /**
+  * Removes the ref with the given id.
+  */
+  removeById: (refs, id) => {
+    const index = refs.findIndex(Ref.hasObjectId(id));
+    if (index >= 0) {
+      refs.splice(index, 1);
+    }
+  }
+});
+
+export {
+  RefArray
+};
+//# sourceMappingURL=chunk-YWXWXIE5.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ref/ref-array.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { type ObjectId } from '@dxos/keys';\nimport { isNonNullable } from '@dxos/util';\n\nimport { type AnyEntity } from '../common/types';\n\nimport { Ref } from './ref';\n\n/**\n * Helper functions for working with arrays of refs.\n */\nexport const RefArray = Object.freeze({\n  /**\n   * @returns all resolved targets.\n   */\n  targets: <T extends AnyEntity>(refs: readonly Ref<T>[]): T[] => {\n    return refs.map((ref) => ref.target).filter(isNonNullable);\n  },\n\n  /**\n   * Load all referenced objects.\n   */\n  loadAll: <T extends AnyEntity>(refs: readonly Ref<T>[]): Promise<T[]> => {\n    return Promise.all(refs.map((ref) => ref.load()));\n  },\n\n  /**\n   * Removes the ref with the given id.\n   */\n  removeById: (refs: Ref<AnyEntity>[], id: ObjectId) => {\n    const index = refs.findIndex(Ref.hasObjectId(id));\n    if (index >= 0) {\n      refs.splice(index, 1);\n    }\n  },\n});\n"],
+  "mappings": ";;;;;AAKA,SAASA,qBAAqB;AASvB,IAAMC,WAAWC,OAAOC,OAAO;;;;EAIpCC,SAAS,CAAsBC,SAAAA;AAC7B,WAAOA,KAAKC,IAAI,CAACC,QAAQA,IAAIC,MAAM,EAAEC,OAAOC,aAAAA;EAC9C;;;;EAKAC,SAAS,CAAsBN,SAAAA;AAC7B,WAAOO,QAAQC,IAAIR,KAAKC,IAAI,CAACC,QAAQA,IAAIO,KAAI,CAAA,CAAA;EAC/C;;;;EAKAC,YAAY,CAACV,MAAwBW,OAAAA;AACnC,UAAMC,QAAQZ,KAAKa,UAAUC,IAAIC,YAAYJ,EAAAA,CAAAA;AAC7C,QAAIC,SAAS,GAAG;AACdZ,WAAKgB,OAAOJ,OAAO,CAAA;IACrB;EACF;AACF,CAAA;",
+  "names": ["isNonNullable", "RefArray", "Object", "freeze", "targets", "refs", "map", "ref", "target", "filter", "isNonNullable", "loadAll", "Promise", "all", "load", "removeById", "id", "index", "findIndex", "Ref", "hasObjectId", "splice"]
+}

package/dist/lib/neutral/index.mjs

@@ -1,70 +1,82 @@
 import {
+  Collection_exports,
   DXN,
+  Dataset_exports,
   Hypergraph_exports,
-  QueryAST
-} from "./chunk-X2MPMYYN.mjs";
+  QueryAST,
+  View_exports
+} from "./chunk-6DNYDXCV.mjs";
+import {
+  SchemaRegistry_exports
+} from "./chunk-BNCCGLJN.mjs";
 import {
   Tag_exports
-} from "./chunk-IP2GHXWA.mjs";
+} from "./chunk-6K2MVI2O.mjs";
 import {
   Order_exports
-} from "./chunk-ROKO4RKJ.mjs";
+} from "./chunk-UI6MWK5W.mjs";
 import {
   Key_exports
 } from "./chunk-ANHVGJI4.mjs";
-import {
-  Type_exports
-} from "./chunk-XMIDBDE6.mjs";
 import {
   Format_exports
-} from "./chunk-4TT624YA.mjs";
+} from "./chunk-FZO7LQO7.mjs";
 import {
   Relation_exports
-} from "./chunk-VR4A4WGG.mjs";
+} from "./chunk-W47JKR3X.mjs";
 import {
   JsonSchema_exports
-} from "./chunk-3ZEAZF7T.mjs";
+} from "./chunk-UTBRYVQC.mjs";
 import {
   QueryResult_exports
 } from "./chunk-OMUPQMLR.mjs";
 import {
   Query_exports
-} from "./chunk-XK5OUUBY.mjs";
+} from "./chunk-6GPU7XC3.mjs";
+import {
+  Feed_exports
+} from "./chunk-7VNVH63N.mjs";
+import {
+  Type_exports
+} from "./chunk-YMNSMKKW.mjs";
 import {
   Filter_exports
-} from "./chunk-VB5HVDCA.mjs";
+} from "./chunk-NXMFBIT5.mjs";
 import {
   Ref_exports
-} from "./chunk-HMOXCO27.mjs";
-import {
-  SchemaRegistry_exports
-} from "./chunk-4L6DOFXP.mjs";
+} from "./chunk-FXEG7EOK.mjs";
 import {
   Obj_exports
-} from "./chunk-2MTHJ5UW.mjs";
+} from "./chunk-4JRI2ZJI.mjs";
 import {
   Entity_exports
-} from "./chunk-6QPSGMEF.mjs";
-import "./chunk-SU2LVM7J.mjs";
-import "./chunk-62DWJ6CE.mjs";
+} from "./chunk-ROAGDPV7.mjs";
+import "./chunk-C4JZK4J7.mjs";
+import "./chunk-YWXWXIE5.mjs";
+import "./chunk-BOZZPUXE.mjs";
+import "./chunk-B5OXLWZL.mjs";
+import "./chunk-43Y5DOS6.mjs";
 import {
   Annotation_exports
-} from "./chunk-NWUO5FKZ.mjs";
+} from "./chunk-OENWMTE6.mjs";
 import {
   Database_exports
-} from "./chunk-KRHDMXSU.mjs";
-import "./chunk-CUDIBUM4.mjs";
-import "./chunk-YQYMWZAD.mjs";
+} from "./chunk-NEGC54NE.mjs";
+import "./chunk-SEMVAGBM.mjs";
+import "./chunk-WYOKA6AE.mjs";
 import {
   Err_exports
-} from "./chunk-RPB6V4BE.mjs";
+} 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,
+  Feed_exports as Feed,
   Filter_exports as Filter,
   Format_exports as Format,
   Hypergraph_exports as Hypergraph,
@@ -79,6 +91,7 @@ export {
   Relation_exports as Relation,
   SchemaRegistry_exports as SchemaRegistry,
   Tag_exports as Tag,
-  Type_exports as Type
+  Type_exports as Type,
+  View_exports as View
 };
 //# sourceMappingURL=index.mjs.map