@dxos/echo 0.10.0 → 0.11.0

package/dist/lib/Annotation.mjs

@@ -0,0 +1,3 @@
+import { $ as ReferenceAnnotation, B as FormLayoutAnnotationId, D as DEFAULT_LAYOUT_NAME, Et as setDescriptionWithSchema, F as FormInlineAnnotation, G as HiddenAnnotation, J as IconFromRefAnnotation, L as FormInputAnnotation, N as FormCreateAnnotation, O as DescriptionAnnotation, Ot as setLabelWithSchema, P as FormCreateAnnotationId, U as GeneratorAnnotation, V as FormOrderedAnnotation, W as GeneratorAnnotationId, Y as LabelAnnotation, bt as getTypeAnnotation, et as ReferenceAnnotationId, ht as getLabelWithSchema, j as FieldLookupAnnotationId, lt as getDescriptionWithSchema, nt as TypeAnnotation, q as IconAnnotation, xt as getTypeIdentifierAnnotation, z as FormLayoutAnnotation } from "./chunk-Database.mjs";
+import { a as atom, c as get, d as make, f as set, i as TypeId, l as getDictionary, m as update, n as Dictionary, o as atomProperty, p as setDictionary, r as Key, s as buildDictionary, u as getFromAst } from "./chunk-Annotation.mjs";
+export { DEFAULT_LAYOUT_NAME, DescriptionAnnotation, Dictionary, FieldLookupAnnotationId, FormCreateAnnotation, FormCreateAnnotationId, FormInlineAnnotation, FormInputAnnotation, FormLayoutAnnotation, FormLayoutAnnotationId, FormOrderedAnnotation, GeneratorAnnotation, GeneratorAnnotationId, HiddenAnnotation, IconAnnotation, IconFromRefAnnotation, Key, LabelAnnotation, ReferenceAnnotation, ReferenceAnnotationId, TypeAnnotation, TypeId, atom, atomProperty, buildDictionary, get, getDescriptionWithSchema, getDictionary, getFromAst, getLabelWithSchema, getTypeAnnotation, getTypeIdentifierAnnotation, make, set, setDescriptionWithSchema, setDictionary, setLabelWithSchema, update };

package/dist/lib/Blob.mjs

@@ -0,0 +1,160 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { G as HiddenAnnotation, q as IconAnnotation, r as Service } from "./chunk-Database.mjs";
+import { BlobNotAvailableError, BlobTooLargeError, BlobWriteError } from "./Err.mjs";
+import { makeObject } from "./Type.mjs";
+import { make as make$1 } from "./Obj.mjs";
+import { DXN } from "@dxos/keys";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+//#region src/Blob.ts
+var Blob_exports = /* @__PURE__ */ __exportAll({
+	Blob: () => Blob,
+	BlobData: () => BlobData,
+	ExternalData: () => ExternalData,
+	InlineData: () => InlineData,
+	MAX_INLINE_SIZE: () => MAX_INLINE_SIZE,
+	Scheme: () => Scheme,
+	Storage: () => Storage,
+	exists: () => exists,
+	externalData: () => externalData,
+	fromBytes: () => fromBytes,
+	inlineData: () => inlineData,
+	make: () => make,
+	read: () => read,
+	url: () => url
+});
+/**
+* Inline blob data: bytes stored directly on the ECHO object.
+*/
+var InlineData = Schema.TaggedStruct("inline", { bytes: Schema.Uint8ArrayFromSelf.annotations({ jsonSchema: {
+	type: "string",
+	contentEncoding: "base64"
+} }) });
+/**
+* External blob data: bytes stored by a registered blob backend, addressed by `uri`.
+*/
+var ExternalData = Schema.TaggedStruct("external", { 
+/**
+* URI locating the bytes. The scheme selects the backend at read time (e.g. `ni:///sha-256;…` for
+* the edge backend — an RFC 6920 content digest, not a backend name — or `wnfs://…` for the
+* plugin-wnfs extension), resolved via the scheme→backend map built from `registerBlobBackend`
+* calls. Core code never parses or constructs backend-specific URIs beyond reading the scheme.
+*
+* @see {@link https://www.rfc-editor.org/rfc/rfc6920 RFC 6920} for the `ni:` URI format.
+*/
+uri: Schema.String });
+var BlobData = Schema.Union(InlineData, ExternalData);
+/**
+* Runtime schema for a Blob object.
+*
+* NOTE: This export shadows the DOM `Blob` global within modules that import it as a namespace.
+* Code that needs the DOM class should use `globalThis.Blob` explicitly.
+*
+* @example
+* ```ts
+* const blob = yield* Blob.fromBytes(bytes, { type: 'image/png' });
+* ```
+*/
+var Blob = class extends makeObject(DXN.make("org.dxos.type.blob", "0.1.0"))(Schema.Struct({
+	/** MIME type. */
+	type: Schema.optional(Schema.String),
+	size: Schema.Number,
+	data: BlobData
+}).pipe(HiddenAnnotation.set(true), IconAnnotation.set({
+	icon: "ph--file--regular",
+	hue: "teal"
+}))) {};
+/**
+* Storage backend names, selected at write time via {@link FromBytesOptions.storage}. Call sites
+* always use these constants, never raw string literals. Extensions (e.g. plugin-wnfs) define
+* their own storage names in their own package — core code knows nothing of them.
+*
+* Distinct from {@link Scheme}: a storage name picks *where* to write, a URI scheme describes
+* *what the identifier is* at read time. They coincide for backends with no content-addressing
+* (e.g. wnfs uses `'wnfs'` for both), but the edge backend's storage name (`'edge'`) differs from
+* its URI scheme (`Scheme.ni`) because the identifier it produces is a content hash, not an
+* edge-specific address.
+*/
+var Storage = {
+	inline: "inline",
+	edge: "edge"
+};
+/**
+* URI schemes claimed by core backends (see `BlobBackend.schemes` in `@dxos/echo-protocol`).
+*
+* `ni` marks an {@link https://www.rfc-editor.org/rfc/rfc6920 RFC 6920} Named Information URI whose
+* authority is empty and whose path carries a registered hash-algorithm name plus a base64url-encoded
+* digest (e.g. `ni:///sha-256;UyaQNQIUxQKgg1jVMKMbg1Yr8Rrb2Y3RaOx2N0mVJhc`, produced by the edge
+* backend). The scheme names *what the identifier is* — a content digest over the complete blob —
+* not which backend wrote it, so any backend or cache that can resolve that digest may claim it.
+* The URI is an identity claim, not a retrievability promise; transport is selected by the registered
+* backend at read time.
+*
+* Extensions (e.g. plugin-wnfs) define their own schemes in their own package.
+*/
+var Scheme = { ni: "ni" };
+var MAX_INLINE_SIZE = 4 * 1024 * 1024;
+/**
+* Creates a new blob object. Does not add it to the database — see {@link fromBytes}.
+*/
+var make = (props) => make$1(Blob, props);
+/**
+* Creates an inline {@link BlobData} variant that embeds raw bytes on the ECHO object.
+*/
+var inlineData = (bytes) => ({
+	_tag: "inline",
+	bytes
+});
+/**
+* Creates an external {@link BlobData} variant that references bytes held by a registered backend.
+* @param uri - Backend-scoped URI, e.g. as returned by a `BlobBackend.put` call.
+*/
+var externalData = (uri) => ({
+	_tag: "external",
+	uri
+});
+/**
+* Hashes and uploads `bytes` via the chosen storage backend (a no-op for `inline`), returning an
+* un-added Blob object. The caller is responsible for adding it to the database.
+*
+* @example
+* ```ts
+* const blob = yield* Blob.fromBytes(bytes, { type: 'image/png' });
+* yield* Database.add(blob);
+* ```
+*/
+var fromBytes = (bytes, options) => Service.pipe(Effect.flatMap(({ db }) => Effect.tryPromise({
+	try: () => db.createBlob(bytes, options),
+	catch: (error) => error instanceof BlobTooLargeError || error instanceof BlobWriteError ? error : new BlobWriteError({ backend: options?.storage ?? "unknown" }, { cause: error })
+}))).pipe(Effect.withSpan("Blob.fromBytes"));
+/**
+* Loads a blob's bytes. Inline: read directly off the object. External: dispatched to the
+* registered backend for the URI's scheme.
+*
+* @example
+* ```ts
+* const bytes = yield* Blob.read(blob);
+* ```
+*/
+var read = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.tryPromise({
+	try: () => db.readBlob(blob),
+	catch: (error) => error instanceof BlobNotAvailableError ? error : new BlobNotAvailableError({
+		backend: "unknown",
+		key: blob.id,
+		reason: "not-found"
+	}, { cause: error })
+}))).pipe(Effect.withSpan("Blob.read"));
+/**
+* Checks whether a blob's bytes are currently available.
+*/
+var exists = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.blobExists(blob)))).pipe(Effect.withSpan("Blob.exists"));
+/**
+* Returns a renderable URL for the blob: inline blobs resolve to a `data:` URL; external blobs
+* are resolved by the registered backend's `getUrl`, if it implements one.
+*/
+var url = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.getBlobUrl(blob))), Effect.map(Option.fromNullable)).pipe(Effect.withSpan("Blob.url"));
+//#endregion
+export { Blob, BlobData, ExternalData, InlineData, MAX_INLINE_SIZE, Scheme, Storage, exists, externalData, fromBytes, inlineData, make, read, Blob_exports as t, url };
+
+//# sourceMappingURL=Blob.mjs.map

