@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/dist/lib/neutral/chunk-4ZUHOTCG.mjs

@@ -0,0 +1,184 @@
+import {
+  Ref,
+  createEchoReferenceSchema,
+  getRefSavedTarget
+} from "./chunk-WTQJHC75.mjs";
+import {
+  Dictionary,
+  MetaId,
+  getDatabase,
+  getDictionary,
+  setDictionary
+} from "./chunk-R5W6DXR4.mjs";
+import {
+  KindId,
+  SnapshotKindId
+} from "./chunk-O6BH7EPN.mjs";
+
+// src/internal/common/types/well-known-types.ts
+import { DXN } from "@dxos/keys";
+var TagTypeDXN = DXN.make("org.dxos.type.tag", "0.1.0");
+
+// src/internal/common/types/meta.ts
+import * as Schema from "effect/Schema";
+import { ForeignKey } from "@dxos/echo-protocol";
+import { invariant } from "@dxos/invariant";
+import { DXN as DXN2 } from "@dxos/keys";
+import { intersection } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/types/meta.ts";
+var ATTR_META = "@meta";
+var TagRefSchema = Schema.suspend(() => (
+  // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.
+  createEchoReferenceSchema(void 0, DXN2.getName(TagTypeDXN), DXN2.getVersion(TagTypeDXN))
+));
+var EntityMetaSchema = Schema.Struct({
+  keys: Schema.Array(ForeignKey),
+  /**
+  * Tags applied to this entity, as references to {@link Tag} objects.
+  */
+  tags: Schema.Array(TagRefSchema),
+  /**
+  * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
+  * Identifies the canonical registry entry the object instance was created from.
+  */
+  key: Schema.optional(Schema.String),
+  /**
+  * Semantic version of the registry entry the object was created from.
+  * Must be a valid semver string (e.g. `1.2.3`).
+  */
+  version: Schema.optional(Schema.String),
+  /**
+  * Dictionary of annotations to this entity.
+  */
+  annotations: Dictionary,
+  /**
+  * Unix ms timestamp when this entity was created.
+  * Read-only; sourced from the system section of the automerge document — not stored in meta.
+  */
+  createdAt: Schema.optional(Schema.Number),
+  /**
+  * Unix ms timestamp of the last automerge change on this entity's document.
+  * Read-only; derived from the automerge change graph — not stored in meta.
+  */
+  updatedAt: Schema.optional(Schema.Number)
+});
+var getMeta = (obj) => {
+  const metadata = obj[MetaId];
+  invariant(metadata, "EntityMeta not found.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 63, S: void 0, A: ["metadata", "'EntityMeta not found.'"] });
+  return metadata;
+};
+var foreignKey = (source, id) => ({
+  source,
+  id
+});
+var foreignKeyEquals = (a, b) => a.source === b.source && a.id === b.id;
+var compareForeignKeys = (a, b) => intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;
+
+// src/internal/common/api/meta.ts
+import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/api/meta.ts";
+function getMetaChecked(entity) {
+  assertArgument(entity, "entity", "Should be an entity.");
+  const meta = getMeta(entity);
+  invariant2(meta != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 9, S: this, A: ["meta != null", "'Invalid entity.'"] });
+  return meta;
+}
+var getKeys = (entity, source) => {
+  assertArgument(entity, "entity", "Should be an entity.");
+  const meta = getMetaChecked(entity);
+  invariant2(meta != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 18, S: void 0, A: ["meta != null", "'Invalid entity.'"] });
+  return meta.keys.filter((key) => key.source === source);
+};
+var deleteKeys = (entity, source) => {
+  const meta = getMetaChecked(entity);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
+  }
+};
+var addTag = (entity, tag) => {
+  const meta = getMetaChecked(entity);
+  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {
+    meta.tags.push(tag);
+  }
+};
+var removeTag = (entity, tag) => {
+  const meta = getMetaChecked(entity);
+  for (let i = 0; i < meta.tags.length; i++) {
+    if (meta.tags[i].uri === tag.uri) {
+      meta.tags.splice(i, 1);
+      i--;
+    }
+  }
+};
+
+// src/internal/Entity/guard.ts
+var isEntity = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[KindId] !== void 0;
+};
+var isSnapshot = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[SnapshotKindId] !== void 0;
+};
+
+// src/internal/Annotation/entity-dictionary.ts
+import { deepMapValues } from "@dxos/util";
+var get = (target, annotation) => {
+  if (isEntity(target) || isSnapshot(target)) {
+    const meta = getMetaChecked(target);
+    return getDictionary(meta.annotations, annotation);
+  } else {
+    throw new TypeError("Target is not an annotation target.");
+  }
+};
+var set = (target, annotation, value) => {
+  if (isEntity(target)) {
+    const meta = getMetaChecked(target);
+    persistRefTargets(target, value);
+    setDictionary(meta.annotations, annotation, value);
+  } else {
+    throw new TypeError("Target is not an annotation target.");
+  }
+};
+var persistRefTargets = (host, value) => {
+  const database = getDatabase(host);
+  if (database == null) {
+    return;
+  }
+  deepMapValues(value, (current, recurse) => {
+    if (Ref.isRef(current)) {
+      const refTarget = getRefSavedTarget(current);
+      if (refTarget != null && isEntity(refTarget) && getDatabase(refTarget) == null) {
+        database.add(refTarget);
+      }
+      return current;
+    }
+    return recurse(current);
+  });
+};
+
+export {
+  TagTypeDXN,
+  ATTR_META,
+  EntityMetaSchema,
+  getMeta,
+  foreignKey,
+  foreignKeyEquals,
+  compareForeignKeys,
+  getMetaChecked,
+  getKeys,
+  deleteKeys,
+  addTag,
+  removeTag,
+  isEntity,
+  get,
+  set
+};
+//# sourceMappingURL=chunk-4ZUHOTCG.mjs.map

