@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.ac66bdf99f

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

@@ -0,0 +1,132 @@
+import {
+  object
+} from "./chunk-ROG4RXXL.mjs";
+import {
+  getDXN,
+  make
+} from "./chunk-B4BASU6W.mjs";
+import {
+  FormInputAnnotation,
+  IconAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-2KHZ36F5.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Feed.ts
+var Feed_exports = {};
+__export(Feed_exports, {
+  Feed: () => Feed,
+  FeedService: () => FeedService,
+  Service: () => Service,
+  append: () => append,
+  cursor: () => cursor,
+  getQueueDxn: () => getQueueDxn,
+  make: () => make2,
+  next: () => next,
+  nextOption: () => nextOption,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  remove: () => remove,
+  runQuery: () => runQuery,
+  setRetention: () => setRetention,
+  unsafeFromQueueDXN: () => unsafeFromQueueDXN
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
+var Feed = Schema.Struct({
+  /** User-facing display name. */
+  name: Schema.String.pipe(Schema.optional),
+  /** Identifier for the feed's kind (e.g., plugin id). */
+  kind: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+  /**
+  * Feed namespace.
+  * Controls how feed data is stored and replicated.
+  * - `data`: Data feed (default).
+  * - `trace`: Trace feed.
+  */
+  namespace: Schema.optional(Schema.Literal("data", "trace"))
+}).pipe(object({
+  typename: "org.dxos.type.feed",
+  version: "0.1.0"
+}), SystemTypeAnnotation.set(true), IconAnnotation.set({
+  icon: "ph--rows--regular",
+  hue: "yellow"
+}));
+var make2 = (props = {}) => make(Feed, props);
+var getQueueDxn = (feed) => {
+  const self = getDXN(feed).asEchoDXN();
+  if (!self || !self.spaceId) {
+    return void 0;
+  }
+  return new DXN(DXN.kind.QUEUE, [
+    feed.namespace ?? "data",
+    self.spaceId,
+    self.echoId
+  ]);
+};
+var unsafeFromQueueDXN = (queueDxn) => {
+  const parts = queueDxn.asQueueDXN();
+  if (!parts) {
+    throw new Error(`Expected a queue DXN, got: ${queueDxn.toString()}`);
+  }
+  return make(Feed, {
+    id: parts.queueId,
+    namespace: parts.subspaceTag === "trace" ? "trace" : void 0
+  });
+};
+var FeedService = class extends Context.Tag("@dxos/echo/Feed/FeedService")() {
+};
+var Service = FeedService;
+var notAvailable = Layer.succeed(FeedService, {
+  append: () => {
+    throw new Error("Feed.FeedService not available");
+  },
+  remove: () => {
+    throw new Error("Feed.FeedService not available");
+  },
+  query: () => {
+    throw new Error("Feed.FeedService not available");
+  }
+});
+var append = (feed, items) => Effect.gen(function* () {
+  const service = yield* FeedService;
+  yield* Effect.promise(() => service.append(feed, items));
+});
+var remove = (feed, items) => Effect.gen(function* () {
+  const service = yield* FeedService;
+  const ids = items.map((item) => item.id);
+  yield* Effect.promise(() => service.remove(feed, ids));
+});
+var query = (feed, queryOrFilter) => FeedService.pipe(Effect.map((service) => service.query(feed, queryOrFilter)));
+var runQuery = (feed, queryOrFilter) => query(feed, queryOrFilter).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));
+var cursor = (_feed) => Effect.succeed({
+  _tag: "Cursor"
+});
+var next = (_cursor) => Effect.die("Feed.next is not yet implemented");
+var nextOption = (_cursor) => Effect.die("Feed.nextOption is not yet implemented");
+var setRetention = (_feed, _options) => Effect.void;
+
+export {
+  Feed,
+  make2 as make,
+  getQueueDxn,
+  unsafeFromQueueDXN,
+  FeedService,
+  Service,
+  notAvailable,
+  append,
+  remove,
+  query,
+  runQuery,
+  cursor,
+  next,
+  nextOption,
+  setRetention,
+  Feed_exports
+};
+//# sourceMappingURL=chunk-TU3GW67D.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Feed.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport type * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport { DXN, type ObjectId } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport type * as Entity from './Entity';\nimport type * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport * as Type from './Type';\n\n/**\n * Runtime schema for a Feed object.\n *\n * @example\n * ```ts\n * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });\n * ```\n */\nexport const Feed = Schema.Struct({\n  /** User-facing display name. */\n  name: Schema.String.pipe(Schema.optional),\n  /** Identifier for the feed's kind (e.g., plugin id). */\n  kind: Schema.String.pipe(internal.FormInputAnnotation.set(false), Schema.optional),\n\n  /**\n   * Feed namespace.\n   * Controls how feed data is stored and replicated.\n   * - `data`: Data feed (default).\n   * - `trace`: Trace feed.\n   */\n  namespace: Schema.optional(Schema.Literal('data', 'trace')),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.feed',\n    version: '0.1.0',\n  }),\n  internal.SystemTypeAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--rows--regular',\n    hue: 'yellow',\n  }),\n);\n\n/**\n * TypeScript instance type for a Feed object.\n */\nexport interface Feed extends Schema.Schema.Type<typeof Feed> {}\n\n//\n// Types\n//\n\n/**\n * Opaque cursor for iterating over feed items.\n */\n// TODO(dmaretskyi): T needs to be referenced in the type structure for typescript to respect it during inference and type-checking.\nexport interface Cursor<T = Obj.Snapshot> {\n  readonly _tag: 'Cursor';\n}\n\n/**\n * Retention options for a feed.\n */\nexport interface RetentionOptions {\n  /** Retain items after this cursor position. */\n  // TODO(wittjosiah): Use FeedCursor from @dxos/feed?\n  cursor?: string;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a new feed object.\n *\n * @example\n * ```ts\n * const feed = Feed.make({ name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });\n * ```\n */\n// TODO(wittjosiah): How to control the feed namespace (data/trace)? Why do feeds have namespaces?\nexport const make = (props: Obj.MakeProps<typeof Feed> = {}): Feed => Obj.make(Feed, props);\n\n/**\n * Derives the queue DXN from the feed object's DXN.\n * Returns `undefined` when the feed is not stored in a space yet.\n *\n * Used internally by the feed service layer.\n */\nexport const getQueueDxn = (feed: Feed): DXN | undefined => {\n  const self = Obj.getDXN(feed).asEchoDXN();\n  if (!self || !self.spaceId) {\n    return undefined;\n  }\n  return new DXN(DXN.kind.QUEUE, [feed.namespace ?? 'data', self.spaceId, self.echoId]);\n};\n\n/**\n * Creates a Feed object from a queue DXN, inferring the feed's id and namespace from the DXN parts.\n *\n * The resulting Feed, when added to the same space as the queue, will have a queue DXN\n * equal to the input (see `Feed.getQueueDxn`). Useful when migrating `Ref(Queue)` fields to\n * `Ref(Feed.Feed)`.\n *\n * @remarks Unsafe because the caller must ensure the queue DXN's space matches the database\n * the feed is added to; the feed id is set from the queue id, bypassing id generation.\n */\nexport const unsafeFromQueueDXN = (queueDxn: DXN): Feed => {\n  const parts = queueDxn.asQueueDXN();\n  if (!parts) {\n    throw new Error(`Expected a queue DXN, got: ${queueDxn.toString()}`);\n  }\n  return Obj.make(Feed, {\n    id: parts.queueId as ObjectId,\n    namespace: parts.subspaceTag === 'trace' ? 'trace' : undefined,\n  });\n};\n\n//\n// Service\n//\n\n/**\n * Effect service for feed operations.\n * Provides the bridge to the underlying storage implementation.\n * Must be provided by the application layer (e.g., echo-db).\n */\nexport class FeedService extends Context.Tag('@dxos/echo/Feed/FeedService')<\n  FeedService,\n  {\n    /**\n     * Appends items to a feed.\n     */\n    append(feed: Feed, items: Entity.Unknown[]): Promise<void>;\n\n    /**\n     * Removes items from a feed by ID.\n     */\n    // TODO(dmaretskyi): Change type to ObjectId.\n    remove(feed: Feed, ids: string[]): Promise<void>;\n\n    /**\n     * Queries items in a feed.\n     */\n    query: {\n      <Q extends Query.Any>(feed: Feed, query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n      <F extends Filter.Any>(feed: Feed, filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n    };\n  }\n>() {}\n\n/**\n * @deprecated Use `FeedService` instead.\n */\nexport type Service = FeedService;\n\n/**\n * @deprecated Use `FeedService` instead.\n */\nexport const Service = FeedService;\n\n/**\n * Layer that provides a Feed service that throws when accessed.\n * Useful as a default layer when no feed service is available.\n */\nexport const notAvailable: Layer.Layer<FeedService> = Layer.succeed(FeedService, {\n  append: () => {\n    throw new Error('Feed.FeedService not available');\n  },\n  remove: () => {\n    throw new Error('Feed.FeedService not available');\n  },\n  query: () => {\n    throw new Error('Feed.FeedService not available');\n  },\n} as Context.Tag.Service<FeedService>);\n\n//\n// Operations\n//\n\n/**\n * Appends items to a feed.\n *\n * @example\n * ```ts\n * yield* Feed.append(feed, [Obj.make(Notification, { title: 'Hello' })]);\n * ```\n */\nexport const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, FeedService> =>\n  Effect.gen(function* () {\n    const service = yield* FeedService;\n    yield* Effect.promise(() => service.append(feed, items));\n  });\n\n/**\n * Removes items from a feed.\n *\n * @example\n * ```ts\n * yield* Feed.remove(feed, [item]);\n * ```\n */\n// TODO(dmaretskyi): Should we allow snapshots here? - what does it mean to remove a snapshot?\nexport const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Effect.Effect<void, never, FeedService> =>\n  Effect.gen(function* () {\n    const service = yield* FeedService;\n    const ids = items.map((item) => item.id);\n    yield* Effect.promise(() => service.remove(feed, ids));\n  });\n\n/**\n * Creates a reactive query over items in a feed.\n *\n * @example\n * ```ts\n * const result = yield* Feed.query(feed, Filter.type(Person));\n * ```\n */\n// TODO(dmaretskyi): Suport chained queries:\n//                   const result = yield* feed.pipe(Feed.query(Filter.type(Person))); result.subscribe(...)\n//                   const objects = yield* feed.pipe(Feed.query(Filter.type(Person))).run;\n//                   const object = yield* feed.pipe(Feed.query(Filter.type(Person))).first;\n// ... unify for Database and schema queries.\nexport const query: {\n  <Q extends Query.Any>(\n    feed: Feed,\n    query: Q,\n  ): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, FeedService>;\n  <F extends Filter.Any>(\n    feed: Feed,\n    filter: F,\n  ): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, FeedService>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  FeedService.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));\n\n/**\n * Executes a feed query once and returns the results.\n *\n * @example\n * ```ts\n * const items = yield* Feed.runQuery(feed, Filter.type(Person));\n * ```\n */\nexport const runQuery: {\n  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<Query.Type<Q>[], never, FeedService>;\n  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<Filter.Type<F>[], never, FeedService>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  query(feed, queryOrFilter as any).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));\n\n/**\n * Creates a cursor for iterating over feed items.\n * Currently stubbed — cursor operations are not yet implemented.\n *\n * @example\n * ```ts\n * const cursor = yield* Feed.cursor<Person>(feed);\n * const item = yield* Feed.next(cursor);\n * ```\n */\n// TODO(wittjosiah): Implement cursor operations. Use Effect streams?\nexport const cursor = <T = Obj.Snapshot>(_feed: Feed): Effect.Effect<Cursor<T>, never, FeedService> =>\n  Effect.succeed({ _tag: 'Cursor' } as Cursor<T>);\n\n/**\n * Returns the next item from a feed cursor.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const next = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<T, never, FeedService> =>\n  Effect.die('Feed.next is not yet implemented');\n\n/**\n * Returns the next item from a feed cursor as an Option.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<Option.Option<T>, never, FeedService> =>\n  Effect.die('Feed.nextOption is not yet implemented');\n\n/**\n * Sets the local retention policy for a feed.\n * Currently stubbed — queues do not yet support retention.\n *\n * @example\n * ```ts\n * yield* Feed.setRetention(feed, { count: 1000 });\n * ```\n */\n// TODO(feed): Implement when queue retention is supported.\nexport const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, FeedService> =>\n  Effect.void;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;;;;;;;;cAAAA;EAAA;;;;;;;;;AAMA,YAAYC,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAEvB,YAAYC,YAAY;AAExB,SAASC,WAA0B;AAmB5B,IAAMC,OAAcC,cAAO;;EAEhCC,MAAaC,cAAOC,KAAYC,eAAQ;;EAExCC,MAAaH,cAAOC,KAAcG,oBAAoBC,IAAI,KAAA,GAAeH,eAAQ;;;;;;;EAQjFI,WAAkBJ,gBAAgBK,eAAQ,QAAQ,OAAA,CAAA;AACpD,CAAA,EAAGN,KACIO,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,qBAAqBN,IAAI,IAAA,GACvBO,eAAeP,IAAI;EAC5BQ,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AA0CK,IAAMC,QAAO,CAACC,QAAoC,CAAC,MAAgBD,KAAKlB,MAAMmB,KAAAA;AAQ9E,IAAMC,cAAc,CAACC,SAAAA;AAC1B,QAAMC,OAAWC,OAAOF,IAAAA,EAAMG,UAAS;AACvC,MAAI,CAACF,QAAQ,CAACA,KAAKG,SAAS;AAC1B,WAAOC;EACT;AACA,SAAO,IAAIC,IAAIA,IAAIrB,KAAKsB,OAAO;IAACP,KAAKZ,aAAa;IAAQa,KAAKG;IAASH,KAAKO;GAAO;AACtF;AAYO,IAAMC,qBAAqB,CAACC,aAAAA;AACjC,QAAMC,QAAQD,SAASE,WAAU;AACjC,MAAI,CAACD,OAAO;AACV,UAAM,IAAIE,MAAM,8BAA8BH,SAASI,SAAQ,CAAA,EAAI;EACrE;AACA,SAAWjB,KAAKlB,MAAM;IACpBoC,IAAIJ,MAAMK;IACV5B,WAAWuB,MAAMM,gBAAgB,UAAU,UAAUZ;EACvD,CAAA;AACF;AAWO,IAAMa,cAAN,cAAkCC,YAAI,6BAAA,EAAA,EAAA;AAsBxC;AAUE,IAAMC,UAAUF;AAMhB,IAAMG,eAA+CC,cAAQJ,aAAa;EAC/EK,QAAQ,MAAA;AACN,UAAM,IAAIV,MAAM,gCAAA;EAClB;EACAW,QAAQ,MAAA;AACN,UAAM,IAAIX,MAAM,gCAAA;EAClB;EACAY,OAAO,MAAA;AACL,UAAM,IAAIZ,MAAM,gCAAA;EAClB;AACF,CAAA;AAcO,IAAMU,SAAS,CAACvB,MAAY0B,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOV;AACvB,SAAcW,eAAQ,MAAMD,QAAQL,OAAOvB,MAAM0B,KAAAA,CAAAA;AACnD,CAAA;AAWK,IAAMF,SAAS,CAACxB,MAAY0B,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOV;AACvB,QAAMY,MAAMJ,MAAMK,IAAI,CAACC,SAASA,KAAKjB,EAAE;AACvC,SAAcc,eAAQ,MAAMD,QAAQJ,OAAOxB,MAAM8B,GAAAA,CAAAA;AACnD,CAAA;AAeK,IAAML,QAST,CAACzB,MAAYiC,kBACff,YAAYnC,KAAYgD,WAAI,CAACH,YAAYA,QAAQH,MAAMzB,MAAMiC,aAAAA,CAAAA,CAAAA;AAUxD,IAAMC,WAGT,CAAClC,MAAYiC,kBACfR,MAAMzB,MAAMiC,aAAAA,EAAsBlD,KAAYoD,eAAQ,CAACC,gBAAuBP,eAAQ,MAAMO,YAAYC,IAAG,CAAA,CAAA,CAAA;AAatG,IAAMC,SAAS,CAAmBC,UAChCjB,eAAQ;EAAEkB,MAAM;AAAS,CAAA;AAM3B,IAAMC,OAAO,CAAmBC,YAC9BC,WAAI,kCAAA;AAMN,IAAMC,aAAa,CAAmBF,YACpCC,WAAI,wCAAA;AAYN,IAAME,eAAe,CAACN,OAAaO,aACjCC;",
+  "names": ["make", "Context", "Effect", "Layer", "Schema", "DXN", "Feed", "Struct", "name", "String", "pipe", "optional", "kind", "FormInputAnnotation", "set", "namespace", "Literal", "object", "typename", "version", "SystemTypeAnnotation", "IconAnnotation", "icon", "hue", "make", "props", "getQueueDxn", "feed", "self", "getDXN", "asEchoDXN", "spaceId", "undefined", "DXN", "QUEUE", "echoId", "unsafeFromQueueDXN", "queueDxn", "parts", "asQueueDXN", "Error", "toString", "id", "queueId", "subspaceTag", "FeedService", "Tag", "Service", "notAvailable", "succeed", "append", "remove", "query", "items", "gen", "service", "promise", "ids", "map", "item", "queryOrFilter", "runQuery", "flatMap", "queryResult", "run", "cursor", "_feed", "_tag", "next", "_cursor", "die", "nextOption", "setRetention", "_options", "void"]
+}

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

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Err.ts
+var Err_exports = {};
+__export(Err_exports, {
+  GetReactiveError: () => GetReactiveError,
+  ObjectNotFoundError: () => ObjectNotFoundError,
+  SchemaNotFoundError: () => SchemaNotFoundError
+});
+import { BaseError } from "@dxos/errors";
+var SchemaNotFoundError = class extends BaseError.extend("SchemaNotFoundError", "Schema not found") {
+  constructor(schema, options) {
+    super({
+      context: {
+        schema
+      },
+      ...options
+    });
+  }
+};
+var ObjectNotFoundError = class extends BaseError.extend("ObjectNotFoundError", "Object not found") {
+  constructor(dxn, options) {
+    super({
+      context: {
+        dxn
+      },
+      ...options
+    });
+  }
+};
+var GetReactiveError = class extends BaseError.extend("GetReactiveError", "Failed to get reactive object from snapshot") {
+  constructor(options) {
+    super({
+      context: {
+        reason: options.reason,
+        snapshotId: options.snapshotId
+      },
+      ...options
+    });
+  }
+};
+
+export {
+  SchemaNotFoundError,
+  ObjectNotFoundError,
+  GetReactiveError,
+  Err_exports
+};
+//# sourceMappingURL=chunk-UBEZSGXY.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Err.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type DXN } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class ObjectNotFoundError extends BaseError.extend('ObjectNotFoundError', 'Object not found') {\n  constructor(dxn: DXN, options?: BaseErrorOptions) {\n    super({ context: { dxn }, ...options });\n  }\n}\n\n/**\n * Reason why getting a reactive object from a snapshot failed.\n * - `no-database`: The snapshot is not associated with a database.\n * - `object-not-found`: The object was removed or does not exist in the database.\n */\nexport type GetReactiveErrorReason = 'no-database' | 'object-not-found';\n\n/**\n * Error thrown when a reactive object cannot be resolved from a snapshot.\n * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.\n */\nexport class GetReactiveError extends BaseError.extend(\n  'GetReactiveError',\n  'Failed to get reactive object from snapshot',\n) {\n  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {\n    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });\n  }\n}\n"],
+  "mappings": ";;;;;AAAA;;;;;;AAMA,SAASA,iBAAwC;AAG1C,IAAMC,sBAAN,cAAkCC,UAAUC,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYC,QAAgBC,SAA4B;AACtD,UAAM;MAAEC,SAAS;QAAEF;MAAO;MAAG,GAAGC;IAAQ,CAAA;EAC1C;AACF;AAEO,IAAME,sBAAN,cAAkCL,UAAUC,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYK,KAAUH,SAA4B;AAChD,UAAM;MAAEC,SAAS;QAAEE;MAAI;MAAG,GAAGH;IAAQ,CAAA;EACvC;AACF;AAaO,IAAMI,mBAAN,cAA+BP,UAAUC,OAC9C,oBACA,6CAAA,EAAA;EAEA,YAAYE,SAAqF;AAC/F,UAAM;MAAEC,SAAS;QAAEI,QAAQL,QAAQK;QAAQC,YAAYN,QAAQM;MAAW;MAAG,GAAGN;IAAQ,CAAA;EAC1F;AACF;",
+  "names": ["BaseError", "SchemaNotFoundError", "BaseError", "extend", "schema", "options", "context", "ObjectNotFoundError", "dxn", "GetReactiveError", "reason", "snapshotId"]
+}

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

