@dxos/echo 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/dist/lib/Aggregate.mjs

@@ -3,10 +3,15 @@ import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
 var Aggregate_exports = /* @__PURE__ */ __exportAll({
 	AggregateTypeId: () => AggregateTypeId,
 	count: () => count,
+	created: () => created,
 	group: () => group,
 	items: () => items,
 	max: () => max,
-	min: () => min
+	min: () => min,
+	sum: () => sum,
+	time: () => time,
+	type: () => type,
+	updated: () => updated
 });
 var AggregateTypeId = "~@dxos/echo/Aggregate";
 var AggregateClass = class AggregateClass {
@@ -31,6 +36,8 @@ var AggregateClass = class AggregateClass {
 * member lacking the leading property its own singleton group instead of pooling them under `null`,
 * where an {@link items} `limit` would truncate unrelated members. `id` qualifies: it resolves to
 * the object's entity id even though documents don't store it as data.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
 */
 var group = (key) => new AggregateClass({
 	kind: "group",
@@ -40,6 +47,8 @@ var group = (key) => new AggregateClass({
 * Aggregate the maximum of a scalar property across the group's members.
 * `T` is inferred from the `Query.aggregate` context, so `property` is checked against the query's
 * element type (like {@link Order.property}).
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
 */
 var max = (property) => new AggregateClass({
 	kind: "max",
@@ -47,6 +56,8 @@ var max = (property) => new AggregateClass({
 });
 /**
 * Aggregate the minimum of a scalar property across the group's members.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
 */
 var min = (property) => new AggregateClass({
 	kind: "min",
@@ -62,6 +73,8 @@ var min = (property) => new AggregateClass({
 * they arrived in from a preceding `orderBy` (unspecified if there is none), so a per-group
 * top-`limit` moved position in the chain would silently change; declaring `order` here makes the
 * ordering explicit and local to this aggregate regardless of where it sits.
+*
+* @performance O(k) in the number of orders; builds an aggregate spec without evaluating anything.
 */
 var items = (options) => new AggregateClass({
 	kind: "items",
@@ -69,10 +82,62 @@ var items = (options) => new AggregateClass({
 	order: options?.order?.map((order) => order.ast)
 });
 /**
+* Sum a numeric property across the group's members; values that are not numbers count as 0, so
+* a group always sums to a number.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
+*/
+var sum = (property) => new AggregateClass({
+	kind: "sum",
+	property
+});
+/**
 * Count the group's members. Opt-in — groups carry no count unless this aggregate is declared.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
 */
 var count = () => new AggregateClass({ kind: "count" });
+/**
+* Group members by their stored type URI. The field carries the URI string as written, so two
+* schema versions are two groups.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
+*/
+var type = () => new AggregateClass({ kind: "type" });
+/**
+* Group members by the UTC hour or day their system `updatedAt` falls in. The field carries the start
+* of that interval in unix ms, or `null` when the timestamp is unknown.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
+*/
+var updated = (unit) => new AggregateClass({
+	kind: "timestamp",
+	field: "updatedAt",
+	unit
+});
+/**
+* Like {@link updated}, over the system `createdAt` timestamp.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
+*/
+var created = (unit) => new AggregateClass({
+	kind: "timestamp",
+	field: "createdAt",
+	unit
+});
+/**
+* Group members by the UTC hour or day a unix-ms property falls in, like {@link updated} over a
+* property instead of a system timestamp. The field carries the start of that interval in unix ms,
+* or `null` when the property is not a number.
+*
+* @performance O(1); builds an aggregate spec without evaluating anything.
+*/
+var time = (property, unit) => new AggregateClass({
+	kind: "time",
+	property,
+	unit
+});
 //#endregion
-export { AggregateTypeId, count, group, items, max, min, Aggregate_exports as t };
+export { AggregateTypeId, count, created, group, items, max, min, sum, Aggregate_exports as t, time, type, updated };
 
 //# sourceMappingURL=Aggregate.mjs.map

package/dist/lib/Aggregate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Aggregate.mjs","names":[],"sources":["../../src/Aggregate.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as EffectTypes from 'effect/Types';\n\nimport type { QueryAST } from '@dxos/echo-protocol';\n\nimport type * as Order from './Order';\nimport type * as Query from './Query';\n\n/**\n * The aggregate spec sans name; the name is supplied by the `Query.aggregate` record key. A tagged\n * union per kind so `property`/`limit`/`order` are present exactly when the kind uses them (no\n * unused optional fields to guard against at read sites).\n */\nexport type Spec =\n  | { kind: 'group'; properties: readonly [string, ...string[]] }\n  | { kind: 'max'; property: string }\n  | { kind: 'min'; property: string }\n  | { kind: 'items'; limit?: number; order?: readonly QueryAST.Order[] }\n  | { kind: 'count' };\n\nexport const AggregateTypeId = '~@dxos/echo/Aggregate' as const;\nexport type AggregateTypeId = typeof AggregateTypeId;\n\n/**\n * A per-group aggregate declaration, materialised as a top-level field on the flat result record\n * `Query.aggregate` produces and orderable via a following `orderBy(Order.property(name))`. Name it\n * via the record passed to `Query.aggregate({ name: Aggregate.max('created') })`.\n *\n * `T` is the query's element type (so a reduced/grouped property is checked against it); `V` is the\n * value the aggregate produces. {@link group} entries define the grouping keys; a record with no\n * `group` entries aggregates the entire input into a single row.\n */\nexport interface Aggregate<T, V> {\n  readonly [AggregateTypeId]: { element: T; value: V };\n\n  spec: Spec;\n}\n\nexport type Any = Aggregate<any, any>;\n\n/** Extracts the value type a {@link Aggregate} produces. */\nexport type ValueOf<A> = A extends Aggregate<any, infer V> ? V : never;\n\n/** Computes the flat result type of `Query.aggregate(aggregates)` for a given aggregate record `A`. */\nexport type AggregationResult<A extends Record<string, Any>> = EffectTypes.Simplify<\n  Query.AggregateResult & { readonly [N in keyof A]: ValueOf<A[N]> }\n>;\n\nclass AggregateClass<T, V> implements Aggregate<T, V> {\n  private static 'variance': Aggregate<any, any>[AggregateTypeId] = {} as Aggregate<any, any>[AggregateTypeId];\n\n  static is(value: unknown): value is Any {\n    return typeof value === 'object' && value !== null && AggregateTypeId in value;\n  }\n\n  constructor(public readonly spec: Spec) {}\n\n  [AggregateTypeId] = AggregateClass.variance as Aggregate<T, V>[AggregateTypeId];\n}\n\n/**\n * Group members by a scalar property, or by the first property of a `coalesce` chain holding a\n * scalar value (`threadId ?? id`). The record key names the result field carrying the coerced\n * group-key value; multiple `group` entries form a composite key (a `coalesce` chain is one\n * component, not several). Members whose key is missing, `null`, `undefined`, or non-scalar group\n * under the `null` key, so the field value includes `null`.\n *\n * A chain ending in an always-present property (e.g. `{ coalesce: ['threadId', 'id'] }`) gives each\n * member lacking the leading property its own singleton group instead of pooling them under `null`,\n * where an {@link items} `limit` would truncate unrelated members. `id` qualifies: it resolves to\n * the object's entity id even though documents don't store it as data.\n */\nexport const group: {\n  <T, K extends keyof T & string>(property: K): Aggregate<T, T[K] | null>;\n  <T, const K extends readonly [keyof T & string, ...(keyof T & string)[]]>(key: {\n    coalesce: K;\n  }): Aggregate<T, T[K[number]] | null>;\n} = (key: string | { coalesce: readonly [string, ...string[]] }): Any =>\n  new AggregateClass({ kind: 'group', properties: typeof key === 'string' ? [key] : key.coalesce });\n\n/**\n * Aggregate the maximum of a scalar property across the group's members.\n * `T` is inferred from the `Query.aggregate` context, so `property` is checked against the query's\n * element type (like {@link Order.property}).\n */\nexport const max = <T, K extends keyof T & string>(property: K): Aggregate<T, T[K] | null> =>\n  new AggregateClass({ kind: 'max', property });\n\n/**\n * Aggregate the minimum of a scalar property across the group's members.\n */\nexport const min = <T, K extends keyof T & string>(property: K): Aggregate<T, T[K] | null> =>\n  new AggregateClass({ kind: 'min', property });\n\n/**\n * Collect the group's members, optionally ordered by `order` and capped to `limit` per group.\n * Opt-in — groups carry no members unless this aggregate is declared.\n *\n * `order` is this aggregate's own per-group ordering — independent of any `orderBy` elsewhere in\n * the query, which orders the whole input stream (and, following `aggregate`, the resulting\n * groups), not this aggregate's member selection. Without `order`, members keep whatever order\n * they arrived in from a preceding `orderBy` (unspecified if there is none), so a per-group\n * top-`limit` moved position in the chain would silently change; declaring `order` here makes the\n * ordering explicit and local to this aggregate regardless of where it sits.\n */\nexport const items = <T>(options?: { limit?: number; order?: Order.Any[] }): Aggregate<T, T[]> =>\n  new AggregateClass({ kind: 'items', limit: options?.limit, order: options?.order?.map((order) => order.ast) });\n\n/**\n * Count the group's members. Opt-in — groups carry no count unless this aggregate is declared.\n */\nexport const count = <T>(): Aggregate<T, number> => new AggregateClass({ kind: 'count' });\n"],"mappings":";;;;;;;;;;AAyBA,IAAa,kBAAkB;AA4B/B,IAAM,iBAAN,MAAM,eAAgD;CAOxB;CAN5B,OAAe,aAAmD,CAAC;CAEnE,OAAO,GAAG,OAA8B;EACtC,OAAO,OAAO,UAAU,YAAY,UAAU,QAAA,2BAA2B;CAC3E;CAEA,YAAY,MAA4B;EAAZ,KAAA,OAAA;CAAa;CAEzC,CAAC,mBAAmB,eAAe;AACrC;;;;;;;;;;;;;AAcA,IAAa,SAKR,QACH,IAAI,eAAe;CAAE,MAAM;CAAS,YAAY,OAAO,QAAQ,WAAW,CAAC,GAAG,IAAI,IAAI;AAAS,CAAC;;;;;;AAOlG,IAAa,OAAsC,aACjD,IAAI,eAAe;CAAE,MAAM;CAAO;AAAS,CAAC;;;;AAK9C,IAAa,OAAsC,aACjD,IAAI,eAAe;CAAE,MAAM;CAAO;AAAS,CAAC;;;;;;;;;;;;AAa9C,IAAa,SAAY,YACvB,IAAI,eAAe;CAAE,MAAM;CAAS,OAAO,SAAS;CAAO,OAAO,SAAS,OAAO,KAAK,UAAU,MAAM,GAAG;AAAE,CAAC;;;;AAK/G,IAAa,cAAuC,IAAI,eAAe,EAAE,MAAM,QAAQ,CAAC"}
+{"version":3,"file":"Aggregate.mjs","names":[],"sources":["../../src/Aggregate.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as EffectTypes from 'effect/Types';\n\nimport type { QueryAST } from '@dxos/echo-protocol';\n\nimport type * as Order from './Order.ts';\nimport type * as Query from './Query.ts';\n\n/**\n * The aggregate spec sans name; the name is supplied by the `Query.aggregate` record key. A tagged\n * union per kind so `property`/`limit`/`order` are present exactly when the kind uses them (no\n * unused optional fields to guard against at read sites).\n */\nexport type Spec =\n  | { kind: 'group'; properties: readonly [string, ...string[]] }\n  | { kind: 'max'; property: string }\n  | { kind: 'min'; property: string }\n  | { kind: 'items'; limit?: number; order?: readonly QueryAST.Order[] }\n  | { kind: 'count' }\n  | { kind: 'type' }\n  | { kind: 'timestamp'; field: 'createdAt' | 'updatedAt'; unit: TimeUnit }\n  | { kind: 'time'; property: string; unit: TimeUnit }\n  | { kind: 'sum'; property: string };\n\nexport const AggregateTypeId = '~@dxos/echo/Aggregate' as const;\nexport type AggregateTypeId = typeof AggregateTypeId;\n\n/**\n * A per-group aggregate declaration, materialised as a top-level field on the flat result record\n * `Query.aggregate` produces and orderable via a following `orderBy(Order.property(name))`. Name it\n * via the record passed to `Query.aggregate({ name: Aggregate.max('created') })`.\n *\n * `T` is the query's element type (so a reduced/grouped property is checked against it); `V` is the\n * value the aggregate produces. {@link group} entries define the grouping keys; a record with no\n * `group` entries aggregates the entire input into a single row.\n */\nexport interface Aggregate<T, V> {\n  readonly [AggregateTypeId]: { element: T; value: V };\n\n  spec: Spec;\n}\n\nexport type Any = Aggregate<any, any>;\n\n/** Extracts the value type a {@link Aggregate} produces. */\nexport type ValueOf<A> = A extends Aggregate<any, infer V> ? V : never;\n\n/** Computes the flat result type of `Query.aggregate(aggregates)` for a given aggregate record `A`. */\nexport type AggregationResult<A extends Record<string, Any>> = EffectTypes.Simplify<\n  Query.RecordResult & { readonly [N in keyof A]: ValueOf<A[N]> }\n>;\n\nclass AggregateClass<T, V> implements Aggregate<T, V> {\n  private static 'variance': Aggregate<any, any>[AggregateTypeId] = {} as Aggregate<any, any>[AggregateTypeId];\n\n  static is(value: unknown): value is Any {\n    return typeof value === 'object' && value !== null && AggregateTypeId in value;\n  }\n\n  constructor(public readonly spec: Spec) {}\n\n  [AggregateTypeId] = AggregateClass.variance as Aggregate<T, V>[AggregateTypeId];\n}\n\n/**\n * Group members by a scalar property, or by the first property of a `coalesce` chain holding a\n * scalar value (`threadId ?? id`). The record key names the result field carrying the coerced\n * group-key value; multiple `group` entries form a composite key (a `coalesce` chain is one\n * component, not several). Members whose key is missing, `null`, `undefined`, or non-scalar group\n * under the `null` key, so the field value includes `null`.\n *\n * A chain ending in an always-present property (e.g. `{ coalesce: ['threadId', 'id'] }`) gives each\n * member lacking the leading property its own singleton group instead of pooling them under `null`,\n * where an {@link items} `limit` would truncate unrelated members. `id` qualifies: it resolves to\n * the object's entity id even though documents don't store it as data.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const group: {\n  <T, K extends keyof T & string>(property: K): Aggregate<T, T[K] | null>;\n  <T, const K extends readonly [keyof T & string, ...(keyof T & string)[]]>(key: {\n    coalesce: K;\n  }): Aggregate<T, T[K[number]] | null>;\n} = (key: string | { coalesce: readonly [string, ...string[]] }): Any =>\n  new AggregateClass({ kind: 'group', properties: typeof key === 'string' ? [key] : key.coalesce });\n\n/**\n * Aggregate the maximum of a scalar property across the group's members.\n * `T` is inferred from the `Query.aggregate` context, so `property` is checked against the query's\n * element type (like {@link Order.property}).\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const max = <T, K extends keyof T & string>(property: K): Aggregate<T, T[K] | null> =>\n  new AggregateClass({ kind: 'max', property });\n\n/**\n * Aggregate the minimum of a scalar property across the group's members.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const min = <T, K extends keyof T & string>(property: K): Aggregate<T, T[K] | null> =>\n  new AggregateClass({ kind: 'min', property });\n\n/**\n * Collect the group's members, optionally ordered by `order` and capped to `limit` per group.\n * Opt-in — groups carry no members unless this aggregate is declared.\n *\n * `order` is this aggregate's own per-group ordering — independent of any `orderBy` elsewhere in\n * the query, which orders the whole input stream (and, following `aggregate`, the resulting\n * groups), not this aggregate's member selection. Without `order`, members keep whatever order\n * they arrived in from a preceding `orderBy` (unspecified if there is none), so a per-group\n * top-`limit` moved position in the chain would silently change; declaring `order` here makes the\n * ordering explicit and local to this aggregate regardless of where it sits.\n *\n * @performance O(k) in the number of orders; builds an aggregate spec without evaluating anything.\n */\nexport const items = <T>(options?: { limit?: number; order?: Order.Any[] }): Aggregate<T, T[]> =>\n  new AggregateClass({ kind: 'items', limit: options?.limit, order: options?.order?.map((order) => order.ast) });\n\nexport type NumericKeys<T> = { [K in keyof T & string]: T[K] extends number | null | undefined ? K : never }[keyof T &\n  string];\n\n/**\n * Sum a numeric property across the group's members; values that are not numbers count as 0, so\n * a group always sums to a number.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const sum = <T, K extends NumericKeys<T>>(property: K): Aggregate<T, number> =>\n  new AggregateClass({ kind: 'sum', property });\n\n/**\n * Count the group's members. Opt-in — groups carry no count unless this aggregate is declared.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const count = <T>(): Aggregate<T, number> => new AggregateClass({ kind: 'count' });\n\n/**\n * Group members by their stored type URI. The field carries the URI string as written, so two\n * schema versions are two groups.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const type = <T>(): Aggregate<T, string | null> => new AggregateClass({ kind: 'type' });\n\n/**\n * Time units a timestamp aggregate can group by, both in UTC. To show local days, group by `hour` and\n * roll the hours into the viewer's days; an hour straddles local midnight in a zone offset by a\n * fraction of an hour (India, Newfoundland), so its members land on one side of it.\n */\nexport type TimeUnit = 'hour' | 'day';\n\n/**\n * Group members by the UTC hour or day their system `updatedAt` falls in. The field carries the start\n * of that interval in unix ms, or `null` when the timestamp is unknown.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const updated = <T>(unit: TimeUnit): Aggregate<T, number | null> =>\n  new AggregateClass({ kind: 'timestamp', field: 'updatedAt', unit });\n\n/**\n * Like {@link updated}, over the system `createdAt` timestamp.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const created = <T>(unit: TimeUnit): Aggregate<T, number | null> =>\n  new AggregateClass({ kind: 'timestamp', field: 'createdAt', unit });\n\n/**\n * Group members by the UTC hour or day a unix-ms property falls in, like {@link updated} over a\n * property instead of a system timestamp. The field carries the start of that interval in unix ms,\n * or `null` when the property is not a number.\n *\n * @performance O(1); builds an aggregate spec without evaluating anything.\n */\nexport const time = <T, K extends NumericKeys<T>>(property: K, unit: TimeUnit): Aggregate<T, number | null> =>\n  new AggregateClass({ kind: 'time', property, unit });\n"],"mappings":";;;;;;;;;;;;;;;AA6BA,IAAa,kBAAkB;AA4B/B,IAAM,iBAAN,MAAM,eAAgD;CAOxB;CAN5B,OAAe,aAAmD,CAAC;CAEnE,OAAO,GAAG,OAA8B;EACtC,OAAO,OAAO,UAAU,YAAY,UAAU,QAAA,2BAA2B;CAC3E;CAEA,YAAY,MAA4B;EAAZ,KAAA,OAAA;CAAa;CAEzC,CAAC,mBAAmB,eAAe;AACrC;;;;;;;;;;;;;;;AAgBA,IAAa,SAKR,QACH,IAAI,eAAe;CAAE,MAAM;CAAS,YAAY,OAAO,QAAQ,WAAW,CAAC,GAAG,IAAI,IAAI;AAAS,CAAC;;;;;;;;AASlG,IAAa,OAAsC,aACjD,IAAI,eAAe;CAAE,MAAM;CAAO;AAAS,CAAC;;;;;;AAO9C,IAAa,OAAsC,aACjD,IAAI,eAAe;CAAE,MAAM;CAAO;AAAS,CAAC;;;;;;;;;;;;;;AAe9C,IAAa,SAAY,YACvB,IAAI,eAAe;CAAE,MAAM;CAAS,OAAO,SAAS;CAAO,OAAO,SAAS,OAAO,KAAK,UAAU,MAAM,GAAG;AAAE,CAAC;;;;;;;AAW/G,IAAa,OAAoC,aAC/C,IAAI,eAAe;CAAE,MAAM;CAAO;AAAS,CAAC;;;;;;AAO9C,IAAa,cAAuC,IAAI,eAAe,EAAE,MAAM,QAAQ,CAAC;;;;;;;AAQxF,IAAa,aAA6C,IAAI,eAAe,EAAE,MAAM,OAAO,CAAC;;;;;;;AAe7F,IAAa,WAAc,SACzB,IAAI,eAAe;CAAE,MAAM;CAAa,OAAO;CAAa;AAAK,CAAC;;;;;;AAOpE,IAAa,WAAc,SACzB,IAAI,eAAe;CAAE,MAAM;CAAa,OAAO;CAAa;AAAK,CAAC;;;;;;;;AASpE,IAAa,QAAqC,UAAa,SAC7D,IAAI,eAAe;CAAE,MAAM;CAAQ;CAAU;AAAK,CAAC"}

package/dist/lib/Annotation.mjs

@@ -1,3 +1,3 @@
-import { A as DEFAULT_LAYOUT_NAME, At as setDescriptionWithSchema, B as FormInputAnnotation, H as FormLayoutAnnotation, I as FormCreateAnnotation, J as HiddenAnnotation, K as GeneratorAnnotation, L as FormCreateAnnotationId, Mt as setLabelWithSchema, P as FieldLookupAnnotationId, Q as LabelAnnotation, R as FormInlineAnnotation, Tt as getTypeIdentifierAnnotation, U as FormLayoutAnnotationId, W as FormOrderedAnnotation, X as IconAnnotation, Z as IconFromRefAnnotation, at as SetParentAnnotation, j as DescriptionAnnotation, nt as ReferenceAnnotation, ot as TypeAnnotation, pt as getDescriptionWithSchema, q as GeneratorAnnotationId, rt as ReferenceAnnotationId, wt as getTypeAnnotation, yt as getLabelWithSchema } from "./chunk-Database.mjs";
+import { $ as GeneratorAnnotation, At as getTypeAnnotation, F as ArrayPresentationAnnotation, G as FormInlineAnnotation, It as setDescriptionWithSchema, L as DEFAULT_LAYOUT_NAME, R as DescriptionAnnotation, Rt as setLabelWithSchema, Tt as getLabelWithSchema, U as FormCreateAnnotation, V as FieldLookupAnnotationId, W as FormCreateAnnotationId, X as FormLayoutAnnotationId, Y as FormLayoutAnnotation, Z as FormOrderedAnnotation, ct as ReferenceAnnotationId, dt as TypeAnnotation, et as GeneratorAnnotationId, gt as UserTypeAnnotation, jt as getTypeIdentifierAnnotation, nt as IconFromRefAnnotation, q as FormInputAnnotation, rt as LabelAnnotation, st as ReferenceAnnotation, tt as IconAnnotation, ut as SetParentAnnotation, yt as getDescriptionWithSchema } from "./chunk-Database.mjs";
 import { a as atom, c as get, d as make, f as set, i as TypeId, l as getDictionary, m as update, n as Dictionary, o as atomProperty, p as setDictionary, r as Key, s as buildDictionary, u as getFromAst } from "./chunk-Annotation.mjs";
-export { DEFAULT_LAYOUT_NAME, DescriptionAnnotation, Dictionary, FieldLookupAnnotationId, FormCreateAnnotation, FormCreateAnnotationId, FormInlineAnnotation, FormInputAnnotation, FormLayoutAnnotation, FormLayoutAnnotationId, FormOrderedAnnotation, GeneratorAnnotation, GeneratorAnnotationId, HiddenAnnotation, IconAnnotation, IconFromRefAnnotation, Key, LabelAnnotation, ReferenceAnnotation, ReferenceAnnotationId, SetParentAnnotation as SetParent, TypeAnnotation, TypeId, atom, atomProperty, buildDictionary, get, getDescriptionWithSchema, getDictionary, getFromAst, getLabelWithSchema, getTypeAnnotation, getTypeIdentifierAnnotation, make, set, setDescriptionWithSchema, setDictionary, setLabelWithSchema, update };
+export { ArrayPresentationAnnotation, DEFAULT_LAYOUT_NAME, DescriptionAnnotation, Dictionary, FieldLookupAnnotationId, FormCreateAnnotation, FormCreateAnnotationId, FormInlineAnnotation, FormInputAnnotation, FormLayoutAnnotation, FormLayoutAnnotationId, FormOrderedAnnotation, GeneratorAnnotation, GeneratorAnnotationId, IconAnnotation, IconFromRefAnnotation, Key, LabelAnnotation, ReferenceAnnotation, ReferenceAnnotationId, SetParentAnnotation as SetParent, TypeAnnotation, TypeId, UserTypeAnnotation as UserType, atom, atomProperty, buildDictionary, get, getDescriptionWithSchema, getDictionary, getFromAst, getLabelWithSchema, getTypeAnnotation, getTypeIdentifierAnnotation, make, set, setDescriptionWithSchema, setDictionary, setLabelWithSchema, update };

package/dist/lib/Blob.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
-import { J as HiddenAnnotation, X as IconAnnotation, r as Service } from "./chunk-Database.mjs";
+import { i as Service, tt as IconAnnotation } from "./chunk-Database.mjs";
 import { BlobNotAvailableError, BlobTooLargeError, BlobWriteError } from "./Error.mjs";
 import { makeObject } from "./Type.mjs";
 import { make as make$1 } from "./Obj.mjs";
@@ -19,6 +19,7 @@ var Blob_exports = /* @__PURE__ */ __exportAll({
 	exists: () => exists,
 	externalData: () => externalData,
 	fromBytes: () => fromBytes,
+	fromUpload: () => fromUpload,
 	inlineData: () => inlineData,
 	make: () => make,
 	read: () => read,
@@ -61,7 +62,7 @@ var Blob = class extends makeObject(DXN.make("org.dxos.type.blob", "0.1.0"))(Sch
 	type: Schema.optional(Schema.String),
 	size: Schema.Number,
 	data: BlobData
-}).pipe(HiddenAnnotation.set(true), IconAnnotation.set({
+}).pipe(IconAnnotation.set({
 	icon: "ph--file--regular",
 	hue: "teal"
 }))) {};
@@ -81,7 +82,7 @@ var Storage = {
 	edge: "edge"
 };
 /**
-* URI schemes claimed by core backends (see `BlobBackend.schemes` in `@dxos/echo-protocol`).
+* URI schemes claimed by core backends (see `BlobBackend.schemes` in `@dxos/blob`).
 *
 * `ni` marks an {@link https://www.rfc-editor.org/rfc/rfc6920 RFC 6920} Named Information URI whose
 * authority is empty and whose path carries a registered hash-algorithm name plus a base64url-encoded
@@ -97,10 +98,14 @@ var Scheme = { ni: "ni" };
 var MAX_INLINE_SIZE = 4194304;
 /**
 * Creates a new blob object. Does not add it to the database — see {@link fromBytes}.
+*
+* @performance O(1); allocates an in-memory blob object.
 */
 var make = (props) => make$1(Blob, props);
 /**
 * Creates an inline {@link BlobData} variant that embeds raw bytes on the ECHO object.
+*
+* @performance O(1); wraps the bytes without copying.
 */
 var inlineData = (bytes) => ({
 	_tag: "inline",
@@ -109,6 +114,8 @@ var inlineData = (bytes) => ({
 /**
 * Creates an external {@link BlobData} variant that references bytes held by a registered backend.
 * @param uri - Backend-scoped URI, e.g. as returned by a `BlobBackend.put` call.
+*
+* @performance O(1).
 */
 var externalData = (uri) => ({
 	_tag: "external",
@@ -123,12 +130,35 @@ var externalData = (uri) => ({
 * const blob = yield* Blob.fromBytes(bytes, { type: 'image/png' });
 * yield* Database.add(blob);
 * ```
+*
+* @performance Async; O(size) to hash, plus the backend upload (a no-op for inline storage).
 */
 var fromBytes = (bytes, options) => Service.pipe(Effect.flatMap(({ db }) => Effect.tryPromise({
 	try: () => db.createBlob(bytes, options),
 	catch: (error) => error instanceof BlobTooLargeError || error instanceof BlobWriteError ? error : new BlobWriteError({ backend: options?.storage ?? "unknown" }, { cause: error })
 }))).pipe(Effect.withSpan("Blob.fromBytes"));
 /**
+* Adopts bytes already staged by a direct upload, returning an un-added Blob object. The caller is
+* responsible for adding it to the database.
+*
+* The counterpart to {@link fromBytes} for content this process never holds: an agent uploaded the
+* file straight to the store over a signed URL, because passing it through a tool call would mean
+* a model emitting it byte by byte. Size and type are reported by the store, which is the only
+* party that saw what arrived.
+*
+* @example
+* ```ts
+* const blob = yield* Blob.fromUpload(uploadId);
+* yield* Database.add(blob);
+* ```
+*
+* @performance Async; one backend round trip, and the bytes never pass through this process.
+*/
+var fromUpload = (uploadId, options) => Service.pipe(Effect.flatMap(({ db }) => Effect.tryPromise({
+	try: () => db.createBlobFromUpload(uploadId, options),
+	catch: (error) => error instanceof BlobNotAvailableError || error instanceof BlobWriteError ? error : new BlobWriteError({ backend: options?.storage ?? "unknown" }, { cause: error })
+}))).pipe(Effect.withSpan("Blob.fromUpload"));
+/**
 * Loads a blob's bytes. Inline: read directly off the object. External: dispatched to the
 * registered backend for the URI's scheme.
 *
@@ -136,6 +166,8 @@ var fromBytes = (bytes, options) => Service.pipe(Effect.flatMap(({ db }) => Effe
 * ```ts
 * const bytes = yield* Blob.read(blob);
 * ```
+*
+* @performance Async; O(size), read inline or fetched from the backend.
 */
 var read = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.tryPromise({
 	try: () => db.readBlob(blob),
@@ -147,14 +179,19 @@ var read = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.tryPromise({
 }))).pipe(Effect.withSpan("Blob.read"));
 /**
 * Checks whether a blob's bytes are currently available.
+*
+* @performance Async; one backend check, with no byte transfer.
 */
 var exists = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.blobExists(blob)))).pipe(Effect.withSpan("Blob.exists"));
 /**
 * Returns a renderable URL for the blob: inline blobs resolve to a `data:` URL; external blobs
 * are resolved by the registered backend's `getUrl`, if it implements one.
+*
+* @performance Async; an inline blob encodes all of its bytes into a `data:` URL (O(size)), an external one asks the
+* backend.
 */
 var url = (blob) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.getBlobUrl(blob))), Effect.map(Option.fromNullishOr)).pipe(Effect.withSpan("Blob.url"));
 //#endregion
-export { Blob, BlobData, ExternalData, InlineData, MAX_INLINE_SIZE, Scheme, Storage, exists, externalData, fromBytes, inlineData, make, read, Blob_exports as t, url };
+export { Blob, BlobData, ExternalData, InlineData, MAX_INLINE_SIZE, Scheme, Storage, exists, externalData, fromBytes, fromUpload, inlineData, make, read, Blob_exports as t, url };
 
 //# sourceMappingURL=Blob.mjs.map

package/dist/lib/Blob.mjs.map

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

package/dist/lib/Change.mjs

@@ -0,0 +1,30 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import * as Schema from "effect/Schema";
+//#region src/Change.ts
+var Change_exports = /* @__PURE__ */ __exportAll({ Change: () => Change });
+/**
+* One change to a document, as {@link Filter.changes} returns it: a plain, frozen record, not an
+* entity. It cannot be added to a database, referenced or mutated.
+*/
+var Change = Schema.Struct({
+	/** Unique among a query's results: the Automerge change hash for a document change. */
+	key: Schema.String,
+	/** Where the change is stored; only documents report changes today. */
+	source: Schema.Literals(["document", "feed"]),
+	/** The author's clock when the change was made, unix ms. */
+	time: Schema.Number,
+	/** Writer that made the change; for a document change, an Automerge actor, which is a device, not a member. */
+	actor: Schema.String,
+	/** The actor's sequence number for this change. */
+	seq: Schema.Number,
+	/**
+	* Primitive writes in the change, at the storage's granularity: Automerge ops (a field set, a
+	* character inserted) for a document change; 1 for a feed block, which writes one whole object.
+	* Compare sums within one `source`.
+	*/
+	ops: Schema.Number
+});
+//#endregion
+export { Change, Change_exports as t };
+
+//# sourceMappingURL=Change.mjs.map

package/dist/lib/Change.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Change.mjs","names":[],"sources":["../../src/Change.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport type * as Query from './Query.ts';\n\n/**\n * One change to a document, as {@link Filter.changes} returns it: a plain, frozen record, not an\n * entity. It cannot be added to a database, referenced or mutated.\n */\nexport const Change = Schema.Struct({\n  /** Unique among a query's results: the Automerge change hash for a document change. */\n  key: Schema.String,\n  /** Where the change is stored; only documents report changes today. */\n  source: Schema.Literals(['document', 'feed']),\n  /** The author's clock when the change was made, unix ms. */\n  time: Schema.Number,\n  /** Writer that made the change; for a document change, an Automerge actor, which is a device, not a member. */\n  actor: Schema.String,\n  /** The actor's sequence number for this change. */\n  seq: Schema.Number,\n  /**\n   * Primitive writes in the change, at the storage's granularity: Automerge ops (a field set, a\n   * character inserted) for a document change; 1 for a feed block, which writes one whole object.\n   * Compare sums within one `source`.\n   */\n  ops: Schema.Number,\n});\n\n/** The metadata every change carries, whether it is a query row or an object's history entry. */\nexport type Metadata = Schema.Schema.Type<typeof Change>;\n\n/**\n * One change to an object, as {@link Obj.getChanges} returns it: the document change's metadata plus\n * the value the change touched, as it read before and after. A plain, frozen record, not an entity.\n */\nexport interface ValueChange<T> extends Metadata {\n  /** Id of the object the change touched. */\n  readonly object: string;\n  /** The property the history was filtered to, when {@link Obj.getChanges} was given one. */\n  readonly property?: string;\n  /** The document's frontier once the change applied; `Obj.getVersion(obj, heads)` reads the object as it left it. */\n  readonly heads: readonly string[];\n  /** The writer's commit message, if it gave one. */\n  readonly message?: string;\n  /** The value before the change; `undefined` where the object (or property) did not exist yet. */\n  readonly before: T | undefined;\n  /** The value after the change; `undefined` where the change removed the property. */\n  readonly after: T | undefined;\n}\n\n/**\n * A change: with no type argument, one row of a {@link Filter.changes} query; with a type argument,\n * one entry of an object's history ({@link ValueChange}) whose `before`/`after` hold that type.\n */\nexport type Change<T = never> = [T] extends [never] ? Metadata & Query.RecordResult : ValueChange<T>;\n"],"mappings":";;;;;;;;AAcA,IAAa,SAAS,OAAO,OAAO;;CAElC,KAAK,OAAO;;CAEZ,QAAQ,OAAO,SAAS,CAAC,YAAY,MAAM,CAAC;;CAE5C,MAAM,OAAO;;CAEb,OAAO,OAAO;;CAEd,KAAK,OAAO;;;;;;CAMZ,KAAK,OAAO;AACd,CAAC"}

package/dist/lib/Collection.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
-import { B as FormInputAnnotation, X as IconAnnotation } from "./chunk-Database.mjs";
+import { gt as UserTypeAnnotation, q as FormInputAnnotation, tt as IconAnnotation, ut as SetParentAnnotation } from "./chunk-Database.mjs";
 import { makeObject } from "./Type.mjs";
 import { Ref } from "./Ref.mjs";
 import { Unknown, instanceOf, make as make$1 } from "./Obj.mjs";
@@ -8,25 +8,42 @@ import * as Schema from "effect/Schema";
 //#region src/Collection.ts
 var Collection_exports = /* @__PURE__ */ __exportAll({
 	Collection: () => Collection,
+	ItemTag: () => ItemTag,
 	isCollection: () => isCollection,
 	make: () => make
 });
 /**
+* {@link Annotation.UserType} tag for types made to live in a collection, which creating into a collection
+* offers. Any user type can join a collection; untagged ones do so from the object itself.
+*/
+var ItemTag = "org.dxos.tag.collectionItem";
+/**
 * A an ordered set of objects.
 */
 var Collection = class extends makeObject(DXN.make("org.dxos.type.collection", "0.1.0"))(Schema.Struct({
 	name: Schema.String.pipe(Schema.optional),
-	objects: Schema.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
+	/** Members, in order. */
+	objects: Schema.Array(Ref(Unknown)).pipe(SetParentAnnotation.set({ override: false }), FormInputAnnotation.set(false))
 }).pipe(IconAnnotation.set({
 	icon: "ph--folder--regular",
 	hue: "indigo"
-}))) {};
+}), UserTypeAnnotation.set({ tags: [ItemTag] }))) {};
+/**
+* Creates a new collection object.
+*
+* @performance O(n) in initial members; allocates an in-memory collection object.
+*/
 var make = (props = {}) => make$1(Collection, {
 	objects: [],
 	...props
 });
+/**
+* Type guard for collections.
+*
+* @performance O(1) type-URI comparison with a typename fallback; no schema validation.
+*/
 var isCollection = instanceOf(Collection);
 //#endregion
-export { Collection, isCollection, make, Collection_exports as t };
+export { Collection, ItemTag, isCollection, make, Collection_exports as t };
 
 //# sourceMappingURL=Collection.mjs.map

package/dist/lib/Collection.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Collection.mjs","names":[],"sources":["../../src/Collection.ts"],"sourcesContent":["//\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 class Collection extends Type.makeObject<Collection>(DXN.make('org.dxos.type.collection', '0.1.0'))(\n  Schema.Struct({\n    name: Schema.String.pipe(Schema.optional),\n    objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(internal.FormInputAnnotation.set(false)),\n  }).pipe(Annotation.IconAnnotation.set({ icon: 'ph--folder--regular', hue: 'indigo' })),\n) {}\n\nexport const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Type.InstanceType<typeof Collection> =>\n  Obj.make(Collection, { objects: [], ...props });\n\nexport const isCollection: (value: unknown) => value is Type.InstanceType<typeof Collection> =\n  Obj.instanceOf(Collection);\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,IAAa,aAAb,cAAgC,WAA4B,IAAI,KAAK,4BAA4B,OAAO,CAAC,CAAC,CACxG,OAAO,OAAO;CACZ,MAAM,OAAO,OAAO,KAAK,OAAO,QAAQ;CACxC,SAAS,OAAO,MAAM,IAAQ,OAAW,CAAC,CAAC,CAAC,KAAA,oBAAkC,IAAI,KAAK,CAAC;AAC1F,CAAC,CAAC,CAAC,KAAA,eAA+B,IAAI;CAAE,MAAM;CAAuB,KAAK;AAAS,CAAC,CAAC,CACvF,CAAC,CAAC,CAAC;AAEH,IAAa,QAAQ,QAAmD,CAAC,MACvE,OAAS,YAAY;CAAE,SAAS,CAAC;CAAG,GAAG;AAAM,CAAC;AAEhD,IAAa,eACX,WAAe,UAAU"}
+{"version":3,"file":"Collection.mjs","names":[],"sources":["../../src/Collection.ts"],"sourcesContent":["//\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.ts';\nimport * as internal from './internal/index.ts';\nimport * as Obj from './Obj.ts';\nimport * as Ref from './Ref.ts';\nimport * as Type from './Type.ts';\n\n/**\n * {@link Annotation.UserType} tag for types made to live in a collection, which creating into a collection\n * offers. Any user type can join a collection; untagged ones do so from the object itself.\n */\nexport const ItemTag = 'org.dxos.tag.collectionItem';\n\n/**\n * A an ordered set of objects.\n */\nexport class Collection extends Type.makeObject<Collection>(DXN.make('org.dxos.type.collection', '0.1.0'))(\n  Schema.Struct({\n    name: Schema.String.pipe(Schema.optional),\n    /** Members, in order. */\n    objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(\n      Annotation.SetParent.set({ override: false }),\n      internal.FormInputAnnotation.set(false),\n    ),\n  }).pipe(\n    Annotation.IconAnnotation.set({ icon: 'ph--folder--regular', hue: 'indigo' }),\n    Annotation.UserType.set({ tags: [ItemTag] }),\n  ),\n) {}\n\n/**\n * Creates a new collection object.\n *\n * @performance O(n) in initial members; allocates an in-memory collection object.\n */\nexport const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Type.InstanceType<typeof Collection> =>\n  Obj.make(Collection, { objects: [], ...props });\n\n/**\n * Type guard for collections.\n *\n * @performance O(1) type-URI comparison with a typename fallback; no schema validation.\n */\nexport const isCollection: (value: unknown) => value is Type.InstanceType<typeof Collection> =\n  Obj.instanceOf(Collection);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAa,UAAU;;;;AAKvB,IAAa,aAAb,cAAgC,WAA4B,IAAI,KAAK,4BAA4B,OAAO,CAAC,CAAC,CACxG,OAAO,OAAO;CACZ,MAAM,OAAO,OAAO,KAAK,OAAO,QAAQ;;CAExC,SAAS,OAAO,MAAM,IAAQ,OAAW,CAAC,CAAC,CAAC,KAAA,oBACrB,IAAI,EAAE,UAAU,MAAM,CAAC,GAAA,oBACf,IAAI,KAAK,CACxC;AACF,CAAC,CAAC,CAAC,KAAA,eACyB,IAAI;CAAE,MAAM;CAAuB,KAAK;AAAS,CAAC,GAAA,mBACxD,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAC7C,CACF,CAAC,CAAC,CAAC;;;;;;AAOH,IAAa,QAAQ,QAAmD,CAAC,MACvE,OAAS,YAAY;CAAE,SAAS,CAAC;CAAG,GAAG;AAAM,CAAC;;;;;;AAOhD,IAAa,eACX,WAAe,UAAU"}

package/dist/lib/Database.mjs

@@ -1,2 +1,2 @@
-import { C as subscribeToSyncState, S as stats, _ as remove, a as add, b as runGarbageCollection, c as deleteFromFeed, d as isDatabase, f as layer, g as query, h as notAvailable, i as TypeId, l as flush, m as makeService, o as addType, p as load, r as Service, s as appendToFeed, t as Database, u as getSyncState, v as resolve, x as spaceId, y as retainObjects } from "./chunk-Database.mjs";
-export { Database, Service, TypeId, add, addType, appendToFeed, deleteFromFeed, flush, getSyncState, isDatabase, layer, load, makeService, notAvailable, query, remove, resolve, retainObjects, runGarbageCollection, spaceId, stats, subscribeToSyncState };
+import { C as retainObjects, D as subscribeToSyncState, E as stats, O as withSpaceId, S as resolve, T as spaceId, _ as makeService, a as TraceEvents, b as query, c as addType, d as flush, f as getSyncState, g as makeRef, h as load, i as Service, l as appendToFeed, m as layer, o as TypeId, p as isDatabase, r as Origin, s as add, t as Database, u as deleteFromFeed, v as notAvailable, w as runGarbageCollection, x as remove, y as peek } from "./chunk-Database.mjs";
+export { Database, Origin, Service, TraceEvents, TypeId, add, addType, appendToFeed, deleteFromFeed, flush, getSyncState, isDatabase, layer, load, makeRef, makeService, notAvailable, peek, query, remove, resolve, retainObjects, runGarbageCollection, spaceId, stats, subscribeToSyncState, withSpaceId };

package/dist/lib/Dataset.mjs

@@ -17,6 +17,11 @@ var Dataset = Schema.Union([
 	getSchema(Collection),
 	getSchema(View)
 ]);
+/**
+* Type guard for datasets.
+*
+* @performance O(1); at most three type-URI comparisons.
+*/
 var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Predicate.or(instanceOf(View)));
 //#endregion
 export { Dataset, isDataset, Dataset_exports as t };

package/dist/lib/Dataset.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Dataset.mjs","names":[],"sources":["../../src/Dataset.ts"],"sourcesContent":["//\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":";;;;;;;;;;;;;;AAuBA,IAAa,UAAU,OAAO,MAAM;CAClC,UAAe,IAAS;CACxB,UAAe,UAAqB;CACpC,UAAe,IAAS;AAC1B,CAAC;AAED,IAAa,YAAkD,KAC7D,WAAe,IAAS,GACxB,UAAU,GAAG,WAAe,UAAqB,CAAC,GAClD,UAAU,GAAG,WAAe,IAAS,CAAC,CACxC"}
+{"version":3,"file":"Dataset.mjs","names":[],"sources":["../../src/Dataset.ts"],"sourcesContent":["//\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.ts';\nimport * as Feed from './Feed.ts';\nimport * as Obj from './Obj.ts';\nimport * as Type from './Type.ts';\nimport * as View from './View.ts';\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\n/**\n * Type guard for datasets.\n *\n * @performance O(1); at most three type-URI comparisons.\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":";;;;;;;;;;;;;;AAuBA,IAAa,UAAU,OAAO,MAAM;CAClC,UAAe,IAAS;CACxB,UAAe,UAAqB;CACpC,UAAe,IAAS;AAC1B,CAAC;;;;;;AAOD,IAAa,YAAkD,KAC7D,WAAe,IAAS,GACxB,UAAU,GAAG,WAAe,UAAqB,CAAC,GAClD,UAAU,GAAG,WAAe,IAAS,CAAC,CACxC"}