package/dist/lib/neutral/chunk-4ZUHOTCG.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/common/types/well-known-types.ts", "../../../src/internal/common/types/meta.ts", "../../../src/internal/common/api/meta.ts", "../../../src/internal/Entity/guard.ts", "../../../src/internal/Annotation/entity-dictionary.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { DXN } from '@dxos/keys';\n\n/**\n * DXN identity of the system {@link Tag} type.\n *\n * Defined in this low-level leaf so it can be shared by the public `Tag` type (which brands the\n * schema with this DXN) and by `EntityMetaSchema.tags` (which builds a `Ref<Tag>` schema from it)\n * without either importing the other — `Tag` is top-level and `meta` is deep-internal, so a direct\n * dependency between them would form an eval-order cycle.\n */\nexport const TagTypeDXN = DXN.make('org.dxos.type.tag', '0.1.0');\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { type EncodedReference, ForeignKey } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Comparator, intersection } from '@dxos/util';\n\nimport type * as Tag from '../../../Tag';\nimport { Dictionary } from '../../Annotation/dictionary';\n// `meta` is no longer re-exported from the `common/types` barrel (see ./index.ts), so importing the\n// Ref schema builder here no longer forms an eval-order cycle with `Annotation`/`Database`.\nimport { type Ref, createEchoReferenceSchema } from '../../Ref/ref';\nimport { type AnyProperties } from './base';\nimport { MetaId } from './model-symbols';\nimport { TagTypeDXN } from './well-known-types';\n\n/**\n * Property name for meta when object is serialized to JSON.\n */\nexport const ATTR_META = '@meta';\n\n//\n// EntityMeta\n//\n\n/**\n * Schema for references to {@link Tag} objects stored in {@link EntityMetaSchema.tags}.\n *\n * Built from the shared {@link createEchoReferenceSchema} (the same builder `Ref.Ref` uses) via\n * `Schema.suspend`, so it reuses the canonical ref codec rather than duplicating it. The Tag type\n * identity comes from the shared {@link TagTypeDXN} constant; `suspend` defers construction until\n * first use, and `Tag` is referenced type-only, so no `Tag` value import is needed.\n */\nconst TagRefSchema = Schema.suspend(\n  (): Schema.Schema<Ref<Tag.Tag>, EncodedReference> =>\n    // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.\n    createEchoReferenceSchema(undefined, DXN.getName(TagTypeDXN), DXN.getVersion(TagTypeDXN)) as Schema.Schema<\n      Ref<Tag.Tag>,\n      EncodedReference\n    >,\n);\n\nexport const EntityMetaSchema = Schema.Struct({\n  keys: Schema.Array(ForeignKey),\n\n  /**\n   * Tags applied to this entity, as references to {@link Tag} objects.\n   */\n  tags: Schema.Array(TagRefSchema),\n\n  /**\n   * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).\n   * Identifies the canonical registry entry the object instance was created from.\n   */\n  key: Schema.optional(Schema.String),\n\n  /**\n   * Semantic version of the registry entry the object was created from.\n   * Must be a valid semver string (e.g. `1.2.3`).\n   */\n  version: Schema.optional(Schema.String),\n\n  /**\n   * Dictionary of annotations to this entity.\n   */\n  annotations: Dictionary,\n\n  /**\n   * Unix ms timestamp when this entity was created.\n   * Read-only; sourced from the system section of the automerge document — not stored in meta.\n   */\n  createdAt: Schema.optional(Schema.Number),\n\n  /**\n   * Unix ms timestamp of the last automerge change on this entity's document.\n   * Read-only; derived from the automerge change graph — not stored in meta.\n   */\n  updatedAt: Schema.optional(Schema.Number),\n});\n\nexport type EntityMeta = Schema.Schema.Type<typeof EntityMetaSchema>;\n\n/*\n * Get metadata from object.\n * Only callable on the object root.\n *\n * @internal (use Obj.getMeta or Relation.getMeta)\n */\n// TODO(burdon): Refine type to BaseObj.\nexport const getMeta = (obj: AnyProperties): EntityMeta => {\n  const metadata = (obj as any)[MetaId];\n  invariant(metadata, 'EntityMeta not found.');\n  return metadata;\n};\n\n//\n// Foreign keys\n//\n\nexport const foreignKey = (source: string, id: string): ForeignKey => ({ source, id });\nexport const foreignKeyEquals = (a: ForeignKey, b: ForeignKey) => a.source === b.source && a.id === b.id;\n\n// TODO(dmaretskyi): Move to echo-schema.\nexport const compareForeignKeys: Comparator<AnyProperties> = (a: AnyProperties, b: AnyProperties) =>\n  intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport type { DeepReadonly } from '@dxos/util';\n\nimport type * as Tag from '../../../Tag';\nimport type { Ref } from '../../Ref/ref';\nimport { type Mutable } from '../proxy';\nimport { type AnyProperties } from '../types';\nimport { type EntityMeta, getMeta as getMeta$ } from '../types/meta';\n\n/**\n * Deeply read-only version of EntityMeta.\n */\nexport type ReadonlyMeta = DeepReadonly<EntityMeta>;\n\n/**\n * Mutable meta type received in meta mutation callbacks.\n */\nexport type Meta = Mutable<EntityMeta>;\n\n/**\n * Get the metadata for an entity with validation.\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(burdon): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\n */\nexport function getMetaChecked(entity: Mutable<AnyProperties>): Meta;\nexport function getMetaChecked(entity: AnyProperties): ReadonlyMeta;\nexport function getMetaChecked(entity: AnyProperties): Meta | ReadonlyMeta {\n  assertArgument(entity, 'entity', 'Should be an entity.');\n  const meta = getMeta$(entity);\n  invariant(meta != null, 'Invalid entity.');\n  return meta;\n}\n\n/**\n * @returns Foreign keys for the entity from the specified source.\n * Accepts both reactive entities and snapshots.\n */\nexport const getKeys = (entity: AnyProperties, source: string): ForeignKey[] => {\n  assertArgument(entity, 'entity', 'Should be an entity.');\n  const meta = getMetaChecked(entity);\n  invariant(meta != null, 'Invalid entity.');\n  return meta.keys.filter((key) => key.source === source);\n};\n\n/**\n * Delete all keys from the entity for the specified source.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const deleteKeys = (entity: Mutable<AnyProperties>, source: string) => {\n  const meta = getMetaChecked(entity);\n  for (let i = 0; i < meta.keys.length; i++) {\n    if (meta.keys[i].source === source) {\n      meta.keys.splice(i, 1);\n      i--;\n    }\n  }\n};\n\n/**\n * Add a tag (a reference to a {@link Tag} object) to the entity. Idempotent.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const addTag = (entity: Mutable<AnyProperties>, tag: Ref<Tag.Tag>) => {\n  const meta = getMetaChecked(entity);\n  // Two refs to the same target are not `===`; dedupe by URI.\n  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {\n    meta.tags.push(tag);\n  }\n};\n\n/**\n * Remove a tag (a reference to a {@link Tag} object) from the entity. No-op when not present.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const removeTag = (entity: Mutable<AnyProperties>, tag: Ref<Tag.Tag>) => {\n  const meta = getMetaChecked(entity);\n  for (let i = 0; i < meta.tags.length; i++) {\n    if (meta.tags[i].uri === tag.uri) {\n      meta.tags.splice(i, 1);\n      i--;\n    }\n  }\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport type * as Entity from '../../Entity';\nimport { KindId, SnapshotKindId } from '../common/types';\n\n/**\n * Returns true if the value is an ECHO entity instance (object or relation).\n */\nexport const isEntity = (value: unknown): value is Entity.Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[KindId] !== undefined;\n};\n\n/**\n * Returns true if the value is an ECHO entity snapshot.\n */\nexport const isSnapshot = (value: unknown): value is Entity.Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[SnapshotKindId] !== undefined;\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\n\nimport { deepMapValues } from '@dxos/util';\n\nimport type * as Annotation from '../../Annotation';\nimport type * as Entity from '../../Entity';\nimport { getMetaChecked } from '../common/api/meta';\nimport { type Mutable } from '../common/proxy/reactive';\nimport { getDatabase } from '../Entity/api';\nimport { isEntity, isSnapshot } from '../Entity/guard';\nimport { Ref, getRefSavedTarget } from '../Ref';\nimport { getDictionary, setDictionary } from './dictionary';\n\n/**\n * Get the value of an annotation from an entity instance or snapshot.\n */\nexport const get = <T>(\n  target: Entity.Unknown | Entity.Snapshot,\n  annotation: Annotation.Annotation<T>,\n): Option.Option<T> => {\n  if (isEntity(target) || isSnapshot(target)) {\n    const meta = getMetaChecked(target);\n    return getDictionary(meta.annotations, annotation);\n  } else {\n    throw new TypeError('Target is not an annotation target.');\n  }\n};\n\n/**\n * Set the value of an annotation on an entity instance.\n * Must be called with a mutable entity — i.e. inside an `Obj.update` callback.\n */\nexport const set = <T>(target: Mutable<Entity.Unknown>, annotation: Annotation.Annotation<T>, value: T): void => {\n  if (isEntity(target)) {\n    const meta = getMetaChecked(target);\n    // Persist any unsaved Ref targets in the value into the entity's database so\n    // the encoded DXN resolves on read. This mirrors normal property assignment,\n    // where the reactive proxy links unsaved ref targets via `createRef` →\n    // `database.add`. `setDictionary` pre-encodes the value (`Schema.encodeSync`),\n    // so the live Ref never reaches the proxy's link handling and would otherwise\n    // be stored as a dangling reference.\n    persistRefTargets(target, value);\n    setDictionary(meta.annotations, annotation, value);\n  } else {\n    throw new TypeError('Target is not an annotation target.');\n  }\n};\n\n/**\n * Add any unsaved Ref targets found in `value` to the host entity's database, matching the\n * auto-persistence applied to refs assigned to ordinary entity properties. Refs whose target\n * already lives in a database (the host's or a foreign one) are left untouched.\n */\nconst persistRefTargets = (host: Entity.Unknown, value: unknown): void => {\n  const database = getDatabase(host);\n  if (database == null) {\n    return;\n  }\n\n  deepMapValues(value, (current, recurse) => {\n    if (Ref.isRef(current)) {\n      const refTarget = getRefSavedTarget(current);\n      if (refTarget != null && isEntity(refTarget) && getDatabase(refTarget) == null) {\n        database.add(refTarget);\n      }\n      return current;\n    }\n    return recurse(current);\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["DXN", "TagTypeDXN", "make", "Schema", "ForeignKey", "invariant", "DXN", "intersection", "Schema", "Struct", "keys", "ForeignKey", "invariant", "metadata", "id", "compareForeignKeys", "a", "b", "intersection", "getMeta", "assertArgument", "invariant", "__dxlog_file", "getMetaChecked", "meta", "entity", "invariant", "keys", "key", "source", "splice", "i", "tags", "existing", "length", "uri", "isEntity", "value", "KindId", "undefined", "isSnapshot", "SnapshotKindId", "deepMapValues", "get", "target", "annotation", "isEntity", "isSnapshot", "meta", "getMetaChecked", "getDictionary", "annotations", "TypeError", "set", "value", "persistRefTargets", "setDictionary", "host", "database", "getDatabase", "deepMapValues", "current", "recurse", "Ref", "isRef", "refTarget", "getRefSavedTarget", "add"]
+}