package/dist/lib/Blob.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Blob.mjs","names":[],"sources":["../../src/Blob.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as Database from './Database';\nimport * as Err from './Err';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\n/**\n * Inline blob data: bytes stored directly on the ECHO object.\n */\nexport const InlineData = Schema.TaggedStruct('inline', {\n  bytes: Schema.Uint8ArrayFromSelf.annotations({ jsonSchema: { type: 'string', contentEncoding: 'base64' } }),\n});\n\n/**\n * External blob data: bytes stored by a registered blob backend, addressed by `uri`.\n */\nexport const ExternalData = Schema.TaggedStruct('external', {\n  /**\n   * URI locating the bytes. The scheme selects the backend at read time (e.g. `ni:///sha-256;…` for\n   * the edge backend — an RFC 6920 content digest, not a backend name — or `wnfs://…` for the\n   * plugin-wnfs extension), resolved via the scheme→backend map built from `registerBlobBackend`\n   * calls. Core code never parses or constructs backend-specific URIs beyond reading the scheme.\n   *\n   * @see {@link https://www.rfc-editor.org/rfc/rfc6920 RFC 6920} for the `ni:` URI format.\n   */\n  uri: Schema.String,\n});\n\nexport const BlobData = Schema.Union(InlineData, ExternalData);\nexport type BlobData = Schema.Schema.Type<typeof BlobData>;\n\n/**\n * Runtime schema for a Blob object.\n *\n * NOTE: This export shadows the DOM `Blob` global within modules that import it as a namespace.\n * Code that needs the DOM class should use `globalThis.Blob` explicitly.\n *\n * @example\n * ```ts\n * const blob = yield* Blob.fromBytes(bytes, { type: 'image/png' });\n * ```\n */\nexport class Blob extends Type.makeObject<Blob>(DXN.make('org.dxos.type.blob', '0.1.0'))(\n  Schema.Struct({\n    /** MIME type. */\n    type: Schema.optional(Schema.String),\n    size: Schema.Number,\n    data: BlobData,\n  }).pipe(\n    internal.HiddenAnnotation.set(true),\n    Annotation.IconAnnotation.set({ icon: 'ph--file--regular', hue: 'teal' }),\n  ),\n) {}\n\n//\n// Storage constants\n//\n\n/**\n * Storage backend names, selected at write time via {@link FromBytesOptions.storage}. Call sites\n * always use these constants, never raw string literals. Extensions (e.g. plugin-wnfs) define\n * their own storage names in their own package — core code knows nothing of them.\n *\n * Distinct from {@link Scheme}: a storage name picks *where* to write, a URI scheme describes\n * *what the identifier is* at read time. They coincide for backends with no content-addressing\n * (e.g. wnfs uses `'wnfs'` for both), but the edge backend's storage name (`'edge'`) differs from\n * its URI scheme (`Scheme.ni`) because the identifier it produces is a content hash, not an\n * edge-specific address.\n */\nexport const Storage = { inline: 'inline', edge: 'edge' } as const;\nexport type Storage = (typeof Storage)[keyof typeof Storage];\n\n/**\n * URI schemes claimed by core backends (see `BlobBackend.schemes` in `@dxos/echo-protocol`).\n *\n * `ni` marks an {@link https://www.rfc-editor.org/rfc/rfc6920 RFC 6920} Named Information URI whose\n * authority is empty and whose path carries a registered hash-algorithm name plus a base64url-encoded\n * digest (e.g. `ni:///sha-256;UyaQNQIUxQKgg1jVMKMbg1Yr8Rrb2Y3RaOx2N0mVJhc`, produced by the edge\n * backend). The scheme names *what the identifier is* — a content digest over the complete blob —\n * not which backend wrote it, so any backend or cache that can resolve that digest may claim it.\n * The URI is an identity claim, not a retrievability promise; transport is selected by the registered\n * backend at read time.\n *\n * Extensions (e.g. plugin-wnfs) define their own schemes in their own package.\n */\nexport const Scheme = { ni: 'ni' } as const;\nexport type Scheme = (typeof Scheme)[keyof typeof Scheme];\n\n//\n// Factory\n//\n\nexport const MAX_INLINE_SIZE = 4 * 1024 * 1024;\n\n/**\n * Creates a new blob object. Does not add it to the database — see {@link fromBytes}.\n */\nexport const make = (props: Obj.MakeProps<typeof Blob>): Blob => Obj.make(Blob, props);\n\n/**\n * Creates an inline {@link BlobData} variant that embeds raw bytes on the ECHO object.\n */\nexport const inlineData = (bytes: Uint8Array): BlobData => ({ _tag: 'inline', bytes });\n\n/**\n * Creates an external {@link BlobData} variant that references bytes held by a registered backend.\n * @param uri - Backend-scoped URI, e.g. as returned by a `BlobBackend.put` call.\n */\nexport const externalData = (uri: string): BlobData => ({ _tag: 'external', uri });\n\nexport interface FromBytesOptions {\n  /** MIME type. */\n  type?: string;\n  /**\n   * Storage backend name. Defaults to the registry's configured default (initially `'inline'`;\n   * `@dxos/client` marks `'edge'` as the default when configured).\n   */\n  storage?: Storage | (string & {});\n}\n\n//\n// Operations\n//\n\n/**\n * Hashes and uploads `bytes` via the chosen storage backend (a no-op for `inline`), returning an\n * un-added Blob object. The caller is responsible for adding it to the database.\n *\n * @example\n * ```ts\n * const blob = yield* Blob.fromBytes(bytes, { type: 'image/png' });\n * yield* Database.add(blob);\n * ```\n */\nexport const fromBytes = (\n  bytes: Uint8Array,\n  options?: FromBytesOptions,\n): Effect.Effect<Blob, Err.BlobTooLargeError | Err.BlobWriteError, Database.Service> =>\n  Database.Service.pipe(\n    Effect.flatMap(({ db }) =>\n      Effect.tryPromise({\n        try: () => db.createBlob(bytes, options),\n        catch: (error) =>\n          error instanceof Err.BlobTooLargeError || error instanceof Err.BlobWriteError\n            ? error\n            : new Err.BlobWriteError({ backend: options?.storage ?? 'unknown' }, { cause: error }),\n      }),\n    ),\n  ).pipe(Effect.withSpan('Blob.fromBytes'));\n\n/**\n * Loads a blob's bytes. Inline: read directly off the object. External: dispatched to the\n * registered backend for the URI's scheme.\n *\n * @example\n * ```ts\n * const bytes = yield* Blob.read(blob);\n * ```\n */\nexport const read = (blob: Blob): Effect.Effect<Uint8Array, Err.BlobNotAvailableError, Database.Service> =>\n  Database.Service.pipe(\n    Effect.flatMap(({ db }) =>\n      Effect.tryPromise({\n        try: () => db.readBlob(blob),\n        catch: (error) =>\n          error instanceof Err.BlobNotAvailableError\n            ? error\n            : new Err.BlobNotAvailableError(\n                { backend: 'unknown', key: blob.id, reason: 'not-found' },\n                { cause: error },\n              ),\n      }),\n    ),\n  ).pipe(Effect.withSpan('Blob.read'));\n\n/**\n * Checks whether a blob's bytes are currently available.\n */\nexport const exists = (blob: Blob): Effect.Effect<boolean, never, Database.Service> =>\n  Database.Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.blobExists(blob)))).pipe(\n    Effect.withSpan('Blob.exists'),\n  );\n\n/**\n * Returns a renderable URL for the blob: inline blobs resolve to a `data:` URL; external blobs\n * are resolved by the registered backend's `getUrl`, if it implements one.\n */\nexport const url = (blob: Blob): Effect.Effect<Option.Option<string>, never, Database.Service> =>\n  Database.Service.pipe(\n    Effect.flatMap(({ db }) => Effect.promise(() => db.getBlobUrl(blob))),\n    Effect.map(Option.fromNullable),\n  ).pipe(Effect.withSpan('Blob.url'));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,aAAa,OAAO,aAAa,UAAU,EACtD,OAAO,OAAO,mBAAmB,YAAY,EAAE,YAAY;CAAE,MAAM;CAAU,iBAAiB;AAAS,EAAE,CAAC,EAC5G,CAAC;;;;AAKD,IAAa,eAAe,OAAO,aAAa,YAAY;;;;;;;;;AAS1D,KAAK,OAAO,OACd,CAAC;AAED,IAAa,WAAW,OAAO,MAAM,YAAY,YAAY;;;;;;;;;;;;AAc7D,IAAa,OAAb,cAA0B,WAAsB,IAAI,KAAK,sBAAsB,OAAO,CAAC,CAAC,CACtF,OAAO,OAAO;;CAEZ,MAAM,OAAO,SAAS,OAAO,MAAM;CACnC,MAAM,OAAO;CACb,MAAM;AACR,CAAC,CAAC,CAAC,KAAA,iBACyB,IAAI,IAAI,GAAA,eACR,IAAI;CAAE,MAAM;CAAqB,KAAK;AAAO,CAAC,CAC1E,CACF,CAAC,CAAC,CAAC;;;;;;;;;;;;AAiBH,IAAa,UAAU;CAAE,QAAQ;CAAU,MAAM;AAAO;;;;;;;;;;;;;;AAgBxD,IAAa,SAAS,EAAE,IAAI,KAAK;AAOjC,IAAa,kBAAkB,IAAI,OAAO;;;;AAK1C,IAAa,QAAQ,UAA4C,OAAS,MAAM,KAAK;;;;AAKrF,IAAa,cAAc,WAAiC;CAAE,MAAM;CAAU;AAAM;;;;;AAMpF,IAAa,gBAAgB,SAA2B;CAAE,MAAM;CAAY;AAAI;;;;;;;;;;;AA0BhF,IAAa,aACX,OACA,YAAA,QAEiB,KACf,OAAO,SAAS,EAAE,SAChB,OAAO,WAAW;CAChB,WAAW,GAAG,WAAW,OAAO,OAAO;CACvC,QAAQ,UACN,iBAAiB,qBAAyB,iBAAiB,iBACvD,QACA,IAAI,eAAmB,EAAE,SAAS,SAAS,WAAW,UAAU,GAAG,EAAE,OAAO,MAAM,CAAC;AAC3F,CAAC,CACH,CACF,CAAC,CAAC,KAAK,OAAO,SAAS,gBAAgB,CAAC;;;;;;;;;;AAW1C,IAAa,QAAQ,SAAA,QACF,KACf,OAAO,SAAS,EAAE,SAChB,OAAO,WAAW;CAChB,WAAW,GAAG,SAAS,IAAI;CAC3B,QAAQ,UACN,iBAAiB,wBACb,QACA,IAAI,sBACF;EAAE,SAAS;EAAW,KAAK,KAAK;EAAI,QAAQ;CAAY,GACxD,EAAE,OAAO,MAAM,CACjB;AACR,CAAC,CACH,CACF,CAAC,CAAC,KAAK,OAAO,SAAS,WAAW,CAAC;;;;AAKrC,IAAa,UAAU,SAAA,QACJ,KAAK,OAAO,SAAS,EAAE,SAAS,OAAO,cAAc,GAAG,WAAW,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAC3F,OAAO,SAAS,aAAa,CAC/B;;;;;AAMF,IAAa,OAAO,SAAA,QACD,KACf,OAAO,SAAS,EAAE,SAAS,OAAO,cAAc,GAAG,WAAW,IAAI,CAAC,CAAC,GACpE,OAAO,IAAI,OAAO,YAAY,CAChC,CAAC,CAAC,KAAK,OAAO,SAAS,UAAU,CAAC"}

