@dxos/echo 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/dist/lib/neutral/chunk-UQAMAXDU.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 * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { raise } from '@dxos/debug';\nimport { type EncodedReference } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, EchoURI, type ObjectId, type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as EntityModule from './Entity';\nimport * as internal from './internal';\nimport * as typeInternal from './internal/Type';\nimport type * as RelationModule from './Relation';\n\n//\n// Internal types (not exported)\n//\n\n/**\n * Structural base shared by the three sibling type-entity interfaces\n * ({@link Obj}, {@link Relation}, {@link Type}). NOT exported — callers\n * should constrain on {@link AnyEntity} when they want \"any of the three\"\n * and on the specific kind interface otherwise.\n */\ninterface BaseTypeEntity<A> {\n  /**\n   * Entity-kind brand of the type-entity value itself — always `EntityKind.Type`.\n   * The kind of instance the type *describes* lives on `[SchemaKindId]`\n   * (Object / Relation / Type). Lets `Obj.isObject` / `Relation.isRelation`\n   * reject type entities by a single `[KindId]` check.\n   */\n  readonly [internal.KindId]: internal.EntityKind.Type;\n\n  /**\n   * Object id. Like all ECHO entities, type entities always carry an id —\n   * stamped at construction for in-memory (static) declarations and assigned by\n   * the database once persisted. The id does NOT determine the entity's URI:\n   * static types resolve to their typename DXN, persisted types to `echo:/<id>`\n   * (see `getTypeURIFromSpecifier`).\n   */\n  readonly id: ObjectId;\n\n  readonly name?: string;\n  // NOTE: `typename` / `version` are intentionally NOT fields on any type-entity\n  // interface. Both static and persisted entities carry them in `ObjectMeta`\n  // (`key` / `version`); read them via `Type.getTypename(self)` /\n  // `Type.getVersion(self)` — never as a direct property.\n  readonly jsonSchema: internal.JsonSchemaType;\n  readonly [InstancePhantomId]?: A;\n}\n\n//\n// Obj — `Type.Type` value for an ECHO object schema.\n//\n\n/**\n * TypeScript type for an ECHO object type — a `Type.Type<A>` entity.\n *\n * `T` is the instance type produced by `Obj.make(Foo, props)`. `Fields` is\n * retained as a structural hint (the runtime value still carries `.fields`),\n * but consumers should derive instance/encoded types via `Type.InstanceType`.\n *\n * **Not a `Schema.Schema`.** `Foo.ast` / `Schema.Schema.Type<typeof Foo>` /\n * `Schema.extend(Foo)` no longer typecheck — extract the Effect Schema via\n * `Type.getSchema(Foo)` first, or derive instance types via\n * `Type.InstanceType<typeof Foo>`.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));\n *\n * type Person = Type.InstanceType<typeof Person>;\n * ```\n */\nexport interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields> extends BaseTypeEntity<\n  T & EntityModule.OfKind<typeof EntityModule.Kind.Object>\n> {\n  /** Schema-kind brand (object). */\n  readonly [internal.SchemaKindId]: internal.EntityKind.Object;\n\n  /** Source Effect Schema — used internally by `Type.getSchema(self)`. */\n  readonly [internal.StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;\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 * Type that represents any ECHO object type — a `Type.Type` entity branded\n * with the object entity kind, i.e. what `Type.makeObject(dxn)` produces.\n */\nexport type AnyObj = Obj<unknown>;\n\n/**\n * Factory function to create an ECHO object type.\n *\n * Returns a `Type.Type` entity — a live, in-memory `TypeSchema` instance,\n * NOT a `Schema.Schema`. Use `Type.InstanceType<typeof Foo>` for the instance\n * type and `Type.getSchema(Foo)` to obtain the underlying Effect Schema.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));\n * ```\n */\nexport const makeObject: {\n  (dxn: DXN.DXN): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;\n} = internal.EchoObjectSchema as any;\n\n//\n// Type — the ECHO entity that holds a schema and metadata.\n// Persisted via `db.add()`; subscribed to via `Filter.type(Type.Type)`.\n//\n\n/**\n * ECHO meta-schema entity — stores `{ name?, typename, version, jsonSchema }`.\n * Type-kind sibling of `Type.makeObject(...)` / `Type.makeRelation(...)` outputs.\n * Stored types live under this entity; filter via `Filter.type(Type.Type)`.\n */\nexport const Type: Type<typeInternal.TypeSchema> = typeInternal.TypeSchema as any;\n\n/**\n * Default version stamped on draft (unnamed) types created via\n * {@link makeObjectFromJsonSchema} / {@link makeRelationFromJsonSchema} when\n * the caller does not supply one. Pure dynamic drafts surface as `'0.0.0'`\n * until they are persisted, at which point automerge-heads suffix the version.\n */\nconst DRAFT_VERSION = '0.0.0';\n\n/**\n * Common props shared by the type-kind factories. Typename and version are\n * optional — drafts omit typename and default version to {@link DRAFT_VERSION}.\n */\ntype MakeTypeProps = {\n  jsonSchema: internal.JsonSchemaType;\n  typename?: string;\n  version?: string;\n  name?: string;\n  id?: ObjectId;\n};\n\n/**\n * Construct a new object-kind type entity from raw metadata — for cases where\n * an Effect Schema isn't available (e.g. JSON-Schema arriving over the network\n * or from a UI editor). Parallel to {@link makeObject} but takes pre-built\n * `jsonSchema` instead of piping through an Effect schema.\n *\n * The returned entity is in-memory; persist it with `db.add(entity)`.\n */\nexport const makeObjectFromJsonSchema = (props: MakeTypeProps): Type<typeInternal.TypeSchema> => {\n  const { typename, version, ...data } = props;\n  // `typename` / `version` are routed through `ObjectMeta` (`key` / `version`)\n  // — the canonical registry-provenance pair — not data fields. Drafts default\n  // to `'0.0.0'`; the version is omitted from meta entirely when the caller\n  // doesn't supply one so the proxy projection can apply its own default.\n  return internal.makeObject(\n    internal.getStaticTypeSchema(typeInternal.TypeSchema) as any,\n    data as any,\n    {\n      keys: [],\n      key: typename,\n      version: version ?? DRAFT_VERSION,\n    },\n    typeInternal.TypeSchema,\n  ) as unknown as Type<typeInternal.TypeSchema>;\n};\n\n/**\n * Construct a new relation-kind type entity from raw metadata. Parallel to\n * {@link makeRelation} but takes pre-built `jsonSchema` instead of piping\n * through an Effect schema. `source` / `target` accept either a static\n * `Type.Obj` entity or the well-known `Obj.Unknown` schema.\n *\n * The returned entity is in-memory; persist it with `db.add(entity)`.\n */\nexport const makeRelationFromJsonSchema = (\n  props: MakeTypeProps & {\n    source: AnyObj | internal.UnknownTypeSchema<any, typeof EntityModule.Kind.Object>;\n    target: AnyObj | internal.UnknownTypeSchema<any, typeof EntityModule.Kind.Object>;\n  },\n): Type<typeInternal.TypeSchema> => {\n  const { source, target, jsonSchema, typename, version, ...rest } = props;\n  // Embed source/target DXNs + relation entity-kind into the jsonSchema so the\n  // entity round-trips correctly through `toEffectSchema` / queries / refs.\n  const sourceURI = internal.getTypeURIFromSpecifier(source);\n  const targetURI = internal.getTypeURIFromSpecifier(target);\n  const enrichedJsonSchema: internal.JsonSchemaType = {\n    ...jsonSchema,\n    entityKind: internal.EntityKind.Relation,\n    relationSource: { $ref: sourceURI },\n    relationTarget: { $ref: targetURI },\n  };\n  // `typename` / `version` route through `ObjectMeta` (see\n  // {@link makeObjectFromJsonSchema}); drafts default version to `'0.0.0'`.\n  return internal.makeObject(\n    internal.getStaticTypeSchema(typeInternal.TypeSchema) as any,\n    { ...rest, jsonSchema: enrichedJsonSchema } as any,\n    {\n      keys: [],\n      key: typename,\n      version: version ?? DRAFT_VERSION,\n    },\n    typeInternal.TypeSchema,\n  ) as unknown as Type<typeInternal.TypeSchema>;\n};\n\n/**\n * TypeScript type for an ECHO relation type — a `Type.Type<A>` entity.\n *\n * `T` is the instance-property type produced by `Relation.make(...)` (excluding\n * source/target endpoints). `Source` and `Target` are the endpoint types.\n *\n * **Not a `Schema.Schema`.** See {@link Obj}'s note.\n */\nexport interface Relation<\n  T,\n  Source,\n  Target,\n  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,\n> extends BaseTypeEntity<\n  RelationModule.Endpoints<Source, Target> & T & EntityModule.OfKind<typeof EntityModule.Kind.Relation>\n> {\n  /** Schema-kind brand (relation). */\n  readonly [internal.SchemaKindId]: internal.EntityKind.Relation;\n\n  /** Source Effect Schema — used internally by `Type.getSchema(self)`. */\n  readonly [internal.StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;\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 * Type that represents any ECHO relation type — a `Type.Type` entity branded\n * with the relation entity kind, i.e. what `Type.makeRelation(...)` produces.\n */\nexport type AnyRelation = Relation<unknown, unknown, unknown>;\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.makeRelation({\n *   dxn: DXN.make('com.example.type.worksFor', '0.1.0'),\n *   source: Person,\n *   target: Company,\n * }));\n * ```\n */\nexport const makeRelation: {\n  <SourceInstance, TargetInstance>(opts: {\n    dxn: DXN.DXN;\n    source: Obj<SourceInstance, any> | internal.UnknownTypeSchema<SourceInstance, typeof EntityModule.Kind.Object>;\n    target: Obj<TargetInstance, any> | internal.UnknownTypeSchema<TargetInstance, typeof EntityModule.Kind.Object>;\n  }): <Self extends Schema.Schema.Any>(\n    self: Self,\n  ) => Relation<\n    Schema.Schema.Type<Self>,\n    SourceInstance & EntityModule.OfKind<typeof EntityModule.Kind.Object>,\n    TargetInstance & EntityModule.OfKind<typeof EntityModule.Kind.Object>\n  >;\n} = internal.EchoRelationSchema as any;\n\n/**\n * Type that represents any ECHO type-kind entity — a `Type.Type` meta-schema\n * value (static `Type.Type` or a persisted draft from `db.add(...)`).\n * Mirrors {@link AnyObj} / {@link AnyRelation} for the third sibling kind.\n */\nexport type AnyType = Type<unknown>;\n\n/**\n * Any ECHO type-entity — one of the three sibling kinds: object-kind, relation-kind,\n * or type-kind (the meta-schema). APIs that want \"any ECHO type\" use this union;\n * the underlying Effect Schema is retrieved via `Type.getSchema`.\n */\nexport type AnyEntity = AnyObj | AnyRelation | AnyType;\n\n/**\n * Type guard: narrows a `Type.AnyEntity` to an object-kind entity. Checks\n * ENTITIES, not instances — use `Obj.isObject` for instances. Raw\n * `Schema.Schema` values (including the branded `Obj.Unknown` companion)\n * are intentionally not accepted; inspect their `TypeAnnotation` directly.\n */\nexport const isObject = (entity: AnyEntity): entity is AnyObj => {\n  return internal.getSchemaKind(entity) === internal.EntityKind.Object;\n};\n\n/**\n * Type guard: narrows a `Type.AnyEntity` to a relation-kind entity. Checks\n * ENTITIES, not instances — use `Relation.isRelation` for instances.\n */\nexport const isRelation = (entity: AnyEntity): entity is AnyRelation => {\n  return internal.getSchemaKind(entity) === internal.EntityKind.Relation;\n};\n\n/**\n * Type guard: narrows a `Type.AnyEntity` to the type-kind meta-schema\n * (e.g. `Type.Type`). Mirrors {@link isObject} / {@link isRelation}.\n */\nexport const isTypeKindSchema = (entity: AnyEntity): entity is Type => {\n  return internal.getSchemaKind(entity) === internal.EntityKind.Type;\n};\n\n/**\n * Narrow a `Type.AnyEntity` (e.g. one returned from `schemaRegistry.query(...)`)\n * to `AnyObj`, throwing if it describes a relation or the type-kind\n * meta-schema. Use at call sites that need to pass the value to `Obj.make`,\n * `Filter.type`, or other object-only APIs.\n */\nexport const assertObject = (entity: AnyEntity): AnyObj => {\n  invariant(isObject(entity), 'Expected an object-kind Type entity.');\n  return entity;\n};\n\n/** Narrow a `Type.AnyEntity` to `AnyRelation`, throwing otherwise. */\nexport const expectRelation = (entity: AnyEntity): AnyRelation => {\n  invariant(isRelation(entity), 'Expected a relation-kind Type entity.');\n  return entity;\n};\n\n/** Narrow a `Type.AnyEntity` to the `Type.Type` meta-schema, throwing otherwise. */\nexport const expectTypeKind = (entity: AnyEntity): Type => {\n  invariant(isTypeKindSchema(entity), 'Expected a type-kind Type entity.');\n  return entity;\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 * Returns the URI identifying a type entity. Always defined.\n *\n * - Static `Type.Obj` / `Type.Relation` → typename DXN (e.g. `dxn:com.example.type.person:0.1.0`).\n * - Persisted `Type.Type` instance (has `id`) → local `EchoURI` (`echo:/<objectId>`).\n * - In-memory `Type.Type` draft (has `id`, no typename) → local `EchoURI`.\n *\n * Only accepts `Type.AnyEntity` entities. Raw `Schema.Schema` values and the\n * branded `Obj.Unknown` / `Relation.Unknown` schemas are intentionally not\n * supported — use `internal.getSchemaURI` or the schema's typename annotation\n * directly when working at the schema level.\n */\nexport const getURI = (input: AnyEntity): URI.URI => {\n  // For Type entities, route through `getTypeURIFromSpecifier` (id → EchoURI,\n  // typename/version → DXN). For Obj/Relation entities, unwrap to the source\n  // Effect Schema first and read its annotations.\n  if (isType(input)) {\n    return internal.getTypeURIFromSpecifier(input);\n  }\n  return internal.getSchemaURI(getSchema(input)) ?? raise(new TypeError('Type entity has no URI'));\n};\n\n/**\n * @returns The typename. Example: `com.example.type.person`.\n *\n * Persisted `Type.Type` entities carry typename in `ObjectMeta.key` (the\n * canonical registry-provenance field); unnamed drafts fall back to the\n * entity's object id so the helper always returns a string. Any `dxn:` or\n * `echo:/` prefix is stripped — typename is a bare identifier, not a URI.\n */\n// TODO(wittjosiah): For in-database types this should return the object id once the registry\n//   has more robust options for shadowing types (so callers can disambiguate db-stored copies).\nexport const getTypename = (input: AnyEntity): string => {\n  // Both in-memory and in-database entities carry typename in `ObjectMeta.key`\n  // — the canonical registry-provenance field. In-memory entities attach meta\n  // eagerly (see `makeEchoTypeSchema`), so a single meta-backed read covers\n  // both forms. Unnamed drafts fall back to the entity id.\n  const meta = internal.getMetaChecked(input);\n  let typename: string = (meta.key as string | undefined) ?? (input.id as string);\n  // Typename is a bare identifier — strip URI prefixes if a caller seeded\n  // meta.key with one accidentally (or if a static entity carries a DXN-\n  // style typename).\n  typename = stripTypenamePrefix(typename);\n  invariant(typeof typename === 'string' && typename.length > 0, 'Invalid typename');\n  return typename;\n};\n\n/**\n * Gets the version.\n * @example 0.1.0\n * @example 0.1.0-<heads> (in-database, versioned by automerge heads)\n *\n * The registry-provenance semver lives in `ObjectMeta.version`; unversioned\n * drafts default to {@link DRAFT_VERSION} (`'0.0.0'`). In-database entities are\n * additionally versioned by their automerge heads, which are exposed as the\n * semver pre-release tag (`<semver>-<heads>`). In-memory declarations have no\n * heads and surface the bare semver. Read the registry semver alone via\n * `Type.getMeta(input).version`.\n */\nexport const getVersion = (input: AnyEntity): string => {\n  const meta = internal.getMetaChecked(input);\n  const semver = (meta.version as string | undefined) ?? DRAFT_VERSION;\n  invariant(typeof semver === 'string' && semver.match(/^\\d+\\.\\d+\\.\\d+$/), 'Invalid version');\n  // In-database entities are versioned by their automerge heads; expose them as\n  // the semver pre-release tag. In-memory drafts carry no heads → bare semver.\n  const heads = internal.version(input).automergeHeads;\n  if (heads != null && heads.length > 0) {\n    return `${semver}-${[...heads].sort().join('.')}`;\n  }\n  return semver;\n};\n\n/**\n * Strip URI prefixes (`dxn:`, `echo:/`, `echo://`) from a typename string.\n * Typename is a bare identifier — callers reading from meta or from a\n * caller-supplied seed value shouldn't propagate URI prefixes downstream.\n */\nconst stripTypenamePrefix = (value: string): string => {\n  if (value.startsWith('dxn:')) {\n    return value.slice('dxn:'.length);\n  }\n  if (value.startsWith('echo://')) {\n    return value.slice('echo://'.length);\n  }\n  if (value.startsWith('echo:/')) {\n    return value.slice('echo:/'.length);\n  }\n  return value;\n};\n\n/**\n * Type predicate: true iff the value is any type-kind ECHO entity — a static\n * `Type.Obj` / `Type.Relation` produced by `Type.makeObject` / `Type.makeRelation`, a\n * static meta `Type.Type`, or a persisted `Type.Type` returned by the database.\n *\n * All three branches stamp `[KindId] = Type`, so this is a single brand check.\n * Use {@link isObject} / {@link isRelation} / {@link isTypeKindSchema}\n * when you need to discriminate further; use {@link getDatabase} when you mean\n * \"is this a db-attached type\" (vs. an in-memory declaration).\n */\nexport const isType = (value: unknown): value is AnyEntity =>\n  internal.getEntityKindBrand(value) === internal.EntityKind.Type;\n\n/**\n * Get the database the type entity belongs to, or `undefined` if it is an\n * in-memory declaration (`Type.makeObject` / `Type.makeRelation` result) not\n * yet attached to a database. Mirrors `Obj.getDatabase` / `Relation.getDatabase`.\n *\n * Database attachment is the canonical discriminator between in-memory and\n * in-database type entities — both are live reactive `TypeSchema` instances and\n * are otherwise indistinguishable.\n */\nexport const getDatabase = (input: AnyEntity): Database.Database | undefined => internal.getDatabase(input);\n\n/**\n * Mutable meta type returned by `Type.getMeta` inside a `Type.update` callback.\n * Mirrors `Obj.Meta` / `Relation.Meta` — `Type.Type` is an Entity like its\n * siblings, so its meta is the same `ObjectMeta` record:\n * `{ keys, tags?, key?, version? }`.\n *\n * `key` / `version` here are the canonical registry-provenance pair\n * (typename + semver) on persisted Type.Type entities; they are absent on\n * unnamed drafts. Use {@link getTypename} / {@link getVersion} when you want\n * a non-`undefined` value with id / {@link DRAFT_VERSION} fallbacks.\n */\nexport type Meta = internal.Meta;\n\n/**\n * Deeply read-only version of {@link Meta}.\n * Prevents mutation at all nesting levels (e.g., `meta.keys.push()` is a TS error).\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Returns the entity's `ObjectMeta`. Same semantics as `Obj.getMeta` /\n * `Relation.getMeta` — `Type.Type` is an Entity and carries the canonical\n * `ObjectMeta` directly. Returns mutable meta when passed a mutable type\n * (inside a `Type.update` callback), read-only meta otherwise.\n *\n * For persisted Type entities, `meta.key` holds the typename and\n * `meta.version` holds the semver. Use {@link getTypename} / {@link getVersion}\n * if you want the helpers' id / {@link DRAFT_VERSION} fallbacks for drafts.\n *\n * Both persisted and in-memory type entities (`Type.makeObject` /\n * `Type.makeRelation` results) carry their `ObjectMeta` via `[MetaId]`, so the\n * lookup is uniform.\n */\nexport function getMeta(entity: internal.Mutable<AnyEntity>): Meta;\nexport function getMeta(entity: Mutable): Meta;\nexport function getMeta(entity: AnyEntity): ReadonlyMeta;\nexport function getMeta(entity: AnyEntity | internal.Mutable<AnyEntity> | Mutable): ReadonlyMeta | Meta {\n  // The `Mutable` overload accepts the narrowed view passed to `Type.update`\n  // callbacks; at runtime that draft IS the underlying persisted Type entity,\n  // so the same `MetaId` lookup works.\n  invariant(isType(entity), 'Expected a Type entity.');\n  // Both persisted and in-memory type entities carry runtime `ObjectMeta` via\n  // `[MetaId]`, so the lookup is uniform.\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * String key used to phantom-carry the instance type produced by a `Type.Type`.\n * Used by `Type.InstanceType<typeof Foo>` to recover the schema instance type\n * since `Type.makeObject(dxn)` does not return a `Schema.Schema`.\n *\n * Re-exported from the internal types layer so both `Type.ts` and internal\n * helpers (`makeObject`, `createObject`) reference the same phantom key.\n */\nexport const InstancePhantomId = internal.InstancePhantomId;\nexport type InstancePhantomId = internal.InstancePhantomId;\n\n/**\n * Sibling of {@link Obj} / {@link Relation} for the third ECHO entity kind:\n * **type-kind** entities (meta-schemas). The singleton {@link Type} const is\n * the canonical example — it describes stored type definitions themselves.\n *\n * Not a `Schema.Schema`. Use `Type.getSchema(value)` to obtain the underlying\n * Effect Schema and `Type.update(value, draft => ...)` to mutate.\n *\n * `A` is the instance-type phantom — what `Obj.make(value, ...)` would produce.\n * Merged with the `Type` const value via TypeScript declaration merging.\n */\nexport interface Type<A = unknown> extends BaseTypeEntity<A & EntityModule.OfKind<typeof EntityModule.Kind.Type>> {\n  /** Schema-kind brand (type — the meta-schema kind). */\n  readonly [internal.SchemaKindId]: internal.EntityKind.Type;\n\n  /** Source Effect Schema — used internally by `Type.getSchema(self)`. */\n  readonly [internal.StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;\n}\n\n/**\n * Instance type produced by a Type entity.\n *\n * Accepts ONLY {@link AnyEntity} inputs — `Type.Obj`, `Type.Relation`, or\n * `Type.Type`. Raw Effect `Schema.Schema` values are rejected: for those, use\n * `Schema.Schema.Type<typeof Foo>` directly. This separation keeps the type\n * system honest about which values represent ECHO entities versus plain\n * Effect schemas.\n *\n * Dispatches on the entity kind:\n *  - `Relation<Props, S, T>` → `Endpoints<S,T> & Props & OfKind<Relation>`\n *  - `Obj<A>`                → `A & OfKind<Object>`\n *  - `Type<A>`               → `A & OfKind<Type>`\n */\nexport type InstanceType<T extends AnyEntity> =\n  T extends Relation<infer Props, infer Source, infer Target, any>\n    ? RelationModule.Endpoints<Source, Target> & Props & EntityModule.OfKind<typeof EntityModule.Kind.Relation>\n    : T extends Obj<infer A, any>\n      ? A & EntityModule.OfKind<typeof EntityModule.Kind.Object>\n      : T extends Type<infer A>\n        ? A & EntityModule.OfKind<typeof EntityModule.Kind.Type>\n        : never;\n\n/**\n * Returns the Effect Schema for a type entity.\n *\n * - For static `Type.Obj` / `Type.Relation` entities the source Effect Schema is\n *   read from a hidden slot — these overloads preserve the instance type.\n * - For `Type.Type` entities (the meta-schema kind) the schema is rebuilt from\n *   `type.jsonSchema`; the instance type isn't statically knowable so the wide\n *   `AnyEntity` overload widens to `Schema.Schema.AnyNoContext`.\n *\n * Always call this when you need to interact with the Effect Schema API\n * (e.g. before passing to Effect.Schema functions). For ECHO-side APIs\n * (`Obj.make`, `Filter.type`, `Ref`) pass the type entity directly.\n *\n * Only accepts `Type.AnyEntity` — raw `Schema.Schema` values can be used\n * directly without unwrapping.\n */\nexport function getSchema<T extends AnyObj>(type: T): Schema.Schema<InstanceType<T>>;\nexport function getSchema<T extends AnyRelation>(type: T): Schema.Schema<InstanceType<T>>;\nexport function getSchema(type: AnyEntity): Schema.Schema.AnyNoContext;\nexport function getSchema(type: AnyEntity): Schema.Schema.AnyNoContext {\n  // Static `Type.Type` entities carry the source Effect Schema on a hidden\n  // slot so we can return it without round-tripping through JsonSchema.\n  const staticSchema = internal.getStaticTypeSchema(type);\n  if (staticSchema != null) {\n    return staticSchema;\n  }\n  invariant(isType(type), 'Expected a Type entity.');\n  // Persisted `Type.Type` entity — build the Effect Schema from its stored\n  // jsonSchema and re-attach the TypeIdentifierAnnotation so the rebuilt\n  // schema's URI (via getSchemaURI) matches the entity's local EchoURI.\n  const rebuilt = internal.toEffectSchema(type.jsonSchema);\n  if (typeof type.id === 'string') {\n    return rebuilt.annotations({\n      [internal.TypeIdentifierAnnotationId]: EchoURI.make({ objectId: type.id }),\n    });\n  }\n  return rebuilt;\n}\n\n/**\n * Mutable view of a `Type.Type` — the shape passed to the `Type.update` callback.\n * Outside `Type.update`, `Type.Type` fields are read-only (both at the type level\n * and at runtime — direct assignment throws). Use this to constrain mutation to\n * the change context, analogous to `Obj.update(obj, (draft) => ...)`.\n *\n * NOTE: `typename` and `version` are intentionally absent — they live in\n * `ObjectMeta` (`key` / `version` — the canonical registry-provenance pair).\n * Read them via {@link getTypename} / {@link getVersion} / {@link getMeta};\n * `typename` is treated as immutable on persisted entities.\n *\n * Unlike `Obj.update` — whose mutable view is inferred as `Mutable<A>` over the\n * whole instance type because every data field is editable — a `Type.Type`\n * exposes only `name` and `jsonSchema` for mutation. The rest of its shape\n * (`id`, the `[KindId]` / `[SchemaKindId]` brands, and `typename` / `version`\n * in meta) is immutable, so this view is declared explicitly rather than\n * derived from `InstanceType<Type.Type>`.\n */\nexport interface Mutable {\n  name?: string;\n  // Deep-mutable within the change context — `Type.update`'s purpose is to allow\n  // mutation, so the draft exposes `jsonSchema` as writable (the readonly\n  // `JsonSchemaType` would force callers to cast).\n  jsonSchema: Types.DeepMutable<internal.JsonSchemaType>;\n}\n\n/**\n * Perform mutations on a `Type.Type` within a change context.\n *\n * The callback receives a {@link Mutable} view of the type — direct mutation of\n * a `Type.Type` outside `Type.update` throws at runtime, mirroring `Obj.update`.\n * Delegates to the same automerge-transaction primitive `Obj.update(obj, cb)` uses.\n */\nexport const update = (type: AnyEntity, callback: (mutable: Mutable) => void): void => {\n  // `Type.Type` is an ECHO object; the change machinery is the same as `Obj.update`.\n  internal.change(type, callback as internal.ChangeCallback<AnyEntity>);\n};\n\n//\n// Field-level helpers for mutating persisted types.\n// These are thin wrappers over `Type.update` plus the JsonSchema manipulation\n// utilities. Callers pass a persisted `Type.Type` (e.g. one returned by\n// `DatabaseSchemaRegistry.register`) and the helper drives the change context.\n//\n\n/**\n * Add fields to a persisted type's schema.\n * @throws if the type is not persisted.\n */\nexport const addFields = (type: AnyEntity, fields: Schema.Struct.Fields): void => {\n  const extended = typeInternal.addFieldsToSchema(getSchema(type), fields);\n  update(type, (draft) => {\n    draft.jsonSchema = internal.toJsonSchema(extended);\n  });\n};\n\n/**\n * Replace existing fields on a persisted type's schema.\n * @throws if the type is not persisted.\n */\nexport const updateFields = (type: AnyEntity, fields: Schema.Struct.Fields): void => {\n  const updated = typeInternal.updateFieldsInSchema(getSchema(type), fields);\n  update(type, (draft) => {\n    draft.jsonSchema = internal.toJsonSchema(updated);\n  });\n};\n\n/**\n * Rename a field on a persisted type's schema.\n * @throws if the type is not persisted.\n */\nexport const updateFieldPropertyName = (\n  type: Type,\n  { before, after }: { before: PropertyKey; after: PropertyKey },\n): void => {\n  const renamed = typeInternal.updateFieldNameInSchema(getSchema(type), { before, after });\n  update(type, (draft) => {\n    draft.jsonSchema = internal.toJsonSchema(renamed);\n  });\n};\n\n/**\n * Remove fields from a persisted type's schema.\n * @throws if the type is not persisted.\n */\nexport const removeFields = (type: AnyEntity, fieldNames: string[]): void => {\n  const removed = typeInternal.removeFieldsFromSchema(getSchema(type), fieldNames);\n  update(type, (draft) => {\n    draft.jsonSchema = internal.toJsonSchema(removed);\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["InstancePhantomId", "getDatabase", "makeObject", "raise", "invariant", "EchoURI", "makeObject", "version", "typename", "typeInternal", "enrichedJsonSchema", "entityKind", "EntityKind", "relationSource", "sourceURI", "relationTarget", "keys", "entity", "getSchemaURI", "input", "semver", "DRAFT_VERSION", "invariant", "heads", "join", "value", "startsWith", "getDatabase", "InstancePhantomId", "staticSchema", "isType", "annotations", "internal", "TypeIdentifierAnnotationId", "objectId", "change", "callback", "type", "draft", "extended", "updated", "before", "after", "update", "removed"]
+}

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

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

