@dxos/echo 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

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

@@ -0,0 +1,27 @@
+import {
+  JsonSchemaType,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-ZCBOJ6I7.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/JsonSchema.ts
+var JsonSchema_exports = {};
+__export(JsonSchema_exports, {
+  JsonSchema: () => JsonSchema,
+  toEffectSchema: () => toEffectSchema2,
+  toJsonSchema: () => toJsonSchema2
+});
+var toEffectSchema2 = toEffectSchema;
+var toJsonSchema2 = toJsonSchema;
+var JsonSchema = JsonSchemaType;
+
+export {
+  toEffectSchema2 as toEffectSchema,
+  toJsonSchema2 as toJsonSchema,
+  JsonSchema,
+  JsonSchema_exports
+};
+//# sourceMappingURL=chunk-IICPQK3M.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/JsonSchema.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as jsonSchemaInternal from './internal/JsonSchema';\n\n/**\n * Decode JSON Schema to Effect Schema.\n */\nexport const toEffectSchema = jsonSchemaInternal.toEffectSchema;\n\n/**\n * Encode Effect Schema to JSON Schema.\n */\nexport const toJsonSchema = jsonSchemaInternal.toJsonSchema;\n\n/**\n * Serializable JsonSchema type definition.\n */\nexport type JsonSchema = jsonSchemaInternal.JsonSchemaType;\n\nexport const JsonSchema: Schema.Schema<jsonSchemaInternal.JsonSchemaType> = jsonSchemaInternal.JsonSchemaType;\n"],
+  "mappings": ";;;;;;;;;;AAAA;;;wBAAAA;EAAA,oBAAAC;;AAaO,IAAMC,kBAAoCA;AAK1C,IAAMC,gBAAkCA;AAOxC,IAAMC,aAAkFC;",
+  "names": ["toEffectSchema", "toJsonSchema", "toEffectSchema", "toJsonSchema", "JsonSchema", "JsonSchemaType"]
+}

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

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

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

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

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

@@ -0,0 +1,56 @@
+import {
+  object
+} from "./chunk-DUTD5HFU.mjs";
+import {
+  make
+} from "./chunk-CAB5PWUF.mjs";
+import {
+  LabelAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-4ZRIO2QF.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Tag.ts
+var Tag_exports = {};
+__export(Tag_exports, {
+  Tag: () => Tag,
+  createTagList: () => createTagList,
+  findTagByLabel: () => findTagByLabel,
+  make: () => make2,
+  sortTags: () => sortTags
+});
+import * as Schema from "effect/Schema";
+var Tag = Schema.Struct({
+  label: Schema.String,
+  hue: Schema.optional(Schema.String)
+}).pipe(object({
+  typename: "org.dxos.type.tag",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "label"
+]), SystemTypeAnnotation.set(true));
+var make2 = (props) => make(Tag, props);
+var sortTags = ({ label: a }, { label: b }) => a.localeCompare(b);
+var createTagList = (tags) => Object.entries(tags).map(([id, tag]) => ({
+  ...tag,
+  id
+})).sort(sortTags);
+var findTagByLabel = (tags, name) => {
+  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());
+  return entry ? {
+    ...entry[1],
+    id: entry[0]
+  } : void 0;
+};
+
+export {
+  Tag,
+  make2 as make,
+  sortTags,
+  createTagList,
+  findTagByLabel,
+  Tag_exports
+};
+//# sourceMappingURL=chunk-NKPWM67P.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Tag.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\nexport const Tag = Schema.Struct({\n  label: Schema.String,\n  hue: Schema.optional(Schema.String), // TODO(burdon): Color name?\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.tag',\n    version: '0.1.0',\n  }),\n  internal.LabelAnnotation.set(['label']),\n  internal.SystemTypeAnnotation.set(true),\n);\n\nexport type Tag = Schema.Schema.Type<typeof Tag>;\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\nexport type Map = Record<string, Tag>;\n\nexport const sortTags = ({ label: a }: Tag, { label: b }: Tag) => a.localeCompare(b);\n\nexport const createTagList = (tags: Map): Tag[] =>\n  Object.entries(tags)\n    .map(([id, tag]) => ({ ...tag, id }))\n    .sort(sortTags);\n\nexport const findTagByLabel = (tags: Map | undefined, name: string): Tag | undefined => {\n  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());\n  return entry ? { ...entry[1], id: entry[0] } : undefined;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;cAAAA;EAAA;;AAMA,YAAYC,YAAY;AAMjB,IAAMC,MAAaC,cAAO;EAC/BC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG,KACIC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,gBAAgBC,IAAI;EAAC;CAAQ,GAC7BC,qBAAqBD,IAAI,IAAA,CAAA;AAK7B,IAAME,QAAO,CAACC,UAAyCD,KAAKb,KAAKc,KAAAA;AAIjE,IAAMC,WAAW,CAAC,EAAEb,OAAOc,EAAC,GAAS,EAAEd,OAAOe,EAAC,MAAYD,EAAEE,cAAcD,CAAAA;AAE3E,IAAME,gBAAgB,CAACC,SAC5BC,OAAOC,QAAQF,IAAAA,EACZG,IAAI,CAAC,CAACC,IAAIC,GAAAA,OAAU;EAAE,GAAGA;EAAKD;AAAG,EAAA,EACjCE,KAAKX,QAAAA;AAEH,IAAMY,iBAAiB,CAACP,MAAuBQ,SAAAA;AACpD,QAAMC,QAAQR,OAAOC,QAAQF,QAAQ,CAAC,CAAA,EAAGU,KAAK,CAAC,CAACC,GAAGN,GAAAA,MAASA,IAAIvB,MAAM8B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;",
+  "names": ["make", "Schema", "Tag", "Struct", "label", "String", "hue", "optional", "pipe", "object", "typename", "version", "LabelAnnotation", "set", "SystemTypeAnnotation", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined"]
+}

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

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