package/dist/lib/neutral/chunk-5SMDBFVB.mjs

@@ -0,0 +1,108 @@
+import {
+  foreignKeys,
+  type
+} from "./chunk-6YDI3J37.mjs";
+import {
+  Meta,
+  getMeta,
+  make,
+  update
+} from "./chunk-TYGKCRMK.mjs";
+import {
+  makeObject
+} from "./chunk-T6E37YIP.mjs";
+import {
+  TagTypeDXN
+} from "./chunk-4ZUHOTCG.mjs";
+import {
+  HiddenAnnotation,
+  LabelAnnotation
+} from "./chunk-R5W6DXR4.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Tag.ts
+var Tag_exports = {};
+__export(Tag_exports, {
+  Tag: () => Tag,
+  createTagList: () => createTagList,
+  findOrCreate: () => findOrCreate,
+  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(
+  LabelAnnotation.set([
+    "label"
+  ]),
+  HiddenAnnotation.set(true),
+  // Shared DXN so `meta.tags` (the `Ref<Tag>` schema) and this type stay in sync.
+  makeObject(TagTypeDXN)
+);
+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;
+};
+var findOrCreate = async (db, options) => {
+  const { label, hue, key } = options;
+  const withHue = hue ? {
+    hue
+  } : {};
+  if (key) {
+    const [existing2] = await db.query(foreignKeys(Tag, [
+      key
+    ])).run();
+    if (existing2) {
+      if (existing2.label !== label || hue !== void 0 && existing2.hue !== hue) {
+        update(existing2, (existing3) => {
+          existing3.label = label;
+          if (hue !== void 0) {
+            existing3.hue = hue;
+          }
+        });
+      }
+      return existing2;
+    }
+    return db.add(make(Tag, {
+      [Meta]: {
+        keys: [
+          key
+        ]
+      },
+      label,
+      ...withHue
+    }));
+  }
+  const lowered = label.toLowerCase();
+  const candidates = await db.query(type(Tag)).run();
+  const existing = candidates.find((tag) => tag.label.toLowerCase() === lowered && (getMeta(tag).keys ?? []).length === 0);
+  return existing ?? db.add(make2({
+    label,
+    ...withHue
+  }));
+};
+
+export {
+  Tag,
+  make2 as make,
+  sortTags,
+  createTagList,
+  findTagByLabel,
+  findOrCreate,
+  Tag_exports
+};
+//# sourceMappingURL=chunk-5SMDBFVB.mjs.map

package/dist/lib/neutral/chunk-5SMDBFVB.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 type { ForeignKey } from '@dxos/echo-protocol';\n\nimport type * as Database from './Database';\nimport * as Filter from './Filter';\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  internal.LabelAnnotation.set(['label']),\n  internal.HiddenAnnotation.set(true),\n  // Shared DXN so `meta.tags` (the `Ref<Tag>` schema) and this type stay in sync.\n  Type.makeObject(internal.TagTypeDXN),\n);\n\nexport type Tag = Type.InstanceType<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\n/**\n * Finds or creates a {@link Tag} object in the database.\n *\n * - With a foreign `key` (system/provider tags): matched by that key; the label is kept current on\n *   re-sync. Use a stable key (e.g. `{ source: 'google.com/gmail/label', id }`) for tags whose\n *   identity is external or well-known.\n * - Without a key (user tags): matched by case-insensitive label among tags that carry **no**\n *   foreign key, so it never collides with a keyed system/provider tag of the same label.\n */\nexport const findOrCreate = async (\n  db: Pick<Database.Database, 'query' | 'add'>,\n  options: { label: string; hue?: string; key?: ForeignKey },\n): Promise<Tag> => {\n  const { label, hue, key } = options;\n  const withHue = hue ? { hue } : {};\n  if (key) {\n    const [existing] = await db.query(Filter.foreignKeys(Tag, [key])).run();\n    if (existing) {\n      // Keep label (and hue, when provided) current on re-sync. `hue` is only touched when supplied,\n      // so a label-only re-sync (e.g. Gmail) doesn't wipe a user-set colour.\n      if (existing.label !== label || (hue !== undefined && existing.hue !== hue)) {\n        Obj.update(existing, (existing) => {\n          existing.label = label;\n          if (hue !== undefined) {\n            existing.hue = hue;\n          }\n        });\n      }\n      return existing;\n    }\n    return db.add(Obj.make(Tag, { [Obj.Meta]: { keys: [key] }, label, ...withHue }));\n  }\n\n  const lowered = label.toLowerCase();\n  const candidates = await db.query(Filter.type(Tag)).run();\n  const existing = candidates.find(\n    (tag) => tag.label.toLowerCase() === lowered && (Obj.getMeta(tag).keys ?? []).length === 0,\n  );\n  return existing ?? db.add(make({ label, ...withHue }));\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;cAAAA;EAAA;;AAMA,YAAYC,YAAY;AAUjB,IAAMC,MAAaC,cAAO;EAC/BC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG;EACQC,gBAAgBC,IAAI;IAAC;GAAQ;EAC7BC,iBAAiBD,IAAI,IAAA;;EAEzBE,WAAoBC,UAAU;AAAA;AAK9B,IAAMC,QAAO,CAACC,UAAyCD,KAAKZ,KAAKa,KAAAA;AAIjE,IAAMC,WAAW,CAAC,EAAEZ,OAAOa,EAAC,GAAS,EAAEb,OAAOc,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,IAAItB,MAAM6B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;AAWO,IAAMC,eAAe,OAC1BC,IACAC,YAAAA;AAEA,QAAM,EAAEjC,OAAOE,KAAKgC,IAAG,IAAKD;AAC5B,QAAME,UAAUjC,MAAM;IAAEA;EAAI,IAAI,CAAC;AACjC,MAAIgC,KAAK;AACP,UAAM,CAACE,SAAAA,IAAY,MAAMJ,GAAGK,MAAaC,YAAYxC,KAAK;MAACoC;KAAI,CAAA,EAAGK,IAAG;AACrE,QAAIH,WAAU;AAGZ,UAAIA,UAASpC,UAAUA,SAAUE,QAAQ4B,UAAaM,UAASlC,QAAQA,KAAM;AAC3EsC,QAAIC,OAAOL,WAAU,CAACA,cAAAA;AACpBA,UAAAA,UAASpC,QAAQA;AACjB,cAAIE,QAAQ4B,QAAW;AACrBM,YAAAA,UAASlC,MAAMA;UACjB;QACF,CAAA;MACF;AACA,aAAOkC;IACT;AACA,WAAOJ,GAAGU,IAAQhC,KAAKZ,KAAK;MAAE,CAAK6C,IAAI,GAAG;QAAEC,MAAM;UAACV;;MAAK;MAAGlC;MAAO,GAAGmC;IAAQ,CAAA,CAAA;EAC/E;AAEA,QAAMU,UAAU7C,MAAM6B,YAAW;AACjC,QAAMiB,aAAa,MAAMd,GAAGK,MAAaU,KAAKjD,GAAAA,CAAAA,EAAMyC,IAAG;AACvD,QAAMH,WAAWU,WAAWnB,KAC1B,CAACL,QAAQA,IAAItB,MAAM6B,YAAW,MAAOgB,YAAgBG,QAAQ1B,GAAAA,EAAKsB,QAAQ,CAAA,GAAIK,WAAW,CAAA;AAE3F,SAAOb,YAAYJ,GAAGU,IAAIhC,MAAK;IAAEV;IAAO,GAAGmC;EAAQ,CAAA,CAAA;AACrD;",
+  "names": ["make", "Schema", "Tag", "Struct", "label", "String", "hue", "optional", "pipe", "LabelAnnotation", "set", "HiddenAnnotation", "makeObject", "TagTypeDXN", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined", "findOrCreate", "db", "options", "key", "withHue", "existing", "query", "foreignKeys", "run", "Obj", "update", "add", "Meta", "keys", "lowered", "candidates", "type", "getMeta", "length"]
+}

package/dist/lib/neutral/{chunk-OS35K56T.mjs → chunk-5SUJPHAE.mjs}

@@ -1,6 +1,6 @@
 import {
   Ref
-} from "./chunk-G3IQMKF7.mjs";
+} from "./chunk-WTQJHC75.mjs";
 
 // src/internal/Ref/ref-array.ts
 import { isNonNullable } from "@dxos/util";
