alinea 1.7.0 → 2.0.0-preview.1

package/dist/core/Field.d.ts

@@ -1,13 +1,16 @@
+import type { EntryReferenceTarget, FieldReferenceContext } from 'alinea/core/db/EntryReference';
 import type { LinkResolver } from 'alinea/core/db/LinkResolver';
 import { Expr } from './Expr.js';
 import { type HasField, internalField } from './Internal.js';
-import type { Shape } from './Shape.js';
+import type { User } from './User.js';
 import type { View } from './View.js';
 export interface FieldOptions<StoredValue> {
     /** A description of the field */
     label: string;
     /** Hide this field in the dashboard */
     hidden?: boolean;
+    /** Display this field in overview listings */
+    overview?: boolean;
     /** Mark this field as read-only */
     readOnly?: boolean;
     /** The initial value of the field */
@@ -19,17 +22,44 @@ export interface FieldOptions<StoredValue> {
     /** Validate the given value */
     validate?(value: StoredValue): boolean | string | undefined;
 }
+export interface EntryAnchorTarget {
+    id: string;
+    fieldPath: string;
+    fieldLabel?: string;
+    label?: string;
+}
+export interface FieldAnchorContext {
+    anchors: Set<string>;
+}
 export type WithoutLabel<Options extends FieldOptions<any>> = Omit<Options, 'label'>;
 export interface FieldMeta<StoredValue, QueryValue, Mutator, Options> {
     options: Options & FieldOptions<StoredValue>;
     view: View<{
         field: Field<StoredValue, QueryValue, Mutator, Options>;
     }>;
-    postProcess?: (value: StoredValue, loader: LinkResolver) => Promise<void>;
+    compactView?: View<{
+        field: Field<StoredValue, QueryValue, Mutator, Options>;
+        value: StoredValue;
+    }>;
+    queryValue?: (value: StoredValue, loader: LinkResolver) => Promise<QueryValue>;
+    references?: (value: StoredValue, context: FieldReferenceContext) => Array<EntryReferenceTarget>;
+    anchors?: (value: StoredValue, context: FieldReferenceContext) => Array<EntryAnchorTarget>;
+    normalizeAnchors?: (value: StoredValue, context: FieldAnchorContext) => StoredValue;
+    beforeSave?: (context: FieldBeforeSaveContext<StoredValue>) => StoredValue;
+}
+export type FieldBeforeSaveAction = 'create' | 'update' | 'publish' | 'translate';
+export interface FieldBeforeSaveContext<StoredValue> {
+    value: StoredValue;
+    action: FieldBeforeSaveAction;
+    user?: User | null;
+    now: Date;
 }
 export interface FieldData<StoredValue, QueryValue, Mutator, Options> extends FieldMeta<StoredValue, QueryValue, Mutator, Options> {
-    shape: Shape<StoredValue, Mutator>;
-    referencedViews: Array<string>;
+    referencedViews?: Array<string>;
+    defaultValue?: () => StoredValue;
+    withInitialValue?: (value: StoredValue) => StoredValue;
+    applyLinks?: (value: StoredValue, loader: LinkResolver) => Promise<void>;
+    searchableText?: (value: StoredValue) => string;
 }
 export interface FieldInternal extends FieldData<any, any, any, any> {
     ref: symbol;
@@ -42,14 +72,25 @@ export declare class Field<StoredValue = any, QueryValue = any, Mutator = any, O
 }
 export declare namespace Field {
     function ref(field: HasField): symbol;
-    function shape(field: HasField): Shape;
     function label(field: HasField): string;
     function initialValue(field: HasField): unknown;
+    function withInitialValue<StoredValue>(field: HasField, value: StoredValue): StoredValue;
     function view<StoredValue, QueryValue, Mutator, Options extends FieldOptions<StoredValue>>(field: Field<StoredValue, QueryValue, Mutator, Options>): View<{
         field: Field<StoredValue, QueryValue, Mutator, Options>;
     }>;
     function referencedViews(field: Field): Array<string>;
+    function compactView<StoredValue, QueryValue, Mutator, Options extends FieldOptions<StoredValue>>(field: Field<StoredValue, QueryValue, Mutator, Options>): View<{
+        field: Field<StoredValue, QueryValue, Mutator, Options>;
+        value: StoredValue;
+    }> | undefined;
     function options<StoredValue, QueryValue, Options extends FieldOptions<StoredValue>>(field: Field<StoredValue, QueryValue, any, Options>): Options;
+    function queryValue<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, loader: LinkResolver): Promise<QueryValue>;
+    function beforeSave<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, context: Omit<FieldBeforeSaveContext<StoredValue>, 'value'>): StoredValue;
+    function applyLinks<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, loader: LinkResolver): Promise<void>;
+    function searchableText<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue): string;
+    function references<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, context: FieldReferenceContext): Array<EntryReferenceTarget>;
+    function anchors<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>, value: StoredValue, context: FieldReferenceContext): Array<EntryAnchorTarget>;
+    function normalizeAnchors<StoredValue>(field: HasField, value: StoredValue, context: FieldAnchorContext): StoredValue;
     function isField(value: any): value is Field;
 }
 export {};

