@dxos/echo 0.8.4-main.40e3dcdf1b → 0.8.4-main.43cb759274

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

@@ -0,0 +1,379 @@
+import {
+  select
+} from "./chunk-OIYW7R2G.mjs";
+import {
+  Feed
+} from "./chunk-BDQGMDIX.mjs";
+import {
+  nothing
+} from "./chunk-ZACMEAYV.mjs";
+import {
+  ID,
+  Unknown,
+  getMeta,
+  instanceOf,
+  make,
+  update
+} from "./chunk-Q5FKCVBC.mjs";
+import {
+  Ref,
+  fromURI
+} from "./chunk-J3MNM65T.mjs";
+import {
+  getSchema,
+  makeObject
+} from "./chunk-JE7AOSWF.mjs";
+import {
+  JsonSchemaType
+} from "./chunk-7PRCIDHH.mjs";
+import {
+  FormInputAnnotation,
+  HiddenAnnotation,
+  IconAnnotation
+} from "./chunk-H26LSXVJ.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/index.ts
+import { QueryAST as QueryAST2 } from "@dxos/echo-protocol";
+import { DXN as DXN3, EID as EID3, URI as URI2 } from "@dxos/keys";
+
+// src/Hypergraph.ts
+var Hypergraph_exports = {};
+
+// src/Json.ts
+var Json_exports = {};
+__export(Json_exports, {
+  createRefReplacer: () => createRefReplacer
+});
+import { EID } from "@dxos/keys";
+var isEncodedRef = (value) => typeof value === "object" && value !== null && Object.keys(value).length === 1 && typeof value["/"] === "string";
+var toJson = (obj) => typeof obj.toJSON === "function" ? obj.toJSON() : obj;
+var createRefReplacer = ({ db, depth = 1 }) => {
+  const hops = /* @__PURE__ */ new WeakMap();
+  return function(key, value) {
+    const parentHops = this && typeof this === "object" ? hops.get(this) ?? 0 : 0;
+    if (isEncodedRef(value)) {
+      if (parentHops >= depth) {
+        return value;
+      }
+      const dxnString = value["/"];
+      if (!dxnString.startsWith("dxn:") && !dxnString.startsWith("echo:")) {
+        return value;
+      }
+      let echoUri;
+      try {
+        const parsed = EID.tryParse(dxnString);
+        echoUri = parsed ? EID.getEntityId(parsed) : void 0;
+      } catch {
+        return value;
+      }
+      if (!echoUri) {
+        return value;
+      }
+      const target = db.getObjectById(echoUri);
+      if (!target) {
+        return value;
+      }
+      const encoded = toJson(target);
+      if (encoded != null && typeof encoded === "object") {
+        hops.set(encoded, parentHops + 1);
+      }
+      return encoded;
+    }
+    if (value != null && typeof value === "object") {
+      hops.set(value, parentHops);
+    }
+    return value;
+  };
+};
+
+// src/StateMap.ts
+var StateMap_exports = {};
+__export(StateMap_exports, {
+  bind: () => bind,
+  field: () => field
+});
+import * as Schema from "effect/Schema";
+var field = (value) => Schema.Record({
+  key: Schema.String,
+  value
+}).pipe(FormInputAnnotation.set(false), Schema.optional);
+var bind = (host, key) => {
+  const asView = (obj) => obj;
+  const read = () => asView(host)[key] ?? {};
+  const write = (mutate) => {
+    update(host, (host2) => {
+      const view = asView(host2);
+      if (view[key] === void 0) {
+        view[key] = {};
+      }
+      mutate(view[key]);
+    });
+  };
+  const has = (record, id) => Object.keys(record).includes(id);
+  return {
+    ids: (predicate) => {
+      const record = read();
+      const keys = Object.keys(record);
+      return predicate ? keys.filter((id) => predicate(record[id], id)) : keys;
+    },
+    get: (id) => {
+      const record = read();
+      return has(record, id) ? record[id] : {};
+    },
+    entries: () => {
+      const record = read();
+      return Object.keys(record).map((id) => [
+        id,
+        record[id]
+      ]);
+    },
+    patch: (id, patch) => write((record) => {
+      if (!has(record, id)) {
+        record[id] = {
+          ...patch
+        };
+      } else {
+        Object.assign(record[id], patch);
+      }
+    }),
+    remove: (id) => write((record) => {
+      if (has(record, id)) {
+        delete record[id];
+      }
+    })
+  };
+};
+
+// src/TagIndex.ts
+var TagIndex_exports = {};
+__export(TagIndex_exports, {
+  bind: () => bind2,
+  field: () => field2
+});
+import * as Schema2 from "effect/Schema";
+var field2 = () => Schema2.Record({
+  key: Schema2.String,
+  value: Schema2.Array(ID)
+}).pipe(FormInputAnnotation.set(false), Schema2.optional);
+var bind2 = (host, key) => {
+  const asView = (obj) => obj;
+  const read = () => asView(host)[key] ?? {};
+  const write = (mutate) => {
+    update(host, (host2) => {
+      const view = asView(host2);
+      if (view[key] === void 0) {
+        view[key] = {};
+      }
+      mutate(view[key]);
+    });
+  };
+  const has = (record, tagId) => Object.keys(record).includes(tagId);
+  return {
+    tagIds: () => Object.keys(read()),
+    objects: (tagId) => {
+      const record = read();
+      return has(record, tagId) ? record[tagId] : [];
+    },
+    tags: (objectId) => {
+      const record = read();
+      return Object.keys(record).filter((tagId) => record[tagId].includes(objectId));
+    },
+    setTag: (tagId, objectId) => write((record) => {
+      if (!has(record, tagId)) {
+        record[tagId] = [
+          objectId
+        ];
+      } else if (!record[tagId].includes(objectId)) {
+        record[tagId] = [
+          ...record[tagId],
+          objectId
+        ];
+      }
+    }),
+    unsetTag: (tagId, objectId) => write((record) => {
+      if (!has(record, tagId)) {
+        return;
+      }
+      const next = record[tagId].filter((existing) => existing !== objectId);
+      if (next.length === 0) {
+        delete record[tagId];
+      } else {
+        record[tagId] = next;
+      }
+    })
+  };
+};
+
+// src/Tagging.ts
+var Tagging_exports = {};
+__export(Tagging_exports, {
+  get: () => get,
+  resolve: () => resolve,
+  set: () => set,
+  unset: () => unset
+});
+import { EID as EID2, URI } from "@dxos/keys";
+var DEFAULT_KEY = "tags";
+var get = (object, options = {}) => {
+  const { host, key = DEFAULT_KEY } = options;
+  if (host) {
+    return bind2(host, key).tags(object.id);
+  }
+  return getMeta(object).tags.map((tag) => tag.uri);
+};
+var set = (object, tagId, options = {}) => {
+  const { host, key = DEFAULT_KEY } = options;
+  if (host) {
+    bind2(host, key).setTag(tagId, object.id);
+    return;
+  }
+  const id = EID2.tryParse(tagId) ?? tagId;
+  update(object, (object2) => {
+    const meta = getMeta(object2);
+    if (!meta.tags.some((tag) => tag.uri === id)) {
+      meta.tags.push(fromURI(URI.make(id)));
+    }
+  });
+};
+var unset = (object, tagId, options = {}) => {
+  const { host, key = DEFAULT_KEY } = options;
+  if (host) {
+    bind2(host, key).unsetTag(tagId, object.id);
+    return;
+  }
+  const id = EID2.tryParse(tagId) ?? tagId;
+  update(object, (object2) => {
+    const meta = getMeta(object2);
+    for (let i = meta.tags.length - 1; i >= 0; i--) {
+      if (meta.tags[i].uri === id) {
+        meta.tags.splice(i, 1);
+      }
+    }
+  });
+};
+var resolve = (db, tagIds) => tagIds.map((id) => db.makeRef(URI.make(id)));
+
+// src/Collection.ts
+var Collection_exports = {};
+__export(Collection_exports, {
+  Collection: () => Collection,
+  isCollection: () => isCollection,
+  make: () => make2
+});
+import * as Schema3 from "effect/Schema";
+import { DXN } from "@dxos/keys";
+var Collection = Schema3.Struct({
+  name: Schema3.String.pipe(Schema3.optional),
+  objects: Schema3.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
+}).pipe(IconAnnotation.set({
+  icon: "ph--folder--regular",
+  hue: "amber"
+}), makeObject(DXN.make("org.dxos.type.collection", "0.1.0")));
+var make2 = (props = {}) => make(Collection, {
+  objects: [],
+  ...props
+});
+var isCollection = instanceOf(Collection);
+
+// src/View.ts
+var View_exports = {};
+__export(View_exports, {
+  FieldSchema: () => FieldSchema,
+  KeyValueProps: () => KeyValueProps,
+  Projection: () => Projection,
+  View: () => View,
+  createFieldId: () => createFieldId,
+  make: () => make3
+});
+import * as Schema4 from "effect/Schema";
+import { QueryAST } from "@dxos/echo-protocol";
+import { JsonPath } from "@dxos/effect";
+import { DXN as DXN2, PublicKey } from "@dxos/keys";
+var FieldSchema = Schema4.Struct({
+  id: Schema4.String,
+  path: JsonPath,
+  visible: Schema4.optional(Schema4.Boolean),
+  // TODO(wittjosiah): Presentation-specific?
+  referencePath: Schema4.optional(JsonPath)
+});
+var KeyValueProps = Schema4.Record({
+  key: Schema4.String,
+  value: Schema4.Any
+});
+var createFieldId = () => PublicKey.random().truncate();
+var Projection = Schema4.Struct({
+  /**
+  * Optional schema override used to customize the underlying schema.
+  */
+  schema: JsonSchemaType.pipe(Schema4.optional),
+  /**
+  * UX metadata associated with displayed fields (in table, form, etc.)
+  */
+  // TODO(wittjosiah): Should this just be an array of JsonPath?
+  fields: Schema4.Array(FieldSchema),
+  /**
+  * The id for the field used to pivot the view.
+  * E.g., the field to use for kanban columns or the field to use for map coordinates.
+  */
+  pivotFieldId: Schema4.String.pipe(Schema4.optional)
+});
+var ViewSchema = Schema4.Struct({
+  /**
+  * Query used to retrieve data.
+  * Can be a user-provided query grammar string or a query AST.
+  */
+  query: Schema4.Struct({
+    raw: Schema4.optional(Schema4.String),
+    ast: QueryAST.Query
+  }),
+  /**
+  * Projection of the data returned from the query.
+  */
+  projection: Projection
+}).pipe(HiddenAnnotation.set(true), IconAnnotation.set({
+  icon: "ph--funnel--regular",
+  hue: "green"
+}), makeObject(DXN2.make("org.dxos.type.view", "0.1.0")));
+var View = ViewSchema;
+var make3 = (props) => {
+  return make(View, {
+    query: {
+      ast: select(nothing()).ast
+    },
+    projection: {
+      fields: []
+    },
+    ...props
+  });
+};
+
+// src/Dataset.ts
+var Dataset_exports = {};
+__export(Dataset_exports, {
+  Dataset: () => Dataset,
+  isDataset: () => isDataset
+});
+import { pipe } from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Schema5 from "effect/Schema";
+var Dataset = Schema5.Union(getSchema(Feed), getSchema(Collection), getSchema(View));
+var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Predicate.or(instanceOf(View)));
+
+export {
+  Hypergraph_exports,
+  Json_exports,
+  StateMap_exports,
+  TagIndex_exports,
+  Tagging_exports,
+  Collection_exports,
+  View_exports,
+  Dataset_exports,
+  QueryAST2 as QueryAST,
+  DXN3 as DXN,
+  EID3 as EID,
+  URI2 as URI
+};
+//# sourceMappingURL=chunk-LAF3LSWI.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/Hypergraph.ts", "../../../src/Json.ts", "../../../src/StateMap.ts", "../../../src/TagIndex.ts", "../../../src/Tagging.ts", "../../../src/Collection.ts", "../../../src/View.ts", "../../../src/Dataset.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport { QueryAST } from '@dxos/echo-protocol';\nexport { DXN, EID, URI } from '@dxos/keys';\n\nexport * as Annotation from './Annotation';\nexport * as Database from './Database';\nexport * as Entity from './Entity';\n// TODO(burdon): Rename to Error (less problematic than Obj/Object).\nexport * as Err from './Err';\nexport * as Feed from './Feed';\nexport * as Filter from './Filter';\nexport * as Format from './Format';\nexport * as Hypergraph from './Hypergraph';\nexport * as Json from './Json';\nexport * as JsonSchema from './JsonSchema';\nexport * as Key from './Key';\nexport * as Migration from './Migration';\nexport * as Obj from './Obj';\nexport * as Order from './Order';\nexport * as Query from './Query';\nexport * as QueryResult from './QueryResult';\nexport * as Ref from './Ref';\nexport * as Registry from './Registry';\nexport * as Relation from './Relation';\nexport * as Scope from './Scope';\nexport * as StateMap from './StateMap';\nexport * as Tag from './Tag';\nexport * as TagIndex from './TagIndex';\nexport * as Tagging from './Tagging';\nexport * as Type from './Type';\nexport * as Collection from './Collection';\nexport * as View from './View';\nexport * as Dataset from './Dataset';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport type * as internal from './internal';\nimport type * as Key from './Key';\nimport type * as Ref from './Ref';\nimport type * as Registry from './Registry';\n\n/**\n * Resolution context.\n * Affects how non-absolute DXNs are resolved.\n */\nexport interface RefResolutionContext {\n  /**\n   * Space that the resolution is happening from.\n   */\n  space?: Key.SpaceId;\n\n  /**\n   * Feed that the resolution is happening from.\n   * This feed will be searched first, and then the space it belongs to.\n   */\n  feed?: URI.URI;\n}\n\nexport interface RefResolverOptions {\n  /**\n   * Resolution context.\n   * Affects how non-absolute DXNs are resolved.\n   */\n  context?: RefResolutionContext;\n\n  /**\n   * Middleware to change the resolved object before returning it.\n   * @deprecated On track to be removed.\n   */\n  middleware?: (obj: internal.AnyProperties) => internal.AnyProperties;\n}\n\n/**\n * Manages cross-space database interactions.\n */\nexport interface Hypergraph extends Database.Queryable {\n  /**\n   * In-process registry of keyed objects and static schema types.\n   * Populated at startup via `registry.add(objects)` / `registry.add(schemas)`.\n   * Queries that include no explicit from() clause will fan out to this registry automatically.\n   */\n  get registry(): Registry.Registry;\n\n  /**\n   * Query objects.\n   */\n  query: Database.QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.fromURI`\n   * `Ref.fromURI(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.\n   * `db.makeRef(dxn)` is preferable in cases with access to the database.\n   */\n  makeRef<T extends Entity.Unknown = Entity.Unknown>(uri: URI.URI): Ref.Ref<T>;\n\n  /**\n   * @param hostDb Host database for reference resolution.\n   * @param middleware Called with the loaded object. The caller may change the object.\n   * @returns Result of `onLoad`.\n   */\n  // TODO(dmaretskyi): Restructure API: Remove middleware.\n  createRefResolver(options: RefResolverOptions): Ref.Resolver;\n\n  /**\n   * Get a database by space ID.\n   * @returns The database for the given space ID, or undefined if not found.\n   */\n  getDatabase(spaceId: Key.SpaceId): Database.Database | undefined;\n}\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { EID } from '@dxos/keys';\n\nimport * as Database from './Database';\nimport * as Obj from './Obj';\n\n/**\n * `JSON.stringify` replacer signature.\n *\n * Defined here (rather than re-imported from a UI package) so other ECHO-aware utilities can\n * share a stable signature without creating a dependency edge into the UI tree.\n */\nexport type JsonReplacer = (key: string, value: any) => any;\n\nexport type CreateRefReplacerOptions = {\n  db: Database.Database;\n  /** How many ref hops to follow. `0` leaves all refs as-is. Default: `1`. */\n  depth?: number;\n};\n\nconst isEncodedRef = (value: unknown): value is { '/': string } =>\n  typeof value === 'object' &&\n  value !== null &&\n  Object.keys(value as object).length === 1 &&\n  typeof (value as { '/': unknown })['/'] === 'string';\n\nconst toJson = (obj: Obj.Any): unknown => (typeof (obj as any).toJSON === 'function' ? (obj as any).toJSON() : obj);\n\n/**\n * Returns a {@link JsonReplacer} that inlines ECHO ref objects (`{ \"/\": \"dxn:echo:...\" }`) up to\n * `depth` ref hops. Beyond that depth refs are left in their encoded form.\n *\n * Implemented as a per-call `JSON.stringify` replacer (not a one-shot tree walk at root) so it\n * composes with wrappers like `safeStringify` that intercept the root call. JSON.stringify\n * already drives the recursion; we only need to (a) detect a ref at the current callback,\n * (b) resolve and return the target if hop budget remains, and (c) tag the returned object\n * with its hop count so children know how far in they are.\n *\n * The hop count is tracked per-object via a `WeakMap`: a ref-resolved target's children inherit\n * `parentHops + 1`; a regular intermediate object's children inherit `parentHops`. This makes the\n * budget count *ref hops*, not tree depth — a ref deep in a tree still resolves once when\n * `depth >= 1`.\n *\n * Note: ECHO objects' `toJSON` runs before the replacer is invoked, so by the time we see a\n * value refs are already encoded as `{ \"/\": \"dxn:...\" }`.\n */\nexport const createRefReplacer = ({ db, depth = 1 }: CreateRefReplacerOptions): JsonReplacer => {\n  // Per-object hop count. Set when we return an object (via ref resolution or pass-through) so\n  // the child callbacks (which carry that object as `this`) can read it.\n  const hops = new WeakMap<object, number>();\n\n  return function (this: any, key: string, value: any) {\n    // Hop count for this call: hops at the parent, or 0 for the root.\n    const parentHops = this && typeof this === 'object' ? (hops.get(this) ?? 0) : 0;\n    if (isEncodedRef(value)) {\n      if (parentHops >= depth) {\n        return value;\n      }\n\n      // The `{ '/': string }` shape is shared with non-DXN IPLD-style refs (e.g. CIDs);\n      // an unparseable string would otherwise crash the whole `JSON.stringify`.\n      // Treat any parse miss as \"leave as-is\" rather than propagating.\n      const dxnString = value['/'];\n      if (!dxnString.startsWith('dxn:') && !dxnString.startsWith('echo:')) {\n        return value;\n      }\n\n      let echoUri: string | undefined;\n      try {\n        const parsed = EID.tryParse(dxnString);\n        echoUri = parsed ? EID.getEntityId(parsed) : undefined;\n      } catch {\n        return value;\n      }\n\n      if (!echoUri) {\n        return value;\n      }\n      const target = db.getObjectById(echoUri);\n      if (!target) {\n        return value;\n      }\n\n      const encoded = toJson(target);\n      if (encoded != null && typeof encoded === 'object') {\n        // Children of the resolved target are one hop deeper.\n        hops.set(encoded as object, parentHops + 1);\n      }\n      return encoded;\n    }\n\n    // Pass-through object: children inherit the parent's hop count (this branch doesn't burn\n    // budget).\n    if (value != null && typeof value === 'object') {\n      hops.set(value, parentHops);\n    }\n\n    return value;\n  };\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { FormInputAnnotation } from './internal';\nimport * as Obj from './Obj';\n\n/**\n * A per-object state side-map: an in-document `Record<objectId, S>` holding small mutable metadata\n * for each object, keyed by object id.\n *\n * The companion to immutable feed/queue objects: the objects are immutable, so their mutable\n * per-item state (read-marker, hero image, snippet, …) lives here on a host object. Use this for\n * non-tag metadata; boolean labels (starred, archived) belong in the tag model ({@link TagIndex} /\n * {@link Tagging}) so they share the space-wide `Tag` registry.\n */\n\n/** Read/write accessor over a host object's state side-map field, bound to a single field key. */\nexport interface Accessor<S extends object> {\n  /** All object ids with an entry, optionally filtered by a predicate over their state. */\n  ids(predicate?: (state: Partial<S>, id: string) => boolean): string[];\n  /** The entry for an object id; `{}` when absent (so call sites read fields without `?` chains). */\n  get(id: string): Partial<S>;\n  /** All `[id, state]` entries. */\n  entries(): Array<[string, Partial<S>]>;\n  /** Shallow-merges a patch into an object's entry, creating it when absent. */\n  patch(id: string, patch: Partial<S>): void;\n  /** Removes an object's entry. */\n  remove(id: string): void;\n}\n\n/**\n * Schema fragment for a state side-map field. Splice into a host Struct. Optional record, hidden\n * from forms. Keyed by object id; the value is the per-object state struct `S`.\n */\nexport const field = <S, I>(value: Schema.Schema<S, I>) =>\n  Schema.Record({ key: Schema.String, value }).pipe(FormInputAnnotation.set(false), Schema.optional);\n\n/** Binds an {@link Accessor} over `host[key]`; all mutations go through `Obj.update`. */\nexport const bind = <S extends object = Record<string, unknown>>(host: Obj.Any, key: string): Accessor<S> => {\n  type Entry = Partial<S>;\n\n  // The field is addressed by a runtime key, so the ECHO object is viewed as a keyed record — a\n  // deliberate type-system boundary (dynamic field access — the field name is a parameter).\n  const asView = (obj: Obj.Any) => obj as unknown as Record<string, Record<string, Entry> | undefined>;\n  const read = (): Record<string, Entry> => asView(host)[key] ?? {};\n\n  // Mutate the live typed record in place (do NOT reassign the whole tree); assigning a detached\n  // plain object tree bypasses ECHO's schema-aware conversion. Mutating the typed proxy preserves it.\n  const write = (mutate: (record: Record<string, Entry>) => void): void => {\n    Obj.update(host, (host) => {\n      const view = asView(host);\n      if (view[key] === undefined) {\n        view[key] = {};\n      }\n      // Re-read after assignment: the assignment expression yields the plain RHS, not the\n      // ECHO-backed reactive record, so mutating that would not persist.\n      mutate(view[key]!);\n    });\n  };\n\n  // Existence check via `Object.keys` — ECHO's reactive record proxy auto-vivifies missing keys on\n  // direct access, so `record[id]` is not reliably `undefined` for absent ids.\n  const has = (record: Record<string, Entry>, id: string): boolean => Object.keys(record).includes(id);\n\n  return {\n    ids: (predicate) => {\n      const record = read();\n      const keys = Object.keys(record);\n      return predicate ? keys.filter((id) => predicate(record[id], id)) : keys;\n    },\n    get: (id) => {\n      const record = read();\n      return has(record, id) ? record[id] : {};\n    },\n    entries: () => {\n      const record = read();\n      return Object.keys(record).map((id) => [id, record[id]]);\n    },\n    patch: (id, patch) =>\n      write((record) => {\n        if (!has(record, id)) {\n          record[id] = { ...patch };\n        } else {\n          Object.assign(record[id], patch);\n        }\n      }),\n    remove: (id) =>\n      write((record) => {\n        if (has(record, id)) {\n          delete record[id];\n        }\n      }),\n  };\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { FormInputAnnotation } from './internal';\nimport * as Obj from './Obj';\n\n/**\n * An inverse tag index: an in-document `Record<tagId, objectId[]>` mapping a tag id to the ids of\n * the objects carrying that tag.\n *\n * Mutable database objects track their tags in `Obj.getMeta(obj).tags` (an array of tag ids).\n * Immutable feed/queue objects cannot carry their own meta, so this index — managed alongside the\n * feed on its host object — augments that same process for them. Tags are sparse, so keying by tag\n * id (rather than object id) keeps the index small and makes \"filter the feed by tag\" a single\n * lookup.\n *\n * The tag id is an existing {@link Tag} object's id/URI; labels are never duplicated here — they\n * live on the {@link Tag} object and stay editable in one place.\n */\n\n/** Read/write accessor over a host object's tag-index field, bound to a single field key. */\nexport interface Accessor {\n  /** All tag ids present in the index. */\n  tagIds(): string[];\n  /** Object ids carrying the given tag; `[]` when the tag is absent (filter the feed by tag). */\n  objects(tagId: string): readonly string[];\n  /** Inverse lookup: the tag ids applied to the given object id. */\n  tags(objectId: string): string[];\n  /** Applies a tag to an object (creating the tag entry when absent); idempotent. */\n  setTag(tagId: string, objectId: string): void;\n  /** Removes a tag from an object, pruning the tag entry when it empties. */\n  unsetTag(tagId: string, objectId: string): void;\n}\n\n/**\n * Schema fragment for a tag-index field. Splice into a host Struct. Optional record, hidden from\n * forms. Keyed by tag id; the value is the array of object ids carrying that tag.\n */\nexport const field = () =>\n  Schema.Record({ key: Schema.String, value: Schema.Array(Obj.ID) }).pipe(\n    FormInputAnnotation.set(false),\n    Schema.optional,\n  );\n\n/** Binds an {@link Accessor} over `host[key]`; all mutations go through `Obj.update`. */\nexport const bind = (host: Obj.Any, key: string): Accessor => {\n  type Record_ = Record<string, string[]>;\n\n  // The field is addressed by a runtime key, so the ECHO object is viewed as a keyed record — a\n  // deliberate type-system boundary (dynamic field access — the field name is a parameter).\n  const asView = (obj: Obj.Any) => obj as unknown as Record<string, Record_ | undefined>;\n  const read = (): Record_ => asView(host)[key] ?? {};\n\n  // Mutate the live typed record in place (do NOT reassign the whole tree); assigning a detached\n  // plain object tree bypasses ECHO's schema-aware conversion and stores arrays as numeric-keyed\n  // objects. Mutating the typed proxy (and assigning real arrays to its values) preserves arrays.\n  const write = (mutate: (record: Record_) => void): void => {\n    Obj.update(host, (host) => {\n      const view = asView(host);\n      if (view[key] === undefined) {\n        view[key] = {};\n      }\n      // Re-read after assignment: the assignment expression yields the plain RHS, not the\n      // ECHO-backed reactive record, so mutating that would not persist.\n      mutate(view[key]!);\n    });\n  };\n\n  // Existence check via `Object.keys` — ECHO's reactive record proxy auto-vivifies missing keys on\n  // direct access, so `record[tagId]` is not reliably `undefined` for absent tags.\n  const has = (record: Record_, tagId: string): boolean => Object.keys(record).includes(tagId);\n\n  return {\n    tagIds: () => Object.keys(read()),\n    objects: (tagId) => {\n      const record = read();\n      return has(record, tagId) ? record[tagId] : [];\n    },\n    tags: (objectId) => {\n      const record = read();\n      return Object.keys(record).filter((tagId) => record[tagId].includes(objectId));\n    },\n    setTag: (tagId, objectId) =>\n      write((record) => {\n        // Use `has` (not `record[tagId]`) for absence — the proxy auto-vivifies missing keys.\n        if (!has(record, tagId)) {\n          record[tagId] = [objectId];\n        } else if (!record[tagId].includes(objectId)) {\n          record[tagId] = [...record[tagId], objectId];\n        }\n      }),\n    unsetTag: (tagId, objectId) =>\n      write((record) => {\n        if (!has(record, tagId)) {\n          return;\n        }\n        const next = record[tagId].filter((existing) => existing !== objectId);\n        if (next.length === 0) {\n          delete record[tagId];\n        } else {\n          record[tagId] = next;\n        }\n      }),\n  };\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { EID, URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport * as Obj from './Obj';\nimport * as Ref from './Ref';\nimport type * as Tag from './Tag';\nimport * as TagIndex from './TagIndex';\n\n/**\n * Unified tag handling for objects whether their tags live on the object (mutable database objects)\n * or alongside it (immutable feed/queue objects).\n *\n * - Mutable database objects track their tags in `Obj.getMeta(obj).tags` (an array of `Ref<Tag>`).\n * - Immutable feed objects can't carry their own meta, so their tags live in a {@link TagIndex} on\n *   a host object; pass that host via {@link Options.host}.\n *\n * Either way the tag id is an existing {@link Tag} object's id/URI, so the same tag applies across\n * mutable and immutable objects and its label is resolved (and edited) in one place. This API works\n * in terms of those URI tag ids; on the mutable path it converts to/from the stored `Ref<Tag>`.\n */\nexport interface Options {\n  /** Host object whose tag index holds tags for the (immutable) object. Omit for mutable objects. */\n  host?: Obj.Any;\n  /** Tag-index field name on the host (default `tags`). */\n  key?: string;\n}\n\nconst DEFAULT_KEY = 'tags';\n\n/** Returns the tag ids (URIs) applied to an object. */\nexport const get = (object: Obj.Any, options: Options = {}): string[] => {\n  const { host, key = DEFAULT_KEY } = options;\n  if (host) {\n    return TagIndex.bind(host, key).tags(object.id);\n  }\n  return Obj.getMeta(object).tags.map((tag) => tag.uri);\n};\n\n/** Applies a tag (by id/URI) to an object (idempotent). */\nexport const set = (object: Obj.Any, tagId: string, options: Options = {}): void => {\n  const { host, key = DEFAULT_KEY } = options;\n  if (host) {\n    TagIndex.bind(host, key).setTag(tagId, object.id);\n    return;\n  }\n  // Stored tag refs are canonical EIDs (read-time upgrade normalizes legacy DXN ids); normalize the\n  // incoming id the same way so dedupe compares like-for-like.\n  const id = EID.tryParse(tagId) ?? tagId;\n  Obj.update(object, (object) => {\n    const meta = Obj.getMeta(object);\n    if (!meta.tags.some((tag) => tag.uri === id)) {\n      meta.tags.push(Ref.fromURI(URI.make(id)));\n    }\n  });\n};\n\n/** Removes a tag (by id/URI) from an object. No-op when not present. */\nexport const unset = (object: Obj.Any, tagId: string, options: Options = {}): void => {\n  const { host, key = DEFAULT_KEY } = options;\n  if (host) {\n    TagIndex.bind(host, key).unsetTag(tagId, object.id);\n    return;\n  }\n  const id = EID.tryParse(tagId) ?? tagId;\n  Obj.update(object, (object) => {\n    const meta = Obj.getMeta(object);\n    for (let i = meta.tags.length - 1; i >= 0; i--) {\n      if (meta.tags[i].uri === id) {\n        meta.tags.splice(i, 1);\n      }\n    }\n  });\n};\n\n/** Resolves tag ids (URIs) to {@link Tag} object refs via the database. */\nexport const resolve = (db: Pick<Database.Database, 'makeRef'>, tagIds: readonly string[]): Ref.Ref<Tag.Tag>[] =>\n  tagIds.map((id) => db.makeRef<Tag.Tag>(URI.make(id)));\n", "//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Ref from './Ref';\nimport * as Type from './Type';\n\n/**\n * A an ordered set of objects.\n */\nexport const Collection = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n  objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(internal.FormInputAnnotation.set(false)),\n}).pipe(\n  Annotation.IconAnnotation.set({ icon: 'ph--folder--regular', hue: 'amber' }),\n  Type.makeObject(DXN.make('org.dxos.type.collection', '0.1.0')),\n);\n\nexport type Collection = Type.InstanceType<typeof Collection>;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Collection =>\n  Obj.make(Collection, { objects: [], ...props });\n\nexport const isCollection: (value: unknown) => value is Collection = Obj.instanceOf(Collection);\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { QueryAST } from '@dxos/echo-protocol';\nimport { JsonPath } from '@dxos/effect';\nimport { DXN, PublicKey } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Query from './Query';\nimport * as Type from './Type';\n\n/**\n * Stored field metadata (e.g., for UX).\n */\nexport const FieldSchema = Schema.Struct({\n  id: Schema.String,\n  path: JsonPath,\n  visible: Schema.optional(Schema.Boolean),\n\n  // TODO(wittjosiah): Presentation-specific?\n  referencePath: Schema.optional(JsonPath),\n});\n\nexport type FieldType = Schema.Schema.Type<typeof FieldSchema>;\n\nexport const KeyValueProps = Schema.Record({ key: Schema.String, value: Schema.Any });\n\nexport const createFieldId = () => PublicKey.random().truncate();\n\nexport const Projection = Schema.Struct({\n  /**\n   * Optional schema override used to customize the underlying schema.\n   */\n  schema: internal.JsonSchemaType.pipe(Schema.optional),\n\n  /**\n   * UX metadata associated with displayed fields (in table, form, etc.)\n   */\n  // TODO(wittjosiah): Should this just be an array of JsonPath?\n  fields: Schema.Array(FieldSchema),\n\n  /**\n   * The id for the field used to pivot the view.\n   * E.g., the field to use for kanban columns or the field to use for map coordinates.\n   */\n  pivotFieldId: Schema.String.pipe(Schema.optional),\n});\n\nexport type Projection = Schema.Schema.Type<typeof Projection>;\n\n/**\n * Views are generated or user-defined projections of a schema's properties.\n * They are used to configure the visual representation of the data.\n */\nconst ViewSchema = Schema.Struct({\n  /**\n   * Query used to retrieve data.\n   * Can be a user-provided query grammar string or a query AST.\n   */\n  query: Schema.Struct({\n    raw: Schema.optional(Schema.String),\n    ast: QueryAST.Query,\n  }),\n\n  /**\n   * Projection of the data returned from the query.\n   */\n  projection: Projection,\n}).pipe(\n  internal.HiddenAnnotation.set(true),\n  Annotation.IconAnnotation.set({ icon: 'ph--funnel--regular', hue: 'green' }),\n  Type.makeObject(DXN.make('org.dxos.type.view', '0.1.0')),\n);\n\n// NOTE: Declared as a named interface and the `View` const is annotated `Type.Obj<View>` so\n//   downstream consumers see a named `View` type instead of the inlined `QueryAST.Query` union.\n//   Without the named interface, embedding `Type.getSchema(View.View)` in a downstream\n//   `Schema.Struct` triggers TS2742 portability errors (e.g. plugin-kanban, plugin-table).\n// TODO(wittjosiah): Find a better solution that doesn't require manually keeping the interface in sync.\nexport interface View extends Type.InstanceType<typeof ViewSchema> {}\n\nexport const View: Type.Obj<View> = ViewSchema as any;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof View>>): View => {\n  return Obj.make(View, {\n    query: { ast: Query.select(Filter.nothing()).ast },\n    projection: { fields: [] },\n    ...props,\n  });\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { pipe } from 'effect/Function';\nimport * as Predicate from 'effect/Predicate';\nimport * as Schema from 'effect/Schema';\n\nimport * as Collection from './Collection';\nimport * as Feed from './Feed';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\nimport * as View from './View';\n\n/**\n * Abstract set of objects, represented by a view, feed, or collection.\n * Schema-level union of the underlying type entities (rebuilt via\n * `Type.getSchema`) so this can still be consumed by Schema-side APIs such\n * as `Filter.type(...)` on a union.\n */\nexport type Dataset = Feed.Feed | Collection.Collection | View.View;\nexport const Dataset = Schema.Union(\n  Type.getSchema(Feed.Feed),\n  Type.getSchema(Collection.Collection),\n  Type.getSchema(View.View),\n);\n\nexport const isDataset: (value: unknown) => value is Dataset = pipe(\n  Obj.instanceOf(Feed.Feed),\n  Predicate.or(Obj.instanceOf(Collection.Collection)),\n  Predicate.or(Obj.instanceOf(View.View)),\n);\n"],
+  "mappings": "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",
+  "names": ["QueryAST", "DXN", "EID", "URI", "EID", "isEncodedRef", "value", "Object", "keys", "length", "toJson", "obj", "toJSON", "createRefReplacer", "db", "depth", "hops", "WeakMap", "key", "parentHops", "get", "dxnString", "startsWith", "echoUri", "parsed", "tryParse", "getEntityId", "undefined", "target", "getObjectById", "encoded", "set", "Schema", "field", "value", "Record", "key", "String", "pipe", "FormInputAnnotation", "set", "optional", "bind", "host", "asView", "obj", "read", "write", "mutate", "Obj", "update", "view", "undefined", "has", "record", "id", "Object", "keys", "includes", "ids", "predicate", "filter", "get", "entries", "map", "patch", "assign", "remove", "bind", "field", "Schema", "field", "Record", "key", "String", "value", "Array", "ID", "pipe", "FormInputAnnotation", "set", "optional", "bind", "host", "asView", "obj", "read", "write", "mutate", "Obj", "update", "view", "undefined", "has", "record", "tagId", "Object", "keys", "includes", "tagIds", "objects", "tags", "objectId", "filter", "setTag", "unsetTag", "next", "existing", "length", "EID", "URI", "DEFAULT_KEY", "get", "object", "options", "host", "key", "bind", "tags", "id", "getMeta", "map", "tag", "uri", "set", "tagId", "TagIndex", "setTag", "EID", "tryParse", "Obj", "update", "meta", "some", "push", "fromURI", "URI", "make", "unset", "unsetTag", "i", "length", "splice", "resolve", "db", "tagIds", "makeRef", "make", "Schema", "DXN", "Collection", "Struct", "name", "String", "pipe", "optional", "objects", "Array", "Ref", "Unknown", "FormInputAnnotation", "set", "IconAnnotation", "icon", "hue", "makeObject", "DXN", "make", "props", "isCollection", "instanceOf", "make", "Schema", "QueryAST", "JsonPath", "DXN", "PublicKey", "FieldSchema", "Struct", "id", "String", "path", "JsonPath", "visible", "optional", "Boolean", "referencePath", "KeyValueProps", "Record", "key", "value", "Any", "createFieldId", "PublicKey", "random", "truncate", "Projection", "schema", "JsonSchemaType", "pipe", "fields", "Array", "pivotFieldId", "ViewSchema", "query", "raw", "ast", "QueryAST", "Query", "projection", "HiddenAnnotation", "set", "IconAnnotation", "icon", "hue", "makeObject", "DXN", "make", "View", "props", "select", "nothing", "pipe", "Predicate", "Schema", "Dataset", "Union", "getSchema", "Feed", "Collection", "View", "isDataset", "pipe", "instanceOf", "or"]
+}

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