@@ -0,0 +1,42 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Order.ts
+var Order_exports = {};
+__export(Order_exports, {
+  natural: () => natural,
+  property: () => property,
+  rank: () => rank
+});
+var OrderClass = class _OrderClass {
+  ast;
+  static "variance" = {};
+  static is(value) {
+    return typeof value === "object" && value !== null && "~Order" in value;
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Order" = _OrderClass.variance;
+};
+var natural = new OrderClass({
+  kind: "natural"
+});
+var property = (property2, direction) => new OrderClass({
+  kind: "property",
+  property: property2,
+  direction
+});
+var rank = (direction = "desc") => new OrderClass({
+  kind: "rank",
+  direction
+});
+
+export {
+  natural,
+  property,
+  rank,
+  Order_exports
+};
+//# sourceMappingURL=chunk-UI6MWK5W.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Order.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nexport interface Order<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Order': { value: T };\n\n  ast: QueryAST.Order;\n}\n\nexport type Any = Order<any>;\n\nclass OrderClass implements Order<any> {\n  private static 'variance': Order<any>['~Order'] = {} as Order<any>['~Order'];\n\n  static is(value: unknown): value is Order<any> {\n    return typeof value === 'object' && value !== null && '~Order' in value;\n  }\n\n  constructor(public readonly ast: QueryAST.Order) {}\n\n  '~Order' = OrderClass.variance;\n}\n\nexport const natural: Order<any> = new OrderClass({ kind: 'natural' });\nexport const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order<T> =>\n  new OrderClass({\n    kind: 'property',\n    property,\n    direction,\n  });\n\n/**\n * Order by relevance rank (for FTS/vector search results).\n * Higher rank = better match. Default direction is 'desc' (best matches first).\n */\nexport const rank = <T>(direction: QueryAST.OrderDirection = 'desc'): Order<T> =>\n  new OrderClass({\n    kind: 'rank',\n    direction,\n  });\n"],
+  "mappings": ";;;;;AAAA;;;;;;AAiBA,IAAMA,aAAN,MAAMA,YAAAA;;EACJ,OAAe,aAAmC,CAAC;EAEnD,OAAOC,GAAGC,OAAqC;AAC7C,WAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,YAAYA;EACpE;EAEA,YAA4BC,KAAqB;SAArBA,MAAAA;EAAsB;EAElD,WAAWH,YAAWI;AACxB;AAEO,IAAMC,UAAsB,IAAIL,WAAW;EAAEM,MAAM;AAAU,CAAA;AAC7D,IAAMC,WAAW,CAAIA,WAA4BC,cACtD,IAAIR,WAAW;EACbM,MAAM;EACNC,UAAAA;EACAC;AACF,CAAA;AAMK,IAAMC,OAAO,CAAID,YAAqC,WAC3D,IAAIR,WAAW;EACbM,MAAM;EACNE;AACF,CAAA;",
+  "names": ["OrderClass", "is", "value", "ast", "variance", "natural", "kind", "property", "direction", "rank"]
+}

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

