animl 0.0.0-stage → 0.1.0

package/modules/data-artboard/core/index.js

@@ -0,0 +1,193 @@
+import { after } from "../manifest.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { compatible } from "./schema.js";
+import { entries } from "../capabilities/data-host-artboard/registry.js";
+function component(document, name) {
+  return { document, name };
+}
+function failure(code, path) {
+  throw Object.assign(
+    new Error(
+      V ? code === "artboard-model" ? "assigned artboard data model is incompatible with the placement model" : "invalid artboard value (" + code + ")" : code
+    ),
+    {
+      code,
+      pointer: "/data/" + path.replace(/~/g, "~0").replace(/\//g, "~1"),
+      hint: V && (code === "artboard-model" ? "use matching data property types, enum members and referenced models in the placement context" : "use a declared component and its loaded document")
+    }
+  );
+}
+const assignments = /* @__PURE__ */ new WeakMap();
+const queued = /* @__PURE__ */ new WeakMap();
+const parents = /* @__PURE__ */ new WeakMap();
+const dataArtboard = {
+  resources: {},
+  name: "dataartboard",
+  after,
+  entries,
+  init(registry, shared) {
+    const data = registry.get("data");
+    const components = registry.get("components");
+    const lists = registry.get("lists");
+    const host = registry.get("host");
+    if (!data || !components || !host) return dataArtboard;
+    const property = shared.DOC.p.data.p.models.of.p.properties.of;
+    const type = property.p.type;
+    if (!type.of.includes("artboard")) type.of = [...type.of, "artboard"];
+    const ownerOf = (p) => {
+      const parent = parents.get(p) ?? lists?.parents.get(p);
+      return parent ? ownerOf(parent) : p;
+    };
+    const prune = (p) => {
+      const choices = assignments.get(p);
+      if (!choices) return;
+      const live = new Set(queued.get(p)), seen = /* @__PURE__ */ new Set();
+      const scan = (value) => {
+        if (!value || typeof value !== "object") live.add(value);
+        else if (!seen.has(value)) {
+          seen.add(value);
+          Object.values(value).forEach(scan);
+        }
+      };
+      const visit = (player) => {
+        scan(data.dataState(player)?.instances);
+        for (const child of host.children(player)) visit(child);
+      };
+      visit(p);
+      for (const [name] of choices) if (!live.has(name)) choices.delete(name);
+    };
+    const configure = components.configure;
+    let depth = 0;
+    components.configure = (parent, child, node) => {
+      parents.set(child, parent);
+      const scope = data.dataState(child);
+      if (scope) scope.componentValues = assignments.get(ownerOf(parent));
+      configure?.(parent, child, node);
+      const target = data.compiled.get(parent.model), source = data.compiled.get(child.model);
+      if (target && String(data.dataState(parent)?.read(node.raw.component)).startsWith("$external:") && (source && child.model.inheritedData || node.raw.data || target.refs.get(node.raw.component)?.property.model) && !compatible(target, source, node.raw.data, node.raw.component))
+        failure("artboard-model", node.raw.component);
+      dataArtboard.resources.adopt?.(parent, child);
+      if (!parent.model.doc.requires?.includes("dataartboard") && !depth) return;
+      const step = child.step;
+      child.step = function(dt) {
+        if (depth >= 8) failure("limit-exceeded", node.raw.component);
+        depth++;
+        try {
+          return step.call(this, dt);
+        } finally {
+          depth--;
+        }
+      };
+    };
+    data.normalize = (document, model) => {
+      if (model.doc.requires?.includes("dataartboard")) {
+        for (const def of Object.values(document.models ?? {}))
+          for (const p of Object.values(def?.properties ?? {}))
+            if (p?.type === "artboard") p.type = "component";
+      }
+    };
+    host.Data.prototype.artboard = function(path) {
+      const handle = this.component(path);
+      return {
+        ...handle,
+        get value() {
+          return handle.value;
+        },
+        set: (value) => {
+          let name;
+          if (typeof value === "string") name = value;
+          else {
+            if (!value || typeof value !== "object") failure("data-type", path);
+            const child = value?.document && components.catalog.get(value.document)?.get(value.name);
+            if (!child) failure(value?.document ? "unknown-component" : "artboard-document", path);
+            const owner = ownerOf(this.player);
+            let choices = assignments.get(owner);
+            if (!choices) assignments.set(owner, choices = /* @__PURE__ */ new Map());
+            name = [...choices].find(([, model]) => model === child)?.[0];
+            if (!name) name = "$external:" + (choices.next = (choices.next ?? -1) + 1);
+            choices.set(name, child);
+            const scope = data.dataState(this.player);
+            if (scope) scope.componentValues = choices;
+          }
+          try {
+            handle.set(name);
+            const owner = ownerOf(this.player);
+            let pending = queued.get(owner);
+            if (!pending) queued.set(owner, pending = []);
+            pending.push(name);
+            this.enqueue(() => pending.splice(pending.indexOf(name), 1));
+          } catch (error) {
+            if (name && error.code === "data-type")
+              failure("unknown-component", path);
+            throw error;
+          }
+        }
+      };
+    };
+    return {
+      ...dataArtboard,
+      prepare(model) {
+        if (model.doc.requires?.includes("dataartboard") && model.nodes.some(
+          (n) => n.type === "instance" && n.raw.component.startsWith("$")
+        ) && !Object.keys(model.doc.components ?? {}).some((k) => k !== "$comment"))
+          model.doc = {
+            ...model.doc,
+            components: {
+              empty: { grid: 20, nodes: [{ id: "empty", type: "group", children: [] }] }
+            }
+          };
+      },
+      load(model) {
+        if (!model.doc.requires?.includes("dataartboard")) return;
+        const after2 = model.afterStep;
+        model.afterStep = (p) => {
+          after2?.(p);
+          prune(p);
+        };
+        const factory = model.nesting;
+        if (!factory) return;
+        model.nesting = (p) => {
+          const base = factory(p);
+          if (!base) return base;
+          const step = base.step.bind(base);
+          base.step = (dt) => {
+            const values = assignments.get(p);
+            if (!values?.size) return step(dt);
+            const restore = [], seen = /* @__PURE__ */ new Set();
+            const patch = (m) => {
+              if (seen.has(m)) return;
+              seen.add(m);
+              for (const node of m.nodes) {
+                const choices = components.placements.get(node);
+                if (node.type !== "instance" || !node.raw.component.startsWith("$") || !choices)
+                  continue;
+                for (const [key, child] of values) {
+                  const before = choices.get(key);
+                  choices.set(key, child);
+                  restore.push(() => {
+                    if (before) choices.set(key, before);
+                    else choices.delete(key);
+                  });
+                }
+              }
+              for (const child of components.catalog.get(m)?.values() ?? []) patch(child);
+            };
+            patch(p.model);
+            for (const source of values.values()) patch(source);
+            try {
+              return step(dt);
+            } finally {
+              for (const run of restore.reverse()) run();
+            }
+          };
+          return base;
+        };
+      }
+    };
+  }
+};
+export {
+  assignments,
+  component,
+  dataArtboard
+};

package/modules/data-artboard/core/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Compiled } from '../../data/core/types.js';
+/** Structural compatibility ignores defaults and document-local component/style names. */
+export declare function compatible(target: Compiled, source: Compiled | undefined, placement?: string, path?: string): boolean;