package/dist/lib/Database.mjs

@@ -0,0 +1,2 @@
+import { _ as remove, a as add, b as subscribeToSyncState, c as deleteFromFeed, d as isDatabase, f as layer, g as query, h as notAvailable, i as TypeId, l as flush, m as makeService, o as addType, p as load, r as Service, s as appendToFeed, t as Database, u as getSyncState, v as resolve, y as spaceId } from "./chunk-Database.mjs";
+export { Database, Service, TypeId, add, addType, appendToFeed, deleteFromFeed, flush, getSyncState, isDatabase, layer, load, makeService, notAvailable, query, remove, resolve, spaceId, subscribeToSyncState };

package/dist/lib/Entity.mjs

@@ -0,0 +1,231 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { a as isEntity$1, c as getKeys$1, l as getMetaChecked, o as addTag$1, u as removeTag$1 } from "./chunk-atom-snapshot.mjs";
+import { T as objectToJSON, c as makeEntity, h as isDeleted$1, l as makeLabelAtom } from "./chunk-internal.mjs";
+import { d as SnapshotKindId$1, l as KindId$1, m as getEntityKindBrand, o as EntityKind, s as EntityKindSchema } from "./chunk-util.mjs";
+import { Ct as getTypename$1, Dt as setLabel$1, Gt as MetaId, Lt as getType$1, S as isInstanceOf, St as getTypeURI$1, T as getUri, ct as getDescription$1, ft as getIcon$1, mt as getLabelProperty, pt as getLabel$1, ut as getEntityKind, w as getDatabase$1 } from "./chunk-Database.mjs";
+import { g as subscribe$1, h as change } from "./chunk-ref.mjs";
+import { Type, getTypename as getTypename$2, getURI as getURI$1 } from "./Type.mjs";
+import * as Schema from "effect/Schema";
+//#region src/Entity.ts
+var Entity_exports = /* @__PURE__ */ __exportAll({
+	Kind: () => Kind,
+	KindId: () => KindId,
+	KindSchema: () => KindSchema,
+	Meta: () => Meta,
+	SnapshotKindId: () => SnapshotKindId,
+	Unknown: () => Unknown,
+	addTag: () => addTag,
+	atom: () => atom,
+	getDatabase: () => getDatabase,
+	getDescription: () => getDescription,
+	getIcon: () => getIcon,
+	getKeys: () => getKeys,
+	getKind: () => getKind,
+	getLabel: () => getLabel,
+	getMeta: () => getMeta,
+	getType: () => getType,
+	getTypeURI: () => getTypeURI,
+	getTypename: () => getTypename,
+	getURI: () => getURI,
+	instanceOf: () => instanceOf,
+	isDeleted: () => isDeleted,
+	isEntity: () => isEntity,
+	isSnapshot: () => isSnapshot,
+	labelAtom: () => labelAtom,
+	labelProperty: () => labelProperty,
+	removeTag: () => removeTag,
+	setLabel: () => setLabel,
+	subscribe: () => subscribe,
+	toJSON: () => toJSON,
+	update: () => update
+});
+var KindId = KindId$1;
+var SnapshotKindId = SnapshotKindId$1;
+var Kind = EntityKind;
+var KindSchema = EntityKindSchema;
+/**
+* Effect Schema for any ECHO entity (object or relation).
+*
+* Kind-agnostic counterpart to `Obj.Unknown` / `Relation.Unknown` — validates
+* the structural shape (id + properties) without constraining `[KindId]`. Used
+* in operation input schemas that accept any entity flavour (e.g.
+* `Schema.Array(Entity.Unknown)`).
+*
+* The cast bridges the runtime structural schema to the branded `Unknown` type:
+* `[KindId]` is a symbol brand that can't be expressed in a runtime `Struct`,
+* so the entity guarantee is carried at the type level only (same approach as
+* `Obj.Unknown` / `Relation.Unknown`). Unlike those, this is kind-agnostic so it
+* isn't an `UnknownTypeSchema<_, K>` (there's no single `K`) and carries no
+* `TypeAnnotation`.
+*/
+var Unknown = Schema.Struct({ id: Schema.String }).pipe(Schema.extend(Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+})));
+/**
+* Check if a value is an ECHO entity (object or relation).
+* Returns `false` for snapshots.
+*/
+var isEntity = isEntity$1;
+/**
+* Test if a value is an instance of a given object or relation type.
+*
+* Kind-agnostic counterpart to `Obj.instanceOf` / `Relation.instanceOf` —
+* use this when the caller's input type is `Type.AnyObj | Type.AnyRelation`.
+*
+* @example
+* ```ts
+* // Caller doesn't know whether `type` is object- or relation-kind.
+* const matches = <T extends Type.AnyObj | Type.AnyRelation>(type: T, value: unknown) =>
+*   Entity.instanceOf(type, value);
+* ```
+*/
+var instanceOf = ((...args) => {
+	if (args.length === 1) return (entity) => isInstanceOf(args[0], entity);
+	return isInstanceOf(args[0], args[1]);
+});
+/**
+* Check if a value is an ECHO entity snapshot.
+* Returns `false` for entities.
+*/
+var isSnapshot = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	return value[SnapshotKindId] !== void 0;
+};
+var getKind = getEntityKind;
+/**
+* Property that accesses metadata for an entity.
+*/
+var Meta = MetaId;
+/**
+* Whether the entity is a type-kind entity (a `Type.Type` produced by
+* `Type.makeObject` / `Type.makeRelation`, or a persisted schema). Type entities
+* carry their identity (typename/version) on themselves rather than referencing a
+* separate type, so the accessors below route them through the `Type.*` module.
+*/
+var isTypeEntity = (entity) => getEntityKindBrand(entity) === EntityKind.Type;
+/**
+* Get the canonical URI of an entity (object, relation, or type). Returns `URI.URI` —
+* an `EID` for object/relation instances and persisted types, or a typename
+* `DXN` for static type entities; narrow with `EID.parse(uri)` or
+* `DXN.tryMake(uri)` at the point of use.
+*
+* @param options.prefer - Controls the URI form (see {@link internal.GetURIOptions}).
+*/
+var getURI = (entity, options) => isTypeEntity(entity) ? getURI$1(entity, options) : getUri(entity, options);
+/**
+* Get the DXN of an entity's type. For object/relation instances this is the URI
+* of the type they were created from; for a type entity it is the URI of the
+* meta-type ({@link Type.Type}, `dxn:org.dxos.type.schema:0.1.0`).
+*/
+var getTypeURI = (entity) => isTypeEntity(entity) ? getURI$1(Type) : getTypeURI$1(entity);
+/**
+* Get the type entity (`Type.AnyEntity`) the instance was created from.
+*
+* Returns `undefined` when the entity's type isn't registered in this runtime
+* (e.g. a freshly deserialized snapshot whose type entity hasn't been wired
+* up yet, or an entity loaded from storage before its schema is known). To
+* get the Effect Schema from the returned entity, use `Type.getSchema(...)`.
+*
+* For a type entity, returns the meta-type {@link Type.Type} (a type entity's
+* type is "Type").
+*/
+var getType = (entity) => isTypeEntity(entity) ? Type : getType$1(entity);
+/**
+* Get the typename of an entity's type. For object/relation instances this is the
+* typename of the type they were created from; for a type entity it is the type's
+* own typename (e.g. `com.example.type.person`).
+*/
+var getTypename = (entity) => isTypeEntity(entity) ? getTypename$2(entity) : getTypename$1(entity);
+/**
+* Get the database an entity belongs to.
+*/
+var getDatabase = (entity) => getDatabase$1(entity);
+function getMeta(entity) {
+	return getMetaChecked(entity);
+}
+/**
+* Get foreign keys for an entity from the specified source.
+*/
+var getKeys = (entity, source) => getKeys$1(entity, source);
+/**
+* Check if an entity is deleted.
+*/
+var isDeleted = (entity) => isDeleted$1(entity);
+/**
+* Get the label of an entity.
+*
+* @param options.fallback `'typename'` returns the entity's typename when no
+*   label is set (e.g. `org.dxos.type.table`).
+*/
+var getLabel = (entity, options) => getLabel$1(entity, options);
+/**
+* Set the label of an entity.
+* Must be called within an `Entity.update` / `Obj.update` / `Relation.update` callback.
+*/
+var setLabel = (entity, label) => setLabel$1(entity, label);
+/**
+* Get the description of an entity.
+*/
+var getDescription = (entity) => getDescription$1(entity);
+/**
+* Get the icon annotation for an entity (object or relation), resolved via its type-level
+* `IconAnnotation`. Returns the full `{ icon, hue }` annotation so callers can use both
+* the phosphor icon name and the suggested colour.
+*/
+var getIcon = (entity) => getIcon$1(entity);
+/**
+* Convert an entity to its JSON representation.
+*/
+var toJSON = (entity) => objectToJSON(entity);
+/**
+* Subscribe to changes on an entity (object or relation).
+* @returns Unsubscribe function.
+*/
+var subscribe = (entity, callback) => {
+	return subscribe$1(entity, callback);
+};
+/**
+* Perform mutations on an entity (object or relation) within a change context.
+*
+* Entities are read-only by default. Mutations are batched and notifications fire
+* when the callback completes. Direct mutations outside of `Entity.update` will throw
+* at runtime.
+*
+* @param entity - The echo entity (object or relation) to mutate.
+* @param callback - Receives a mutable view of the entity. All mutations must occur here.
+*
+* @example
+* ```typescript
+* // Mutate within Entity.update
+* Entity.update(entity, (obj) => {
+*   obj.name = 'Updated';
+*   obj.count = 42;
+* });
+*
+* // Direct mutation throws
+* entity.name = 'Bob'; // Error: Cannot modify outside Entity.update()
+* ```
+*
+* Note: For type-specific operations, prefer `Obj.update` or `Relation.update`.
+*/
+var update = (entity, callback) => {
+	change(entity, callback);
+};
+/**
+* Add a tag to an entity.
+* Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.
+*/
+var addTag = (entity, tag) => addTag$1(entity, tag);
+/**
+* Remove a tag from an entity.
+* Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.
+*/
+var removeTag = (entity, tag) => removeTag$1(entity, tag);
+var atom = makeEntity;
+var labelAtom = makeLabelAtom;
+var labelProperty = getLabelProperty;
+//#endregion
+export { Kind, KindId, KindSchema, Meta, SnapshotKindId, Unknown, addTag, atom, getDatabase, getDescription, getIcon, getKeys, getKind, getLabel, getMeta, getType, getTypeURI, getTypename, getURI, instanceOf, isDeleted, isEntity, isSnapshot, labelAtom, labelProperty, removeTag, setLabel, subscribe, Entity_exports as t, toJSON, update };
+
+//# sourceMappingURL=Entity.mjs.map

