From ca0850d7ef6c49634ee52044011699c8416d77d2 Mon Sep 17 00:00:00 2001
From: Scott Wei <leescott@microsoft.com>
Date: Mon, 30 Sep 2024 15:19:09 +0800
Subject: [PATCH] Add the behaviors API.

---
 packages/@ot-doc/model/src/behavior/hkt.ts    |   0
 .../@ot-doc/model/src/behavior/operation.ts   |  85 --------------
 .../@ot-doc/model/src/behavior/variable.ts    |   2 -
 .../@ot-doc/model/src/behaviors/behavior.ts   |  84 ++++++++++++++
 .../@ot-doc/model/src/behaviors/editable.ts   | 105 ++++++++++++++++++
 packages/@ot-doc/model/src/behaviors/eq.ts    |  32 ++++++
 packages/@ot-doc/model/src/behaviors/hkt.ts   |  20 ++++
 packages/@ot-doc/model/src/behaviors/maybe.ts |   6 +
 .../@ot-doc/model/src/behaviors/operation.ts  |  49 ++++++++
 .../@ot-doc/model/src/behaviors/preset.ts     |  17 +++
 .../@ot-doc/model/src/behaviors/readable.ts   |  79 +++++++++++++
 .../@ot-doc/model/src/behaviors/signatured.ts |  21 ++++
 .../@ot-doc/model/src/behaviors/struct.ts     |  40 +++++++
 .../@ot-doc/model/src/behaviors/variables.ts  |   8 ++
 packages/@ot-doc/model/src/data/index.ts      |   0
 15 files changed, 461 insertions(+), 87 deletions(-)
 delete mode 100644 packages/@ot-doc/model/src/behavior/hkt.ts
 delete mode 100644 packages/@ot-doc/model/src/behavior/operation.ts
 delete mode 100644 packages/@ot-doc/model/src/behavior/variable.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/behavior.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/editable.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/eq.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/hkt.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/maybe.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/operation.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/preset.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/readable.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/signatured.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/struct.ts
 create mode 100644 packages/@ot-doc/model/src/behaviors/variables.ts
 delete mode 100644 packages/@ot-doc/model/src/data/index.ts