@@ -0,0 +1,108 @@
+import {
+  foreignKeys,
+  type
+} from "./chunk-ZACMEAYV.mjs";
+import {
+  Meta,
+  getMeta,
+  make,
+  update
+} from "./chunk-Q5FKCVBC.mjs";
+import {
+  makeObject
+} from "./chunk-JE7AOSWF.mjs";
+import {
+  TagTypeDXN
+} from "./chunk-4BB4MFCN.mjs";
+import {
+  HiddenAnnotation,
+  LabelAnnotation
+} from "./chunk-H26LSXVJ.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-LMNRFOVB.mjs.map

package/dist/lib/neutral/chunk-LMNRFOVB.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-WYOKA6AE.mjs → chunk-O6BH7EPN.mjs}

@@ -3,13 +3,35 @@ import * as Schema from "effect/Schema";
 var KindId = "~@dxos/echo/Kind";
 var SchemaKindId = "~@dxos/echo/SchemaKind";
 var SnapshotKindId = "~@dxos/echo/SnapshotKind";
+var StaticTypeSchemaSlot = "~@dxos/echo/Type.StaticSchema";
+var getStaticTypeSchema = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[StaticTypeSchemaSlot];
+};
+var getSchemaKind = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[SchemaKindId];
+};
+var getEntityKindBrand = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[KindId];
+};
+var InstancePhantomId = "~@dxos/echo/Type.Instance";
+var UnknownTypeSchemaBrandId = "~@dxos/echo/UnknownTypeSchemaBrand";
 var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
   EntityKind2["Object"] = "object";
   EntityKind2["Relation"] = "relation";
