animl 0.0.0-stage → 0.1.0

package/packages/core/src/random.d.ts

@@ -0,0 +1,11 @@
+import type { Player } from './player.js';
+/** Portable uint32 LCG. Legacy callers keep their own default stream; an explicit seed unifies it. */
+export declare class RandomSource {
+    static current?: RandomSource;
+    seed?: number;
+    streams: Record<string, number>;
+    reset(seed: number): void;
+    next(legacy?: number, stream?: string): number;
+}
+/** Install once on the shared Player class, including independently loaded optional bundles. */
+export declare function installRandom(PlayerClass: typeof Player): void;

package/packages/core/src/random.js

@@ -0,0 +1,43 @@
+class RandomSource {
+  static current;
+  seed;
+  streams = {};
+  reset(seed) {
+    this.seed = seed >>> 0;
+    this.streams = {};
+  }
+  next(legacy = 1, stream = "convert") {
+    const key = this.seed === void 0 ? stream : "";
+    const n = Math.imul(1664525, this.streams[key] ?? this.seed ?? legacy) + 1013904223 >>> 0;
+    this.streams[key] = n;
+    return n / 4294967296;
+  }
+}
+function installRandom(PlayerClass) {
+  if (Object.getOwnPropertyDescriptor(PlayerClass.prototype, "randomSource")) return;
+  const sources = /* @__PURE__ */ new WeakMap();
+  Object.defineProperty(PlayerClass.prototype, "randomSource", {
+    get() {
+      let source = sources.get(this);
+      if (!source) {
+        sources.set(this, source = new RandomSource());
+        if (this.seed !== void 0) source.reset(this.seed);
+      }
+      return source.seed === void 0 && RandomSource.current ? RandomSource.current : source;
+    }
+  });
+  const step = PlayerClass.prototype.step;
+  PlayerClass.prototype.step = function(...args) {
+    const previous = RandomSource.current;
+    if (this.randomSource.seed !== void 0) RandomSource.current = this.randomSource;
+    try {
+      return step.apply(this, args);
+    } finally {
+      RandomSource.current = previous;
+    }
+  };
+}
+export {
+  RandomSource,
+  installRandom
+};

package/packages/core/src/registry.d.ts

@@ -0,0 +1,106 @@
+export type ValueType = 'point' | 'number' | 'bool' | 'color' | 'path' | 'int' | 'uint' | 'string' | 'reference';
+export interface Prop {
+    type: ValueType;
+    feature?: string;
+    discrete?: boolean;
+    /** Default when the document omits it; undefined means the key is required. */
+    def?: number | boolean | string;
+    /** Range the resolved value is clamped to, and the document value must lie in. */
+    min?: number;
+    max?: number;
+    /** The AniML attribute name, where it differs from the .ani key (spec/ANIML.md §3). */
+    markup?: string;
+}
+/** Animatable properties every node has (spec §4). */
+export declare const COMMON: Record<string, Prop>;
+export declare const NODE_TYPES: readonly ["group", "path", "circle", "rect", "arc"];
+export type NodeType = (typeof NODE_TYPES)[number];
+export declare const PAINTED: readonly NodeType[];
+/** Animatable properties per node type. */
+export declare const OWN: Record<NodeType, Record<string, Prop>>;
+/** Animatable paint fields, addressed `<id>.fill.<field>` / `<id>.stroke.<field>`. */
+export declare const PAINT: Record<'fill' | 'stroke', Record<string, Prop>>;
+/** One entry defines both spellings: `markup` is the AniML name where it differs from the key. */
+export type Shape = ({
+    k: 'str';
+    re?: RegExp;
+    of?: readonly string[];
+} | {
+    k: 'num';
+    min?: number;
+    max?: number;
+    gt?: number;
+    int?: boolean;
+} | {
+    k: 'bool';
+} | {
+    k: 'any';
+} | {
+    k: 'arr';
+    of: Shape;
+    min?: number;
+} | {
+    k: 'tup';
+    of: Shape[];
+    min: number;
+} | {
+    k: 'obj';
+    p: Record<string, Shape>;
+    req?: string[];
+    reserved?: Record<string, string>;
+} | {
+    k: 'map';
+    of: Shape;
+    key?: RegExp;
+} | {
+    k: 'alt';
+    of: Shape[];
+} | {
+    k: 'node';
+}) & {
+    markup?: string;
+    feature?: string;
+    element?: string;
+    default?: unknown;
+    format?: Shape;
+    schema?: Shape;
+    description?: string;
+};
+/** The AniML attribute name of a key: its `markup` name, or the key itself. */
+export declare const markupName: (s: Shape | Prop | undefined, key: string) => string;
+export declare const NAME: RegExp;
+export declare const DOC_NAME: RegExp;
+export declare const FILL: Shape;
+export declare const STROKE: Shape;
+/** Non-animatable keys per node type (beyond `id`, `type`, `pivot`). */
+export declare const STATIC: Record<NodeType, Record<string, Shape>>;
+export type ObjShape = Extract<Shape, {
+    k: 'obj';
+}>;
+/** Structural markup supplied by modules; field names still come from shapes. */
+export interface ElementForm {
+    /** A keyed root resource authored as a child element. */
+    root?: string;
+    mapKey?: string;
+    shape: ObjShape;
+    values?: Record<string, string>;
+    target?: {
+        attribute: string;
+        default: string;
+        choices: string[];
+        array?: boolean;
+        mapKey?: string;
+        wrapper?: string;
+        /** Object path below the selected target (for example fill.feather). */
+        path?: string[];
+    };
+}
+export declare const ELEMENTS: Record<string, ElementForm>;
+/** The object shape of one node type. */
+export declare function nodeShape(type: NodeType): ObjShape;
+export declare const TRANSITION: Shape;
+export declare const STATE: Shape;
+export declare const TIMELINE: Shape;
+/** The whole document. */
+export declare const DOC: Shape;
+export declare function resetRegistry(): void;