package/dist/lib/neutral/chunk-V5NE2X7Y.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   *  - org.dxos.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\n// TODO(dmaretskyi): Rename TypeRegistry\nexport interface SchemaRegistry {\n  /**\n   * Checks if the provided schema is registered.\n   */\n  hasSchema(schema: Type.AnyEntity): boolean;\n\n  /**\n   * Registers the provided schema(s).\n   *\n   * @returns The persisted type entities. The entity kind of each input is\n   * preserved (an object schema comes back as `Type.AnyObj`), so the result can\n   * be chained into `Obj.make` / `Relation.make` without casts. Each stored\n   * schema is also a `Type.Type` record, so its `Ref` targets a\n   * `Ref(Type.Type)` field.\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<T extends Type.AnyEntity>(input: T[]): Promise<T[]>;\n  register(input: RegisterSchemaInput[]): Promise<Type.Type[]>;\n\n  query<Q extends Types.NoExcessProperties<Query, Q>>(query?: Q & Query): QueryResult.QueryResult<Type.Type>;\n}\n"],
+  "mappings": ";AAAA;",
+  "names": []
+}

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

@@ -0,0 +1,7 @@
+// src/QueryResult.ts
+var QueryResult_exports = {};
+
+export {
+  QueryResult_exports
+};
+//# sourceMappingURL=chunk-V72DY6LU.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryResult.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\n// TODO(burdon): Should T be constrained to Entity.Any?\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n}\n"],
+  "mappings": ";AAAA;",
+  "names": []
+}

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

