@ai-matrx/applets 0.2.7

package/dist/platform.cjs

@@ -0,0 +1,699 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/platform/index.ts
+var platform_exports = {};
+__export(platform_exports, {
+  APPLET_BASE_SURFACE: () => APPLET_BASE_SURFACE,
+  DEFINITION_COLUMNS: () => DEFINITION_COLUMNS,
+  appletSurfaceName: () => appletSurfaceName,
+  createPlatformHost: () => createPlatformHost,
+  definitionToRecord: () => definitionToRecord
+});
+module.exports = __toCommonJS(platform_exports);
+
+// src/platform/host.ts
+var import_core = require("@ai-matrx/records/core");
+var import_realtime = require("@ai-matrx/records/realtime");
+var import_data = require("@ai-matrx/records/data");
+var import_actions = require("@ai-matrx/alchemy/actions");
+
+// src/types.ts
+var PAGE_ACTION_STREAM = "actions";
+var NAV_STREAM = "nav";
+var valueStream = (name) => `value:${name}`;
+function ok(data) {
+  return { ok: true, data };
+}
+function fail(code, message, retryable = false, diagnostic) {
+  const error = { code, message, retryable };
+  if (diagnostic !== void 0) error.diagnostic = diagnostic;
+  return { ok: false, error };
+}
+function fromRecordsError(error) {
+  const out = { code: error.code, message: error.message, retryable: error.code === "unreachable" || error.code === "timed_out" };
+  if (error.diagnostic !== void 0) out.diagnostic = error.diagnostic;
+  return out;
+}
+function toAppletError(err, code = "internal") {
+  if (err && typeof err === "object") {
+    const o = err;
+    if (typeof o.code === "string" && typeof o.message === "string") {
+      const out = { code: o.code, message: o.message, retryable: o.retryable === true };
+      if (typeof o.diagnostic === "string") out.diagnostic = o.diagnostic;
+      return out;
+    }
+    if (err instanceof Error) return { code, message: err.message, retryable: false };
+  }
+  return { code, message: String(err), retryable: false };
+}
+
+// src/platform/supabase.ts
+function asPlatformSupabase(client) {
+  const c = client;
+  if (typeof c.schema !== "function" || typeof c.auth?.getSession !== "function") {
+    throw new Error(
+      "[applets/platform] createPlatformHost needs a supabase-js v2 client carrying the viewer's session (it has no schema() or auth.getSession())."
+    );
+  }
+  return c;
+}
+function readError(error, code = "read_failed") {
+  const out = { code: error.code ? `${code}:${error.code}` : code, message: error.message, retryable: false };
+  if (error.details) out.diagnostic = error.details;
+  return out;
+}
+async function read(chain, shape) {
+  try {
+    const answer = await chain;
+    if (answer.error) return { ok: false, error: readError(answer.error) };
+    return { ok: true, data: shape(answer.data) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: { code: "unreachable", message: err instanceof Error ? err.message : String(err), retryable: true }
+    };
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/platform/record.ts
+var DEFINITION_COLUMNS = "id, version, organization_id, slug, name, status, files, entry, pages, mandates, sources, parent_applet_id, allowed_imports, component_code";
+var APPLET_BASE_SURFACE = "applets/applet";
+var appletSurfaceName = (appletId) => `applets/${appletId}`;
+function strings(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+function files(value) {
+  const out = {};
+  if (!isRecord(value)) return out;
+  for (const [name, source] of Object.entries(value)) if (typeof source === "string") out[name] = source;
+  return out;
+}
+function pages(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const p of value) {
+    if (!isRecord(p) || typeof p.path !== "string" || typeof p.file !== "string") continue;
+    const page = { path: p.path, title: typeof p.title === "string" ? p.title : p.path, file: p.file };
+    if (typeof p.parent === "string") page.parent = p.parent;
+    out.push(page);
+  }
+  return out;
+}
+function mandates(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((m) => isRecord(m) && typeof m.alias === "string" && typeof m.key === "string" ? [{ alias: m.alias, key: m.key }] : []);
+}
+function sources(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const s of value) {
+    if (!isRecord(s) || typeof s.alias !== "string") continue;
+    if (typeof s.table_id === "string" && typeof s.organization_id === "string") {
+      out.push({ alias: s.alias, table_id: s.table_id, organization_id: s.organization_id });
+    } else if (typeof s.entity === "string") {
+      out.push({ alias: s.alias, entity: s.entity });
+    }
+  }
+  return out;
+}
+function definitionToRecord(row) {
+  if (!isRecord(row) || typeof row.id !== "string") return { ok: false, message: "The Applet row has no id." };
+  if (typeof row.organization_id !== "string") return { ok: false, message: `Applet ${row.id} has no organization.` };
+  const id = row.id;
+  let recordFiles = files(row.files);
+  let entry = typeof row.entry === "string" && row.entry ? row.entry : "";
+  let recordPages = pages(row.pages);
+  if ((Object.keys(recordFiles).length === 0 || !entry) && typeof row.component_code === "string" && row.component_code) {
+    recordFiles = { "App.tsx": row.component_code };
+    entry = "App.tsx";
+    if (recordPages.length === 0) {
+      recordPages = [{ path: "/", title: typeof row.name === "string" && row.name ? row.name : "Home", file: "App.tsx" }];
+    }
+  }
+  if (!entry || recordFiles[entry] === void 0) {
+    return { ok: false, message: `Applet ${id} has no entry file to run.` };
+  }
+  return {
+    ok: true,
+    record: {
+      id,
+      version: typeof row.version === "number" ? row.version : 1,
+      organizationId: row.organization_id,
+      slug: typeof row.slug === "string" ? row.slug : id,
+      published: row.status === "published",
+      files: recordFiles,
+      entry,
+      scope: { entries: strings(row.allowed_imports), shadowDangerousGlobals: true },
+      pages: recordPages,
+      mandates: mandates(row.mandates),
+      sources: sources(row.sources),
+      parentId: typeof row.parent_applet_id === "string" ? row.parent_applet_id : null,
+      surfaceName: appletSurfaceName(id)
+    }
+  };
+}
+
+// src/platform/host.ts
+var BASE_PAGE_ACTIONS = /* @__PURE__ */ new Set(["write_row"]);
+var MAX_CHAIN = 16;
+function mint(world, prefix) {
+  world.seq += 1;
+  const c = globalThis.crypto;
+  return `${prefix}_${c?.randomUUID ? c.randomUUID() : `${Date.now().toString(36)}${world.seq}`}`;
+}
+function clone(value) {
+  return value === void 0 ? value : JSON.parse(JSON.stringify(value));
+}
+function refuseRecords(code, message) {
+  return { ok: false, error: { code, message } };
+}
+function createPlatformHost(opts) {
+  const world = {
+    opts,
+    supabase: asPlatformSupabase(opts.supabase),
+    hosts: /* @__PURE__ */ new Map(),
+    pending: /* @__PURE__ */ new Map(),
+    viewer: null,
+    records: null,
+    seq: 0,
+    stopNav: null
+  };
+  const root = buildHost(world, opts.appletId, `platform:${opts.appletId}`, null);
+  if (opts.nav.subscribe) {
+    world.stopNav = opts.nav.subscribe((location) => {
+      for (const h of world.hosts.values()) h.emit(NAV_STREAM, location);
+    });
+  }
+  return root;
+}
+function loadViewer(world) {
+  world.viewer ??= (async () => {
+    const report = (error, where) => void world.opts.reportError({ ...error, where });
+    let userId = null;
+    try {
+      const session = await world.supabase.auth.getSession();
+      if (session.error) report({ code: "session_unreadable", message: session.error.message, retryable: true }, "viewer.session");
+      userId = session.data.session?.user.id ?? null;
+    } catch (err) {
+      report(toAppletError(err, "session_unreadable"), "viewer.session");
+    }
+    if (!userId) return { userId: null, organizationIds: [], activeOrganizationId: null, guest: true };
+    const memberships = await read(
+      world.supabase.schema("iam").from("organization_member").select("organization_id").eq("user_id", userId),
+      (data) => [...new Set((Array.isArray(data) ? data : []).flatMap((r) => isRecord(r) && typeof r.organization_id === "string" ? [r.organization_id] : []))]
+    );
+    if (!memberships.ok) report(memberships.error, "viewer.memberships");
+    return {
+      userId,
+      organizationIds: memberships.ok ? memberships.data : [],
+      activeOrganizationId: world.opts.activeOrganizationId,
+      guest: false
+    };
+  })().catch((err) => {
+    world.viewer = null;
+    throw err;
+  });
+  return world.viewer;
+}
+function loadRecordsClient(world) {
+  world.records ??= loadViewer(world).then((viewer) => {
+    const actor = viewer.userId ? { actor: "user", user_id: viewer.userId } : { actor: "user" };
+    return (0, import_core.createRecordsClient)({
+      dataSource: world.opts.supabase,
+      actor,
+      // Writes to a custom table go to the TABLE's organization (createTableDataPort's `clientIn`);
+      // reads span every membership. Nothing here narrows a read to the active organization.
+      organizationId: world.opts.activeOrganizationId,
+      organizationIds: viewer.organizationIds,
+      onError: (e) => void world.opts.reportError({ code: e.code, message: e.message, retryable: false, where: `records:${e.where}` }),
+      realtime: world.opts.records?.realtime ?? (0, import_realtime.createRecordsRealtimePort)(),
+      ...world.opts.records?.knownDoors ? { knownDoors: world.opts.records.knownDoors } : {}
+    });
+  });
+  return world.records;
+}
+function buildHost(world, appletId, hostId, parent) {
+  const { opts, supabase } = world;
+  const listeners = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const values = /* @__PURE__ */ new Map();
+  let recordPromise = null;
+  let mounted = null;
+  let childCount = 0;
+  const report = (error, where) => {
+    void Promise.resolve(opts.reportError({ ...error, where })).catch(() => void 0);
+  };
+  const deliver = (subscriptionId, payload) => {
+    const message = { subscriptionId, payload: clone(payload) };
+    for (const l of [...listeners]) l(message);
+  };
+  const emit = (stream, payload) => {
+    for (const [id, s] of subscriptions) if (s.stream === stream) deliver(id, payload);
+  };
+  const record = () => {
+    recordPromise ??= (async () => {
+      const answer = await read(
+        supabase.schema("app").from("definition").select(DEFINITION_COLUMNS).eq("id", appletId).is("deleted_at", null).maybeSingle(),
+        (data2) => data2
+      );
+      if (!answer.ok) throw answer.error;
+      if (answer.data === null) {
+        throw { code: "applet_not_found", message: `There is no Applet ${appletId} you can open.`, retryable: false };
+      }
+      const mapped = definitionToRecord(answer.data);
+      if (!mapped.ok) throw { code: "applet_unreadable", message: mapped.message, retryable: false };
+      return mapped.record;
+    })().catch((err) => {
+      recordPromise = null;
+      throw err;
+    });
+    return recordPromise.then(clone);
+  };
+  let dataPort = null;
+  const loadData = () => {
+    dataPort ??= (async () => {
+      const rec = await record();
+      const aliases = {};
+      const entities = /* @__PURE__ */ new Map();
+      for (const s of rec.sources) {
+        if ("table_id" in s) aliases[s.alias] = { kind: "table", tableId: s.table_id, organizationId: s.organization_id };
+        else entities.set(s.alias, s.entity);
+      }
+      const port = Object.keys(aliases).length ? (0, import_data.createTableDataPort)({ client: await loadRecordsClient(world), aliases }) : null;
+      return { port, entities };
+    })().catch((err) => {
+      dataPort = null;
+      throw err;
+    });
+    return dataPort;
+  };
+  const entityRefusal = (alias, entity) => refuseRecords("not_supported", `"${alias}" is a ${entity} source; platform record sources are not readable from an Applet yet (AP-3 phase B).`);
+  const routed = async (alias, call) => {
+    let d;
+    try {
+      d = await loadData();
+    } catch (err) {
+      const e = toAppletError(err);
+      return refuseRecords("unreachable", e.message);
+    }
+    const entity = d.entities.get(alias);
+    if (entity !== void 0) return entityRefusal(alias, entity);
+    if (!d.port) return refuseRecords("not_found", `This Applet has no data source called "${alias}".`);
+    return call(d.port);
+  };
+  const data = {
+    subscribe(event, listener) {
+      let stop = null;
+      let stopped = false;
+      void loadData().then(
+        (d) => {
+          const alias = event.slice("rows:".length);
+          if (stopped || !d.port || d.entities.has(alias)) return;
+          stop = d.port.subscribe(event, listener);
+        },
+        (err) => report(toAppletError(err), `events.on(${event})`)
+      );
+      return () => {
+        stopped = true;
+        stop?.();
+      };
+    },
+    async sources() {
+      try {
+        const d = await loadData();
+        const tables = d.port ? await d.port.sources() : { ok: true, data: [] };
+        if (!tables.ok) return tables;
+        const ents = [...d.entities].map(([alias]) => ({ alias, label: alias, kind: "entity", canCreate: false, canUpdate: false }));
+        return { ok: true, data: [...tables.data, ...ents] };
+      } catch (err) {
+        return refuseRecords("unreachable", toAppletError(err).message);
+      }
+    },
+    columns: (alias) => routed(alias, (p) => p.columns(alias)),
+    list: (alias, q, cursor) => routed(alias, (p) => cursor === void 0 ? p.list(alias, q) : p.list(alias, q, cursor)),
+    get: (alias, id) => routed(alias, (p) => p.get(alias, id)),
+    create: (alias, v) => routed(alias, (p) => p.create(alias, v)),
+    update: (alias, id, patch, baseVersion) => routed(alias, (p) => p.update(alias, id, patch, baseVersion)),
+    archive: (alias, id) => routed(alias, (p) => p.archive(alias, id)),
+    restore: (alias, id) => routed(alias, (p) => p.restore(alias, id))
+  };
+  const keyFor = async (aliasOrKey) => {
+    try {
+      const rec = await record();
+      return rec.mandates.find((m) => m.alias === aliasOrKey)?.key ?? aliasOrKey;
+    } catch {
+      return aliasOrKey;
+    }
+  };
+  const agents = opts.agents;
+  const intelligence = {
+    async describe(key) {
+      return agents.describe(await keyFor(key));
+    },
+    async run(req) {
+      let rec;
+      try {
+        rec = await record();
+      } catch (err) {
+        return { ok: false, error: toAppletError(err) };
+      }
+      const viewer = await loadViewer(world);
+      const organizationId = req.organizationId ?? opts.activeOrganizationId;
+      if (organizationId === null && !viewer.guest) {
+        return fail("organization_required", "Choose an organization to run this job in.");
+      }
+      return agents.run({
+        ...req,
+        key: rec.mandates.find((m) => m.alias === req.key)?.key ?? req.key,
+        organizationId,
+        appletId: rec.id,
+        // the scope's own Applet, always
+        surfaceName: req.surfaceName ?? rec.surfaceName
+      });
+    },
+    result: (ref) => agents.result(ref),
+    answer: (ref, v) => agents.answer(ref, v),
+    rejoin: (ref) => agents.rejoin(ref),
+    async listRuns(key, scopedApplet) {
+      return agents.listRuns(await keyFor(key), scopedApplet ?? appletId);
+    },
+    createSoft: (spec) => agents.createSoft(spec)
+  };
+  const nav = {
+    async go(to) {
+      await opts.nav.go(to);
+      if (opts.nav.subscribe) return;
+      const location = await opts.nav.current();
+      for (const h of world.hosts.values()) h.emit(NAV_STREAM, location);
+    },
+    current: () => opts.nav.current()
+  };
+  const readChain = async (name, maxDepth) => {
+    const names = [];
+    let at = name;
+    while (at) {
+      if (names.includes(at)) return fail("surface_cycle", `The surface chain loops at "${at}": ${[...names, at].join(" \u2192 ")}.`);
+      if (names.length >= MAX_CHAIN) return fail("surface_too_deep", `The surface chain for "${name}" is deeper than ${MAX_CHAIN}.`);
+      const row = await read(
+        supabase.schema("ui").from("ui_surface").select("name, parent_surface_name").eq("name", at).is("deleted_at", null).maybeSingle(),
+        (d) => d
+      );
+      if (!row.ok) return row;
+      if (!isRecord(row.data)) {
+        return fail(
+          "surface_not_found",
+          names.length === 0 ? `The surface "${at}" does not exist yet; saving the Applet writes it (ui.save_applet_surface).` : `The surface "${names[names.length - 1]}" names a parent "${at}" that does not exist.`
+        );
+      }
+      names.push(at);
+      at = typeof row.data.parent_surface_name === "string" && row.data.parent_surface_name ? row.data.parent_surface_name : null;
+    }
+    const rows = await read(
+      supabase.schema("ui").from("ui_surface_action").select("*").in("surface_name", names).is("deleted_at", null).order("sort_order", { ascending: true }),
+      (d) => Array.isArray(d) ? d : []
+    );
+    if (!rows.ok) return rows;
+    const chain = [...names].reverse().map((surfaceName) => ({
+      surfaceName,
+      actions: rows.data.filter((r) => r.surface_name === surfaceName).map(import_actions.surfaceActionRowToAction)
+    }));
+    try {
+      return ok((0, import_actions.resolveActionChain)(chain, maxDepth === void 0 ? {} : { maxDepth }));
+    } catch (err) {
+      return { ok: false, error: toAppletError(err, "surface_chain") };
+    }
+  };
+  const seedValues = async (rec) => {
+    const viewer = await loadViewer(world);
+    let location = null;
+    try {
+      location = await opts.nav.current();
+    } catch (err) {
+      report(toAppletError(err), "nav.current");
+    }
+    const seeds = {
+      viewer: { userId: viewer.userId, guest: viewer.guest },
+      organization: viewer.activeOrganizationId,
+      record: { id: rec.id, slug: rec.slug, version: rec.version },
+      sources: rec.sources.map((s) => s.alias),
+      route: location ? `/${location.path.join("/")}` : null,
+      page: location ? { path: location.path, params: location.params } : null
+    };
+    for (const [name, v] of Object.entries(seeds)) if (!values.has(name)) values.set(name, v);
+  };
+  const dispatchPage = async (name, input, context) => {
+    const declaredOn = context.surfaceName ?? "";
+    if (declaredOn === APPLET_BASE_SURFACE && BASE_PAGE_ACTIONS.has(name)) return builtIn(name, input);
+    let owner = self;
+    for (const h of world.hosts.values()) {
+      if (!h.hasSubscriber(PAGE_ACTION_STREAM)) continue;
+      const surfaceName = await h.surfaceName().catch(() => null);
+      if (surfaceName === declaredOn) owner = h;
+    }
+    if (!owner.hasSubscriber(PAGE_ACTION_STREAM)) {
+      return fail("action_unhandled", `No page is open to run "${name}".`);
+    }
+    return new Promise((resolve) => {
+      world.pending.set(context.runId, resolve);
+      const event = { action: name, input, runId: context.runId, by: context.by };
+      owner.emit(PAGE_ACTION_STREAM, event);
+    });
+  };
+  const builtIn = async (name, input) => {
+    if (name !== "write_row") return fail("action_unhandled", `No handler for "${name}".`);
+    if (!isRecord(input) || typeof input.source !== "string" || !isRecord(input.values)) {
+      return fail("invalid_argument", "write_row needs a source and values.");
+    }
+    let answer;
+    if (typeof input.id === "string") {
+      if (typeof input.baseVersion !== "number") {
+        return fail("invalid_argument", "write_row needs the row's baseVersion to change it, so a stale write is refused.");
+      }
+      answer = await data.update(input.source, input.id, input.values, input.baseVersion);
+    } else {
+      answer = await data.create(input.source, input.values);
+    }
+    return answer.ok ? ok(answer.data) : { ok: false, error: fromRecordsError(answer.error) };
+  };
+  const actionPorts = () => {
+    const diagnostics = {
+      capture(error, context) {
+        report({ ...toAppletError(error, "action_failed"), diagnostic: JSON.stringify(context.detail) }, `surface.${context.area}`);
+      }
+    };
+    const s = opts.surfaces ?? {};
+    return {
+      diagnostics,
+      ...s.serverActions ? { serverActions: s.serverActions } : {},
+      ...s.approvals ? { approvals: s.approvals } : {},
+      ...s.door ? { door: s.door } : {},
+      mandates: {
+        async run(request) {
+          const viewer = await loadViewer(world);
+          const started = await intelligence.run({
+            key: request.key ?? request.alias ?? "",
+            variables: request.variables,
+            ...request.userInput !== void 0 ? { userInput: request.userInput } : {},
+            organizationId: viewer.activeOrganizationId
+          });
+          if (!started.ok) throw new Error(started.error.message);
+          return started.data;
+        }
+      },
+      pageActions: { dispatch: dispatchPage },
+      overlay: {
+        navigate(href) {
+          void nav.go(href).catch((err) => report(toAppletError(err), "nav.go"));
+        },
+        open(overlayId) {
+          report({ code: "not_supported", message: `Overlays cannot be opened from an Applet yet ("${overlayId}").`, retryable: false }, "surface.overlay");
+        },
+        close() {
+        }
+      }
+    };
+  };
+  const chainFor = async () => {
+    if (mounted) return ok(mounted.chain);
+    const rec = await record();
+    return readChain(rec.surfaceName, opts.surfaces?.maxDepth);
+  };
+  const surface = {
+    async mount(name) {
+      try {
+        const chain = await readChain(name, opts.surfaces?.maxDepth);
+        if (!chain.ok) return chain;
+        await seedValues(await record());
+        mounted = { mountId: mint(world, "mount"), name, chain: chain.data };
+        return ok({ mountId: mounted.mountId });
+      } catch (err) {
+        return { ok: false, error: toAppletError(err) };
+      }
+    },
+    async unmount(mountId) {
+      if (mounted?.mountId === mountId) mounted = null;
+    },
+    async getValue(name) {
+      return clone(values.get(name));
+    },
+    async setValue(name, v) {
+      values.set(name, clone(v));
+      emit(valueStream(name), v);
+    },
+    async listActions() {
+      try {
+        const chain = await chainFor();
+        if (!chain.ok) {
+          report(chain.error, "surface.listActions");
+          return [];
+        }
+        return clone(chain.data);
+      } catch (err) {
+        report(toAppletError(err), "surface.listActions");
+        return [];
+      }
+    },
+    async runAction(name, input, by) {
+      let chain;
+      try {
+        chain = await chainFor();
+      } catch (err) {
+        return { ok: false, error: toAppletError(err) };
+      }
+      if (!chain.ok) return chain;
+      const info = chain.data.find((a) => a.name === name);
+      if (!info) return fail("action_not_found", `This page has no action named "${name}".`);
+      const viewer = await loadViewer(world);
+      const result = await (0, import_actions.runSurfaceAction)(info, input, by, actionPorts(), { runId: mint(world, "act"), viewerId: viewer.userId });
+      if (result.ok && info.updatesValue) await surface.setValue(info.updatesValue, result.data);
+      return result;
+    },
+    async completeAction(runId, result) {
+      const resolve = world.pending.get(runId);
+      world.pending.delete(runId);
+      resolve?.(result);
+    }
+  };
+  const kindRow = async (slug) => read(
+    supabase.schema("content_ir").from("kind_definition").select("id, kind, label, data, sample_data, emitted_json_schema, variants, version").eq("kind", slug).is("deleted_at", null).maybeSingle(),
+    (d) => isRecord(d) ? d : null
+  );
+  const kinds = {
+    async definition(slug) {
+      const row = await kindRow(slug);
+      if (!row.ok) return row;
+      if (!row.data) return fail("kind_not_found", `No kind named "${slug}".`);
+      return ok(row.data);
+    },
+    async component(slug, platform) {
+      const row = await kindRow(slug);
+      if (!row.ok) return row;
+      if (!row.data) return fail("kind_not_found", `No kind named "${slug}".`);
+      const comp = await read(
+        supabase.schema("content_ir").from("kind_component").select("component_key, component_source, is_default, sort_order").eq("kind_definition_id", row.data.id).eq("platform", platform).eq("role", "output").eq("is_active", true).is("deleted_at", null).order("is_default", { ascending: false }).order("sort_order", { ascending: true }).limit(1),
+        (d) => Array.isArray(d) && isRecord(d[0]) ? d[0] : null
+      );
+      if (!comp.ok) return comp;
+      if (!comp.data || typeof comp.data.component_source !== "string") return ok(null);
+      const file = `${typeof comp.data.component_key === "string" && comp.data.component_key ? comp.data.component_key : slug}.tsx`;
+      return ok({ files: { [file]: comp.data.component_source }, entry: file });
+    }
+  };
+  const pages2 = {
+    async definition(pageId) {
+      return fail("not_supported", `Table-built pages cannot be opened from an Applet yet (page ${pageId}); there is no page store to read.`);
+    }
+  };
+  const self = {
+    kind: "platform",
+    appletId,
+    hostId,
+    viewer: () => loadViewer(world),
+    record,
+    async child(childId) {
+      childCount += 1;
+      const id = `${hostId}/${childId}#${childCount}`;
+      buildHost(world, childId, id, self);
+      return { hostId: id };
+    },
+    kinds,
+    pages: pages2,
+    data,
+    intelligence,
+    surface,
+    nav,
+    events: {
+      async on(stream) {
+        const subscriptionId = mint(world, "sub");
+        let stop = null;
+        if (stream.startsWith("rows:")) {
+          stop = data.subscribe(stream, (event) => deliver(subscriptionId, event));
+        } else if (stream.startsWith("run:")) {
+          stop = agents.events.on(stream, (event) => deliver(subscriptionId, event));
+        }
+        subscriptions.set(subscriptionId, { stream, stop });
+        return { subscriptionId };
+      },
+      async off(subscriptionId) {
+        subscriptions.get(subscriptionId)?.stop?.();
+        subscriptions.delete(subscriptionId);
+      }
+    },
+    async reportError(err) {
+      await opts.reportError(err);
+    },
+    receive(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    forHost(id) {
+      return world.hosts.get(id) ?? null;
+    },
+    dispose() {
+      for (const s of subscriptions.values()) s.stop?.();
+      subscriptions.clear();
+      listeners.clear();
+      world.hosts.delete(hostId);
+      if (parent === null) {
+        for (const h of [...world.hosts.values()]) h.dispose();
+        world.stopNav?.();
+        world.stopNav = null;
+        for (const resolve of world.pending.values()) resolve(fail("host_disposed", "The page closed before the action finished."));
+        world.pending.clear();
+      }
+    },
+    emit,
+    hasSubscriber(stream) {
+      for (const s of subscriptions.values()) if (s.stream === stream) return true;
+      return false;
+    },
+    async surfaceName() {
+      return (await record()).surfaceName;
+    }
+  };
+  world.hosts.set(hostId, self);
+  return self;
+}
+//# sourceMappingURL=platform.cjs.map