package/packages/core/src/registry.js

@@ -0,0 +1,234 @@
+import { text } from "./diag.js";
+const num = (def, min, max) => ({ type: "number", def, min, max });
+const COMMON = {
+  x: num(0),
+  y: num(0),
+  rotate: num(0),
+  scale: num(1),
+  scaleX: num(1),
+  scaleY: num(1),
+  opacity: num(1, 0, 1),
+  visible: { type: "bool", def: true }
+};
+const NODE_TYPES = ["group", "path", "circle", "rect", "arc"];
+const PAINTED = ["path", "circle", "rect", "arc"];
+const OWN = {
+  group: {},
+  path: {},
+  circle: { r: num(void 0, 0) },
+  rect: {
+    w: { ...num(void 0, 0), markup: "width" },
+    h: { ...num(void 0, 0), markup: "height" },
+    rx: num(0, 0)
+  },
+  arc: { r: num(void 0, 0), from: num(), to: num() }
+};
+const PAINT = {
+  fill: { color: { type: "color", markup: "fill" } },
+  stroke: {
+    color: { type: "color", markup: "stroke" },
+    width: { ...num(1, 0), markup: "stroke-width" },
+    trimStart: num(0, 0, 1),
+    trimEnd: num(1, 0, 1),
+    trimOffset: num(0)
+  }
+};
+const markupName = (s, key) => s?.markup ?? key;
+const NAME = /^[a-z][a-zA-Z0-9-]*$/;
+const DOC_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const S = (re, of) => ({ k: "str", re, of });
+const N = (o = {}) => ({
+  k: "num",
+  ...o
+});
+const B = { k: "bool" };
+const A = (of, min) => ({ k: "arr", of, min });
+const T = (of, min = of.length) => ({ k: "tup", of, min });
+const O = (p, req, reserved) => ({
+  k: "obj",
+  p,
+  req,
+  reserved
+});
+const MAP = (of, key) => ({ k: "map", of, key });
+const ALT = (...of) => ({ k: "alt", of });
+const VEC2 = T([N(), N()]);
+const named = (s, markup) => ({ ...s, markup });
+const NAMES = ALT(S(NAME), A(S(NAME), 1));
+const propShape = (p) => {
+  const s = p.type === "bool" ? B : p.type === "color" || p.type === "path" ? S() : N({ min: p.min, max: p.max });
+  return { ...s, markup: p.markup, feature: p.feature };
+};
+const FILL = O(
+  {
+    color: propShape(PAINT.fill.color),
+    rule: named(S(void 0, ["nonzero", "evenodd"]), "fill-rule")
+  },
+  ["color"]
+);
+const STROKE = O(
+  {
+    color: propShape(PAINT.stroke.color),
+    width: propShape(PAINT.stroke.width),
+    cap: named(S(void 0, ["butt", "round", "square"]), "stroke-linecap"),
+    join: named(S(void 0, ["miter", "round", "bevel"]), "stroke-linejoin"),
+    trimStart: propShape(PAINT.stroke.trimStart),
+    trimEnd: propShape(PAINT.stroke.trimEnd),
+    trimOffset: N()
+  },
+  ["color"]
+);
+const STATIC = {
+  group: { children: A({ k: "node" }) },
+  path: { glyph: S(NAME), subpaths: A(N({ min: 0, int: true }), 1), d: S() },
+  circle: { center: named(VEC2, "cx cy") },
+  rect: { x0: N(), y0: N() },
+  arc: { center: named(VEC2, "cx cy") }
+};
+const ELEMENTS = {};
+const nodeShapes = /* @__PURE__ */ new Map();
+function nodeShape(type) {
+  let s = nodeShapes.get(type);
+  if (!s) {
+    const p = { id: S(NAME), type: S(void 0, NODE_TYPES), pivot: VEC2 };
+    for (const [k, v] of Object.entries({ ...COMMON, ...OWN[type] })) p[k] = propShape(v);
+    Object.assign(p, STATIC[type]);
+    if (PAINTED.includes(type))
+      Object.assign(p, { fill: FILL, stroke: STROKE, knockout: N({ min: 0 }) });
+    const req = [
+      "id",
+      "type",
+      ...Object.keys(OWN[type]).filter((k) => OWN[type][k].def === void 0)
+    ];
+    if (type === "circle" || type === "arc") req.push("center");
+    if (type === "rect") req.push("x0", "y0");
+    s = { k: "obj", p, req };
+    nodeShapes.set(type, s);
+  }
+  return s;
+}
+const VALUE = ALT(N(), B, S(), A({ k: "any" }));
+const TRANSITION = O(
+  { when: S(), to: S(NAME), blend: N({ min: 0 }), ease: S(), interruptible: B },
+  ["when", "to"]
+);
+const STATE = O(
+  { pose: MAP(VALUE), play: S(NAME), speed: N({ gt: 0 }), emit: S(NAME), on: A(TRANSITION) },
+  void 0
+);
+const LAYER = O({ initial: S(NAME), states: MAP(STATE, NAME) }, ["initial", "states"], {
+  mode: text("additive layers arrive in anima 0.2")
+});
+const TIMELINE = O(
+  {
+    duration: N({ gt: 0 }),
+    loop: S(void 0, ["once", "loop", "pingpong"]),
+    reducedMotion: S(void 0, ["play", "end", "skip"]),
+    tracks: MAP(A(T([N(), VALUE, S()], 2))),
+    events: A(T([N(), S(NAME)]))
+  },
+  ["duration", "tracks"],
+  { colorSpace: text("colour interpolation spaces arrive in anima 0.2") }
+);
+const DOC = O(
+  {
+    $schema: S(),
+    anima: S(),
+    name: S(DOC_NAME),
+    title: S(),
+    grid: N({ gt: 0 }),
+    viewBox: T([N(), N(), N({ gt: 0 }), N({ gt: 0 })]),
+    requires: A(S()),
+    meta: { k: "any" },
+    colors: MAP(S(), NAME),
+    glyphs: MAP(O({ source: S(), pick: S(), sha256: S(/^[0-9a-f]{64}$/), d: S() }, ["d"]), NAME),
+    a11y: O({
+      role: S(void 0, ["button", "switch", "img"]),
+      label: S(),
+      activate: S(NAME),
+      pressed: S(NAME),
+      held: S(NAME)
+    }),
+    inputs: MAP(
+      O(
+        {
+          type: named(S(void 0, ["bool", "number", "trigger"]), "element name"),
+          default: ALT(N(), B),
+          min: N(),
+          max: N(),
+          buffer: N({ min: 0 })
+        },
+        ["type"]
+      ),
+      NAME
+    ),
+    hit: O({
+      circle: T([N(), N(), N({ gt: 0 })]),
+      rect: T([N(), N(), N({ gt: 0 }), N({ gt: 0 })])
+    }),
+    nodes: A({ k: "node" }, 1),
+    timelines: MAP(TIMELINE, NAME),
+    machine: O({ layers: MAP(LAYER, NAME) }, ["layers"]),
+    listeners: A(
+      O(
+        {
+          on: S(void 0, ["enter", "leave", "down", "up", "click", "move"]),
+          target: S(NAME),
+          hitPadding: N({ min: 0 }),
+          fire: NAMES,
+          set: MAP(ALT(N(), B, { ...S(), feature: "bind" }), NAME),
+          toggle: NAMES,
+          emit: S(NAME)
+        },
+        ["on"]
+      )
+    )
+  },
+  ["anima", "name", "grid", "nodes"]
+);
+const baseTables = [
+  OWN,
+  STATIC,
+  ...Object.values(OWN),
+  ...Object.values(STATIC),
+  ...Object.values(PAINT),
+  DOC.p,
+  LAYER.p,
+  DOC.p.listeners.of.p,
+  TIMELINE.p,
+  STATE.p,
+  TRANSITION.p,
+  FILL.p,
+  STROKE.p
+].map((table) => [table, { ...table }]);
+const baseTypes = NODE_TYPES.length;
+const basePainted = PAINTED.length;
+function resetRegistry() {
+  for (const [table, base] of baseTables) {
+    for (const key of Object.keys(table)) Reflect.deleteProperty(table, key);
+    Object.assign(table, base);
+  }
+  NODE_TYPES.splice(baseTypes);
+  PAINTED.splice(basePainted);
+  nodeShapes.clear();
+}
+export {
+  COMMON,
+  DOC,
+  DOC_NAME,
+  ELEMENTS,
+  FILL,
+  NAME,
+  NODE_TYPES,
+  OWN,
+  PAINT,
+  PAINTED,
+  STATE,
+  STATIC,
+  STROKE,
+  TIMELINE,
+  TRANSITION,
+  markupName,
+  nodeShape,
+  resetRegistry
+};