package/dist/lib/Entity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.mjs","names":[],"sources":["../../src/Entity.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport type { EntityId, URI } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport * as objInternal from './internal/Obj';\nimport type * as Ref from './Ref';\nimport type * as Relation from './Relation';\nimport type * as Tag from './Tag';\nimport * as Type from './Type';\n\n// Re-export KindId and SnapshotKindId from internal.\nexport const KindId = internal.KindId;\nexport type KindId = typeof internal.KindId;\nexport const SnapshotKindId = internal.SnapshotKindId;\nexport type SnapshotKindId = typeof internal.SnapshotKindId;\n\n// NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.\n//  However, we generally refer to Obj and Relation instances as \"objects\",\n//  and many API methods accept both Obj.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.\n\nexport const Kind = internal.EntityKind;\nexport type Kind = internal.EntityKind;\nexport const KindSchema = internal.EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n * NOTE: Needed to make `isRelation` and `isObject` checks work.\n */\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: EntityId;\n}\n\n/**\n * Assigns a snapshot kind to an Object or Relation snapshot.\n */\nexport interface SnapshotOfKind<K extends Kind> {\n  readonly [SnapshotKindId]: K;\n  readonly id: EntityId;\n}\n\n/**\n * Obj or Relation with a specific set of properties.\n */\nexport type Entity<Props> = OfKind<Kind> & Props;\n\n/**\n * Unknown Obj or Relation (reactive).\n */\nexport interface Unknown extends OfKind<Kind> {}\n\n/**\n * Effect Schema for any ECHO entity (object or relation).\n *\n * Kind-agnostic counterpart to `Obj.Unknown` / `Relation.Unknown` — validates\n * the structural shape (id + properties) without constraining `[KindId]`. Used\n * in operation input schemas that accept any entity flavour (e.g.\n * `Schema.Array(Entity.Unknown)`).\n *\n * The cast bridges the runtime structural schema to the branded `Unknown` type:\n * `[KindId]` is a symbol brand that can't be expressed in a runtime `Struct`,\n * so the entity guarantee is carried at the type level only (same approach as\n * `Obj.Unknown` / `Relation.Unknown`). Unlike those, this is kind-agnostic so it\n * isn't an `UnknownTypeSchema<_, K>` (there's no single `K`) and carries no\n * `TypeAnnotation`.\n */\nexport const Unknown: Schema.Schema<Unknown> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n) as unknown as Schema.Schema<Unknown>;\n\n/**\n * Snapshot of an Obj or Relation.\n * Branded with SnapshotKindId instead of KindId.\n */\nexport interface Snapshot extends SnapshotOfKind<Kind> {}\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how typescript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n *\n * This type is very permissive and allows accessing any property on the object.\n * We should move to Obj.Unknown that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\n/**\n * Returns all properties of an object or relation except for the id and kind.\n */\nexport type Properties<T> = Omit<T, 'id' | KindId | Relation.Source | Relation.Target>;\n\n/**\n * Check if a value is an ECHO entity (object or relation).\n * Returns `false` for snapshots.\n */\nexport const isEntity: (value: unknown) => value is Unknown = internal.isEntity;\n\n/**\n * Test if a value is an instance of a given object or relation type.\n *\n * Kind-agnostic counterpart to `Obj.instanceOf` / `Relation.instanceOf` —\n * use this when the caller's input type is `Type.AnyObj | Type.AnyRelation`.\n *\n * @example\n * ```ts\n * // Caller doesn't know whether `type` is object- or relation-kind.\n * const matches = <T extends Type.AnyObj | Type.AnyRelation>(type: T, value: unknown) =>\n *   Entity.instanceOf(type, value);\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Type.InstanceType<S>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Type.InstanceType<S>;\n} = ((...args: [schema: Type.AnyEntity, value?: unknown]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Check if a value is an ECHO entity snapshot.\n * Returns `false` for entities.\n */\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[SnapshotKindId] !== undefined;\n};\n\n// TODO(dmaretskyi): Type introspection -- move to kind.\nexport const getKind = internal.getEntityKind;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport const Meta: unique symbol = internal.MetaId as any;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport type Meta = typeof Meta;\n\n//\n// Entity-level functions that work on any entity (object or relation).\n// Use these when you don't know or care about the specific entity kind.\n// For kind-specific functions, use Obj.* or Relation.*.\n//\n\n/**\n * JSON representation of an entity.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Whether the entity is a type-kind entity (a `Type.Type` produced by\n * `Type.makeObject` / `Type.makeRelation`, or a persisted schema). Type entities\n * carry their identity (typename/version) on themselves rather than referencing a\n * separate type, so the accessors below route them through the `Type.*` module.\n */\nconst isTypeEntity = (entity: unknown): boolean => internal.getEntityKindBrand(entity) === internal.EntityKind.Type;\n\n/**\n * Any value the read accessors operate on: a reactive entity or a snapshot.\n * Type entities (`Type.AnyEntity`) are also accepted — they're first-class\n * entities, and `Unknown`'s kind-agnostic brand already subsumes them.\n */\nexport type AnyInput = Unknown | Snapshot;\n\n/**\n * Get the canonical URI of an entity (object, relation, or type). Returns `URI.URI` —\n * an `EID` for object/relation instances and persisted types, or a typename\n * `DXN` for static type entities; narrow with `EID.parse(uri)` or\n * `DXN.tryMake(uri)` at the point of use.\n *\n * @param options.prefer - Controls the URI form (see {@link internal.GetURIOptions}).\n */\nexport const getURI = (entity: AnyInput, options?: internal.GetURIOptions): URI.URI =>\n  isTypeEntity(entity) ? Type.getURI(entity as Type.AnyEntity, options) : internal.getUri(entity as Unknown, options);\n\n/**\n * Get the DXN of an entity's type. For object/relation instances this is the URI\n * of the type they were created from; for a type entity it is the URI of the\n * meta-type ({@link Type.Type}, `dxn:org.dxos.type.schema:0.1.0`).\n */\nexport const getTypeURI = (entity: AnyInput): URI.URI | undefined =>\n  isTypeEntity(entity) ? Type.getURI(Type.Type) : internal.getTypeURI(entity as Unknown);\n\n/**\n * Get the type entity (`Type.AnyEntity`) the instance was created from.\n *\n * Returns `undefined` when the entity's type isn't registered in this runtime\n * (e.g. a freshly deserialized snapshot whose type entity hasn't been wired\n * up yet, or an entity loaded from storage before its schema is known). To\n * get the Effect Schema from the returned entity, use `Type.getSchema(...)`.\n *\n * For a type entity, returns the meta-type {@link Type.Type} (a type entity's\n * type is \"Type\").\n */\nexport const getType = (entity: AnyInput): Type.AnyEntity | undefined =>\n  isTypeEntity(entity) ? Type.Type : (internal.getType(entity) as Type.AnyEntity | undefined);\n\n/**\n * Get the typename of an entity's type. For object/relation instances this is the\n * typename of the type they were created from; for a type entity it is the type's\n * own typename (e.g. `com.example.type.person`).\n */\nexport const getTypename = (entity: AnyInput): string | undefined =>\n  isTypeEntity(entity) ? Type.getTypename(entity as Type.AnyEntity) : internal.getTypename(entity as Unknown);\n\n/**\n * Get the database an entity belongs to.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): any | undefined => internal.getDatabase(entity);\n\n/**\n * Get the metadata for an entity.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): internal.EntityMeta;\nexport function getMeta(entity: Unknown | Snapshot): internal.ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): internal.EntityMeta | internal.ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * Get foreign keys for an entity from the specified source.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Check if an entity is deleted.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n/**\n * Get the label of an entity.\n *\n * @param options.fallback `'typename'` returns the entity's typename when no\n *   label is set (e.g. `org.dxos.type.table`).\n */\nexport const getLabel = (entity: Unknown | Snapshot, options?: internal.GetLabelOptions): string | undefined =>\n  internal.getLabel(entity, options);\n\n/**\n * Set the label of an entity.\n * Must be called within an `Entity.update` / `Obj.update` / `Relation.update` callback.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of an entity.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Get the icon annotation for an entity (object or relation), resolved via its type-level\n * `IconAnnotation`. Returns the full `{ icon, hue }` annotation so callers can use both\n * the phosphor icon name and the suggested colour.\n */\nexport const getIcon = (entity: Unknown | Snapshot): internal.IconAnnotation | undefined => internal.getIcon(entity);\n\n/**\n * Convert an entity to its JSON representation.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n/**\n * Subscribe to changes on an entity (object or relation).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (entity: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(entity, callback);\n};\n\n//\n// Change\n//\n\n/**\n * Used to provide a mutable view of an entity within `Entity.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an entity (object or relation) within a change context.\n *\n * Entities are read-only by default. Mutations are batched and notifications fire\n * when the callback completes. Direct mutations outside of `Entity.update` will throw\n * at runtime.\n *\n * @param entity - The echo entity (object or relation) to mutate.\n * @param callback - Receives a mutable view of the entity. All mutations must occur here.\n *\n * @example\n * ```typescript\n * // Mutate within Entity.update\n * Entity.update(entity, (obj) => {\n *   obj.name = 'Updated';\n *   obj.count = 42;\n * });\n *\n * // Direct mutation throws\n * entity.name = 'Bob'; // Error: Cannot modify outside Entity.update()\n * ```\n *\n * Note: For type-specific operations, prefer `Obj.update` or `Relation.update`.\n */\nexport const update = <T extends Unknown>(entity: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(entity, callback);\n};\n\n/**\n * Add a tag to an entity.\n * Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from an entity.\n * Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.removeTag(entity, tag);\n\n//\n// Atoms\n//\n\nexport const atom = objInternal.makeEntity;\nexport const labelAtom = objInternal.makeLabelAtom;\nexport const labelProperty = internal.getLabelProperty;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,IAAa,SAAS;AAEtB,IAAa,iBAAiB;AAO9B,IAAa,OAAO;AAEpB,IAAa,aAAa;;;;;;;;;;;;;;;;AA4C1B,IAAa,UAAkC,OAAO,OAAO,EAC3D,IAAI,OAAO,OACb,CAAC,CAAC,CAAC,KACD,OAAO,OAAO,OAAO,OAAO;CAAE,KAAK,OAAO;CAAQ,OAAO,OAAO;AAAQ,CAAC,CAAC,CAC5E;;;;;AA8BA,IAAa,WAAiD;;;;;;;;;;;;;;AAe9D,IAAa,eAGP,GAAG,SAAoD;CAC3D,IAAI,KAAK,WAAW,GAClB,QAAQ,WAAoB,aAAsB,KAAK,IAAI,MAAM;CAEnE,OAAO,aAAsB,KAAK,IAAI,KAAK,EAAE;AAC/C;;;;;AAMA,IAAa,cAAc,UAAsC;CAC/D,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAET,OAAQ,MAAc,oBAAoB,KAAA;AAC5C;AAGA,IAAa,UAAU;;;;AAKvB,IAAa,OAAsB;;;;;;;AAwBnC,IAAM,gBAAgB,WAA6B,mBAA4B,MAAM,MAAA,WAA0B;;;;;;;;;AAiB/G,IAAa,UAAU,QAAkB,YACvC,aAAa,MAAM,IAAI,SAAY,QAA0B,OAAO,IAAI,OAAgB,QAAmB,OAAO;;;;;;AAOpH,IAAa,cAAc,WACzB,aAAa,MAAM,IAAI,SAAY,IAAS,IAAI,aAAoB,MAAiB;;;;;;;;;;;;AAavF,IAAa,WAAW,WACtB,aAAa,MAAM,IAAI,OAAa,UAAiB,MAAM;;;;;;AAO7D,IAAa,eAAe,WAC1B,aAAa,MAAM,IAAI,cAAiB,MAAwB,IAAI,cAAqB,MAAiB;;;;AAK5G,IAAa,eAAe,WAAgD,cAAqB,MAAM;AAUvG,SAAgB,QAAQ,QAA4F;CAClH,OAAO,eAAwB,MAAM;AACvC;;;;AAKA,IAAa,WAAW,QAA4B,WAAiC,UAAiB,QAAQ,MAAM;;;;AAKpH,IAAa,aAAa,WAAwC,YAAmB,MAAM;;;;;;;AAQ3F,IAAa,YAAY,QAA4B,YACnD,WAAkB,QAAQ,OAAO;;;;;AAMnC,IAAa,YAAY,QAA0B,UAAwB,WAAkB,QAAQ,KAAK;;;;AAK1G,IAAa,kBAAkB,WAAmD,iBAAwB,MAAM;;;;;;AAOhH,IAAa,WAAW,WAAoE,UAAiB,MAAM;;;;AAKnH,IAAa,UAAU,WAAqC,aAAsB,MAAM;;;;;AAMxF,IAAa,aAAa,QAAiB,aAAuC;CAChF,OAAO,YAAmB,QAAQ,QAAQ;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAa,UAA6B,QAAW,aAA+C;CAClG,OAAgB,QAAQ,QAAQ;AAClC;;;;;AAMA,IAAa,UAAU,QAA0B,QAAgC,SAAgB,QAAQ,GAAG;;;;;AAM5G,IAAa,aAAa,QAA0B,QAAgC,YAAmB,QAAQ,GAAG;AAMlH,IAAa,OAAO;AACpB,IAAa,YAAY;AACzB,IAAa,gBAAgB"}