package/modules/data-artboard/core/schema.js

@@ -0,0 +1,27 @@
+function compatible(target, source, placement, path) {
+  const expected = path && target.refs.get(path)?.property.model || target.document.instances?.[placement ? placement.replace(/^\$/, "").replace(/:$/, "") : target.defaultName]?.model;
+  if (!source) return !expected;
+  const actual = source.document.instances?.[source.defaultName]?.model;
+  const seen = /* @__PURE__ */ new Set();
+  const model = (a, b) => {
+    if (!a || !b) return a === b;
+    const key = a + ":" + b;
+    if (seen.has(key)) return true;
+    seen.add(key);
+    const left = target.document.models[a]?.properties, right = source.document.models[b]?.properties;
+    return !!left && !!right && Object.entries(right).every(
+      ([key2, p]) => key2 === "$comment" || !!left[key2] && property(left[key2], p)
+    );
+  };
+  const property = (a, b) => a.type === b.type && a.assetType === b.assetType && a.min === b.min && a.max === b.max && (b.type !== "enum" || JSON.stringify(a.values?.slice().sort()) === JSON.stringify(b.values?.slice().sort())) && (b.type !== "model-ref" || model(a.model, b.model)) && (b.type !== "list" || model(a.of, b.of));
+  if (!model(expected, actual)) return false;
+  for (const [name, instance] of Object.entries(source.document.instances ?? {})) {
+    const targetInstance = target.document.instances?.[name];
+    if (name !== source.defaultName && targetInstance && (source.model.inheritedData || target.document.models[instance.model]?.global) && !model(targetInstance.model, instance.model))
+      return false;
+  }
+  return true;
+}
+export {
+  compatible
+};