package/packages/core/src/schema.d.ts

@@ -0,0 +1,4 @@
+type JSONSchema = Record<string, unknown>;
+/** The JSON Schema of a `.ani` document. */
+export declare function jsonSchema(): JSONSchema;
+export {};

package/packages/core/src/schema.js

@@ -0,0 +1,91 @@
+import { DOC, NODE_TYPES, nodeShape } from "./registry.js";
+const COMMENT = { $comment: { type: "string" } };
+function toSchema(s) {
+  return {
+    // seam(P8-1): module-owned discriminated validation has a precise tooling schema.
+    ...shapeSchema(s.schema ?? s),
+    ...s.feature && { feature: s.feature },
+    ...s.default !== void 0 && { default: s.default }
+  };
+}
+function shapeSchema(s) {
+  switch (s.k) {
+    case "str":
+      return {
+        type: "string",
+        ...s.re && { pattern: s.re.source },
+        ...s.of && { enum: [...s.of] }
+      };
+    case "num":
+      return {
+        type: s.int ? "integer" : "number",
+        ...s.min !== void 0 && { minimum: s.min },
+        ...s.max !== void 0 && { maximum: s.max },
+        ...s.gt !== void 0 && { exclusiveMinimum: s.gt }
+      };
+    case "bool":
+      return { type: "boolean" };
+    case "any":
+      return {};
+    case "arr":
+      return { type: "array", items: toSchema(s.of), ...s.min && { minItems: s.min } };
+    case "tup":
+      return {
+        type: "array",
+        prefixItems: s.of.map(toSchema),
+        items: false,
+        minItems: s.min,
+        maxItems: s.of.length
+      };
+    case "obj": {
+      const properties = { ...COMMENT };
+      for (const [k, v] of Object.entries(s.p)) properties[k] = toSchema(v);
+      return {
+        type: "object",
+        properties,
+        ...s.req?.length && { required: s.req },
+        additionalProperties: false
+      };
+    }
+    case "map":
+      return {
+        type: "object",
+        properties: COMMENT,
+        ...s.key && { propertyNames: { pattern: `^\\$comment$|${s.key.source}` } },
+        additionalProperties: toSchema(s.of)
+      };
+    case "alt":
+      return { anyOf: s.of.map(toSchema) };
+    case "node":
+      return { $ref: "#/$defs/node" };
+  }
+}
+function jsonSchema() {
+  const root = toSchema(DOC);
+  const properties = root.properties;
+  properties.nodes = { ...properties.nodes, minItems: 0 };
+  root.if = {
+    required: ["requires"],
+    properties: { requires: { type: "array", contains: { const: "components" } } }
+  };
+  root.else = { properties: { nodes: { type: "array", minItems: 1 } } };
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://github.com/MRoiban/anima/spec/schema/ani.schema.json",
+    title: "Anima document (.ani) 0.1",
+    description: "Generated from packages/core/src/registry.ts. The loader adds semantic checks (spec \xA711.3) a schema cannot express.",
+    ...root,
+    $defs: {
+      node: {
+        oneOf: NODE_TYPES.map((t) => {
+          const s = toSchema(nodeShape(t));
+          s.properties.type = { const: t };
+          return s;
+        })
+      }
+    }
+  };
+}
+export {
+  jsonSchema
+};