@@ -21,7 +21,7 @@ var RefArray = Object.freeze({
   * Removes the ref with the given id.
   */
   removeById: (refs, id) => {
-    const index = refs.findIndex(Ref.hasObjectId(id));
+    const index = refs.findIndex(Ref.hasEntityId(id));
     if (index >= 0) {
       refs.splice(index, 1);
     }
@@ -31,4 +31,4 @@ var RefArray = Object.freeze({
 export {
   RefArray
 };
-//# sourceMappingURL=chunk-OS35K56T.mjs.map
+//# sourceMappingURL=chunk-5SUJPHAE.mjs.map

package/dist/lib/neutral/{chunk-OS35K56T.mjs.map → chunk-5SUJPHAE.mjs.map}

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

package/dist/lib/neutral/{chunk-GZQTCRJB.mjs → chunk-6M2Z6WBH.mjs}

@@ -1,7 +1,10 @@
 import {
   Currency,
   CurrencyAnnotationId,
+  DateOnly,
+  DateTime,
   DecimalPrecision,
+  Duration,
   Email,
   Format,
   FormatAnnotation,
@@ -18,7 +21,11 @@ import {
   PropertyKind,
   Regex,
   SelectOption,
+  SimpleDate,
+  SimpleDateTime,
+  SimpleTime,
   Text,
+  TimeOnly,
   TypeEnum,
   TypeFormat,
   URL,
@@ -27,8 +34,11 @@ import {
   getFormatAnnotation,
   getOptionsAnnotation,
   getTypeEnum,
+  toSimpleDate,
+  toSimpleDateTime,
+  toSimpleTime,
   typeToFormat
-} from "./chunk-DQYLD2RB.mjs";
+} from "./chunk-TFEWTY5A.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -38,7 +48,10 @@ var Format_exports = {};
 __export(Format_exports, {
   Currency: () => Currency,
   CurrencyAnnotationId: () => CurrencyAnnotationId,
+  DateOnly: () => DateOnly,
+  DateTime: () => DateTime,
   DecimalPrecision: () => DecimalPrecision,
+  Duration: () => Duration,
   Email: () => Email,
   Format: () => Format,
   FormatAnnotation: () => FormatAnnotation,
@@ -55,7 +68,11 @@ __export(Format_exports, {
   PropertyKind: () => PropertyKind,
   Regex: () => Regex,
   SelectOption: () => SelectOption,
+  SimpleDate: () => SimpleDate,
+  SimpleDateTime: () => SimpleDateTime,
+  SimpleTime: () => SimpleTime,
   Text: () => Text,
+  TimeOnly: () => TimeOnly,
   TypeEnum: () => TypeEnum,
   TypeFormat: () => TypeFormat,
   URL: () => URL,
@@ -64,10 +81,13 @@ __export(Format_exports, {
   getFormatAnnotation: () => getFormatAnnotation,
   getOptionsAnnotation: () => getOptionsAnnotation,
   getTypeEnum: () => getTypeEnum,
+  toSimpleDate: () => toSimpleDate,
+  toSimpleDateTime: () => toSimpleDateTime,
+  toSimpleTime: () => toSimpleTime,
   typeToFormat: () => typeToFormat
 });
 
 export {
   Format_exports
 };
-//# sourceMappingURL=chunk-GZQTCRJB.mjs.map
+//# sourceMappingURL=chunk-6M2Z6WBH.mjs.map

package/dist/lib/neutral/chunk-6M2Z6WBH.mjs.map

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

package/dist/lib/neutral/{chunk-V36VO5SS.mjs → chunk-6YDI3J37.mjs}

@@ -1,13 +1,13 @@
 import {
   isRef
-} from "./chunk-BVOFLCVF.mjs";
+} from "./chunk-MZ7K3MLL.mjs";
 import {
-  getDXN,
   prettyFilter
-} from "./chunk-MOR5ERFM.mjs";
+} from "./chunk-7FPIAJIV.mjs";
 import {
-  getTypeDXNFromSpecifier
-} from "./chunk-2KHZ36F5.mjs";
+  getTypeURIFromSpecifier,
+  getUri
+} from "./chunk-R5W6DXR4.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -29,6 +29,7 @@ __export(Filter_exports, {
   id: () => id,
   in: () => in$,
   is: () => is,
+  key: () => key,
   lt: () => lt,
   lte: () => lte,
   neq: () => neq,
@@ -40,15 +41,13 @@ __export(Filter_exports, {
   tag: () => tag,
   text: () => text,
   type: () => type,
-  typeDXN: () => typeDXN,
-  typename: () => typename,
   updated: () => updated
 });
 import * as Match from "effect/Match";
 import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import { assertArgument } from "@dxos/invariant";
-import { DXN, ObjectId } from "@dxos/keys";
+import { EID, EntityId } from "@dxos/keys";
 var FilterClass = class _FilterClass {
   ast;
   static "variance" = {};
@@ -81,7 +80,7 @@ var nothing = () => {
   });
 };
 var id = (...ids) => {
-  assertArgument(ids.every((id2) => ObjectId.isValid(id2)), "ids", "ids must be valid");
+  assertArgument(ids.every((id2) => EntityId.isValid(id2)), "ids", "ids must be valid");
   if (ids.length === 0) {
     return nothing();
   }
@@ -92,44 +91,38 @@ var id = (...ids) => {
     props: {}
   });
 };
-var type = (schema, props2) => {
-  if (Schema.isSchema(schema) && SchemaAST.isUnion(schema.ast)) {
-    const typenames = schema.ast.types.map((type2) => getTypeDXNFromSpecifier(Schema.make(type2)));
+var type = (input, props2) => {
+  if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) {
+    const typenames = input.ast.types.map((t) => getTypeURIFromSpecifier(Schema.make(t)));
     return new FilterClass({
       type: "or",
-      filters: typenames.map((typename2) => ({
+      filters: typenames.map((typename) => ({
         type: "object",
-        typename: typename2.toString(),
+        typename,
         props: {}
       }))
     });
   }
-  const dxn = getTypeDXNFromSpecifier(schema);
+  const uri = getTypeURIFromSpecifier(input);
   return new FilterClass({
     type: "object",
-    typename: dxn.toString(),
+    typename: uri,
     ...propsFilterToAst(props2 ?? {})
   });
 };
-var typename = (typename2) => {
-  assertArgument(!typename2.startsWith("dxn:"), "typename", "Typename must no be qualified");
+var tag = (tag2) => {
   return new FilterClass({
-    type: "object",
-    typename: DXN.fromTypename(typename2).toString(),
-    props: {}
+    type: "tag",
+    tag: tag2
   });
 };
-var typeDXN = (dxn) => {
+var key = (key2, options) => {
   return new FilterClass({
     type: "object",
-    typename: dxn.toString(),
-    props: {}
-  });
-};
-var tag = (tag2) => {
-  return new FilterClass({
-    type: "tag",
-    tag: tag2
+    typename: null,
+    props: {},
+    metaKey: key2,
+    metaVersion: options?.version
   });
 };
 var props = (props2) => {
@@ -147,10 +140,10 @@ var text = (text2, options) => {
   });
 };
 var foreignKeys = (schema, keys) => {
-  const dxn = getTypeDXNFromSpecifier(schema);
+  const uri = getTypeURIFromSpecifier(schema);
   return new FilterClass({
     type: "object",
-    typename: dxn.toString(),
+    typename: uri,
     props: {},
     foreignKeys: keys
   });
@@ -251,9 +244,9 @@ var childOf = (parents, options) => {
   ];
   const dxns = items.map((item) => {
     if (isRef(item)) {
-      return item.dxn.toString();
+      return EID.parse(item.uri);
     }
-    return getDXN(item).toString();
+    return EID.parse(getUri(item));
   });
   return new FilterClass({
     type: "child-of",
@@ -286,7 +279,7 @@ var propsFilterToAst = (predicates) => {
     idFilter = typeof predicates.id === "string" ? [
       predicates.id
     ] : predicates.id;
-    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
+    Schema.Array(EntityId).pipe(Schema.validateSync)(idFilter);
   }
   return {
     id: idFilter,
@@ -305,8 +298,8 @@ var processPredicate = (predicate) => {
       throw new Error("Array predicates are not yet supported.");
     }),
     Match.when((predicate2) => !isRef(predicate2) && typeof predicate2 === "object" && predicate2 !== null, (predicate2) => {
-      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value2]) => [
-        key,
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key2, value2]) => [
+        key2,
         processPredicate(value2)
       ]));
       return {
@@ -327,9 +320,8 @@ export {
   nothing,
   id,
   type,
-  typename,
-  typeDXN,
   tag,
+  key,
   props,
   text,
   foreignKeys,
@@ -351,4 +343,4 @@ export {
   pretty,
   Filter_exports
 };
-//# sourceMappingURL=chunk-V36VO5SS.mjs.map
+//# sourceMappingURL=chunk-6YDI3J37.mjs.map