diff --git a/packages/@ot-doc/model/src/behavior/hkt.ts b/packages/@ot-doc/model/src/behavior/hkt.ts
deleted file mode 100644
index e69de29..0000000
diff --git a/packages/@ot-doc/model/src/behavior/operation.ts b/packages/@ot-doc/model/src/behavior/operation.ts
deleted file mode 100644
index e629a13..0000000
--- a/packages/@ot-doc/model/src/behavior/operation.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { $Var } from "./variable";
-
-declare const symOp: unique symbol;
-export type $Op = { [symOp]: typeof symOp };
-
-export type Prim = string | number | boolean;
-
-/**
- * Update a primitive value
- * @param o the old value
- * @param n to value
- */
-
-export type PrimOp<T extends Prim> = {
-  o?: T;
-  n?: T;
-  t: number;
-};
-
-/**
- * Update a segment in an array, could be deletion or insertion
- * @param i index
- * @param a array of values
- */
-
-export type ArrayOplet<T> = { i: number; a: T[] };
-
-/**
- * Update array
- * @param d deletions
- * @param i insertions
- */
-export type ArrayOp<T> = { d: ArrayOplet<T>[]; i: ArrayOplet<T>[] };
-
-/**
- * Update a dict
- */
-export type DictOp<T> = Record<string, Op<T>>
-
-/**
- * Struct op
- */
-export type ObjectOp<T extends object> = Partial<{ [K in keyof T]: Op<T[K]> }>;
-
-export type Op<T> = T extends $Var
-  ? $Op
-  : T extends string
-  ? PrimOp<string>
-  : T extends number
-  ? PrimOp<number>
-  : T extends boolean
-  ? PrimOp<boolean>
-  : T extends Array<infer E>
-  ? ArrayOp<E>
-  : T extends object
-  ? ObjectOp<T>
-  : never;
-
-export type Updater<T> = (v: T) => Op<T>;
-
-export type GeneralUpdater<T> = T extends Prim
-  ? Updater<T>
-  : T extends Array<any>
-  ? Updater<T>
-  : T extends object
-  ?
-      | Updater<T>
-      | Partial<{
-          [K in keyof T]: Updater<T[K]>;
-        }>
-  : never;
-
-export const updater = <T>(g: GeneralUpdater<T>): Updater<T> => {
-  if (typeof g === 'function') return g;
-  const gStt = g as Partial<{ [K in keyof T]: Updater<T[K]> }>;
-  return (stt) => Object.keys(g).reduce((m, key) => {
-    const keyG = key as keyof typeof gStt;
-    const keyOp = key as keyof Op<T> & string;
-    const f = gStt[keyG];
-    if (f)  {
-    (m as any)[keyOp] = updater<any>(f)((stt as any)[key]);
-    }
-    return m;
-  }, {} as Op<T>);
-}
diff --git a/packages/@ot-doc/model/src/behavior/variable.ts b/packages/@ot-doc/model/src/behavior/variable.ts
deleted file mode 100644
index 8b45dec..0000000
--- a/packages/@ot-doc/model/src/behavior/variable.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-declare const symVar: unique symbol;
-export type $Var = { [symVar]: typeof symVar };
diff --git a/packages/@ot-doc/model/src/behaviors/behavior.ts b/packages/@ot-doc/model/src/behaviors/behavior.ts
new file mode 100644
index 0000000..08e9b19
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/behavior.ts
@@ -0,0 +1,84 @@
+import { $ } from './hkt';
+import { $Struct, AnyDict, Dict } from './struct';
+
+/**
+ * Behavior
+ */
+export type Behavior<T extends AnyDict> = {
+  $string: $<T, string>;
+  $number: $<T, number>;
+  $boolean: $<T, boolean>;
+  $array: <E>(elm: $<T, E>) => $<T, E[]>;
+  $dict: <V>(val: $<T, V>) => $<T, Dict<V>>;
+  $struct: <S extends AnyDict>(struct: $Struct<T, S>) => $<T, S>;
+};
+
+/**
+ * Behavior Definition
+ */
+export type BehaviorDef<
+  Type extends AnyDict,
+  Base extends AnyDict = AnyDict,
+> = {
+  $string: (u: $<Base, string>) => $<Type, string>;
+  $number: (u: $<Base, number>) => $<Type, number>;
+  $boolean: (u: $<Base, boolean>) => $<Type, boolean>;
+  $array: <E>(u: $<Base, E[]>) => (elm: $<Type & Base, E>) => $<Type, E[]>;
+  $dict: <V>(
+    u: $<Base, Dict<V>>,
+  ) => (val: $<Type & Base, V>) => $<Type, Dict<V>>;
+  $struct: <S extends AnyDict>(
+    u: $<Base, S>,
+  ) => (stt: $Struct<Type & Base, S>) => $<Type, S>;
+};
+
+const define = <Type extends AnyDict, Base extends AnyDict>(
+  { $string, $number, $boolean, $array, $dict, $struct }: Behavior<Base>,
+  def: BehaviorDef<Type, Base>,
+) =>
+  ({
+    $string: Object.assign({}, $string, def.$string($string)),
+    $number: Object.assign({}, $number, def.$number($number)),
+    $boolean: Object.assign({}, $boolean, def.$boolean($boolean)),
+    $array: <E>(elm: $<Type & Base, E>) => {
+      const bhv = $array(elm);
+      return Object.assign({}, bhv, def.$array(bhv)(elm));
+    },
+    $dict: <V>(val: $<Type & Base, V>) => {
+      const bhv = $dict(val);
+      return Object.assign({}, bhv, def.$dict(bhv)(val));
+    },
+    $struct: <S extends AnyDict>(stt: $Struct<Type & Base, S>) => {
+      const bhv = $struct(stt);
+      return Object.assign({}, bhv, def.$struct(bhv)(stt));
+    },
+  }) as Behavior<Type & Base>;
+
+type Builder<U extends AnyDict> = {
+  mixin: <T extends AnyDict>(def: BehaviorDef<T, U>) => Builder<T & U>;
+  build: () => Behavior<U>;
+};
+
+const builder = <T extends AnyDict>(bhv: Behavior<T>): Builder<T> => ({
+  mixin: (def) => builder(define(bhv, def)),
+  build: () => bhv,
+});
+
+export const behavior = <T extends AnyDict>(bhv: Behavior<T>) =>
+  ({
+    $string: () => bhv.$string,
+    $number: () => bhv.$number,
+    $boolean: () => bhv.$boolean,
+    $array: () => bhv.$array,
+    $dict: () => bhv.$dict,
+    $struct: () => bhv.$struct,
+  }) as BehaviorDef<T>;
+
+export const BehaviorBuilder = builder({
+  $string: {},
+  $number: {},
+  $boolean: {},
+  $array: () => ({}),
+  $dict: () => ({}),
+  $struct: () => ({}),
+});
diff --git a/packages/@ot-doc/model/src/behaviors/editable.ts b/packages/@ot-doc/model/src/behaviors/editable.ts
new file mode 100644
index 0000000..735d4aa
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/editable.ts
@@ -0,0 +1,105 @@
+import { Maybe, just, nothing } from "./maybe";
+import { BehaviorDef } from "./behavior";
+import { $Var } from "./variables";
+import { Action, ObjectOp, Op, Prim } from "./operation";
+import { $Struct, reduceDict, reduceStruct } from "./struct";
+import { Eq } from "./eq";
+import { Preset } from "./preset";
+
+export type Result<T> = { value: T, op: Op<T> };
+
+export type Update<T> = (action: Action<T>) => (a: T) => Maybe<Result<T>>;
+export type Editable<T = $Var> = { update: Update<T> };
+
+const withUpdate = <T>(update: Update<T>): Editable<T> => ({ update });
+const constant = <T>(value: T) => () => value;
+
+const withUpdatePrim = <T extends Prim>({ preset }: Preset<T>): Editable<T> =>
+  withUpdate((action) => (v) => {
+    const op = action(v);
+    const { o = preset, n = preset } = op;
+    return o === v ? just({ value: n as T, op }) : nothing();
+  });
+
+const editable: BehaviorDef<Editable, Eq & Preset> = {
+  $string: withUpdatePrim,
+  $number: withUpdatePrim,
+  $boolean: withUpdatePrim,
+  $array:
+    ({ eq }) =>
+    () =>
+      withUpdate((updater) => (arrOld) => {
+        const op = updater(arrOld);
+        const { i: ins, d: del } = op;
+        if (del.length === 0 && ins.length === 0)
+          return just({ value: arrOld, op });
+        const arrNew = [...arrOld];
+        for (const { i: idx, a: arr } of del) {
+          if (
+            idx > arrNew.length ||
+            idx < 0 ||
+            !eq(arr)(arrNew.slice(idx, idx + arr.length))
+          )
+            return nothing();
+          arrNew.splice(idx, arr.length);
+        }
+        for (const { i: idx, a: arr } of ins) {
+          if (idx > arrNew.length || idx < 0) return nothing();
+          arrNew.splice(idx, 0, ...arr);
+        }
+        return just({ value: arrNew, op });
+      }),
+  $dict:
+    () =>
+    ({ update, preset, eq }) =>
+      withUpdate((action) => (dictOld) => {
+        const op = action(dictOld);
+        return reduceDict(
+          op,
+          (m, opVal, key) => {
+            if (m.$ === 'Nothing' || !opVal || typeof key !== 'string')
+              return m;
+            const valOld = dictOld[key] ?? preset;
+            const mResult = update(constant(opVal))(valOld);
+            if (mResult.$ === 'Nothing') return nothing();
+            const { value } = mResult.v;
+            if (!eq(dictOld[key])(value)) {
+              if (m.v.value === dictOld) {
+                m.v.value = { ...dictOld };
+              }
+              if (eq(preset)(value)) {
+                delete m.v.value[key];
+              } else {
+                m.v.value[key] = value;
+              }
+            }
+            return m;
+          },
+          just({ value: dictOld, op })
+        );
+      }),
+  $struct: <S extends object>() => (sttDoc: $Struct<Editable & Eq & Preset, S>) =>
+    withUpdate((updater: Action<S>) => (sttOld: S): Maybe<Result<S>> => {
+      const op = updater(sttOld);
+      const opObj = op as ObjectOp<S>;
+      return reduceStruct(
+        sttOld,
+        <K extends keyof S>(m: Maybe<Result<S>>, valOld: S[K], key: K) => {
+          if (m.$ === 'Nothing' || !opObj[key]) return m;
+          const mResult = sttDoc[key].update(constant(opObj[key]))(valOld);
+          if (mResult.$ === 'Nothing') return nothing();
+          const { value } = mResult.v;
+          if (!sttDoc[key].eq(valOld)(value)) {
+            if (m.v.value === sttOld) {
+              m.v.value = { ...sttOld };
+            }
+            m.v.value[key] = value;
+          }
+          return m;
+        },
+        just({ value: sttOld, op })
+      );
+    }),
+};
+
+export default editable;
diff --git a/packages/@ot-doc/model/src/behaviors/eq.ts b/packages/@ot-doc/model/src/behaviors/eq.ts
new file mode 100644
index 0000000..403fe99
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/eq.ts
@@ -0,0 +1,32 @@
+import { $Var } from "./hkt";
+import { behavior } from "./behavior";
+
+export type Relation<T> = (a: T) => (b: T) => boolean;
+export type Eq<T = $Var> = { eq: Relation<T> };
+
+const withEq = <T>(f: Relation<T> = () => () => false): Eq<T> => ({
+  eq: (a) => (b) => a === b || f(a)(b),
+});
+
+export const eq = behavior<Eq>({
+  $string: withEq(),
+  $number: withEq(),
+  $boolean: withEq(),
+  $array: ({ eq }) =>
+    withEq((a) => (b) => {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i += 1) if (!eq(a[i])(b[i])) return false;
+      return true;
+    }),
+  $dict: ({ eq }) =>
+    withEq((a) => (b) => {
+      for (const key in a) if (!(key in b) || !eq(a[key])(b[key])) return false;
+      for (const key in b) if (!(key in a)) return false;
+      return true;
+    }),
+  $struct: (stt) =>
+    withEq((a) => (b) => {
+      for (const key in stt) if (!stt[key].eq(a[key])(b[key])) return false;
+      return true;
+    }),
+});
diff --git a/packages/@ot-doc/model/src/behaviors/hkt.ts b/packages/@ot-doc/model/src/behaviors/hkt.ts
new file mode 100644
index 0000000..71ec893
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/hkt.ts
@@ -0,0 +1,20 @@
+import { Op } from "./operation";
+import { $OpVar, $Var } from "./variables";
+
+
+// Type application (substitutes type variables with types)
+export type $<T, S = $Var> = T extends $Var
+  ? S
+  : T extends $OpVar
+  ? Op<S>
+  : T extends undefined | null | boolean | string | number
+  ? T
+  : T extends Array<infer A>
+  ? $<A, S>[]
+  : T extends (...args: infer Args) => infer R
+  ? (...x: { [K in keyof Args]: $<Args[K], S> }) => $<R, S>
+  : T extends object
+  ? { [K in keyof T]: $<T[K], S> }
+  : T;
+
+export type { $Var };
diff --git a/packages/@ot-doc/model/src/behaviors/maybe.ts b/packages/@ot-doc/model/src/behaviors/maybe.ts
new file mode 100644
index 0000000..29061a3
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/maybe.ts
@@ -0,0 +1,6 @@
+// $: Constructor type
+// v: the value
+export type Maybe<T> = { $: 'Nothing' } | { $: 'Just'; v: T };
+
+export const nothing = <T>(): Maybe<T> => ({ $: 'Nothing' });
+export const just = <T>(v: T): Maybe<T> => ({ $: 'Just', v });
diff --git a/packages/@ot-doc/model/src/behaviors/operation.ts b/packages/@ot-doc/model/src/behaviors/operation.ts
new file mode 100644
index 0000000..37aff42
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/operation.ts
@@ -0,0 +1,49 @@
+import { $Var, $OpVar } from "./variables";
+
+export type Prim = string | number | boolean;
+
+/**
+ * Update a primitive value
+ * @param o the old value
+ * @param n to value
+ */
+export type PrimOp<T extends Prim> = {
+  o?: T;
+  n?: T;
+  t: number;
+};
+
+/**
+ * Update a segment in an array, could be deletion or insertion
+ * @param i index
+ * @param a array of values
+ */
+export type ArrayOplet<T> = { i: number; a: T[] };
+
+/**
+ * Update array
+ * @param d deletions
+ * @param i insertions
+ */
+export type ArrayOp<T> = { d: ArrayOplet<T>[]; i: ArrayOplet<T>[] };
+
+/**
+ * Struct op
+ */
+export type ObjectOp<T extends object> = Partial<{ [K in keyof T]: Op<T[K]> }>;
+
+export type Op<T> = T extends $Var
+  ? $OpVar
+  : T extends string
+  ? PrimOp<string>
+  : T extends number
+  ? PrimOp<number>
+  : T extends boolean
+  ? PrimOp<boolean>
+  : T extends Array<infer E>
+  ? ArrayOp<E>
+  : T extends object
+  ? ObjectOp<T>
+  : never;
+
+export type Action<T> = (v: T) => Op<T>;
\ No newline at end of file
diff --git a/packages/@ot-doc/model/src/behaviors/preset.ts b/packages/@ot-doc/model/src/behaviors/preset.ts
new file mode 100644
index 0000000..bfb95dd
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/preset.ts
@@ -0,0 +1,17 @@
+import { behavior } from './behavior';
+import { mapStruct } from './struct';
+import { $Var } from './variables';
+
+export type Preset<T = $Var> = { preset: T };
+
+const withPreset = <T>(preset: T): Preset<T> => ({ preset });
+
+export const preset = behavior<Preset>({
+  $string: withPreset(''),
+  $number: withPreset(0),
+  $boolean: withPreset(false),
+  $array: () => withPreset([]),
+  $dict: () => withPreset({}),
+  $struct: (stt) => withPreset(mapStruct(stt, ({ preset }) => preset)),
+});
+
diff --git a/packages/@ot-doc/model/src/behaviors/readable.ts b/packages/@ot-doc/model/src/behaviors/readable.ts
new file mode 100644
index 0000000..15ef3aa
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/readable.ts
@@ -0,0 +1,79 @@
+import { BehaviorDef } from './behavior';
+import { $Var } from './hkt';
+import { $Struct, Dict, mapDict, mapStruct } from './struct';
+import { Preset } from './preset';
+import { Signatured } from './signatured';
+
+export type Readable<T> = (
+  raise: (path: string) => (message: string) => void,
+) => (u: unknown) => T;
+
+export type Read<T = $Var> = {
+  read: Readable<T>;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export const noop = () => {};
+
+export const readData =
+  <T>({ read }: Read<T>) =>
+  (u: unknown, onError: (message: string) => void = noop) => 
+    read(path => message => onError(`${message}, at $${path}`))(u);
+
+const withRead = <T>(read: Readable<T>): Read<T> => ({ read });
+
+const withReadPrim = <T extends string | number | boolean>({
+  preset,
+  signature,
+}: Preset<T> & Signatured): Read<T> =>
+  withRead((raise) => (u) => {
+    if (typeof u === typeof preset) {
+      return u as T;
+    }
+    raise('')(`requires ${signature}`);
+    return preset;
+  });
+
+const readable: BehaviorDef<Read, Preset & Signatured> = {
+  $string: withReadPrim,
+  $number: withReadPrim,
+  $boolean: withReadPrim,
+  $array:
+    ({ preset, signature }) =>
+    ({ read }) =>
+      withRead((raise) => (u) => {
+        if (!Array.isArray(u)) {
+          raise('')(`requires ${signature}`);
+          return preset;
+        }
+        return u.map((e, i) => read((path) => raise(`[${i}]${path}`))(e));
+      }),
+  $dict:
+    ({ preset, signature }) =>
+    ({ read }) =>
+      withRead((raise) => (u) => {
+        if (typeof u !== 'object' || !u) {
+          raise('')(`requires ${signature}`);
+          return preset;
+        }
+        return mapDict(u as Dict<unknown>, (v, key) =>
+          read((path) => raise(`.${key}${path}`))(v),
+        );
+      }),
+  $struct:
+    ({ preset, signature }) =>
+    (stt) =>
+      withRead((raise) => (u) => {
+        if (typeof u !== 'object' || !u) {
+          raise('')(`requires ${signature}`);
+          return preset;
+        }
+        return mapStruct(stt, ({ read }, key) =>
+          read((path) => raise(`.${key as string}${path}`))(
+            (u as $Struct<unknown, typeof stt>)[key],
+          ),
+        );
+      }),
+};
+
+export default readable;
\ No newline at end of file
diff --git a/packages/@ot-doc/model/src/behaviors/signatured.ts b/packages/@ot-doc/model/src/behaviors/signatured.ts
new file mode 100644
index 0000000..6f907e6
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/signatured.ts
@@ -0,0 +1,21 @@
+import { behavior } from './behavior';
+
+export type Signatured = {
+  signature: string;
+};
+
+const withSignature = (signature: string): Signatured => ({ signature });
+
+export const signatured = behavior<Signatured>({
+  $string: withSignature('string'),
+  $number: withSignature('number'),
+  $boolean: withSignature('boolean'),
+  $array: ({ signature }) => withSignature(`Array<${signature}>`),
+  $dict: ({ signature }) => withSignature(`Dict<${signature}>`),
+  $struct: (stt) =>
+    withSignature(
+      `{ ${Object.keys(stt)
+        .map((key) => `${key}: ${stt[key].signature}`)
+        .join('; ')} }`
+    ),
+});
diff --git a/packages/@ot-doc/model/src/behaviors/struct.ts b/packages/@ot-doc/model/src/behaviors/struct.ts
new file mode 100644
index 0000000..74b4576
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/struct.ts
@@ -0,0 +1,40 @@
+import { $ } from './hkt';
+
+export type Dict<T> = Record<string, T>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyDict = Dict<any>;
+export type $Struct<T, S extends AnyDict> = { [K in keyof S]: $<T, S[K]> };
+
+export const reduceStruct = <T extends AnyDict, U>(
+  t: T,
+  f: <K extends keyof T>(u: U, v: T[K], key: K) => U,
+  u: U
+): U =>
+  Object.keys(t).reduce(
+    <K extends keyof T>(m: U, k: K) => f(m, t[k], k),
+    u as U
+  );
+
+export const mapStruct = <T extends AnyDict, F>(
+  t: T,
+  f: <K extends keyof T>(v: T[K], key: K) => $<F, T[K]>,
+): $Struct<F, T> =>
+  reduceStruct(
+    t,
+    (m, v, k) => {
+      m[k] = f(v, k);
+      return m;
+    },
+    {} as $Struct<F, T>,
+  );
+
+export const reduceDict = reduceStruct as <T, U>(
+  dict: Dict<T>,
+  f: (u: U, v: T, key: string) => U,
+  u: U,
+) => U;
+
+export const mapDict = mapStruct as <T, V>(
+  dict: Dict<T>,
+  f: (t: T, key: string) => V,
+) => Dict<V>;
\ No newline at end of file
diff --git a/packages/@ot-doc/model/src/behaviors/variables.ts b/packages/@ot-doc/model/src/behaviors/variables.ts
new file mode 100644
index 0000000..1f807b2
--- /dev/null
+++ b/packages/@ot-doc/model/src/behaviors/variables.ts
@@ -0,0 +1,8 @@
+declare const symVar: unique symbol;
+export type $Var = { [symVar]: typeof symVar };
+
+declare const symOp: unique symbol;
+export type $OpVar = { [symOp]: typeof symOp };
+
+declare const symAct: unique symbol;
+export type $ActVar = { [symAct]: typeof symAct };
\ No newline at end of file
diff --git a/packages/@ot-doc/model/src/data/index.ts b/packages/@ot-doc/model/src/data/index.ts
deleted file mode 100644
index e69de29..0000000