@@ -0,0 +1,354 @@
+import {
+  isRef
+} from "./chunk-BVOFLCVF.mjs";
+import {
+  getDXN,
+  prettyFilter
+} from "./chunk-MOR5ERFM.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-2KHZ36F5.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Filter.ts
+var Filter_exports = {};
+__export(Filter_exports, {
+  and: () => and,
+  between: () => between,
+  childOf: () => childOf,
+  contains: () => contains,
+  created: () => created,
+  eq: () => eq,
+  everything: () => everything,
+  foreignKeys: () => foreignKeys,
+  fromAst: () => fromAst,
+  gt: () => gt,
+  gte: () => gte,
+  id: () => id,
+  in: () => in$,
+  is: () => is,
+  lt: () => lt,
+  lte: () => lte,
+  neq: () => neq,
+  not: () => not,
+  nothing: () => nothing,
+  or: () => or,
+  pretty: () => pretty,
+  props: () => props,
+  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";
+var FilterClass = class _FilterClass {
+  ast;
+  static "variance" = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Filter" = _FilterClass.variance;
+};
+var is = (value2) => {
+  return typeof value2 === "object" && value2 !== null && "~Filter" in value2;
+};
+var fromAst = (ast) => {
+  return new FilterClass(ast);
+};
+var everything = () => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    props: {}
+  });
+};
+var nothing = () => {
+  return new FilterClass({
+    type: "not",
+    filter: {
+      type: "object",
+      typename: null,
+      props: {}
+    }
+  });
+};
+var id = (...ids) => {
+  assertArgument(ids.every((id2) => ObjectId.isValid(id2)), "ids", "ids must be valid");
+  if (ids.length === 0) {
+    return nothing();
+  }
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    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)));
+    return new FilterClass({
+      type: "or",
+      filters: typenames.map((typename2) => ({
+        type: "object",
+        typename: typename2.toString(),
+        props: {}
+      }))
+    });
+  }
+  const dxn = getTypeDXNFromSpecifier(schema);
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    ...propsFilterToAst(props2 ?? {})
+  });
+};
+var typename = (typename2) => {
+  assertArgument(!typename2.startsWith("dxn:"), "typename", "Typename must no be qualified");
+  return new FilterClass({
+    type: "object",
+    typename: DXN.fromTypename(typename2).toString(),
+    props: {}
+  });
+};
+var typeDXN = (dxn) => {
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    props: {}
+  });
+};
+var tag = (tag2) => {
+  return new FilterClass({
+    type: "tag",
+    tag: tag2
+  });
+};
+var props = (props2) => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    ...propsFilterToAst(props2)
+  });
+};
+var text = (text2, options) => {
+  return new FilterClass({
+    type: "text-search",
+    text: text2,
+    searchKind: options?.type
+  });
+};
+var foreignKeys = (schema, keys) => {
+  const dxn = getTypeDXNFromSpecifier(schema);
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    props: {},
+    foreignKeys: keys
+  });
+};
+var eq = (value2) => {
+  if (!isRef(value2) && typeof value2 === "object" && value2 !== null) {
+    throw new TypeError("Cannot use object as a value for eq filter");
+  }
+  return new FilterClass({
+    type: "compare",
+    operator: "eq",
+    value: isRef(value2) ? value2.noInline().encode() : value2
+  });
+};
+var neq = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "neq",
+    value: value2
+  });
+};
+var gt = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "gt",
+    value: value2
+  });
+};
+var gte = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "gte",
+    value: value2
+  });
+};
+var lt = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "lt",
+    value: value2
+  });
+};
+var lte = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "lte",
+    value: value2
+  });
+};
+var in$ = (...values) => {
+  return new FilterClass({
+    type: "in",
+    values
+  });
+};
+var contains = (value2) => {
+  return new FilterClass({
+    type: "contains",
+    value: value2
+  });
+};
+var between = (from, to) => {
+  return new FilterClass({
+    type: "range",
+    from,
+    to
+  });
+};
+var _toUnixMs = (date) => typeof date === "number" ? date : date.getTime();
+var _timeRangeFilter = (field, range) => {
+  const filters = [];
+  if (range.after != null) {
+    filters.push(new FilterClass({
+      type: "timestamp",
+      field,
+      operator: "gte",
+      value: _toUnixMs(range.after)
+    }));
+  }
+  if (range.before != null) {
+    filters.push(new FilterClass({
+      type: "timestamp",
+      field,
+      operator: "lte",
+      value: _toUnixMs(range.before)
+    }));
+  }
+  if (filters.length === 0) {
+    return everything();
+  }
+  return filters.length === 1 ? filters[0] : and(...filters);
+};
+var updated = (range) => _timeRangeFilter("updatedAt", range);
+var created = (range) => _timeRangeFilter("createdAt", range);
+var childOf = (parents, options) => {
+  const items = Array.isArray(parents) ? parents : [
+    parents
+  ];
+  const dxns = items.map((item) => {
+    if (isRef(item)) {
+      return item.dxn.toString();
+    }
+    return getDXN(item).toString();
+  });
+  return new FilterClass({
+    type: "child-of",
+    parents: dxns,
+    transitive: options?.transitive ?? true
+  });
+};
+var not = (filter) => {
+  return new FilterClass({
+    type: "not",
+    filter: filter.ast
+  });
+};
+var and = (...filters) => {
+  return new FilterClass({
+    type: "and",
+    filters: filters.map((f) => f.ast)
+  });
+};
+var or = (...filters) => {
+  return new FilterClass({
+    type: "or",
+    filters: filters.map((f) => f.ast)
+  });
+};
+var propsFilterToAst = (predicates) => {
+  let idFilter;
+  if ("id" in predicates) {
+    assertArgument(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
+    idFilter = typeof predicates.id === "string" ? [
+      predicates.id
+    ] : predicates.id;
+    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
+  }
+  return {
+    id: idFilter,
+    props: Object.fromEntries(Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [
+      prop,
+      processPredicate(predicate)
+    ]))
+  };
+};
+var processPredicate = (predicate) => {
+  return Match.value(predicate).pipe(
+    Match.withReturnType(),
+    Match.when(is, (predicate2) => predicate2.ast),
+    // TODO(wittjosiah): Add support for array predicates.
+    Match.when(Array.isArray, (_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,
+        processPredicate(value2)
+      ]));
+      return {
+        type: "object",
+        typename: null,
+        props: nestedProps
+      };
+    }),
+    Match.orElse((value2) => eq(value2).ast)
+  );
+};
+var pretty = (filter) => prettyFilter(filter.ast);
+
+export {
+  is,
+  fromAst,
+  everything,
+  nothing,
+  id,
+  type,
+  typename,
+  typeDXN,
+  tag,
+  props,
+  text,
+  foreignKeys,
+  eq,
+  neq,
+  gt,
+  gte,
+  lt,
+  lte,
+  in$,
+  contains,
+  between,
+  updated,
+  created,
+  childOf,
+  not,
+  and,
+  or,
+  pretty,
+  Filter_exports
+};
+//# sourceMappingURL=chunk-V36VO5SS.mjs.map