package/dist/lib/neutral/chunk-OMUPQMLR.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-OPMZTWI3.mjs

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

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

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

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

@@ -0,0 +1,45 @@
+import {
+  DescriptionAnnotation,
+  FormInputAnnotation,
+  GeneratorAnnotation,
+  IconAnnotation,
+  LabelAnnotation,
+  ReferenceAnnotation,
+  SystemTypeAnnotation,
+  TypeAnnotation,
+  getDescriptionWithSchema,
+  getLabelWithSchema,
+  getTypeAnnotation,
+  makeUserAnnotation,
+  setDescriptionWithSchema,
+  setLabelWithSchema
+} from "./chunk-4ZRIO2QF.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Annotation.ts
+var Annotation_exports = {};
+__export(Annotation_exports, {
+  DescriptionAnnotation: () => DescriptionAnnotation,
+  FormInputAnnotation: () => FormInputAnnotation,
+  GeneratorAnnotation: () => GeneratorAnnotation,
+  IconAnnotation: () => IconAnnotation,
+  LabelAnnotation: () => LabelAnnotation,
+  ReferenceAnnotation: () => ReferenceAnnotation,
+  SystemTypeAnnotation: () => SystemTypeAnnotation,
+  TypeAnnotation: () => TypeAnnotation,
+  getDescriptionWithSchema: () => getDescriptionWithSchema,
+  getLabelWithSchema: () => getLabelWithSchema,
+  getTypeAnnotation: () => getTypeAnnotation,
+  make: () => make,
+  setDescriptionWithSchema: () => setDescriptionWithSchema,
+  setLabelWithSchema: () => setLabelWithSchema
+});
+var make = makeUserAnnotation;
+
+export {
+  make,
+  Annotation_exports
+};
+//# sourceMappingURL=chunk-OPQEHU36.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Annotation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nexport {\n  DescriptionAnnotation,\n  FormInputAnnotation,\n  GeneratorAnnotation,\n  LabelAnnotation,\n  ReferenceAnnotation,\n  SystemTypeAnnotation,\n  TypeAnnotation,\n  getDescriptionWithSchema,\n  getLabelWithSchema,\n  getTypeAnnotation,\n  setDescriptionWithSchema,\n  setLabelWithSchema,\n  IconAnnotation,\n} from './internal/Annotation';\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as internalAnnotations from './internal/Annotation';\n\ninterface MakeProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n/**\n * Create a new schema annotation.\n * Annotation can be assigned both to fields and to the schema itself.\n * Annotation is serialized with the schema.\n *\n * @example\n * ```ts\n * const ColorAnnotation = Annotation.make({\n *   id: 'org.dxos.annotation.color',\n *   schema: Schema.String,\n * });\n *\n * const schema = Schema.String.annotations(ColorAnnotation.set('red'));\n * ```\n */\nexport const make: <T>(props: MakeProps<T>) => internalAnnotations.AnnotationHelper<T> =\n  internalAnnotations.makeUserAnnotation;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;AA8CO,IAAMA,OACSC;",
+  "names": ["make", "makeUserAnnotation"]
+}

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

