tutuca 0.10.0 → 0.11.0

package/dist/tutuca-extra.ext.js

@@ -1,8 +1,80 @@
-// src/value.js
-import { is } from "immutable";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/collection.js
+var isPlainObject = (value) => {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var seqSize = (seq) => {
+  if (seq == null) return 0;
+  if (typeof seq.length === "number") return seq.length;
+  if (typeof seq.size === "number") return seq.size;
+  return isPlainObject(seq) ? Object.keys(seq).length : 0;
+};
+var seqGet = (seq, key, dval = null) => {
+  if (seq == null) return dval;
+  if (seq instanceof Map) return seq.has(key) ? seq.get(key) : dval;
+  if (seq instanceof Set) return seq.has(key) ? key : dval;
+  if (Object.hasOwn(seq, key)) return seq[key];
+  if (typeof seq.get === "function") return seq.get(key, dval);
+  return dval;
+};
+var isIndexedSeq = (seq) => Array.isArray(seq);
+var isKeyedSeq = (seq) => seq instanceof Map || isPlainObject(seq);
+var isSetSeq = (seq) => seq instanceof Set;
+function* seqEntries(seq) {
+  if (seq instanceof Map) yield* seq.entries();
+  else if (seq instanceof Set) for (const value of seq) yield [value, value];
+  else if (isPlainObject(seq)) yield* Object.entries(seq);
+  else if (Array.isArray(seq)) for (let i = 0; i < seq.length; i++) yield [i, seq[i]];
+}
+
+// src/immer.js
+var immer_exports = {};
+__reExport(immer_exports, immer_star);
+import { enableMapSet } from "immer";
+import * as immer_star from "immer";
+enableMapSet();
 
 // src/path.js
 var NONE = /* @__PURE__ */ Symbol("NONE");
+var readKey = (value, key, dval = null) => {
+  if (value == null) return dval;
+  if (value instanceof Map) return value.has(key) ? value.get(key) : dval;
+  if (value instanceof Set) return value.has(key) ? key : dval;
+  return Object.hasOwn(value, key) ? value[key] : dval;
+};
+var writeKey = (value, key, next) => {
+  if (value instanceof Map) value.set(key, next);
+  else if (value instanceof Set) {
+    value.delete(key);
+    value.add(next);
+  } else value[key] = next;
+};
+var readSeqKey = (value, key, dval = null) => {
+  const direct = readKey(value, key, NONE);
+  if (direct !== NONE) return direct;
+  return typeof value?.get === "function" ? value.get(key, dval) : dval;
+};
+var writeSeqKey = (value, key, next) => {
+  if (value instanceof Map || value instanceof Set || Array.isArray(value) || Object.hasOwn(value, key))
+    writeKey(value, key, next);
+  else if (typeof value?.set === "function") value.set(key, next);
+  else writeKey(value, key, next);
+};
 var Step = class {
   lookup(_v, dval = null) {
     return dval;
@@ -10,6 +82,8 @@ var Step = class {
   setValue(root, _v) {
     return root;
   }
+  setDraftValue(_root, _v) {
+  }
   enterFrame(stack, _prev, next) {
     return stack.enter(next, {}, true);
   }
@@ -74,10 +148,13 @@ var FieldStep = class extends Step {
     this.field = field;
   }
   lookup(v, dval = null) {
-    return v?.get ? v.get(this.field, dval) : dval;
+    return readKey(v, this.field, dval);
   }
   setValue(root, v) {
-    return root.set(this.field, v);
+    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
+  }
+  setDraftValue(root, v) {
+    writeKey(root, this.field, v);
   }
   withIndex(i) {
     return new SeqStep(this.field, i);
@@ -96,12 +173,14 @@ var SeqStep = class extends Step {
     this.key = key;
   }
   lookup(v, dval = null) {
-    const o = v?.get(this.field, null);
-    return o?.get ? o.get(this.key, dval) : dval;
+    return readSeqKey(readKey(v, this.field, null), this.key, dval);
   }
   setValue(root, v) {
-    const seq = root?.get(this.field, null);
-    return seq ? root.set(this.field, seq.set(this.key, v)) : root;
+    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
+  }
+  setDraftValue(root, v) {
+    const seq = readKey(root, this.field, null);
+    if (seq != null) writeSeqKey(seq, this.key, v);
   }
   enterFrame(stack, _prev, next) {
     return stack.enter(next, { key: this.key }, true);
@@ -117,19 +196,22 @@ var SeqAccessStep = class extends Step {
     this.keyField = keyField;
   }
   lookup(v, dval = null) {
-    const seq = v?.get(this.seqField, NONE);
-    const key = v?.get(this.keyField, NONE);
-    return key !== NONE && seq?.get ? seq.get(key, dval) : dval;
+    const seq = readKey(v, this.seqField, NONE);
+    const key = readKey(v, this.keyField, NONE);
+    return key !== NONE && seq !== NONE ? readSeqKey(seq, key, dval) : dval;
   }
   setValue(root, v) {
-    const seq = root?.get(this.seqField, NONE);
-    const key = root?.get(this.keyField, NONE);
-    return seq === NONE || key === NONE ? root : root.set(this.seqField, seq.set(key, v));
+    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
+  }
+  setDraftValue(root, v) {
+    const seq = readKey(root, this.seqField, NONE);
+    const key = readKey(root, this.keyField, NONE);
+    if (seq !== NONE && key !== NONE) writeSeqKey(seq, key, v);
   }
   // Resolve `keyField` against `v` now and freeze it as a literal-key `SeqStep`, so a
   // later lookup/setValue lands on this same item even if `keyField` changes meanwhile.
   pinKey(v) {
-    const key = v?.get(this.keyField, NONE);
+    const key = readKey(v, this.keyField, NONE);
     return key === NONE ? this : new SeqStep(this.seqField, key);
   }
   // The key is a *field reference* resolved live, so it is unknown without a value;
@@ -310,19 +392,15 @@ var Path = class _Path {
     return out;
   }
   setValue(root, v) {
-    const intermediates = new Array(this.steps.length);
-    let curVal = root;
-    for (let i = 0; i < this.steps.length; i++) {
-      intermediates[i] = curVal;
-      curVal = this.steps[i].lookup(curVal, NONE);
-      if (curVal === NONE) return root;
-    }
-    let newVal = v;
-    for (let i = this.steps.length - 1; i >= 0; i--) {
-      newVal = this.steps[i].setValue(intermediates[i], newVal);
-      intermediates[i] = newVal;
-    }
-    return newVal;
+    if (this.steps.length === 0) return v;
+    return (0, immer_exports.produce)(root, (draft) => {
+      let parent = draft;
+      for (let i = 0; i < this.steps.length - 1; i++) {
+        parent = this.steps[i].lookup(parent, NONE);
+        if (parent === NONE) return;
+      }
+      this.steps.at(-1).setDraftValue(parent, v);
+    });
   }
   buildStack(stack) {
     let prev = stack.it;
@@ -519,7 +597,8 @@ function sizeOf(v) {
   const s = v.size;
   if (typeof s === "number") return s;
   const l = v.length;
-  return typeof l === "number" ? l : null;
+  if (typeof l === "number") return l;
+  return isPlainObject(v) ? Object.keys(v).length : null;
 }
 var predTruthy = (v) => {
   const n = sizeOf(v);
@@ -530,7 +609,7 @@ var PREDICATES = {
   "truthy?": { name: "truthy?", arity: 1, fn: predTruthy },
   "falsy?": { name: "falsy?", arity: 1, fn: (v) => !predTruthy(v) },
   "null?": { name: "null?", arity: 1, fn: (v) => v == null },
-  "equals?": { name: "equals?", arity: 2, fn: (a, b) => is(a, b) }
+  "equals?": { name: "equals?", arity: 2, fn: (a, b) => Object.is(a, b) }
 };
 function parseToken(s, px) {
   const c0 = s.charCodeAt(0);
@@ -616,20 +695,28 @@ function parseMacroAttr(s, px) {
   return _parseSingle(s, px, G_ALL);
 }
 function parseReceiveHandler(s, px) {
-  return _parseHandler(s, px, "receive", true, true);
+  return _parseHandler(s, px, "receive", true, true, false);
 }
 function parseAlterHandler(s, px) {
-  const r = _parseHandler(s, px, "alter", false, false);
+  const r = _parseHandler(s, px, "alter", false, false, true);
   return r === null ? null : r.handlerVal;
 }
-function _parseHandler(s, px, namespace, allowArgs, report) {
+function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
   const tokens = tokenizeValue(s.trim());
   const headTok = tokens[0] ?? "";
   const head = headTok === "" ? null : parseToken(headTok, px);
   const hk = kindOf(head);
   let handlerVal;
-  if (hk & K_METHOD) handlerVal = head;
-  else if (hk & K_NAME) handlerVal = new HandlerNameVal(head.name, namespace);
+  if (hk & K_METHOD && allowMethod) handlerVal = head;
+  else if (hk & K_METHOD) {
+    if (report)
+      px.onParseIssue("event-method-handler", {
+        name: head.name,
+        role: "handler-name",
+        value: headTok
+      });
+    return null;
+  } else if (hk & K_NAME) handlerVal = new HandlerNameVal(head.name, namespace);
   else {
     if (report) px.onParseIssue("bad-value", { role: "handler-name", value: headTok });
     return null;
@@ -843,7 +930,7 @@ var BindMemberVal = class extends BindVal {
   }
   eval(stack) {
     const v = stack.lookupBind(this.name);
-    return typeof v?.get === "function" ? v.get(this.member, null) : v?.[this.member] ?? null;
+    return seqGet(v, this.member, null);
   }
   toString() {
     return `@${this.name}.${this.member}`;
@@ -890,7 +977,7 @@ var SeqAccessVal = class extends RenderVal {
   }
   eval(stack) {
     const key = this.keyVal.eval(stack);
-    return this.seqVal.eval(stack)?.get(key, null);
+    return seqGet(this.seqVal.eval(stack), key, null);
   }
   toString() {
     return `${this.seqVal}[${this.keyVal}]`;
@@ -1170,9 +1257,6 @@ var IntentHandler = class {
   }
 };
 
-// src/renderer.js
-import { isIndexed, isKeyed } from "immutable";
-
 // src/cache.js
 var isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
 var NullDomCache = class {
@@ -1669,7 +1753,7 @@ var Renderer = class {
         this.cache.set(cachePath, cacheKey, dom);
       }
     };
-    if (keys) imKeysIter(seq, renderOne, keys);
+    if (keys) keysIter(seq, renderOne, keys);
     else
       getSeqInfo(seq)(
         seq,
@@ -1703,7 +1787,7 @@ var Renderer = class {
     return new VFragment([this._renderMetadata({ $: "Scope", nid }), dom]);
   }
 };
-var getSeqInfo = (seq) => isIndexed(seq) ? imIndexedIter : isKeyed(seq) ? imKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
+var getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
 var normalizeRange = (start, end, size) => {
   let s = start == null ? 0 : start < 0 ? size + start : start;
   let e = end == null ? size : end < 0 ? size + end : end;
@@ -1726,22 +1810,22 @@ var unpackLoopResult = (result, seq) => {
   const r = result ?? {};
   return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end, keys: r.keys };
 };
-var imKeysIter = (seq, visit, keys) => {
-  const attrName = isIndexed(seq) ? "si" : "sk";
-  for (const key of keys) visit(key, seq.get(key), attrName);
+var keysIter = (seq, visit, keys) => {
+  const attrName = isIndexedSeq(seq) ? "si" : "sk";
+  for (const key of keys) visit(key, seqGet(seq, key), attrName);
 };
 var makeLoopCtx = (stack, filter) => ({
   lookup: (name) => stack.lookupBind(name),
   filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
 });
-var imIndexedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seq.size);
-  for (let i = s; i < e; i++) visit(i, seq.get(i), "si");
+var nativeIndexedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seqSize(seq));
+  for (let i = s; i < e; i++) visit(i, seq[i], "si");
 };
-var imKeyedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seq.size);
+var nativeKeyedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seqSize(seq));
   let i = 0;
-  for (const [k, v] of seq.toSeq().entries()) {
+  for (const [k, v] of seqEntries(seq)) {
     if (i >= e) break;
     if (i >= s) visit(k, v, "sk");
     i++;
@@ -2261,7 +2345,7 @@ var IterInfo = class {
   // { key, value }, then run @enrich-with (with @loop-with's iterData) if any.
   enrichBinds(stack, key) {
     const { seq, filter, loopWith, enricher } = this.eval(stack);
-    const value = seq?.get ? seq.get(key, null) : null;
+    const value = seqGet(seq, key, null);
     const binds = { key, value };
     if (enricher) {
       const { iterData } = unpackLoopResult(
@@ -2759,12 +2843,12 @@ var Stack = class _Stack {
     const provide = this.comps.getCompFor(this.it)?.provide;
     if (provide == null) return this;
     const dynObj = {};
-    let has2 = false;
+    let has = false;
     for (const k in provide) {
       dynObj[provide[k].symbol] = provide[k].val.eval(this);
-      has2 = true;
+      has = true;
     }
-    if (!has2) return this;
+    if (!has) return this;
     const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
     const { comps, it, binds, views, viewsId, ctx } = this;
     return new _Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
@@ -2835,6 +2919,316 @@ var Stack = class _Stack {
   }
 };
 
+// src/oo.js
+var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
+var nullCoercer = (v) => v;
+var isPlainObject2 = (v) => {
+  if (v === null || typeof v !== "object") return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+function defaultToData(v) {
+  if (v instanceof Map) return [...v.entries()];
+  if (v instanceof Set) return [...v.values()];
+  return v;
+}
+var Field = class {
+  constructor(type, name, typeCheck, coercer, defaultValue = null) {
+    this.type = type;
+    this.name = name;
+    this.typeCheck = typeCheck;
+    this.coercer = coercer;
+    this.checks = [];
+    this.defaultValue = defaultValue;
+  }
+  toDataDef() {
+    return { type: this.type, defaultValue: defaultToData(this.defaultValue) };
+  }
+  getFirstFailingCheck(v) {
+    if (!this.typeCheck.isValid(v)) return this.typeCheck;
+    for (const check3 of this.checks) if (!check3.isValid(v)) return check3;
+    return null;
+  }
+  isValid(v) {
+    return this.getFirstFailingCheck(v) === null;
+  }
+  addCheck(check3) {
+    this.checks.push(check3);
+    return this;
+  }
+  coerceOr(v, defaultValue = null) {
+    if (this.isValid(v)) return v;
+    const v1 = this.coercer(v);
+    return this.isValid(v1) ? v1 : defaultValue;
+  }
+  coerceOrDefault(v) {
+    return this.coerceOr(v, this.defaultValue);
+  }
+};
+var Check = class {
+  isValid(_v) {
+    return true;
+  }
+  getMessage(_v) {
+    return "Invalid";
+  }
+};
+var CheckTypeAny = class extends Check {
+};
+var CHECK_TYPE_ANY = new CheckTypeAny();
+var FnCheck = class extends Check {
+  constructor(isValidFn, getMessageFn) {
+    super();
+    this._isValid = isValidFn;
+    this._getMessage = getMessageFn;
+  }
+  isValid(v) {
+    return this._isValid(v);
+  }
+  getMessage(v) {
+    return this._getMessage(v);
+  }
+};
+var check = (fn, message) => new FnCheck(fn, () => message);
+var CHECK_TYPE_INT = check(Number.isInteger, "Integer expected");
+var CHECK_TYPE_FLOAT = check(Number.isFinite, "Float expected");
+var CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
+var CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
+var CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
+var CHECK_TYPE_OBJECT = check(isPlainObject2, "Plain object expected");
+var CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
+var CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
+var FieldBool = class extends Field {
+  constructor(name, defaultValue = false) {
+    super("bool", name, CHECK_TYPE_BOOL, (v) => !!v, defaultValue);
+  }
+};
+var FieldAny = class extends Field {
+  constructor(name, defaultValue = null) {
+    super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
+  }
+  toDataDef() {
+    return { type: getTypeName(this.defaultValue) ?? "any", defaultValue: this.defaultValue };
+  }
+};
+var FieldString = class extends Field {
+  constructor(name, defaultValue = "") {
+    super("text", name, CHECK_TYPE_STRING, (v) => v?.toString?.() ?? "", defaultValue);
+  }
+};
+var FieldInt = class extends Field {
+  constructor(name, defaultValue = 0) {
+    super(
+      "int",
+      name,
+      CHECK_TYPE_INT,
+      (v) => Number.isFinite(v) ? Math.trunc(v) : null,
+      defaultValue
+    );
+  }
+};
+var FieldFloat = class extends Field {
+  constructor(name, defaultValue = 0) {
+    super("float", name, CHECK_TYPE_FLOAT, (_) => null, defaultValue);
+  }
+};
+var getTypeName = (v) => v?.constructor?.getMetaClass?.()?.name;
+var CheckTypeName = class {
+  constructor(typeName) {
+    this.typeName = typeName;
+  }
+  isValid(v) {
+    return getTypeName(v) === this.typeName;
+  }
+  getMessage(v) {
+    return `Expected "${this.typeName}", got "${getTypeName(v)}"`;
+  }
+};
+var FieldComp = class extends Field {
+  constructor(type, name, args) {
+    super(type, name, new CheckTypeName(type), nullCoercer, null);
+    this.args = args;
+  }
+  toDataDef() {
+    return { component: this.type, args: this.args };
+  }
+};
+var FieldList = class extends Field {
+  constructor(name, defaultValue = []) {
+    super("list", name, CHECK_TYPE_LIST, (v) => Array.isArray(v) ? [...v] : null, defaultValue);
+  }
+};
+var FieldObject = class extends Field {
+  constructor(name, defaultValue = {}) {
+    super(
+      "object",
+      name,
+      CHECK_TYPE_OBJECT,
+      (v) => isPlainObject2(v) ? { ...v } : null,
+      defaultValue
+    );
+  }
+};
+var FieldMap = class extends Field {
+  constructor(name, defaultValue = /* @__PURE__ */ new Map()) {
+    super(
+      "map",
+      name,
+      CHECK_TYPE_MAP,
+      (v) => {
+        if (v instanceof Map) return new Map(v);
+        if (Array.isArray(v) || isPlainObject2(v))
+          return new Map(Array.isArray(v) ? v : Object.entries(v));
+        return null;
+      },
+      defaultValue
+    );
+  }
+};
+var FieldSet = class extends Field {
+  constructor(name, defaultValue = /* @__PURE__ */ new Set()) {
+    super(
+      "set",
+      name,
+      CHECK_TYPE_SET,
+      (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null,
+      defaultValue
+    );
+  }
+};
+function mkCompField(field, scope, args) {
+  const Comp = scope?.lookupComponent(field.type) ?? null;
+  if (Comp === null)
+    console.warn(
+      scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`
+    );
+  return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
+}
+var ClassBuilder = class {
+  constructor(name) {
+    this.name = name;
+    this.fields = {};
+    this.compFields = /* @__PURE__ */ new Set();
+    this._methods = {};
+    this._statics = {};
+  }
+  build() {
+    const { name, fields, compFields, _methods } = this;
+    const defaults = Object.fromEntries(
+      Object.entries(fields).map(([fieldName, field]) => [fieldName, field.defaultValue])
+    );
+    const Class = {
+      [name]: class {
+        constructor(values = {}) {
+          Object.assign(this, defaults, values);
+        }
+      }
+    }[name];
+    Class[immer_exports.immerable] = true;
+    Object.assign(Class.prototype, _methods);
+    const metaClass = { fields, name, methods: _methods };
+    Object.assign(
+      Class,
+      {
+        getMetaClass: () => metaClass,
+        make(inArgs = {}, opts = {}) {
+          const args = {};
+          const scope = opts.scope ?? this.scope;
+          for (const key in inArgs) {
+            const field = fields[key];
+            if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
+            else if (field === void 0)
+              console.warn("extra argument to constructor:", name, key, inArgs);
+            else args[key] = field.coerceOrDefault(inArgs[key]);
+          }
+          for (const key of compFields)
+            if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
+          return (0, immer_exports.freeze)(new this(args), true);
+        }
+      },
+      this._statics
+    );
+    return Class;
+  }
+  methods(proto) {
+    for (const k in proto) this._methods[k] = proto[k];
+  }
+  statics(proto) {
+    for (const k in proto) this._statics[k] = proto[k];
+  }
+  addField(name, dval, FieldCls) {
+    const field = new FieldCls(name, dval);
+    this.fields[name] = field;
+    return field;
+  }
+  addCompField(name, type, args) {
+    const field = new FieldComp(type, name, args);
+    this.compFields.add(name);
+    this.fields[name] = field;
+    return field;
+  }
+};
+var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
+var fieldsByTypeName = {
+  text: FieldString,
+  int: FieldInt,
+  float: FieldFloat,
+  bool: FieldBool,
+  list: FieldList,
+  object: FieldObject,
+  map: FieldMap,
+  set: FieldSet,
+  any: FieldAny
+};
+function fieldFromDescriptor(name, value) {
+  const FieldCls = fieldsByTypeName[value.type] ?? FieldAny;
+  const probe = new FieldCls(name);
+  return [FieldCls, probe.coerceOr(value.defaultValue, probe.defaultValue)];
+}
+function classFromData(name, { fields = {}, methods, statics }) {
+  const b = new ClassBuilder(name);
+  for (const field in fields) {
+    const value = fields[field];
+    const type = typeof value;
+    if (type === "string") b.addField(field, value, FieldString);
+    else if (type === "number")
+      b.addField(field, value, Number.isInteger(value) ? FieldInt : FieldFloat);
+    else if (type === "boolean") b.addField(field, value, FieldBool);
+    else if (Array.isArray(value)) b.addField(field, [...value], FieldList);
+    else if (value instanceof Set) b.addField(field, new Set(value), FieldSet);
+    else if (value instanceof Map) b.addField(field, new Map(value), FieldMap);
+    else if (value?.type && Object.hasOwn(value, "defaultValue")) {
+      const [FieldCls, dval] = fieldFromDescriptor(field, value);
+      b.addField(field, dval, FieldCls);
+    } else if (value?.component && value?.args !== void 0)
+      b.addCompField(field, value.component, value.args);
+    else if (isPlainObject2(value)) b.addField(field, { ...value }, FieldObject);
+    else {
+      const FieldCls = value?.[FIELD_CLASS] ?? FieldAny;
+      b.addField(field, value, FieldCls);
+    }
+  }
+  if (methods) b.methods(methods);
+  if (statics) b.statics(statics);
+  return b.build();
+}
+function validateDraftFields(current, draft) {
+  const meta = current?.constructor?.getMetaClass?.();
+  if (!meta) return;
+  for (const [name, field] of Object.entries(meta.fields)) {
+    const value = draft[name];
+    if (field.isValid(value)) continue;
+    const coerced = field.coerceOr(value, BAD_VALUE);
+    if (coerced !== BAD_VALUE) draft[name] = coerced;
+    else {
+      console.warn(`invalid value for ${meta.name}.${name}`, value);
+      draft[name] = current[name];
+    }
+  }
+}
+Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
+var component = (opts) => Component.fromSpec(opts);
+
 // src/transactor.js
 var State = class {
   constructor(val) {
@@ -3022,10 +3416,10 @@ var Transaction = class {
   get observeName() {
     return null;
   }
-  callHandler(root, instance, comps) {
+  callHandler(root, instance, draft, comps) {
     const [handler, args] = this.getHandlerAndArgs(root, instance, comps);
     this._resolvedHandler = handler;
-    return handler.apply(instance, args);
+    return handler.apply(instance, [draft, ...args]);
   }
   getHandlerAndArgs(_root, _instance, _comps) {
     return null;
@@ -3034,12 +3428,16 @@ var Transaction = class {
   // the data's real location (the dispatch `this.path` keeps intermediates). A subclass
   // may override to supply a pre-resolved path (see ResponseEvent's pinned keys).
   getTransactionPath() {
-    return this.path.toTransactionPath();
+    return this.path.toTransactionPath().compact();
   }
   updateRootValue(curRoot, comps) {
     const txnPath = this.getTransactionPath();
     const curLeaf = txnPath.lookup(curRoot);
-    const newLeaf = this.callHandler(curRoot, curLeaf, comps);
+    const newLeaf = (0, immer_exports.produce)(curLeaf, (draft) => {
+      const result = this.callHandler(curRoot, curLeaf, draft, comps);
+      if (result === void 0 || result === draft) validateDraftFields(curLeaf, draft);
+      return result;
+    });
     this._before = curLeaf;
     this._after = newLeaf;
     this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
@@ -3846,61 +4244,6 @@ function collectAppClassesInSet(app) {
   return classes;
 }
 
-// index.js
-import {
-  Collection,
-  fromJS,
-  get,
-  getIn,
-  has,
-  hash,
-  hasIn,
-  is as is2,
-  isAssociative,
-  isCollection,
-  isImmutable,
-  isIndexed as isIndexed2,
-  isKeyed as isKeyed2,
-  isList,
-  isMap,
-  isMap as isMap2,
-  isOrdered,
-  isOrderedMap,
-  isOrderedMap as isOrderedMap2,
-  isOrderedSet,
-  isPlainObject,
-  isRecord,
-  isSeq,
-  isSet,
-  isStack,
-  isValueObject,
-  List as List2,
-  Map as Map2,
-  Map as Map3,
-  merge,
-  mergeDeep,
-  mergeDeepWith,
-  mergeWith,
-  OrderedMap as OrderedMap2,
-  OrderedMap as OrderedMap3,
-  OrderedSet,
-  PairSorting,
-  Range,
-  Record as Record2,
-  Repeat,
-  remove,
-  removeIn,
-  Seq,
-  Set as Set2,
-  Set as Set3,
-  Stack as Stack2,
-  set,
-  setIn,
-  update,
-  updateIn,
-  version
-} from "immutable";
-
 // src/on.js
 var OP_KINDS = ["send", "intent"];
 function phaseOps(phase) {
@@ -3927,390 +4270,11 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
   }
 }
 
-// src/oo.js
-import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
-var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
-var nullCoercer = (v) => v;
-var Field = class {
-  constructor(type, name, typeCheck, coercer, defaultValue = null) {
-    this.type = type;
-    this.name = name;
-    this.typeCheck = typeCheck;
-    this.coercer = coercer;
-    this.checks = [];
-    this.defaultValue = defaultValue;
-  }
-  toDataDef() {
-    const { type, defaultValue: dv } = this;
-    return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
-  }
-  getFirstFailingCheck(v) {
-    if (!this.typeCheck.isValid(v)) return this.typeCheck;
-    for (const check2 of this.checks) if (!check2.isValid(v)) return check2;
-    return null;
-  }
-  isValid(v) {
-    return this.getFirstFailingCheck(v) === null;
-  }
-  addCheck(check2) {
-    this.checks.push(check2);
-    return this;
-  }
-  coerceOr(v, defaultValue = null) {
-    if (this.isValid(v)) return v;
-    const v1 = this.coercer(v);
-    return this.isValid(v1) ? v1 : defaultValue;
-  }
-  coerceOrDefault(v) {
-    return this.coerceOr(v, this.defaultValue);
-  }
-  extendProtoForType(_proto, _uname) {
-  }
-  extendProto(proto) {
-    const { name } = this;
-    const uname = name[0].toUpperCase() + name.slice(1);
-    const setName = `set${uname}`;
-    const that = this;
-    proto[setName] = function(v) {
-      const v1 = that.coerceOr(v, BAD_VALUE);
-      if (v1 === BAD_VALUE) {
-        console.warn("invalid value", v);
-        return this;
-      }
-      return this.set(name, v1);
-    };
-    proto[`update${uname}`] = function(fn) {
-      return this[setName](fn(this.get(name)));
-    };
-    proto[`reset${uname}`] = function() {
-      return this.set(name, that.defaultValue);
-    };
-    this.extendProtoForType(proto, uname);
-  }
-};
-var Check = class {
-  isValid(_v) {
-    return true;
-  }
-  getMessage(_v) {
-    return "Invalid";
-  }
-};
-var CheckTypeAny = class extends Check {
-};
-var CHECK_TYPE_ANY = new CheckTypeAny();
-var FnCheck = class extends Check {
-  constructor(isValidFn, getMessageFn) {
-    super();
-    this._isValid = isValidFn;
-    this._getMessage = getMessageFn;
-  }
-  isValid(v) {
-    return this._isValid(v);
-  }
-  getMessage(v) {
-    return this._getMessage(v);
-  }
-};
-var CHECK_TYPE_INT = new FnCheck(
-  (v) => Number.isInteger(v),
-  () => "Integer expected"
-);
-var CHECK_TYPE_FLOAT = new FnCheck(
-  (v) => Number.isFinite(v),
-  () => "Float expected"
-);
-var CHECK_TYPE_BOOL = new FnCheck(
-  (v) => typeof v === "boolean",
-  () => "Boolean expected"
-);
-var CHECK_TYPE_STRING = new FnCheck(
-  (v) => typeof v === "string",
-  () => "String expected"
-);
-var CHECK_TYPE_LIST = new FnCheck(
-  (v) => List.isList(v),
-  () => "List expected"
-);
-var CHECK_TYPE_MAP = new FnCheck(
-  (v) => IMap.isMap(v),
-  () => "Map expected"
-);
-var CHECK_TYPE_OMAP = new FnCheck(
-  (v) => OrderedMap.isOrderedMap(v),
-  () => "OrderedMap expected"
-);
-var CHECK_TYPE_SET = new FnCheck(
-  (v) => ISet.isSet(v),
-  () => "Set expected"
-);
-var boolCoercer = (v) => !!v;
-var FieldBool = class extends Field {
-  constructor(name, defaultValue = false) {
-    super("bool", name, CHECK_TYPE_BOOL, boolCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    const { name } = this;
-    proto[`toggle${uname}`] = function() {
-      return this.set(name, !this.get(name, false));
-    };
-    proto[`set${uname}`] = function(v) {
-      return this.set(name, !!v);
-    };
-  }
-};
-var FieldAny = class extends Field {
-  constructor(name, defaultValue = null) {
-    super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
-  }
-  toDataDef() {
-    const { defaultValue: dv } = this;
-    const type = getTypeName(dv) ?? "any";
-    return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
-  }
-};
-var stringCoercer = (v) => v?.toString?.() ?? "";
-var FieldString = class extends Field {
-  constructor(name, defaultValue = "") {
-    super("text", name, CHECK_TYPE_STRING, stringCoercer, defaultValue);
-  }
-  extendProtoForType(proto, _uname) {
-    extendProtoSized(proto, this.name, "", "length");
-  }
-};
-var intCoercer = (v) => Number.isFinite(v) ? Math.trunc(v) : null;
-var FieldInt = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("int", name, CHECK_TYPE_INT, intCoercer, defaultValue);
-  }
-};
-var floatCoercer = (_) => null;
-var FieldFloat = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("float", name, CHECK_TYPE_FLOAT, floatCoercer, defaultValue);
-  }
-};
-var getTypeName = (v) => v?.constructor?.getMetaClass?.()?.name;
-var CheckTypeName = class {
-  constructor(typeName) {
-    this.typeName = typeName;
-  }
-  isValid(v) {
-    return getTypeName(v) === this.typeName;
-  }
-  getMessage(v) {
-    const got = getTypeName(v);
-    return `Expected "${this.typeName}", got "${got}"`;
-  }
-};
-var FieldComp = class extends Field {
-  constructor(type, name, args) {
-    super(type, name, new CheckTypeName(type), nullCoercer, null);
-    this.args = args;
-  }
-  toDataDef() {
-    return { component: this.typeName, args: this.args };
-  }
-};
-var NONE2 = /* @__PURE__ */ Symbol("NONE");
-function extendProtoForKeyed(proto, name, uname) {
-  extendProtoSized(proto, name, EMPTY_LIST);
-  proto[`setIn${uname}At`] = function(i, v) {
-    return this.set(name, this.get(name).set(i, v));
-  };
-  proto[`getIn${uname}At`] = function(i, dval) {
-    return this.get(name).get(i, dval);
-  };
-  proto[`updateIn${uname}At`] = function(i, fn) {
-    const col = this.get(name);
-    const v = col.get(i, NONE2);
-    if (v !== NONE2) return this.set(name, col.set(i, fn(v)));
-    console.warn("key", i, "not found in", name, col);
-    return this;
-  };
-  extendDeleteInAt(proto, name, `${uname}At`);
-}
-function extendDeleteInAt(proto, name, uname) {
-  proto[`deleteIn${uname}`] = function(v) {
-    return this.set(name, this.get(name).delete(v));
-  };
-  proto[`removeIn${uname}`] = proto[`deleteIn${uname}`];
-}
-var EMPTY_LIST = List();
-var listCoercer = (v) => Array.isArray(v) ? List(v) : null;
-var FieldList = class extends Field {
-  constructor(name, defaultValue = EMPTY_LIST) {
-    super("list", name, CHECK_TYPE_LIST, listCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    const { name } = this;
-    extendProtoForKeyed(proto, name, uname);
-    proto[`pushIn${uname}`] = function(v) {
-      return this.set(name, this.get(name).push(v));
-    };
-    proto[`insertIn${uname}At`] = function(i, v) {
-      return this.set(name, this.get(name).insert(i, v));
-    };
-  }
-};
-var imapCoercer = (v) => IMap(v);
-var FieldMap = class extends Field {
-  constructor(name, defaultValue = IMap()) {
-    super("map", name, CHECK_TYPE_MAP, imapCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    extendProtoForKeyed(proto, this.name, uname);
-  }
-};
-var omapCoercer = (v) => OrderedMap(v);
-var FieldOMap = class extends Field {
-  constructor(name, defaultValue = OrderedMap()) {
-    super("omap", name, CHECK_TYPE_OMAP, omapCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    extendProtoForKeyed(proto, this.name, uname);
-  }
-};
-function extendProtoSized(proto, name, defaultEmpty, propName = "size") {
-  proto[`${name}Len`] = function() {
-    return this.get(name, defaultEmpty)[propName];
-  };
-}
-var EMPTY_SET = ISet();
-var isetCoercer = (v) => Array.isArray(v) ? ISet(v) : v instanceof Set ? ISet(v) : null;
-var FieldSet = class extends Field {
-  constructor(name, defaultValue = EMPTY_SET) {
-    super("set", name, CHECK_TYPE_SET, isetCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    const { name } = this;
-    extendProtoSized(proto, name, EMPTY_SET);
-    proto[`addIn${uname}`] = function(v) {
-      return this.set(name, this.get(name).add(v));
-    };
-    extendDeleteInAt(proto, name, uname);
-    proto[`hasIn${uname}`] = function(v) {
-      return this.get(name).has(v);
-    };
-    proto[`toggleIn${uname}`] = function(v) {
-      const current = this.get(name);
-      return this.set(name, current.has(v) ? current.delete(v) : current.add(v));
-    };
-  }
-};
-function mkCompField(field, scope, args) {
-  const Comp = scope?.lookupComponent(field.type) ?? null;
-  if (Comp === null)
-    console.warn(
-      scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`
-    );
-  return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
-}
-var ClassBuilder = class {
-  constructor(name) {
-    const fields = {};
-    const compFields = /* @__PURE__ */ new Set();
-    this.name = name;
-    this.fields = fields;
-    this.compFields = compFields;
-    this._methods = {};
-    this._statics = {
-      make: function(inArgs = {}, opts = {}) {
-        const args = {};
-        const scope = opts.scope ?? this.scope;
-        for (const key in inArgs) {
-          const field = fields[key];
-          if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
-          else if (field === void 0)
-            console.warn("extra argument to constructor:", name, key, inArgs);
-          else args[key] = field.coerceOrDefault(inArgs[key]);
-        }
-        for (const key of compFields)
-          if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
-        return this(args);
-      }
-    };
-  }
-  build() {
-    const fieldVals = {};
-    const proto = {};
-    const { name, _methods, fields } = this;
-    for (const fieldName in fields) {
-      const field = fields[fieldName];
-      fieldVals[fieldName] = field.defaultValue;
-      field.extendProto(proto);
-    }
-    const Class = { [name]: Record(fieldVals, name) }[name];
-    Object.assign(Class.prototype, proto, _methods);
-    const metaClass = { fields, name, methods: _methods };
-    Object.assign(Class, this._statics, { getMetaClass: () => metaClass });
-    return Class;
-  }
-  methods(proto) {
-    for (const k in proto) this._methods[k] = proto[k];
-  }
-  statics(proto) {
-    for (const k in proto) this._statics[k] = proto[k];
-  }
-  addField(name, dval, FieldCls) {
-    const field = new FieldCls(name, dval);
-    this.fields[name] = field;
-    return field;
-  }
-  addCompField(name, type, args) {
-    const field = new FieldComp(type, name, args);
-    this.compFields.add(name);
-    this.fields[name] = field;
-    return field;
-  }
-};
-var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
-var fieldsByTypeName = {
-  text: FieldString,
-  int: FieldInt,
-  float: FieldFloat,
-  bool: FieldBool,
-  list: FieldList,
-  map: FieldMap,
-  omap: FieldOMap,
-  set: FieldSet,
-  any: FieldAny
-};
-function classFromData(name, { fields = {}, methods, statics }) {
-  const b = new ClassBuilder(name);
-  for (const field in fields) {
-    const value = fields[field];
-    const type = typeof value;
-    if (type === "string") b.addField(field, value, FieldString);
-    else if (type === "number") b.addField(field, value, FieldFloat);
-    else if (type === "boolean") b.addField(field, value, FieldBool);
-    else if (List.isList(value) || Array.isArray(value)) b.addField(field, List(value), FieldList);
-    else if (ISet.isSet(value) || value instanceof Set) b.addField(field, ISet(value), FieldSet);
-    else if (OrderedMap.isOrderedMap(value)) b.addField(field, value, FieldOMap);
-    else if (value?.type && value?.defaultValue !== void 0) {
-      const Field2 = fieldsByTypeName[value.type] ?? FieldAny;
-      b.addField(field, new Field2().coerceOr(value.defaultValue), Field2);
-    } else if (value?.component && value?.args !== void 0)
-      b.addCompField(field, value.component, value.args);
-    else if (IMap.isMap(value) || value?.constructor === Object)
-      b.addField(field, IMap(value), FieldMap);
-    else {
-      const Field2 = value?.[FIELD_CLASS] ?? FieldAny;
-      b.addField(field, value, Field2);
-    }
-  }
-  if (methods) b.methods(methods);
-  if (statics) b.statics(statics);
-  return b.build();
-}
-Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
-var component = (opts) => Component.fromSpec(opts);
-
 // index.js
 var css = String.raw;
 var html = String.raw;
 var macro = (defaults, rawView) => new Macro(defaults, rawView);
-function check(_app) {
+function check2(_app) {
   return { error: 0, warn: 0, hint: 0, dummyCheck: true };
 }
 async function test(_opts) {
@@ -4343,74 +4307,23 @@ async function compileClassesToStyleText(app, compileClasses, Ctx = ParseCtxClas
   return await compileClasses(Array.from(collectAppClassesInSet(app)));
 }
 export {
-  Collection,
   FIELD_CLASS,
-  Map3 as IMap,
-  Set3 as ISet,
-  List2 as List,
-  Map2 as Map,
-  OrderedMap3 as OMap,
-  OrderedMap2 as OrderedMap,
-  OrderedSet,
   PASS,
-  PairSorting,
   ParseContext,
-  Range,
-  Record2 as Record,
-  Repeat,
   SEQ_INFO,
-  Seq,
-  Set2 as Set,
-  Stack2 as Stack,
-  check,
+  check2 as check,
   collectIterBindings,
   compileClassesToStyle,
   compileClassesToStyleText,
   component,
   css,
   dispatchPhase,
-  fromJS,
-  get,
-  getIn,
-  has,
-  hasIn,
-  hash,
   html,
   injectCss,
-  is2 as is,
-  isAssociative,
-  isCollection,
-  isMap2 as isIMap,
-  isImmutable,
-  isIndexed2 as isIndexed,
-  isKeyed2 as isKeyed,
-  isList,
-  isMap,
-  isOrderedMap2 as isOMap,
-  isOrdered,
-  isOrderedMap,
-  isOrderedSet,
-  isPlainObject,
-  isRecord,
-  isSeq,
-  isSet,
-  isStack,
-  isValueObject,
   macro,
-  merge,
-  mergeDeep,
-  mergeDeepWith,
-  mergeWith,
   phaseOps,
-  remove,
-  removeIn,
   resolveArgs,
   rootDispatcher,
-  set,
-  setIn,
   test,
-  tutuca,
-  update,
-  updateIn,
-  version
+  tutuca
 };