package/packages/core/src/script-events.d.ts

@@ -0,0 +1 @@
+export declare function captureStep<T>(op: () => T): T;

package/packages/core/src/script-events.js

@@ -0,0 +1,27 @@
+import { MachinePolicy } from "../../../modules/machine/core/runtime.js";
+import { crossings } from "../../../modules/motion/core/clock.js";
+import { capture, occurrence, stampEntryEvent } from "./event-capture.js";
+function captureStep(op) {
+  const original = MachinePolicy.prototype.events;
+  MachinePolicy.prototype.events = function(t, a, b, closed, layer, out, speed, run, source) {
+    const before = out.length;
+    original.call(this, t, a, b, closed, layer, out, speed, run, source);
+    if (!this.base) {
+      const timed = [];
+      crossings(t, a * speed, b * speed, closed, layer, timed, t.loop, source);
+      for (let i = before; i < out.length; i++) {
+        const e = out[i];
+        e[occurrence] = timed[i - before]?.[occurrence] ?? 0;
+        if (closed) stampEntryEvent(e, (e[occurrence] - 1) * (b - a));
+      }
+    }
+  };
+  try {
+    return capture(op);
+  } finally {
+    MachinePolicy.prototype.events = original;
+  }
+}
+export {
+  captureStep
+};