+  EntityKind2["Type"] = "type";
   return EntityKind2;
 })({});
 var EntityKindSchema = Schema.Enums(EntityKind);
-var ANY_OBJECT_TYPENAME = "org.dxos.schema.any-object";
+var ANY_OBJECT_TYPENAME = "org.dxos.schema.anyObject";
 var ANY_OBJECT_VERSION = "0.0.0";
 
 // src/internal/Annotation/util.ts
@@ -35,8 +57,7 @@ var makeTypeJsonSchemaAnnotation = (options) => {
   assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
   assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
   const obj = {
-    // TODO(dmaretskyi): Should this include the version?
-    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    $id: options.identifier ?? DXN.make(options.typename, options.version),
     entityKind: options.kind,
     version: options.version,
     typename: options.typename
@@ -56,6 +77,12 @@ export {
   KindId,
   SchemaKindId,
   SnapshotKindId,
+  StaticTypeSchemaSlot,
+  getStaticTypeSchema,
+  getSchemaKind,
+  getEntityKindBrand,
+  InstancePhantomId,
+  UnknownTypeSchemaBrandId,
   EntityKind,
   EntityKindSchema,
   ANY_OBJECT_TYPENAME,
@@ -64,4 +91,4 @@ export {
   unwrapOptional,
   makeTypeJsonSchemaAnnotation
 };
-//# sourceMappingURL=chunk-WYOKA6AE.mjs.map
+//# sourceMappingURL=chunk-O6BH7EPN.mjs.map