@@ -0,0 +1,269 @@
+import {
+  TypeId,
+  getSchemaURI,
+  getTypename
+} from "./chunk-KHRAQDYX.mjs";
+import {
+  EntityKind,
+  KindId,
+  getStaticTypeSchema
+} from "./chunk-A5HDDVKS.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-GOHDOJE3.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Database: () => Database,
+  Service: () => Service,
+  TypeId: () => TypeId2,
+  add: () => add,
+  flush: () => flush,
+  isDatabase: () => isDatabase,
+  layer: () => layer,
+  load: () => load,
+  loadOption: () => loadOption,
+  makeService: () => makeService,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  registerSchema: () => registerSchema,
+  remove: () => remove,
+  resolve: () => resolve,
+  runQuery: () => runQuery,
+  runQueryFirst: () => runQueryFirst,
+  runSchemaQuery: () => runSchemaQuery,
+  schemaQuery: () => schemaQuery,
+  spaceId: () => spaceId
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema3 from "effect/Schema";
+import { promiseWithCauseCapture } from "@dxos/effect";
+import { invariant as invariant4 } from "@dxos/invariant";
+
+// src/internal/Entity/type-uri.ts
+import * as Schema2 from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { assertArgument as assertArgument2 } from "@dxos/invariant";
+import { DXN, URI } from "@dxos/keys";
+
+// src/internal/common/types/model-symbols.ts
+var ATTR_SELF_URI = "@uri";
+var ATTR_SELF_URI_LEGACY = "@dxn";
+var SelfURIId = /* @__PURE__ */ Symbol.for("@dxos/echo/URI");
+var ATTR_DELETED = "@deleted";
+var ObjectDeletedId = /* @__PURE__ */ Symbol.for("@dxos/echo/Deleted");
+var ObjectVersionId = /* @__PURE__ */ Symbol.for("@dxos/echo/Version");
+var ObjectDatabaseId = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var ATTR_RELATION_SOURCE = "@relationSource";
+var RelationSourceId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationSource");
+var RelationSourceDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationSourceDXN");
+var ATTR_RELATION_TARGET = "@relationTarget";
+var RelationTargetId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationTarget");
+var RelationTargetDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationTargetDXN");
+
+// src/internal/Entity/api.ts
+import { invariant as invariant3 } from "@dxos/invariant";
+import { assumeType as assumeType3 } from "@dxos/util";
+
+// src/internal/Entity/model.ts
+import { invariant } from "@dxos/invariant";
+import { EchoURI, ObjectId } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/model.ts";
+function assertObjectModel(obj) {
+  invariant(typeof obj === "object" && obj !== null, "Invalid object model: not an object", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 12, S: this, A: ["typeof obj === 'object' && obj !== null", "'Invalid object model: not an object'"] });
+  assumeType(obj);
+  invariant(ObjectId.isValid(obj.id), "Invalid object model: invalid id", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 14, S: this, A: ["ObjectId.isValid(obj.id)", "'Invalid object model: invalid id'"] });
+  invariant(obj[TypeId] === void 0 || typeof obj[TypeId] === "string", "Invalid object model: invalid type", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 15, S: this, A: ["obj[TypeId] === undefined || typeof obj[TypeId] === 'string'", "'Invalid object model: invalid type'"] });
+  invariant(obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type, "Invalid object model: invalid entity kind", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 16, S: this, A: ["obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type", "'Invalid object model: invalid entity kind'"] });
+  if (obj[KindId] === EntityKind.Relation) {
+    invariant(EchoURI.isEchoURI(obj[RelationSourceDXNId]), "Invalid object model: invalid relation source", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 18, S: this, A: ["EchoURI.isEchoURI(obj[RelationSourceDXNId])", "'Invalid object model: invalid relation source'"] });
+    invariant(EchoURI.isEchoURI(obj[RelationTargetDXNId]), "Invalid object model: invalid relation target", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 19, S: this, A: ["EchoURI.isEchoURI(obj[RelationTargetDXNId])", "'Invalid object model: invalid relation target'"] });
+    invariant(!EchoURI.isEchoURI(obj[RelationSourceId]), "Invalid object model: source pointer is a DXN", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 20, S: this, A: ["!EchoURI.isEchoURI(obj[RelationSourceId])", "'Invalid object model: source pointer is a DXN'"] });
+    invariant(!EchoURI.isEchoURI(obj[RelationTargetId]), "Invalid object model: target pointer is a DXN", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 21, S: this, A: ["!EchoURI.isEchoURI(obj[RelationTargetId])", "'Invalid object model: target pointer is a DXN'"] });
+  }
+}
+
+// src/internal/Entity/util.ts
+import * as Schema from "effect/Schema";
+import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
+import { EchoURI as EchoURI2, ObjectId as ObjectId2 } from "@dxos/keys";
+import { assumeType as assumeType2 } from "@dxos/util";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/util.ts";
+var getObjectEchoUri = (object) => {
+  invariant2(!Schema.isSchema(object), "schema not allowed in this function", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 15, S: void 0, A: ["!Schema.isSchema(object)", "'schema not allowed in this function'"] });
+  assertArgument(typeof object === "object" && object != null, "object", "expected object");
+  assumeType2(object);
+  if (object[SelfURIId]) {
+    invariant2(EchoURI2.isEchoURI(object[SelfURIId]), "Invalid object model: invalid self dxn", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 19, S: void 0, A: ["EchoURI.isEchoURI(object[SelfURIId])", "'Invalid object model: invalid self dxn'"] });
+    return EchoURI2.parse(object[SelfURIId]);
+  }
+  if (!ObjectId2.isValid(object.id)) {
+    throw new TypeError("Object id is not valid.");
+  }
+  return EchoURI2.make({
+    objectId: object.id
+  });
+};
+
+// src/internal/Entity/api.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/api.ts";
+var getUri = (entity) => {
+  const uri = getObjectEchoUri(entity);
+  invariant3(uri != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 13, S: void 0, A: ["uri != null", "'Invalid entity.'"] });
+  return uri;
+};
+var getDatabase = (entity) => {
+  assumeType3(entity);
+  return entity[ObjectDatabaseId];
+};
+
+// src/internal/Entity/type-uri.ts
+var getTypeURIFromSpecifier = (input) => {
+  if (Schema2.isSchema(input)) {
+    return getSchemaURI(input) ?? raise(new TypeError("Schema has no URI"));
+  }
+  if (typeof input === "object" && input !== null && KindId in input) {
+    const schema = getStaticTypeSchema(input);
+    if (schema != null) {
+      return getSchemaURI(schema) ?? raise(new TypeError("Type entity has no URI"));
+    }
+    return getUri(input);
+  }
+  assertArgument2(typeof input === "string", "input");
+  assertArgument2(!input.startsWith("dxn:"), "input");
+  return DXN.make(input);
+};
+var isInstanceOf = (schemaOrType, object) => {
+  if (object == null) {
+    return false;
+  }
+  const schemaURI = getTypeURIFromSpecifier(schemaOrType);
+  const type = object[TypeId];
+  if (URI.isURI(type) && type === schemaURI) {
+    return true;
+  }
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+  if (!DXN.isDXN(schemaURI)) {
+    return false;
+  }
+  const parsed = DXN.tryMake(schemaURI);
+  return parsed != null && DXN.getName(parsed) === typename;
+};
+
+// src/Database.ts
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+var TypeId2 = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var isDatabase = (obj) => {
+  return obj ? typeof obj === "object" && TypeId2 in obj && obj[TypeId2] === TypeId2 : false;
+};
+var Database = Schema3.Any.pipe(Schema3.filter((space) => isDatabase(space)));
+var Service = class extends Context.Tag("@dxos/echo/Database/Service")() {
+};
+var notAvailable = Layer.succeed(Service, {
+  get db() {
+    throw new Error("Database not available");
+  }
+});
+var makeService = (db) => {
+  return {
+    get db() {
+      return db;
+    }
+  };
+};
+var layer = (db) => {
+  return Layer.succeed(Service, makeService(db));
+};
+var spaceId = Effect.gen(function* () {
+  const { db } = yield* Service;
+  return db.spaceId;
+});
+var resolve = (ref, schema) => Effect.gen(function* () {
+  const { db } = yield* Service;
+  const dxn = typeof ref === "string" ? ref : ref.uri;
+  const object = yield* promiseWithCauseCapture(() => db.graph.createRefResolver({
+    context: {
+      space: db.spaceId
+    }
+  }).resolve(dxn));
+  if (!object) {
+    return yield* Effect.fail(new ObjectNotFoundError(dxn));
+  }
+  invariant4(!schema || isInstanceOf(schema, object), "Object type mismatch.", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 70, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
+  return object;
+}).pipe(Effect.withSpan("Database.resolve"));
+var load = Effect.fn("Database.load")(function* (ref) {
+  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+  if (!object) {
+    return yield* Effect.fail(new ObjectNotFoundError(ref.uri));
+  }
+  return object;
+});
+var loadOption = Effect.fn("Database.loadOption")(function* (ref) {
+  const object = yield* load(ref).pipe(Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(void 0)));
+  return Option.fromNullable(object);
+});
+var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
+var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
+var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
+var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"));
+var runQuery = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())), Effect.withSpan("Database.runQuery"));
+var runQueryFirst = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined()))), Effect.withSpan("Database.runQueryFirst"));
+var registerSchema = (input) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))), Effect.withSpan("Database.registerSchema"));
+var schemaQuery = (schemaQueryOptions) => Service.pipe(Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)), Effect.withSpan("Database.schemaQuery"));
+var runSchemaQuery = (schemaQueryOptions) => schemaQuery(schemaQueryOptions).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+
+export {
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  SelfURIId,
+  ATTR_DELETED,
+  ObjectDeletedId,
+  ObjectVersionId,
+  ObjectDatabaseId,
+  ATTR_RELATION_SOURCE,
+  RelationSourceId,
+  RelationSourceDXNId,
+  ATTR_RELATION_TARGET,
+  RelationTargetId,
+  RelationTargetDXNId,
+  assertObjectModel,
+  getObjectEchoUri,
+  getUri,
+  getDatabase,
+  getTypeURIFromSpecifier,
+  isInstanceOf,
+  TypeId2 as TypeId,
+  isDatabase,
+  Database,
+  Service,
+  notAvailable,
+  makeService,
+  layer,
+  spaceId,
+  resolve,
+  load,
+  loadOption,
+  add,
+  remove,
+  flush,
+  query,
+  runQuery,
+  runQueryFirst,
+  registerSchema,
+  schemaQuery,
+  runSchemaQuery,
+  Database_exports
+};
+//# sourceMappingURL=chunk-ZII2BGPM.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts", "../../../src/internal/Entity/type-uri.ts", "../../../src/internal/common/types/model-symbols.ts", "../../../src/internal/Entity/api.ts", "../../../src/internal/Entity/model.ts", "../../../src/internal/Entity/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { type SpaceId, type URI } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { type AnyProperties } from './internal/common/types';\n// Deep import (not the `./internal/Entity` barrel) to avoid a cycle:\n// Database → internal/Entity → entity → JsonSchema → Ref → Database.\nimport { isInstanceOf } from './internal/Entity/type-uri';\nimport type { Ref } from './internal/Ref/ref';\nimport type * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as SchemaRegistry from './SchemaRegistry';\nimport type * as Type from './Type';\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\nexport interface QueryFn {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database, Feed, and Hypergraph.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default true\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * Identifier denoting an ECHO Database.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Database');\nexport type TypeId = typeof TypeId;\n\n/**\n * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  readonly [TypeId]: TypeId;\n\n  get spaceId(): SpaceId;\n\n  // TODO(burdon): Can we move this into graph?\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  get graph(): Hypergraph.Hypergraph;\n\n  toJSON(): object;\n\n  /**\n   * Return object by local ID.\n   */\n  getObjectById<T extends Obj.Unknown = Obj.OfShape<AnyProperties>>(\n    id: string,\n    opts?: GetObjectByIdOptions,\n  ): T | undefined;\n\n  /**\n   * Query objects.\n   */\n  query: QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.fromURI`\n   * `Ref.fromURI(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.\n   * `db.makeRef(dxn)` is preferable in cases with access to the database.\n   */\n  makeRef<T extends Entity.Unknown = Entity.Unknown>(uri: URI.URI): Ref<T>;\n\n  /**\n   * Adds object to the database.\n   */\n  add<T extends Entity.Unknown = Entity.Unknown>(obj: T, opts?: AddOptions): T;\n\n  /**\n   * Removes object from the database.\n   */\n  // TODO(burdon): Return true if removed (currently throws if not present).\n  remove(obj: Entity.Unknown): void;\n\n  /**\n   * Wait for all pending changes to be saved to disk.\n   * Optionaly waits for changes to be propagated to indexes and event handlers.\n   */\n  flush(opts?: FlushOptions): Promise<void>;\n}\n\nexport const isDatabase = (obj: unknown): obj is Database => {\n  return obj ? typeof obj === 'object' && TypeId in obj && obj[TypeId] === TypeId : false;\n};\n\nexport const Database: Schema.Schema<Database> = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));\n\n/**\n * Effect service tag for Database dependency injection.\n */\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {}\n\n/**\n * Layer that provides a Database service that throws when accessed.\n * Useful as a default layer when no database is available.\n */\nexport const notAvailable = Layer.succeed(Service, {\n  get db(): Database {\n    throw new Error('Database not available');\n  },\n});\n\n/**\n * Creates a Database service instance from a Database.\n */\nexport const makeService = (db: Database): Context.Tag.Service<Service> => {\n  return {\n    get db() {\n      return db;\n    },\n  };\n};\n\n/**\n * Creates a Layer that provides the Database service.\n */\nexport const layer = (db: Database): Layer.Layer<Service> => {\n  return Layer.succeed(Service, makeService(db));\n};\n\n/**\n * Returns the space ID of the database.\n */\nexport const spaceId = Effect.gen(function* () {\n  const { db } = yield* Service;\n  return db.spaceId;\n});\n\n/**\n * Resolves an object by its DXN.\n */\nexport const resolve: {\n  // No type check.\n  (ref: URI.URI | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n  // Check matches schema.\n  <S extends Type.AnyEntity>(\n    ref: URI.URI | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Type.InstanceType<S>, Err.ObjectNotFoundError, Service>;\n} = (<S extends Type.AnyEntity>(\n  ref: URI.URI | Ref<any>,\n  schema?: S,\n): Effect.Effect<Type.InstanceType<S>, Err.ObjectNotFoundError, Service> =>\n  Effect.gen(function* () {\n    const { db } = yield* Service;\n    const dxn = typeof ref === 'string' ? ref : ref.uri;\n    const object = yield* promiseWithCauseCapture(() =>\n      db.graph\n        .createRefResolver({\n          context: {\n            space: db.spaceId,\n          },\n        })\n        .resolve(dxn),\n    );\n\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(dxn));\n    }\n    // `isInstanceOf` uses a conditional generic that TS can't resolve through\n    // the local `S extends Type.AnyEntity` parameter — runtime accepts it fine.\n    invariant(!schema || isInstanceOf(schema as any, object), 'Object type mismatch.');\n    return object as any;\n  }).pipe(Effect.withSpan('Database.resolve'))) as any;\n\n/**\n * Loads an object reference.\n */\nexport const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn('Database.load')(\n  function* (ref) {\n    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(ref.uri));\n    }\n    return object;\n  },\n);\n\n/**\n * Loads an object reference option.\n */\n// TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.\nexport const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(\n  'Database.loadOption',\n)(function* (ref) {\n  const object = yield* load(ref).pipe(Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)));\n\n  return Option.fromNullable(object);\n});\n\n/**\n * Adds an object to the database.\n * @see {@link Database.add}\n */\nexport const add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan('Database.add'));\n\n/**\n * Removes an object from the database.\n * @see {@link Database.remove}\n */\nexport const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan('Database.remove'));\n\n/**\n * Flushes pending changes to disk.\n * @see {@link Database.flush}\n */\nexport const flush = (opts?: FlushOptions) =>\n  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(\n    Effect.withSpan('Database.flush'),\n  );\n\n/**\n * Creates a `QueryResult` object that can be subscribed to.\n */\nexport const query: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(\n    Effect.map(({ db }) => db.query(queryOrFilter as any) as QueryResult.QueryResult<any>),\n    Effect.withSpan('Database.query'),\n  );\n\n/**\n * Executes the query once and returns the results.\n */\nexport const runQuery: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n    Effect.withSpan('Database.runQuery'),\n  );\n\n/**\n * Executes the query once and returns the first result as or None.\n */\nexport const runQueryFirst: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Option.Option<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Option.Option<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) =>\n      promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined())),\n    ),\n    Effect.withSpan('Database.runQueryFirst'),\n  );\n\n/**\n * Persists schemas in the database so they replicate to other clients.\n * @see {@link SchemaRegistry.SchemaRegistry.register}\n */\nexport const registerSchema = (\n  input: SchemaRegistry.RegisterSchemaInput[],\n): Effect.Effect<Type.Type[], never, Service> =>\n  Service.pipe(\n    Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))),\n    Effect.withSpan('Database.registerSchema'),\n  );\n\n/**\n * Creates a schema query result that can be subscribed to.\n */\n// TODO(dmaretskyi): Change API to `yield* Database.querySchema(...).first` and `yield* Database.querySchema(...).schema`.\nexport const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<QueryResult.QueryResult<Type.Type>, never, Service> =>\n  Service.pipe(\n    Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)),\n    Effect.withSpan('Database.schemaQuery'),\n  );\n\n/**\n * Executes a schema query once and returns the results.\n */\nexport const runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<Type.Type[], never, Service> =>\n  schemaQuery(schemaQueryOptions).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n  );\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, URI } from '@dxos/keys';\n\nimport { getSchemaURI, getTypename } from '../Annotation';\nimport { type AnyEntity, InstancePhantomId, KindId, TypeId, getStaticTypeSchema } from '../common/types';\nimport { getUri as getUriFromEntity } from './api';\n\n/**\n * @param input schema, `Type.Type` entity, or a typename string.\n * @return type identifier URI — see {@link getSchemaURI}. For a typename string,\n * always a DXN. For a `Type.Type` entity, the URI of the schema it declares,\n * symmetric with what `Obj.make(typeEntity, ...)` stamps on `system.type`: a\n * static declaration resolves to its typename DXN, a persisted entity to its\n * local `echo:/<objectId>`.\n */\nexport const getTypeURIFromSpecifier = (input: Schema.Schema.All | AnyEntity | string): URI.URI => {\n  if (Schema.isSchema(input)) {\n    return getSchemaURI(input) ?? raise(new TypeError('Schema has no URI'));\n  }\n  if (typeof input === 'object' && input !== null && KindId in input) {\n    // `Type.Type` entity. Both in-memory and persisted forms expose the schema\n    // they declare via `StaticTypeSchemaSlot`, whose URI is exactly what\n    // `Obj.make` stamps on `system.type` — a static declaration carries\n    // `TypeAnnotation` (→ typename DXN), a persisted entity's rebuilt schema\n    // carries `TypeIdentifierAnnotation` (→ local `echo:/<objectId>`).\n    const schema = getStaticTypeSchema(input);\n    if (schema != null) {\n      return getSchemaURI(schema) ?? raise(new TypeError('Type entity has no URI'));\n    }\n    return getUriFromEntity(input as AnyEntity);\n  }\n  assertArgument(typeof input === 'string', 'input');\n  assertArgument(!input.startsWith('dxn:'), 'input');\n  return DXN.make(input);\n};\n\n/**\n * Checks if the object is an instance of the schema.\n * Only typename is compared, the schema version is ignored.\n *\n * The following cases are considered to mean that the object is an instance of the schema:\n *  - Object was created with this exact schema.\n *  - Object was created with a different version of this schema.\n *  - Object was created with a different schema (maybe dynamic) that has the same typename.\n */\n// TODO(burdon): Can we use `Schema.is`?\nexport const isInstanceOf = <S>(\n  schemaOrType: S extends Schema.Schema.AnyNoContext ? S : Schema.Schema.AnyNoContext | AnyEntity,\n  object: any,\n): object is S extends Schema.Schema.AnyNoContext\n  ? Schema.Schema.Type<S>\n  : S extends { readonly [InstancePhantomId]?: infer A }\n    ? A\n    : unknown => {\n  if (object == null) {\n    return false;\n  }\n\n  const schemaURI = getTypeURIFromSpecifier(schemaOrType);\n\n  // `object` is arbitrary input — read TypeId directly (it may be missing on\n  // non-entities) rather than via `getTypeURI` which asserts the URI is set.\n  const type = (object as any)[TypeId];\n  if (URI.isURI(type) && type === schemaURI) {\n    return true;\n  }\n\n  const typename = getTypename(object);\n  if (!typename) {\n    return false;\n  }\n\n  if (!DXN.isDXN(schemaURI)) {\n    // EchoURI-based schema URI — no typename match possible.\n    return false;\n  }\n\n  const parsed = DXN.tryMake(schemaURI);\n  return parsed != null && DXN.getName(parsed) === typename;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\n/**\n * Internal symbol/string constants for the echo object model.\n * Defined in common/ so proxy/ can use them without importing from Entity/.\n * Entity/ re-exports these for external consumers.\n */\n\n/**\n * Property name for the object's own URI when serialized to JSON.\n */\nexport const ATTR_SELF_URI = '@uri';\n\n/**\n * @deprecated Legacy JSON property name accepted on read for backward compat.\n */\nexport const ATTR_SELF_URI_LEGACY = '@dxn';\n\n/**\n * Symbol carrying the object's own URI on live entities.\n */\nexport const SelfURIId = Symbol.for('@dxos/echo/URI');\n\n/**\n * Property name for deleted when object is serialized to JSON.\n */\nexport const ATTR_DELETED = '@deleted';\n\n/**\n * Deletion marker.\n */\nexport const ObjectDeletedId = Symbol.for('@dxos/echo/Deleted');\n\n/**\n * Object version accessor symbol.\n */\nexport const ObjectVersionId: unique symbol = Symbol.for('@dxos/echo/Version');\n\n/**\n * Object database accessor symbol.\n */\nexport const ObjectDatabaseId = Symbol.for('@dxos/echo/Database');\n\n/**\n * Property name for relation source when object is serialized to JSON.\n */\nexport const ATTR_RELATION_SOURCE = '@relationSource';\n\n/**\n * Used to access relation source ref on live ECHO objects.\n */\nexport const RelationSourceId: unique symbol = Symbol.for('@dxos/echo/RelationSource');\n\n/**\n * Used to access relation source DXN on live ECHO objects.\n */\nexport const RelationSourceDXNId: unique symbol = Symbol.for('@dxos/echo/RelationSourceDXN');\n\n/**\n * Property name for relation target when object is serialized to JSON.\n */\nexport const ATTR_RELATION_TARGET = '@relationTarget';\n\n/**\n * Used to access relation target ref on live ECHO objects.\n */\nexport const RelationTargetId: unique symbol = Symbol.for('@dxos/echo/RelationTarget');\n\n/**\n * Used to access relation target DXN on live ECHO objects.\n */\nexport const RelationTargetDXNId: unique symbol = Symbol.for('@dxos/echo/RelationTargetDXN');\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { type EchoURI } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type { AnyEntity } from '../common/types';\nimport { type InternalObjectProps, ObjectDatabaseId } from './model';\nimport { getObjectEchoUri } from './util';\n\n/**\n * Get the canonical EchoURI of an entity.\n * Accepts both reactive entities and snapshots.\n */\nexport const getUri = (entity: AnyEntity): EchoURI.EchoURI => {\n  const uri = getObjectEchoUri(entity);\n  invariant(uri != null, 'Invalid entity.');\n  return uri;\n};\n\n/**\n * Get the database the entity belongs to.\n * Accepts both reactive entities and snapshots.\n */\nexport const getDatabase = (entity: AnyEntity): any | undefined => {\n  assumeType<InternalObjectProps>(entity);\n  return entity[ObjectDatabaseId];\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type ForeignKey } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { EchoURI, ObjectId, type URI } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from '../../Database';\nimport {\n  type ATTR_META,\n  type ATTR_PARENT,\n  type ATTR_TYPE,\n  ATTR_DELETED,\n  ATTR_RELATION_SOURCE,\n  ATTR_RELATION_TARGET,\n  ATTR_SELF_URI,\n  ATTR_SELF_URI_LEGACY,\n  EntityKind,\n  KindId,\n  type MetaId,\n  ObjectDatabaseId,\n  ObjectDeletedId,\n  type ObjectMeta,\n  ObjectVersionId,\n  type ParentId,\n  RelationSourceDXNId,\n  RelationSourceId,\n  RelationTargetDXNId,\n  RelationTargetId,\n  type SchemaId,\n  SelfURIId,\n  TypeId,\n  type Version,\n} from '../common/types';\n\nexport {\n  ATTR_DELETED,\n  ATTR_SELF_URI,\n  ATTR_SELF_URI_LEGACY,\n  ObjectDatabaseId,\n  ObjectDeletedId,\n  ObjectVersionId,\n  SelfURIId,\n};\n\n/**\n * Internal runtime representation of an object.\n * The fields are accessed through getter functions.\n */\n// NOTE: Each symbol has a jsdoc describing its purpose.\nexport interface InternalObjectProps {\n  readonly id: ObjectId;\n  readonly [SelfURIId]: EchoURI.EchoURI;\n  readonly [KindId]: EntityKind;\n  readonly [SchemaId]: Schema.Schema.AnyNoContext;\n  readonly [TypeId]: URI.URI;\n  readonly [MetaId]?: ObjectMeta;\n  [ParentId]?: InternalObjectProps;\n  readonly [ObjectDatabaseId]?: Database.Database;\n  readonly [ObjectDeletedId]?: boolean;\n  readonly [ObjectVersionId]?: Version;\n  readonly [RelationSourceDXNId]?: EchoURI.EchoURI;\n  readonly [RelationTargetDXNId]?: EchoURI.EchoURI;\n  readonly [RelationSourceId]?: InternalObjectProps;\n  readonly [RelationTargetId]?: InternalObjectProps;\n}\n\n/**\n * Entity metadata.\n */\nexport interface ObjectMetaJSON {\n  keys: ForeignKey[];\n  tags?: string[];\n  key?: string;\n  version?: string;\n}\n\n/**\n * JSON representation of an object or relation metadata.\n */\nexport interface ObjectJSON {\n  id: ObjectId;\n  [ATTR_TYPE]?: URI.URI;\n  [ATTR_SELF_URI]?: EchoURI.EchoURI;\n  [ATTR_PARENT]?: EchoURI.EchoURI; // Encoded reference\n  [ATTR_DELETED]?: boolean;\n  [ATTR_META]?: ObjectMetaJSON;\n  [ATTR_RELATION_SOURCE]?: EchoURI.EchoURI;\n  [ATTR_RELATION_TARGET]?: EchoURI.EchoURI;\n\n  /**\n   * Application-specific properties.\n   */\n  [key: string]: unknown;\n}\n\n/**\n * NOTE: Keep as `function` to avoid type inference issues.\n */\nexport function assertObjectModel(obj: unknown): asserts obj is InternalObjectProps {\n  invariant(typeof obj === 'object' && obj !== null, 'Invalid object model: not an object');\n  assumeType<InternalObjectProps>(obj);\n  invariant(ObjectId.isValid(obj.id), 'Invalid object model: invalid id');\n  invariant(obj[TypeId] === undefined || typeof obj[TypeId] === 'string', 'Invalid object model: invalid type');\n  invariant(\n    obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type,\n    'Invalid object model: invalid entity kind',\n  );\n\n  if (obj[KindId] === EntityKind.Relation) {\n    invariant(EchoURI.isEchoURI(obj[RelationSourceDXNId]), 'Invalid object model: invalid relation source');\n    invariant(EchoURI.isEchoURI(obj[RelationTargetDXNId]), 'Invalid object model: invalid relation target');\n    invariant(!EchoURI.isEchoURI(obj[RelationSourceId]), 'Invalid object model: source pointer is a DXN');\n    invariant(!EchoURI.isEchoURI(obj[RelationTargetId]), 'Invalid object model: target pointer is a DXN');\n  }\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { EchoURI, ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport { type InternalObjectProps, SelfURIId } from './model';\n\n/**\n * Returns the EchoURI of an object.\n * Normalizes any legacy `dxn:echo:` / `dxn:queue:` form stored in `SelfURIId`.\n *\n * @internal\n */\nexport const getObjectEchoUri = (object: any): EchoURI.EchoURI | undefined => {\n  invariant(!Schema.isSchema(object), 'schema not allowed in this function');\n  assertArgument(typeof object === 'object' && object != null, 'object', 'expected object');\n  assumeType<InternalObjectProps>(object);\n\n  if (object[SelfURIId]) {\n    invariant(EchoURI.isEchoURI(object[SelfURIId]), 'Invalid object model: invalid self dxn');\n    return EchoURI.parse(object[SelfURIId]);\n  }\n\n  if (!ObjectId.isValid(object.id)) {\n    throw new TypeError('Object id is not valid.');\n  }\n\n  return EchoURI.make({ objectId: object.id });\n};\n"],
+  "mappings": "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",
+  "names": ["TypeId", "Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "Schema", "raise", "assertArgument", "DXN", "URI", "ATTR_SELF_URI", "ATTR_SELF_URI_LEGACY", "SelfURIId", "Symbol", "for", "ATTR_DELETED", "ObjectDeletedId", "ObjectVersionId", "ObjectDatabaseId", "ATTR_RELATION_SOURCE", "RelationSourceId", "RelationSourceDXNId", "ATTR_RELATION_TARGET", "RelationTargetId", "RelationTargetDXNId", "invariant", "assumeType", "invariant", "EchoURI", "ObjectId", "assumeType", "ATTR_DELETED", "assumeType", "obj", "invariant", "ObjectId", "isValid", "TypeId", "KindId", "EntityKind", "Type", "EchoURI", "isEchoURI", "RelationSourceDXNId", "RelationTargetDXNId", "Schema", "assertArgument", "invariant", "EchoURI", "ObjectId", "assumeType", "__dxlog_file", "assertArgument", "object", "assumeType", "SelfURIId", "invariant", "EchoURI", "parse", "ObjectId", "isValid", "__dxlog_file", "invariant", "uri", "entity", "ObjectDatabaseId", "assumeType", "getTypeURIFromSpecifier", "input", "isSchema", "getSchemaURI", "raise", "TypeError", "KindId", "schema", "getStaticTypeSchema", "getUriFromEntity", "assertArgument", "startsWith", "DXN", "make", "isInstanceOf", "schemaOrType", "object", "schemaURI", "type", "TypeId", "URI", "isURI", "typename", "getTypename", "isDXN", "parsed", "tryMake", "getName", "__dxlog_file", "obj", "TypeId", "Database", "Schema", "Any", "space", "isDatabase", "db", "spaceId", "dxn", "ref", "object", "promiseWithCauseCapture", "context", "resolve", "Effect", "pipe", "withSpan", "ObjectNotFoundError", "uri", "Option"]
+}

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