package/dist/core/Field.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Field.ts
 import { Expr } from "./Expr.js";
@@ -7,7 +7,7 @@ var Field = class extends Expr {
   [internalField];
   constructor(data) {
     super({ type: "field" });
-    this[internalField] = { ref: Symbol(), ...data };
+    this[internalField] = { ref: /* @__PURE__ */ Symbol(), ...data };
   }
 };
 ((Field2) => {
@@ -15,33 +15,79 @@ var Field = class extends Expr {
     return getField(field).ref;
   }
   Field2.ref = ref;
-  function shape(field) {
-    return getField(field).shape;
-  }
-  Field2.shape = shape;
   function label(field) {
     return getField(field).options.label;
   }
   Field2.label = label;
   function initialValue(field) {
-    return getField(field).options.initialValue;
+    const data = getField(field);
+    if ("initialValue" in data.options) return data.options.initialValue;
+    return data.defaultValue?.();
   }
   Field2.initialValue = initialValue;
+  function withInitialValue(field, value) {
+    return getField(field).withInitialValue?.(value) ?? value;
+  }
+  Field2.withInitialValue = withInitialValue;
   function view(field) {
     return getField(field).view;
   }
   Field2.view = view;
   function referencedViews(field) {
     const fieldView = Field2.view(field);
-    if (typeof fieldView === "string")
-      return [fieldView, ...getField(field).referencedViews];
-    return getField(field).referencedViews;
+    const compactView2 = Field2.compactView(field);
+    return [
+      typeof fieldView === "string" ? fieldView : void 0,
+      typeof compactView2 === "string" ? compactView2 : void 0,
+      ...getField(field).referencedViews ?? []
+    ].filter((view2) => typeof view2 === "string");
   }
   Field2.referencedViews = referencedViews;
+  function compactView(field) {
+    return getField(field).compactView;
+  }
+  Field2.compactView = compactView;
   function options(field) {
     return getField(field).options;
   }
   Field2.options = options;
+  async function queryValue(field, value, loader) {
+    const data = getField(field);
+    if (data.queryValue) return data.queryValue(value, loader);
+    if (data.applyLinks) await data.applyLinks(value, loader);
+    return value;
+  }
+  Field2.queryValue = queryValue;
+  function beforeSave(field, value, context) {
+    const data = getField(field);
+    if (!data.beforeSave) return value;
+    return data.beforeSave({ ...context, value });
+  }
+  Field2.beforeSave = beforeSave;
+  async function applyLinks(field, value, loader) {
+    const data = getField(field);
+    if (data.applyLinks) await data.applyLinks(value, loader);
+  }
+  Field2.applyLinks = applyLinks;
+  function searchableText(field, value) {
+    const data = getField(field);
+    return data.searchableText?.(value) ?? "";
+  }
+  Field2.searchableText = searchableText;
+  function references(field, value, context) {
+    const data = getField(field);
+    return data.references?.(value, context) ?? [];
+  }
+  Field2.references = references;
+  function anchors(field, value, context) {
+    const data = getField(field);
+    return data.anchors?.(value, context) ?? [];
+  }
+  Field2.anchors = anchors;
+  function normalizeAnchors(field, value, context) {
+    return getField(field).normalizeAnchors?.(value, context) ?? value;
+  }
+  Field2.normalizeAnchors = normalizeAnchors;
   function isField(value) {
     return value && hasField(value);
   }

package/dist/core/Graph.d.ts

@@ -106,6 +106,12 @@ export declare class QuerySettings {
     path?: Condition<string>;
     /** Filter by url */
     url?: Condition<string>;
+    /** Filter by a metadata URL alias */
+    alias?: string;
+    /** Filter by metadata created timestamp */
+    createdAt?: Condition<number | null>;
+    /** Filter by metadata updated timestamp */
+    updatedAt?: Condition<number | null>;
     /** Filter by workspace */
     workspace?: Condition<string> | Workspace;
     /** Filter by root */

package/dist/core/Graph.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Graph.ts
 var Graph = class {

package/dist/core/HttpError.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/HttpError.ts
 var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {

package/dist/core/Id.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Id.ts
 import { crypto } from "@alinea/iso";

package/dist/core/Infer.d.ts

@@ -3,7 +3,7 @@ import type { EntryFields } from './EntryFields.js';
 import type { Expr } from './Expr.js';
 import type { Field } from './Field.js';
 import type { InferProjection } from './Graph.js';
-import type { ListRow } from './shape/ListShape.js';
+import type { ListRow } from './ListRow.js';
 import type { Type } from './Type.js';
 type QueryList<T> = Expand<UnionOfValues<{
     [K in keyof T]: {

package/dist/core/Internal.js

@@ -1,19 +1,19 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Internal.ts
-var internalRoot = Symbol.for("@alinea.Root");
+var internalRoot = /* @__PURE__ */ Symbol.for("@alinea.Root");
 var hasRoot = (obj) => internalRoot in obj;
 var getRoot = (obj) => obj[internalRoot];
-var internalType = Symbol.for("@alinea.Type");
+var internalType = /* @__PURE__ */ Symbol.for("@alinea.Type");
 var hasType = (obj) => internalType in obj;
 var getType = (obj) => obj[internalType];
-var internalField = Symbol.for("@alinea.Field");
+var internalField = /* @__PURE__ */ Symbol.for("@alinea.Field");
 var hasField = (obj) => internalField in obj;
 var getField = (obj) => obj[internalField];
-var internalWorkspace = Symbol.for("@alinea.Workspace");
+var internalWorkspace = /* @__PURE__ */ Symbol.for("@alinea.Workspace");
 var hasWorkspace = (obj) => internalWorkspace in obj;
 var getWorkspace = (obj) => obj[internalWorkspace];
-var internalExpr = Symbol.for("@alinea.Expr");
+var internalExpr = /* @__PURE__ */ Symbol.for("@alinea.Expr");
 var hasExpr = (obj) => internalExpr in obj;
 var getExpr = (obj) => obj[internalExpr];
 export {

package/dist/core/ListRow.d.ts

@@ -0,0 +1,10 @@
+export interface ListRow {
+    _id: string;
+    _type: string;
+    _index: string;
+}
+export declare namespace ListRow {
+    const id = "_id";
+    const index = "_index";
+    const type = "_type";
+}

package/dist/core/ListRow.js

@@ -0,0 +1,12 @@
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/core/ListRow.ts
+var ListRow;
+((ListRow2) => {
+  ListRow2.id = "_id";
+  ListRow2.index = "_index";
+  ListRow2.type = "_type";
+})(ListRow || (ListRow = {}));
+export {
+  ListRow
+};

package/dist/core/Outcome.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Outcome.ts
 function outcome(run) {

package/dist/core/Page.js

@@ -1,9 +1,9 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Page.ts
 var Page;
 ((Page2) => {
-  Page2.Data = Symbol.for("@alinea/Page.Data");
+  Page2.Data = /* @__PURE__ */ Symbol.for("@alinea/Page.Data");
   function data(page2) {
     return page2[Page2.Data];
   }

package/dist/core/Picker.d.ts

@@ -3,7 +3,6 @@ import type { Label } from './Label.js';
 import type { Reference } from './Reference.js';
 import type { Type } from './Type.js';
 import type { PostProcess } from './pages/PostProcess.js';
-import type { RecordShape } from './shape/RecordShape.js';
 export interface PickerProps<T = any> {
     type: string;
     options: T;
@@ -20,7 +19,6 @@ export interface PickerRow {
     target?: string;
 }
 export interface Picker<StoredValue extends Reference, Options extends {} = {}> {
-    shape: RecordShape;
     fields: Type<any> | undefined;
     label: Label;
     handlesMultiple: boolean;

package/dist/core/Picker.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Picker.ts
 function pickerWithView(create, views) {

package/dist/core/Reference.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Reference.ts
 var Reference;

package/dist/core/Role.d.ts

@@ -48,6 +48,7 @@ export interface Permissions {
     archive: boolean;
     upload: boolean;
     explore: boolean;
+    manageMembers: boolean;
     all: boolean;
 }
 export declare enum Permission {
@@ -62,6 +63,7 @@ export declare enum Permission {
     Archive,
     Upload,
     Explore,
+    ManageMembers,
     All,
     Explicit
 }
@@ -102,6 +104,7 @@ export declare class Policy {
     canArchive(resource?: Resource): boolean;
     canUpload(resource?: Resource): boolean;
     canExplore(resource?: Resource): boolean;
+    canManageMembers(): boolean;
     canAll(resource?: Resource): boolean;
 }
 export declare class WriteablePolicy extends Policy {

package/dist/core/Role.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Role.ts
 import { assert } from "alinea/core/util/Assert";
@@ -17,6 +17,7 @@ var Permission = ((Permission2) => {
   Permission2[Permission2["Archive"] = 1 << total++] = "Archive";
   Permission2[Permission2["Upload"] = 1 << total++] = "Upload";
   Permission2[Permission2["Explore"] = 1 << total++] = "Explore";
+  Permission2[Permission2["ManageMembers"] = 1 << total++] = "ManageMembers";
   Permission2[Permission2["All"] = (1 << total) - 1] = "All";
   Permission2[Permission2["Explicit"] = 1 << total++] = "Explicit";
   return Permission2;
@@ -32,6 +33,7 @@ var permissionMap = {
   archive: Permission.Archive,
   upload: Permission.Upload,
   explore: Permission.Explore,
+  manageMembers: Permission.ManageMembers,
   all: Permission.All
 };
 var DENY_MASK = ~((1 << total) - 1);
@@ -72,6 +74,7 @@ function entitlements(packed) {
     archive: Boolean(packed & Permission.Archive),
     upload: Boolean(packed & Permission.Upload),
     explore: Boolean(packed & Permission.Explore),
+    manageMembers: Boolean(packed & Permission.ManageMembers),
     all: Boolean(packed & Permission.All)
   };
 }
@@ -200,6 +203,9 @@ var Policy = class _Policy {
   canExplore(resource) {
     return this.check(Permission.Explore, resource);
   }
+  canManageMembers() {
+    return this.check(Permission.ManageMembers);
+  }
   canAll(resource) {
     return this.check(Permission.All, resource);
   }

package/dist/core/Root.d.ts

@@ -9,12 +9,15 @@ import { Type } from './Type.js';
 import type { View } from './View.js';
 export interface RootI18n {
     locales: ReadonlyArray<string>;
+    fallback?: (requested: string) => ReadonlyArray<string>;
 }
 export interface RootMeta {
     /** Accepts entries of these types as children */
     contains?: Array<string | Type>;
     /** Order children entries in the sidebar content tree */
     orderChildrenBy?: OrderBy | Array<OrderBy>;
+    /** Open this root in the sidebar content tree by default */
+    openByDefault?: boolean;
     icon?: ComponentType;
     i18n?: RootI18n;
     /** Point to a React component used to view this root in the dashboard */
@@ -35,6 +38,7 @@ export declare namespace Root {
     function label(root: Root): Label;
     function contains(root: Root): Array<string | Type>;
     function data(root: Root): RootData;
+    function mediaI18n(root: RootData): RootI18n | undefined;
     function preview(root: Root): Preview | undefined;
     function defaultLocale(root: Root): string | undefined;
     function isRoot(value: any): value is Root;

package/dist/core/Root.js

@@ -3,8 +3,8 @@ import {
   boolean,
   object,
   string
-} from "../chunks/chunk-WD7H5L2L.js";
-import "../chunks/chunk-NZLE2WMY.js";
+} from "../chunks/chunk-I4GC3E65.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Root.ts
 import { getRoot, hasRoot, internalRoot } from "./Internal.js";
@@ -24,6 +24,10 @@ var Root;
     return getRoot(root2);
   }
   Root2.data = data;
+  function mediaI18n(root2) {
+    return root2._media?.i18n;
+  }
+  Root2.mediaI18n = mediaI18n;
   function preview(root2) {
     return getRoot(root2).preview;
   }
@@ -46,6 +50,7 @@ var Root;
       locales: array(string)
     }).optional,
     view: string.optional,
+    openByDefault: boolean.optional,
     isMediaRoot: boolean.optional
   });
   function validate(root2, workspaceLabel, schema) {

package/dist/core/Schema.d.ts

@@ -1,11 +1,9 @@
 import { Type } from './Type.js';
-import type { RecordShape } from './shape/RecordShape.js';
 export interface Schema<Definitions = {}> extends Record<string, Type> {
 }
 export declare namespace Schema {
     function referencedViews(schema: Schema): Array<string>;
     function validate(schema: Schema): void;
-    function shapes(schema: Schema): Record<string, RecordShape>;
     function typeNames(schema: Schema): Map<Type, string>;
     function contained(schema: Schema, contains: Array<string | Type>): Array<string>;
 }

package/dist/core/Schema.js

@@ -1,11 +1,10 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Schema.ts
 import { getType } from "./Internal.js";
 import { Type } from "./Type.js";
 import { isValidIdentifier } from "./util/Identifiers.js";
-import { entries, fromEntries, values } from "./util/Objects.js";
-var shapesCache = /* @__PURE__ */ new WeakMap();
+import { entries, values } from "./util/Objects.js";
 var Schema;
 ((Schema2) => {
   function referencedViews(schema2) {
@@ -47,19 +46,6 @@ var Schema;
     }
   }
   Schema2.validate = validate;
-  function shapes(schema2) {
-    if (!shapesCache.has(schema2))
-      shapesCache.set(
-        schema2,
-        fromEntries(
-          entries(schema2).map(([key, type]) => {
-            return [key, Type.shape(type)];
-          })
-        )
-      );
-    return shapesCache.get(schema2);
-  }
-  Schema2.shapes = shapes;
   function typeNames(schema2) {
     return new Map(entries(schema2).map(([key, type]) => [type, key]));
   }

package/dist/core/Scope.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Scope.ts
 import { Expr } from "./Expr.js";

package/dist/core/Section.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Section.ts
 import { Field } from "./Field.js";
@@ -6,7 +6,7 @@ import { assign, create, defineProperty, entries } from "./util/Objects.js";
 import { rowId } from "./util/RowId.js";
 var Section;
 ((Section2) => {
-  Section2.Data = Symbol.for("@alinea/Section.Data");
+  Section2.Data = /* @__PURE__ */ Symbol.for("@alinea/Section.Data");
   function view(section2) {
     return section2[Section2.Data].view;
   }

package/dist/core/TextDoc.d.ts

@@ -18,11 +18,15 @@ export interface LinkMark extends Mark {
     _id: string;
     _link: 'entry' | 'file' | 'url';
     _entry?: string;
+    _anchor?: string;
+    _suffix?: string;
 }
 export declare namespace LinkMark {
     const id = "_id";
     const link = "_link";
     const entry = "_entry";
+    const anchor = "_anchor";
+    const suffix = "_suffix";
 }
 export interface TextNode {
     _type: 'text';

package/dist/core/TextDoc.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/TextDoc.ts
 var Node;
@@ -28,6 +28,8 @@ var LinkMark;
   LinkMark2.id = "_id";
   LinkMark2.link = "_link";
   LinkMark2.entry = "_entry";
+  LinkMark2.anchor = "_anchor";
+  LinkMark2.suffix = "_suffix";
 })(LinkMark || (LinkMark = {}));
 var TextNode;
 ((TextNode2) => {

package/dist/core/Tracker.d.ts

@@ -3,14 +3,9 @@ export interface FieldGetter {
     <Value>(field: Field<Value>): Value;
 }
 export interface OptionsTracker<Options = any> {
-    (getter: FieldGetter): Partial<Options> | Promise<Partial<Options>>;
-}
-export interface ValueTracker<Value = any> {
-    (getter: FieldGetter): Value;
+    (getter: FieldGetter): Partial<Options>;
 }
 export declare function optionTrackerOf(field: Field): OptionsTracker<any> | undefined;
-export declare function valueTrackerOf(field: Field): ValueTracker<any> | undefined;
 export declare namespace track {
     function options<StoredValue, QueryValue, OnChange, Options>(field: Field<StoredValue, QueryValue, OnChange, Options>, tracker: OptionsTracker<Options & FieldOptions<StoredValue>>): Field<StoredValue, QueryValue, OnChange, Options>;
-    function value<StoredValue, QueryValue, OnChange, Options>(field: Field<StoredValue, QueryValue, OnChange, Options>, tracker: ValueTracker<StoredValue>): Field<StoredValue, QueryValue, OnChange, Options>;
 }

package/dist/core/Tracker.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Tracker.ts
 import { Field } from "./Field.js";
@@ -6,10 +6,6 @@ var optionTrackers = /* @__PURE__ */ new Map();
 function optionTrackerOf(field) {
   return optionTrackers.get(Field.ref(field));
 }
-var valueTrackers = /* @__PURE__ */ new Map();
-function valueTrackerOf(field) {
-  return valueTrackers.get(Field.ref(field));
-}
 var track;
 ((track2) => {
   function options(field, tracker) {
@@ -17,14 +13,8 @@ var track;
     return field;
   }
   track2.options = options;
-  function value(field, tracker) {
-    valueTrackers.set(Field.ref(field), tracker);
-    return field;
-  }
-  track2.value = value;
 })(track || (track = {}));
 export {
   optionTrackerOf,
-  track,
-  valueTrackerOf
+  track
 };

package/dist/core/Trigger.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Trigger.ts
 var { assign } = Object;