@@ -0,0 +1,299 @@
+import {
+  Feed,
+  getQueueDxn
+} from "./chunk-HGHJ36DH.mjs";
+import {
+  everything,
+  is,
+  props,
+  type
+} from "./chunk-4YAAHG3E.mjs";
+import {
+  getTypename,
+  instanceOf
+} from "./chunk-CAB5PWUF.mjs";
+import {
+  prettyQuery
+} from "./chunk-7C2A2RP6.mjs";
+import {
+  isDatabase
+} from "./chunk-XV5R2XZH.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-4ZRIO2QF.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Query.ts
+var Query_exports = {};
+__export(Query_exports, {
+  all: () => all,
+  from: () => from,
+  fromAst: () => fromAst,
+  is: () => is2,
+  pretty: () => pretty,
+  select: () => select,
+  type: () => type2,
+  without: () => without
+});
+var QueryClass = class _QueryClass {
+  ast;
+  static "variance" = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Query" = _QueryClass.variance;
+  select(filter) {
+    if (is(filter)) {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: filter.ast
+      });
+    } else {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: props(filter).ast
+      });
+    }
+  }
+  reference(key) {
+    return new _QueryClass({
+      type: "reference-traversal",
+      anchor: this.ast,
+      property: key
+    });
+  }
+  referencedBy(target, key) {
+    const dxn = target !== void 0 ? getTypeDXNFromSpecifier(target) : null;
+    return new _QueryClass({
+      type: "incoming-references",
+      anchor: this.ast,
+      property: key ?? null,
+      typename: dxn?.toString() ?? null
+    });
+  }
+  sourceOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "outgoing",
+      filter: relation !== void 0 ? type(relation, predicates).ast : void 0
+    });
+  }
+  targetOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "incoming",
+      filter: relation !== void 0 ? type(relation, predicates).ast : void 0
+    });
+  }
+  source() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "source"
+    });
+  }
+  target() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "target"
+    });
+  }
+  parent() {
+    return new _QueryClass({
+      type: "hierarchy-traversal",
+      anchor: this.ast,
+      direction: "to-parent"
+    });
+  }
+  children() {
+    return new _QueryClass({
+      type: "hierarchy-traversal",
+      anchor: this.ast,
+      direction: "to-children"
+    });
+  }
+  orderBy(...order) {
+    return new _QueryClass({
+      type: "order",
+      query: this.ast,
+      order: order.map((o) => o.ast)
+    });
+  }
+  limit(limit) {
+    return new _QueryClass({
+      type: "limit",
+      query: this.ast,
+      limit
+    });
+  }
+  from(arg, options) {
+    if (arg == null) {
+      throw new TypeError('Query.from() requires a valid data source argument (database, feed, query, scope, or "all-accessible-spaces").');
+    }
+    if (is2(arg)) {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "query",
+          query: arg.ast
+        }
+      });
+    }
+    if (arg === "all-accessible-spaces") {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scope: {
+            ...options?.includeFeeds ? {
+              allQueuesFromSpaces: true
+            } : {}
+          }
+        }
+      });
+    }
+    if (_isScope(arg)) {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scope: arg
+        }
+      });
+    }
+    const items = Array.isArray(arg) ? arg : [
+      arg
+    ];
+    if (items.length > 0 && isDatabase(items[0])) {
+      const databases = items;
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scope: {
+            spaceIds: databases.map((db) => db.spaceId),
+            ...options?.includeFeeds ? {
+              allQueuesFromSpaces: true
+            } : {}
+          }
+        }
+      });
+    }
+    if (items.length > 0) {
+      const typename = getTypename(items[0]);
+      if (typename === "org.dxos.type.view") {
+        throw new Error("Query.from(view) is not yet supported.");
+      }
+      if (typename === "org.dxos.type.collection") {
+        throw new Error("Query.from(collection) is not yet supported.");
+      }
+      for (const item of items) {
+        if (!instanceOf(Feed, item)) {
+          throw new TypeError(`Query.from() expects Feed objects (org.dxos.type.feed), but received an object with typename '${typename ?? "unknown"}'.`);
+        }
+      }
+    }
+    const feeds = items;
+    const queueDxns = feeds.flatMap((feed) => {
+      const dxn = getQueueDxn(feed);
+      return dxn ? [
+        dxn.toString()
+      ] : [];
+    });
+    return new _QueryClass({
+      type: "from",
+      query: this.ast,
+      from: {
+        _tag: "scope",
+        scope: {
+          queues: queueDxns
+        }
+      }
+    });
+  }
+  options(options) {
+    return new _QueryClass({
+      type: "options",
+      query: this.ast,
+      options
+    });
+  }
+};
+var is2 = (value) => {
+  return typeof value === "object" && value !== null && "~Query" in value;
+};
+var fromAst = (ast) => {
+  return new QueryClass(ast);
+};
+var select = (filter) => {
+  return new QueryClass({
+    type: "select",
+    filter: filter.ast
+  });
+};
+var type2 = (schema, predicates) => {
+  return new QueryClass({
+    type: "select",
+    filter: type(schema, predicates).ast
+  });
+};
+var all = (...queries) => {
+  if (queries.length === 0) {
+    throw new TypeError("Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())");
+  }
+  return new QueryClass({
+    type: "union",
+    queries: queries.map((q) => q.ast)
+  });
+};
+var without = (source, exclude) => {
+  return new QueryClass({
+    type: "set-difference",
+    source: source.ast,
+    exclude: exclude.ast
+  });
+};
+var from = (source, options) => {
+  const baseQuery = {
+    type: "select",
+    filter: everything().ast
+  };
+  const wrapper = new QueryClass(baseQuery);
+  return wrapper.from(source, options);
+};
+var SCOPE_KEYS = /* @__PURE__ */ new Set([
+  "spaceIds",
+  "queues",
+  "allQueuesFromSpaces"
+]);
+var _isScope = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.keys(value).every((key) => SCOPE_KEYS.has(key));
+};
+var pretty = (query) => prettyQuery(query.ast);
+
+export {
+  is2 as is,
+  fromAst,
+  select,
+  type2 as type,
+  all,
+  without,
+  from,
+  pretty,
+  Query_exports
+};
+//# sourceMappingURL=chunk-QDV7C7VM.mjs.map