@@ -0,0 +1,93 @@
+import {
+  Currency,
+  CurrencyAnnotationId,
+  DateOnly,
+  DateTime,
+  DecimalPrecision,
+  Duration,
+  Email,
+  Format,
+  FormatAnnotation,
+  FormatAnnotationId,
+  FormatEnums,
+  Formula,
+  GeoLocation,
+  GeoPoint,
+  Hostname,
+  JSON,
+  Markdown,
+  OptionsAnnotation,
+  OptionsAnnotationId,
+  PropertyKind,
+  Regex,
+  SelectOption,
+  SimpleDate,
+  SimpleDateTime,
+  SimpleTime,
+  Text,
+  TimeOnly,
+  TypeEnum,
+  TypeFormat,
+  URL,
+  UUID,
+  formatToType,
+  getFormatAnnotation,
+  getOptionsAnnotation,
+  getTypeEnum,
+  toSimpleDate,
+  toSimpleDateTime,
+  toSimpleTime,
+  typeToFormat
+} from "./chunk-O2EOH7XQ.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Format.ts
+var Format_exports = {};
+__export(Format_exports, {
+  Currency: () => Currency,
+  CurrencyAnnotationId: () => CurrencyAnnotationId,
+  DateOnly: () => DateOnly,
+  DateTime: () => DateTime,
+  DecimalPrecision: () => DecimalPrecision,
+  Duration: () => Duration,
+  Email: () => Email,
+  Format: () => Format,
+  FormatAnnotation: () => FormatAnnotation,
+  FormatAnnotationId: () => FormatAnnotationId,
+  FormatEnums: () => FormatEnums,
+  Formula: () => Formula,
+  GeoLocation: () => GeoLocation,
+  GeoPoint: () => GeoPoint,
+  Hostname: () => Hostname,
+  JSON: () => JSON,
+  Markdown: () => Markdown,
+  OptionsAnnotation: () => OptionsAnnotation,
+  OptionsAnnotationId: () => OptionsAnnotationId,
+  PropertyKind: () => PropertyKind,
+  Regex: () => Regex,
+  SelectOption: () => SelectOption,
+  SimpleDate: () => SimpleDate,
+  SimpleDateTime: () => SimpleDateTime,
+  SimpleTime: () => SimpleTime,
+  Text: () => Text,
+  TimeOnly: () => TimeOnly,
+  TypeEnum: () => TypeEnum,
+  TypeFormat: () => TypeFormat,
+  URL: () => URL,
+  UUID: () => UUID,
+  formatToType: () => formatToType,
+  getFormatAnnotation: () => getFormatAnnotation,
+  getOptionsAnnotation: () => getOptionsAnnotation,
+  getTypeEnum: () => getTypeEnum,
+  toSimpleDate: () => toSimpleDate,
+  toSimpleDateTime: () => toSimpleDateTime,
+  toSimpleTime: () => toSimpleTime,
+  typeToFormat: () => typeToFormat
+});
+
+export {
+  Format_exports
+};
+//# sourceMappingURL=chunk-ZM7VFIS2.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Format.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as internal from './internal';\n\nexport * from './internal/Format';\n\nexport type Format = internal.TypeFormat;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+  "names": []
+}