package/dist/lib/Err.mjs

@@ -0,0 +1,105 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { BaseError } from "@dxos/errors";
+//#region src/Err.ts
+var Err_exports = /* @__PURE__ */ __exportAll({
+	BlobNotAvailableError: () => BlobNotAvailableError,
+	BlobTooLargeError: () => BlobTooLargeError,
+	BlobWriteError: () => BlobWriteError,
+	EntityNotFoundError: () => EntityNotFoundError,
+	GetReactiveError: () => GetReactiveError,
+	SchemaNotFoundError: () => SchemaNotFoundError,
+	TextEditNotFoundError: () => TextEditNotFoundError,
+	TextNotSupportedError: () => TextNotSupportedError
+});
+var SchemaNotFoundError = class extends BaseError.extend("SchemaNotFoundError", "Schema not found") {
+	constructor(schema, options) {
+		super({
+			context: { schema },
+			...options
+		});
+	}
+};
+var EntityNotFoundError = class extends BaseError.extend("EntityNotFoundError", "Entity not found") {
+	constructor(uri, options) {
+		super({
+			context: { uri },
+			...options
+		});
+	}
+};
+/**
+* Thrown when a `Text` mutation is attempted on an object whose reactive handler does not implement
+* string CRDT editing (e.g. a snapshot or a non-reactive value).
+*/
+var TextNotSupportedError = class extends BaseError.extend("TextNotSupportedError", "Text operation is not supported for this object") {
+	constructor(operation, options) {
+		super({
+			context: { operation },
+			...options
+		});
+	}
+};
+/**
+* Thrown by `Text.apply` when a non-`replaceAll` edit's `oldString` is not found in the text.
+*/
+var TextEditNotFoundError = class extends BaseError.extend("TextEditNotFoundError", "Edit text not found") {
+	constructor(oldString, options) {
+		super({
+			context: { oldString },
+			...options
+		});
+	}
+};
+/**
+* Thrown when a blob's bytes exceed the size limit of the storage backend writing them (inline
+* storage's fixed cap, or a registered backend's own `maxSize`).
+*/
+var BlobTooLargeError = class extends BaseError.extend("BlobTooLargeError", "Blob is too large for its backend") {
+	constructor(context, options) {
+		super({
+			context,
+			...options
+		});
+	}
+};
+/**
+* Thrown when a blob's bytes cannot be read from its backend.
+*/
+var BlobNotAvailableError = class extends BaseError.extend("BlobNotAvailableError", "Blob is not available") {
+	constructor(context, options) {
+		super({
+			context,
+			...options
+		});
+	}
+};
+/**
+* Thrown when a blob's bytes fail to upload to its backend.
+*/
+var BlobWriteError = class extends BaseError.extend("BlobWriteError", "Failed to write blob") {
+	constructor(context, options) {
+		super({
+			context,
+			...options
+		});
+	}
+};
+/**
+* Error thrown when a reactive object cannot be resolved from a snapshot.
+* Extends `BaseError` with a `reason` and optional `snapshotId` in its context.
+*/
+var GetReactiveError = class extends BaseError.extend("GetReactiveError", "Failed to get reactive object from snapshot") {
+	constructor(options) {
+		super({
+			context: {
+				reason: options.reason,
+				snapshotId: options.snapshotId
+			},
+			...options
+		});
+	}
+};
+//#endregion
+export { BlobNotAvailableError, BlobTooLargeError, BlobWriteError, EntityNotFoundError, GetReactiveError, SchemaNotFoundError, TextEditNotFoundError, TextNotSupportedError, Err_exports as t };
+
+//# sourceMappingURL=Err.mjs.map