package/packages/core/src/script-writes.d.ts

@@ -0,0 +1,12 @@
+import type { Player } from './player.js';
+export interface DataWrite {
+    path: string;
+    before: unknown;
+    value: unknown;
+    writer: string;
+}
+/** Install on an isolated replay player only. Restore shared compiled action arrays afterwards. */
+export declare function traceWrites(player: Player, emit: (write: DataWrite) => void): {
+    run: (_label: string, op: () => void) => void;
+    close(): void;
+};

package/packages/core/src/script-writes.js

@@ -0,0 +1,106 @@
+import { compiledActions } from "../../../modules/machine/core/types.js";
+import { dataState } from "../../../modules/data/core/storage.js";
+function traceWrites(player, emit) {
+  let writer = "runtime input";
+  const undo = [];
+  const scope = dataState(player);
+  if (!scope) return { run: (_label, op) => op(), close() {
+  } };
+  const mark = (label) => {
+    const set2 = [];
+    set2.map = ((...args) => {
+      writer = label;
+      return Array.prototype.map.apply(set2, args);
+    });
+    return { set: set2, fire: [], toggle: [], on: "", target: -1, pad: 0 };
+  };
+  const originalAct = player.act.bind(player);
+  player.act = (action) => {
+    const i = player.model.listeners.indexOf(action);
+    originalAct(mark(i < 0 ? writer : "listener: /listeners/" + i));
+    originalAct(action);
+  };
+  const set = player.set.bind(player), toggle = player.toggle.bind(player);
+  player.set = (name, value) => {
+    originalAct(mark(writer));
+    set(name, value);
+  };
+  player.toggle = (name) => {
+    originalAct(mark(writer));
+    toggle(name);
+  };
+  const api = player.data;
+  const enqueue = api.enqueue.bind(api);
+  api.enqueue = (op) => {
+    const label = writer;
+    enqueue(() => {
+      writer = label;
+      op();
+    });
+  };
+  const seen = /* @__PURE__ */ new WeakSet();
+  const observe = (object, path) => {
+    if (seen.has(object)) return;
+    seen.add(object);
+    for (const key of Object.keys(object)) {
+      let value = object[key];
+      const at = path + (path.endsWith(":") ? "" : ".") + key;
+      if (value && typeof value === "object") observe(value, at);
+      Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        get: () => value,
+        set: (next) => {
+          const stack = new Error().stack ?? "";
+          const source = stack.includes("/data/core/bindings.ts") ? "binding: " + stack.split("\n").find((line) => line.includes("/data/core/bindings.ts"))?.trim() : writer;
+          emit({ path: at, before: value, value: next, writer: source });
+          value = next;
+          if (next && typeof next === "object") observe(next, at);
+        }
+      });
+    }
+  };
+  for (const [name, values] of Object.entries(scope.instances)) observe(values, "$" + name + ":");
+  const actions = (action, label) => {
+    if (!action) return;
+    const set2 = action.set;
+    const map = set2.map;
+    set2.map = ((...args) => {
+      writer = label;
+      return map.apply(set2, args);
+    });
+    undo.push(() => {
+      set2.map = map;
+    });
+  };
+  const model = player.model;
+  for (const layer of model.layers)
+    for (const state of layer.states) {
+      const at = "/machine/layers/" + layer.name + "/states/" + state.name;
+      actions(state.entry, "state action: " + at + "/entry");
+      actions(state.exit, "state action: " + at + "/exit");
+      state.on.forEach((t, i) => actions(t.actions, "transition action: " + at + "/on/" + i));
+    }
+  const visit = (value, pointer) => {
+    if (!value || typeof value !== "object") return;
+    const action = compiledActions.get(
+      value
+    );
+    if (action) actions(action, "machine action: " + pointer);
+    for (const [key, child] of Object.entries(value))
+      visit(child, pointer + "/" + key.replaceAll("~", "~0").replaceAll("/", "~1"));
+  };
+  visit(model.doc.machine, "/machine");
+  return {
+    run(label, op) {
+      writer = label;
+      op();
+    },
+    close() {
+      for (const restore of undo.reverse()) restore();
+    }
+  };
+}
+export {
+  traceWrites
+};