package/modules/data-artboard/manifest.d.ts

@@ -0,0 +1,41 @@
+export declare const after: string[];
+declare const _default: {
+    name: string;
+    summary: string;
+    after: string[];
+    core: {
+        entry: string;
+        export: string;
+    };
+    web: ({
+        name: string;
+        budget: number;
+        over: string;
+        authoring?: undefined;
+    } | {
+        name: string;
+        budget: number;
+        authoring: boolean;
+        over: string;
+    })[];
+    adapters: {
+        'packages/core/src/modules/data-artboard/index.ts': string;
+        'packages/web/src/data-artboard.ts': string;
+        'packages/web/src/dataartboard.ts': string;
+        'packages/web/src/data-artboard-values.ts': string;
+        'packages/web/src/markup-data-artboard.ts': string;
+        'packages/markup/src/data-artboard.ts': string;
+    };
+    exports: {
+        'core:./data-artboard': string;
+        'web:./data-artboard': string;
+        'web:./dataartboard': string;
+        'web:./data-artboard-values': string;
+        'web:./markup-data-artboard': string;
+        'markup:./data-artboard': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/data-artboard/manifest.js

@@ -0,0 +1,44 @@
+const after = ["nested", "host"];
+var manifest_default = {
+  name: "data-artboard",
+  summary: "Data: component-valued model properties (choose which component an instance shows from data).",
+  after,
+  core: { entry: "core/index.ts", export: "dataArtboard" },
+  web: [
+    { name: "data-artboard", budget: 1024, over: "data-artboard-values" },
+    { name: "data-artboard-values", budget: 1536, over: "nested" },
+    { name: "markup-data-artboard", budget: 256, authoring: true, over: "markup-hooks" }
+  ],
+  adapters: {
+    "packages/core/src/modules/data-artboard/index.ts": "core/index.ts",
+    "packages/web/src/data-artboard.ts": "web/index.ts",
+    "packages/web/src/dataartboard.ts": "web/index.ts",
+    "packages/web/src/data-artboard-values.ts": "web/values.ts",
+    "packages/web/src/markup-data-artboard.ts": "web/markup.ts",
+    "packages/markup/src/data-artboard.ts": "markup/index.ts"
+  },
+  exports: {
+    "core:./data-artboard": "packages/core/src/modules/data-artboard/index.ts",
+    "web:./data-artboard": "packages/web/src/data-artboard.ts",
+    "web:./dataartboard": "packages/web/src/dataartboard.ts",
+    "web:./data-artboard-values": "packages/web/src/data-artboard-values.ts",
+    "web:./markup-data-artboard": "packages/web/src/markup-data-artboard.ts",
+    "markup:./data-artboard": "packages/markup/src/data-artboard.ts"
+  },
+  tests: [
+    "modules/data-artboard/test/**/*.test.ts",
+    "packages/markup/test/corpus.test.ts",
+    "packages/markup/test/names.test.ts"
+  ],
+  conformance: [
+    "data-host-artboard",
+    "host-api-bindable-artboards",
+    "host-api-data-artboard",
+    "components-host-artboard-reference"
+  ],
+  docs: ["modules/data-artboard/SPEC.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/data-artboard/markup/index.d.ts

@@ -0,0 +1,2 @@
+import { dataMarkup } from '../../data/markup/index.js';
+export declare function installArtboardMarkup(grammar: Pick<typeof dataMarkup, 'form'>): void;

package/modules/data-artboard/markup/index.js

@@ -0,0 +1,12 @@
+import { VERBOSE } from "animl";
+import { propertyNames } from "../../markup-hooks/markup/data.js";
+import { dataMarkup } from "../../data/markup/index.js";
+function installArtboardMarkup(grammar) {
+  if (!propertyNames.includes("artboard")) propertyNames.push("artboard");
+  const form = grammar.form;
+  grammar.form = (el, base) => form(el.name === "artboard" ? { ...el, name: "component" } : el, base);
+}
+if (VERBOSE) installArtboardMarkup(dataMarkup);
+export {
+  installArtboardMarkup
+};

package/modules/data-artboard/web/index.d.ts

@@ -0,0 +1 @@
+import './values.js';

package/modules/data-artboard/web/index.js

@@ -0,0 +1,136 @@
+import "./values.js";
+const Icon = customElements.get("anima-icon");
+const live = Icon.modules.get("dataartboard");
+const installed = !!live.resources.adopt;
+const initialized = /* @__PURE__ */ new WeakSet();
+const hosts = /* @__PURE__ */ new Set();
+const known = /* @__PURE__ */ new WeakSet();
+const sources = /* @__PURE__ */ new WeakMap();
+const contexts = /* @__PURE__ */ new WeakMap();
+const owners = /* @__PURE__ */ new WeakMap();
+const controllers = /* @__PURE__ */ new WeakMap();
+const retained = /* @__PURE__ */ new WeakMap();
+const module = (name) => Icon.modules.get(name);
+const children = (p) => [
+  ...[...p.nested?.players ?? []].filter(([id]) => {
+    const node = p.model.nodes[p.model.ids.get(id)];
+    return !node || module("components")?.selected?.(p, node) !== false;
+  }).map(([, child]) => child),
+  ...module("lists")?.listState(p)?.runs.flatMap((r) => r.items.map((i) => i.player)) ?? []
+];
+const each = (p, visit) => {
+  visit(p);
+  for (const child of children(p)) each(child, visit);
+};
+function owner(player) {
+  if (!owners.has(player))
+    for (const ref of hosts) {
+      const host = ref.deref();
+      if (!host) hosts.delete(ref);
+      else if (host.player) each(host.player, (p) => owners.set(p, host));
+    }
+  return owners.get(player);
+}
+const component = Icon.prototype.component;
+const values = /* @__PURE__ */ new WeakMap();
+if (!installed)
+  Icon.prototype.component = (document, name) => {
+    const scope = sources.get(document), components = module("components");
+    const source = components?.catalog.get(document)?.get(name);
+    if (!scope || !source) return component(document, name);
+    let choices = values.get(document);
+    if (!choices) values.set(document, choices = /* @__PURE__ */ new Map());
+    let value = choices.get(name);
+    if (!value) {
+      const child = { ...source, doc: { ...source.doc } }, wrapper = { ...document };
+      components.forkModel(source, child);
+      const data = module("data"), compiled = data?.compiled.get(source);
+      if (compiled) data.compiled.set(child, compiled);
+      components.catalog.set(wrapper, /* @__PURE__ */ new Map([[name, child]]));
+      contexts.set(child.doc, new Map([...scope, [child.doc, scope.get(source.doc)]]));
+      choices.set(name, value = component(wrapper, name));
+    }
+    return value;
+  };
+const previousLoader = Icon.loadAssets;
+if (!installed)
+  Icon.loadAssets = async (icon, model) => initialize(model, await previousLoader?.(icon, model));
+function initialize(root, prior) {
+  const scopes = /* @__PURE__ */ new WeakMap();
+  const resources = module("assets");
+  const collect = (model, scope, icon, catalogs) => {
+    if (scope.has(model.doc)) return;
+    scope.set(model.doc, {
+      records: catalogs?.get(model.doc) ?? resources?.resolvedAssets.get(model),
+      fonts: icon.fonts && (model === root ? icon.fonts : icon.fonts.forModel(model)).capture()
+    });
+    const components = module("components");
+    for (const child of [
+      ...components?.catalog.get(model)?.values() ?? [],
+      ...model.nodes.flatMap((n) => [...components?.placements.get(n)?.values() ?? []])
+    ])
+      collect(child, scope, icon, catalogs);
+  };
+  return (player) => {
+    const changed = prior?.(player) ?? false, icon = owner(player);
+    if (!icon?.player) return changed;
+    let scope = scopes.get(icon.player);
+    if (!scope) scopes.set(icon.player, scope = /* @__PURE__ */ new Map());
+    collect(root, scope, icon, resources?.catalogs.get(player));
+    if (player === icon.player && !initialized.has(player)) {
+      initialized.add(player);
+      const source = player.model, clone = { ...source };
+      module("components")?.forkModel(source, clone);
+      const data = module("data"), compiled = data?.compiled.get(source);
+      if (compiled) data.compiled.set(clone, compiled);
+      Object.defineProperty(player, "model", { value: clone });
+    }
+    sources.set(player.model, contexts.get(player) ?? scope);
+    return changed;
+  };
+}
+if (!installed)
+  live.resources.adopt = (parent, child) => {
+    const icon = owner(parent);
+    if (!icon) return;
+    const scope = contexts.get(child.model.doc) ?? contexts.get(parent);
+    each(child, (p) => {
+      owners.set(p, icon);
+      if (!scope) return;
+      contexts.set(p, scope);
+      const resource = scope.get(p.model.doc);
+      if (resource?.records)
+        module("assets")?.resolvedAssets.set(p, resource.records);
+      if (resource?.fonts && icon.fonts && !controllers.has(p)) {
+        const controller = new icon.fonts.constructor(icon);
+        resource.fonts(controller);
+        controllers.set(p, controller);
+        let owned = retained.get(icon);
+        if (!owned) retained.set(icon, owned = /* @__PURE__ */ new Map());
+        owned.set(p, controller);
+      }
+    });
+    const fonts = module("fonts");
+    if (fonts) fonts.controller = (p) => controllers.get(p);
+  };
+const previousHook = Icon.eventHook;
+if (!installed)
+  Icon.eventHook = (icon, kind, detail) => {
+    if (!known.has(icon)) {
+      known.add(icon);
+      hosts.add(new WeakRef(icon));
+    }
+    const owned = retained.get(icon);
+    if (owned && (kind === "cleanup" || kind === "draw")) {
+      const live2 = /* @__PURE__ */ new Set();
+      if (kind !== "cleanup" && icon.player) each(icon.player, (p) => live2.add(p));
+      for (const [p, controller] of owned)
+        if (!live2.has(p)) {
+          controller.clear();
+          controllers.delete(p);
+          owned.delete(p);
+        }
+      if (!owned.size) retained.delete(icon);
+    }
+    previousHook?.(icon, kind, detail);
+  };

package/modules/data-artboard/web/markup.d.ts

@@ -0,0 +1 @@
+import '../../markup/web/hooks.js';

package/modules/data-artboard/web/markup.js

@@ -0,0 +1,5 @@
+import "../../markup/web/hooks.js";
+import { installArtboardMarkup } from "../markup/index.js";
+import { dataMarkup } from "../../markup-hooks/markup/data.js";
+installArtboardMarkup(dataMarkup);
+customElements.get("anima-icon").registerMarkup("data", dataMarkup);

package/modules/data-artboard/web/values.d.ts

@@ -0,0 +1,8 @@
+import '../../nested/web/index.js';
+import { component } from '../core/index.js';
+import '../../../packages/web/src/index.js';
+declare module '../../../packages/web/src/index.ts' {
+    interface AnimaIcon {
+        component: typeof component;
+    }
+}

package/modules/data-artboard/web/values.js

@@ -0,0 +1,6 @@
+import "../../nested/web/index.js";
+import { dataArtboard, component } from "../core/index.js";
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerModule(dataArtboard);
+Icon.prototype.component ??= component;

package/modules/data-host/core/index.d.ts

@@ -0,0 +1,26 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export interface Coordinates {
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+}
+export interface Computed {
+    readonly local: Coordinates;
+    readonly root: Coordinates;
+    readonly world: readonly number[];
+    readonly bounds: Readonly<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    readonly opacity: number;
+}
+declare module '../../../packages/core/src/player.ts' {
+    interface Player {
+        computed(id: string): Computed;
+    }
+}
+export declare const dataHost: Module;

package/modules/data-host/core/index.js

@@ -0,0 +1,130 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { drawFrame } from "../../../packages/core/src/draw.js";
+import { apply, mul } from "../../../packages/core/src/geom.js";
+import { parsePath } from "../../../packages/core/src/path.js";
+import { fail } from "../../host/core/errors.js";
+import { after } from "../manifest.js";
+function coordinates(m) {
+  const [a, b, c, d, x, y] = m;
+  const scaleX = Math.hypot(a, b);
+  return Object.freeze({
+    x,
+    y,
+    rotation: Math.atan2(b, a) * 180 / Math.PI,
+    scaleX,
+    scaleY: scaleX ? (a * d - b * c) / scaleX : Math.hypot(c, d)
+  });
+}
+function computed(player, id) {
+  const index = player.model.ids.get(id);
+  if (index === void 0) fail("path", String(id), "unknown computed node id");
+  const frame = drawFrame(player);
+  let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity;
+  const point = (x, y) => {
+    left = Math.min(left, x);
+    top = Math.min(top, y);
+    right = Math.max(right, x);
+    bottom = Math.max(bottom, y);
+  };
+  const visit = (i, world2) => {
+    const node = frame.nodes[i], entry = frame.tree.nodes[i];
+    const g = node.geometry;
+    if (g?.kind === "circle") {
+      const [x, y] = apply(world2, g.cx, g.cy);
+      const rx = g.r * Math.hypot(world2[0], world2[2]), ry = g.r * Math.hypot(world2[1], world2[3]);
+      point(x - rx, y - ry);
+      point(x + rx, y + ry);
+    } else if (g?.d !== void 0) {
+      for (const path of parsePath(g.d)) {
+        let start = [0, 0], last = start;
+        for (let j = 0; j < path.segs.length; ) {
+          const op = path.segs[j++];
+          if (op === 3) {
+            last = start;
+            continue;
+          }
+          if (op !== 2) {
+            last = apply(world2, path.segs[j++], path.segs[j++]);
+            if (op === 0) start = last;
+            point(...last);
+            continue;
+          }
+          const a = last, b = apply(world2, path.segs[j++], path.segs[j++]), c = apply(world2, path.segs[j++], path.segs[j++]), d = apply(world2, path.segs[j++], path.segs[j++]);
+          point(...d);
+          for (const axis of [0, 1]) {
+            const A = -a[axis] + 3 * b[axis] - 3 * c[axis] + d[axis], B = 2 * (a[axis] - 2 * b[axis] + c[axis]), C = b[axis] - a[axis];
+            const disc = B * B - 4 * A * C;
+            const roots = Math.abs(A) < 1e-12 ? B ? [-C / B] : [] : disc < 0 ? [] : [(-B + Math.sqrt(disc)) / (2 * A), (-B - Math.sqrt(disc)) / (2 * A)];
+            for (const t of roots)
+              if (t > 0 && t < 1) {
+                const v = (k) => (1 - t) ** 3 * a[k] + 3 * (1 - t) ** 2 * t * b[k] + 3 * (1 - t) * t * t * c[k] + t ** 3 * d[k];
+                point(v(0), v(1));
+              }
+          }
+          last = d;
+        }
+      }
+    } else if (g?.width !== void 0 && g.height !== void 0) {
+      for (const x of [g.x ?? 0, (g.x ?? 0) + g.width])
+        for (const y of [g.y ?? 0, (g.y ?? 0) + g.height]) point(...apply(world2, x, y));
+    }
+    for (const child of entry.children) visit(child, mul(world2, frame.nodes[child].transform));
+  };
+  const world = player.world(index);
+  visit(index, world);
+  let opacity = 1;
+  for (let i = index; i >= 0; i = player.model.nodes[i].parent)
+    opacity *= player.num(i, "opacity", 1);
+  return Object.freeze({
+    local: coordinates(player.local(index)),
+    root: coordinates(world),
+    world: Object.freeze([...world]),
+    bounds: Object.freeze(
+      left === Infinity ? { x: world[4], y: world[5], width: 0, height: 0 } : { x: left, y: top, width: right - left, height: bottom - top }
+    ),
+    opacity
+  });
+}
+const dataHost = {
+  name: "datahost",
+  after,
+  entries: [],
+  init(_registry, shared) {
+    shared.Player.prototype.computed = function(id) {
+      return computed(this, id);
+    };
+    return dataHost;
+  },
+  resolve(model, diag) {
+    if (!model.doc.requires?.includes("datahost")) return;
+    for (const [target, binding] of Object.entries(model.doc.bind ?? {})) {
+      const source = typeof binding === "string" ? binding : binding.value;
+      if (typeof source !== "string") continue;
+      const value = source.replace(
+        /asset\(\s*("(?:[^"\\]|\\.)*")\s*\)|"(?:[^"\\]|\\.)*"/g,
+        (token, name) => {
+          if (!name) return token;
+          let id;
+          try {
+            id = JSON.parse(name);
+          } catch {
+            return token;
+          }
+          if (!Object.hasOwn(model.doc.assets ?? {}, id))
+            diag.err(
+              "unknown-asset",
+              "/bind/" + target.replace(/~/g, "~0").replace(/\//g, "~1"),
+              V && "unknown binding asset",
+              V && "declare the asset in this document"
+            );
+          return name;
+        }
+      );
+      if (typeof binding === "string") model.doc.bind[target] = value;
+      else binding.value = value;
+    }
+  }
+};
+export {
+  dataHost
+};