package/dist/lib/Err.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Err.mjs","names":[],"sources":["../../src/Err.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type URI } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class EntityNotFoundError extends BaseError.extend('EntityNotFoundError', 'Entity not found') {\n  constructor(uri: URI.URI, options?: BaseErrorOptions) {\n    super({ context: { uri }, ...options });\n  }\n}\n\n/**\n * Thrown when a `Text` mutation is attempted on an object whose reactive handler does not implement\n * string CRDT editing (e.g. a snapshot or a non-reactive value).\n */\nexport class TextNotSupportedError extends BaseError.extend(\n  'TextNotSupportedError',\n  'Text operation is not supported for this object',\n) {\n  constructor(operation: string, options?: BaseErrorOptions) {\n    super({ context: { operation }, ...options });\n  }\n}\n\n/**\n * Thrown by `Text.apply` when a non-`replaceAll` edit's `oldString` is not found in the text.\n */\nexport class TextEditNotFoundError extends BaseError.extend('TextEditNotFoundError', 'Edit text not found') {\n  constructor(oldString: string, options?: BaseErrorOptions) {\n    super({ context: { oldString }, ...options });\n  }\n}\n\n/**\n * Thrown when a blob's bytes exceed the size limit of the storage backend writing them (inline\n * storage's fixed cap, or a registered backend's own `maxSize`).\n */\nexport class BlobTooLargeError extends BaseError.extend('BlobTooLargeError', 'Blob is too large for its backend') {\n  constructor(context: { size: number; limit: number }, options?: BaseErrorOptions) {\n    super({ context, ...options });\n  }\n}\n\n/**\n * Reason why a blob's bytes could not be read.\n * - `offline`: The backend's transport failed (e.g. network unavailable).\n * - `not-found`: The backend could not locate the bytes for the given URI.\n * - `backend-not-registered`: No backend is registered for the URI's scheme.\n */\nexport type BlobNotAvailableReason = 'offline' | 'not-found' | 'backend-not-registered';\n\n/**\n * Thrown when a blob's bytes cannot be read from its backend.\n */\nexport class BlobNotAvailableError extends BaseError.extend('BlobNotAvailableError', 'Blob is not available') {\n  constructor(context: { backend: string; key: string; reason: BlobNotAvailableReason }, options?: BaseErrorOptions) {\n    super({ context, ...options });\n  }\n}\n\n/**\n * Thrown when a blob's bytes fail to upload to its backend.\n */\nexport class BlobWriteError extends BaseError.extend('BlobWriteError', 'Failed to write blob') {\n  constructor(context: { backend: string }, options?: BaseErrorOptions) {\n    super({ context, ...options });\n  }\n}\n\n/**\n * Reason why getting a reactive object from a snapshot failed.\n * - `no-database`: The snapshot is not associated with a database.\n * - `object-not-found`: The object was removed or does not exist in the database.\n */\nexport type GetReactiveErrorReason = 'no-database' | 'object-not-found';\n\n/**\n * Error thrown when a reactive object cannot be resolved from a snapshot.\n * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.\n */\nexport class GetReactiveError extends BaseError.extend(\n  'GetReactiveError',\n  'Failed to get reactive object from snapshot',\n) {\n  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {\n    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AASA,IAAa,sBAAb,cAAyC,UAAU,OAAO,uBAAuB,kBAAkB,CAAC,CAAC;CACnG,YAAY,QAAgB,SAA4B;EACtD,MAAM;GAAE,SAAS,EAAE,OAAO;GAAG,GAAG;EAAQ,CAAC;CAC3C;AACF;AAEA,IAAa,sBAAb,cAAyC,UAAU,OAAO,uBAAuB,kBAAkB,CAAC,CAAC;CACnG,YAAY,KAAc,SAA4B;EACpD,MAAM;GAAE,SAAS,EAAE,IAAI;GAAG,GAAG;EAAQ,CAAC;CACxC;AACF;;;;;AAMA,IAAa,wBAAb,cAA2C,UAAU,OACnD,yBACA,iDACF,CAAC,CAAC;CACA,YAAY,WAAmB,SAA4B;EACzD,MAAM;GAAE,SAAS,EAAE,UAAU;GAAG,GAAG;EAAQ,CAAC;CAC9C;AACF;;;;AAKA,IAAa,wBAAb,cAA2C,UAAU,OAAO,yBAAyB,qBAAqB,CAAC,CAAC;CAC1G,YAAY,WAAmB,SAA4B;EACzD,MAAM;GAAE,SAAS,EAAE,UAAU;GAAG,GAAG;EAAQ,CAAC;CAC9C;AACF;;;;;AAMA,IAAa,oBAAb,cAAuC,UAAU,OAAO,qBAAqB,mCAAmC,CAAC,CAAC;CAChH,YAAY,SAA0C,SAA4B;EAChF,MAAM;GAAE;GAAS,GAAG;EAAQ,CAAC;CAC/B;AACF;;;;AAaA,IAAa,wBAAb,cAA2C,UAAU,OAAO,yBAAyB,uBAAuB,CAAC,CAAC;CAC5G,YAAY,SAA2E,SAA4B;EACjH,MAAM;GAAE;GAAS,GAAG;EAAQ,CAAC;CAC/B;AACF;;;;AAKA,IAAa,iBAAb,cAAoC,UAAU,OAAO,kBAAkB,sBAAsB,CAAC,CAAC;CAC7F,YAAY,SAA8B,SAA4B;EACpE,MAAM;GAAE;GAAS,GAAG;EAAQ,CAAC;CAC/B;AACF;;;;;AAaA,IAAa,mBAAb,cAAsC,UAAU,OAC9C,oBACA,6CACF,CAAC,CAAC;CACA,YAAY,SAAqF;EAC/F,MAAM;GAAE,SAAS;IAAE,QAAQ,QAAQ;IAAQ,YAAY,QAAQ;GAAW;GAAG,GAAG;EAAQ,CAAC;CAC3F;AACF"}