package/packages/core/src/script.d.ts

@@ -0,0 +1,55 @@
+import { type CapturedEvent } from './event-capture.js';
+import { type Model } from './load.js';
+import { type AnimaEvent, Player } from './player.js';
+export interface Snapshot {
+    time: number;
+    values: Record<string, number | boolean | string | [number, number]>;
+    states: Record<string, string>;
+    events: AnimaEvent[];
+    settled: boolean;
+    data?: Record<string, unknown>;
+    semantics?: unknown;
+}
+export declare class ScriptError extends Error {
+    readonly code: string;
+    readonly pointer: string;
+    readonly hint: string;
+    readonly line: number;
+    constructor(message: string, line: number, code?: string);
+}
+export interface ScriptOptions {
+    reducedMotion?: boolean;
+    all?: boolean;
+    semantics?: boolean;
+    seed?: number;
+    /** Tooling events with absolute occurrence times and their declaring asset scope. */
+    onEvents?: (events: CapturedEvent[]) => void;
+}
+export interface ScriptDiagnostic {
+    code: string;
+    pointer: string;
+    message: string;
+    hint: string;
+    writer?: string[];
+}
+/** Persistent, tooling-only script interpreter. No browser runtime hooks are installed. */
+export declare function createScriptSession(model: Model, opts?: ScriptOptions): {
+    player: Player;
+    execute: (text: string) => {
+        snapshots: Snapshot[];
+        output: unknown[];
+        diagnostics: ScriptDiagnostic[];
+        stopped: boolean;
+    };
+    dataValues: (player?: Player) => Record<string, unknown>;
+    finish(): void;
+    readonly seed: number | undefined;
+};
+/** Run a script against a fresh player; assertion failures accumulate without aborting. */
+export declare function runScript(model: Model, text: string, opts?: ScriptOptions): {
+    player: Player;
+    snapshots: Snapshot[];
+    output: unknown[];
+    diagnostics: ScriptDiagnostic[];
+    stopped: boolean;
+};