@theoremjs/studio 0.0.0-stage → 0.3.2

package/map.js

@@ -0,0 +1,525 @@
+/**
+ * The workspace as a map. Each profile is a card of its sections; what feeds it stands beside it:
+ * the providers and models it runs on, the settings the project shares, the tools it may call. A
+ * line joins each to the section it feeds. It is read from the workspace and changes nothing; each
+ * node and section names the workspace node that opens it.
+ */
+import { mapCurve, mapRail } from "./map-line.js";
+import { sharedOpens } from "./shared-settings.js";
+import { modelBindingNodeId, providerNodeId, toolSpecNodeId } from "./tree.js";
+import { agentNodeId, workspaceTree } from "./workspace.js";
+/**
+ * `nodes` in the order of what each is joined to in the column beside it (`rows`), so the lines
+ * cross less; unjoined ones go last.
+ */
+function byRows(nodes, links, rows) {
+    const rank = (node) => {
+        const joined = links
+            .flatMap(({ from, to }) => (from === node.id ? [to] : to === node.id ? [from] : []))
+            .flatMap((id) => rows.get(id) ?? []);
+        return joined.length === 0
+            ? Infinity
+            : joined.reduce((sum, row) => sum + row, 0) / joined.length;
+    };
+    const ranks = new Map(nodes.map((node) => [node.id, rank(node)]));
+    const at = (node) => ranks.get(node.id) ?? Infinity;
+    // Two unjoined nodes compare equal (Infinity less Infinity is not a number); the sort is stable.
+    return [...nodes].sort((a, b) => (at(a) === at(b) ? 0 : at(a) - at(b)));
+}
+/** What a section's row says beside its name, where one line can say it. */
+function rowNote(agent, facet, tools) {
+    if (facet === 'models')
+        return agent.modelBindings.map((binding) => binding.modelId || 'New model').join(', ');
+    if (facet === 'tools')
+        return String(agent.tools.allow.filter((key) => tools.has(key)).length);
+    if (facet === 'outputs')
+        return agent.outputs.mode;
+    return '';
+}
+/** The map of `workspace`, with the settings its project shares. */
+export function workspaceMap(workspace, shared = []) {
+    const links = [];
+    const agentIds = new Map(workspace.agents.map((agent) => [agent.key, agentNodeId(agent.key)]));
+    const toolIds = new Map(workspace.toolSpecs.map((tool) => [tool.key, toolSpecNodeId(tool.key)]));
+    const tree = workspaceTree(workspace);
+    const agents = workspace.agents.map((agent, index) => {
+        const { agentId, profileType, handle } = agent.identity;
+        const type = profileType || 'text';
+        return {
+            id: agentNodeId(agent.key),
+            kind: 'agent',
+            label: agentId || 'New agent',
+            note: handle ? `${type} · ${handle}` : type,
+            opens: agentNodeId(agent.key),
+            type,
+            rows: (tree.agents[index]?.children ?? []).map((section) => ({
+                id: section.id,
+                label: section.label,
+                note: rowNote(agent, section.ref.facet, toolIds),
+                opens: section.id,
+                type: section.ref.facet,
+            })),
+        };
+    });
+    const sections = new Set(agents.flatMap((agent) => agent.rows ?? []).map((row) => row.id));
+    /** An agent's section when its profile has it, else the agent itself. */
+    const at = (key, facet) => {
+        const row = agentNodeId(key, facet);
+        return sections.has(row) ? row : agentNodeId(key);
+    };
+    const providers = new Map();
+    const definitions = new Map(workspace.providers.map((provider) => [provider.id, provider.definition]));
+    const models = new Map();
+    for (const agent of workspace.agents) {
+        const to = at(agent.key, 'models');
+        for (const binding of agent.modelBindings) {
+            // Two agents share a model's node when they name it alike and reach the same model.
+            const id = `model:${binding.provider}:${binding.apiId}:${binding.modelId}`;
+            const provider = providerNodeId(binding.provider);
+            if (!providers.has(provider)) {
+                // A provider the workspace does not define opens the first model it serves.
+                providers.set(provider, {
+                    id: provider,
+                    kind: 'provider',
+                    label: binding.provider,
+                    note: '',
+                    opens: definitions.has(binding.provider)
+                        ? provider
+                        : agentNodeId(agent.key, modelBindingNodeId(binding.key)),
+                });
+            }
+            const opens = agentNodeId(agent.key, modelBindingNodeId(binding.key));
+            const model = models.get(id);
+            if (model)
+                model.holds?.push(opens);
+            else {
+                models.set(id, {
+                    id,
+                    kind: 'model',
+                    label: binding.modelId || 'New model',
+                    note: binding.apiId,
+                    type: definitions.get(binding.provider),
+                    opens,
+                    holds: [opens],
+                });
+                links.push({ from: provider, to: id, kind: 'serves' });
+            }
+            if (!links.some((link) => link.from === id && link.to === to))
+                links.push({ from: id, to, kind: 'runs' });
+            const writer = binding.compactWith ? agentIds.get(binding.compactWith) : undefined;
+            const summarised = links.some((link) => link.kind === 'summarised' && link.from === to);
+            if (writer && writer !== agentNodeId(agent.key) && !summarised) {
+                links.push({ from: to, to: writer, kind: 'summarised' });
+            }
+        }
+        for (const key of agent.tools.allow) {
+            const tool = toolIds.get(key);
+            if (tool)
+                links.push({ from: at(agent.key, 'tools'), to: tool, kind: 'allows' });
+        }
+    }
+    const tools = workspace.toolSpecs.map((tool) => {
+        const id = toolSpecNodeId(tool.key);
+        const asked = tool.toolType === 'agent' ? agentIds.get(tool.agentKey ?? '') : undefined;
+        if (asked)
+            links.push({ from: id, to: asked, kind: 'asks' });
+        return {
+            id,
+            kind: 'tool',
+            label: tool.toolName || 'New tool',
+            note: tool.description,
+            opens: id,
+            type: tool.toolType,
+        };
+    });
+    const settings = shared.map((entry) => {
+        const { setting, facet } = entry;
+        const id = `shared:${setting.file}:${setting.name}`;
+        const users = entry.agents.filter((key) => agentIds.has(key));
+        const used = setting.tools.flatMap((name) => {
+            const tool = workspace.toolSpecs.find((spec) => spec.toolName === name);
+            return tool ? [toolSpecNodeId(tool.key)] : [];
+        });
+        for (const key of users)
+            links.push({ from: id, to: facet ? at(key, facet) : agentNodeId(key), kind: 'sets' });
+        for (const to of used)
+            links.push({ from: id, to, kind: 'sets' });
+        return {
+            id,
+            kind: 'shared',
+            label: setting.label,
+            note: `${setting.name} · ${setting.file}:${String(setting.line)}`,
+            // It opens where it is changed: the field the files set from it.
+            opens: sharedOpens(entry) ?? used[0],
+            type: facet,
+        };
+    });
+    // Each agent and its sections by the agent's place; then each model by its own, for the providers.
+    const rows = new Map(agents.flatMap((agent, row) => [agent.id, ...(agent.rows ?? []).map((each) => each.id)].map((id) => [id, row])));
+    for (const model of models.values()) {
+        const twin = [...models.values()].some((other) => other !== model && other.label === model.label);
+        if (twin && model.note)
+            model.long = `${model.label} · ${model.note}`;
+    }
+    const ordered = byRows([...models.values()], links, rows);
+    const modelRows = new Map(ordered.map((model, row) => [model.id, row]));
+    const groups = (...all) => all.filter((group) => group.nodes.length > 0);
+    const columns = [
+        groups({ label: 'Providers', nodes: byRows([...providers.values()], links, modelRows) }),
+        groups({ label: 'Shared settings', nodes: byRows(settings, links, rows) }, { label: 'Models', nodes: ordered }),
+        groups({ label: 'Profiles', nodes: agents }),
+        groups({ label: 'Tools', nodes: byRows(tools, links, rows) }),
+    ].filter((column) => column.length > 0);
+    return { columns, links };
+}
+/** Every node and every section, by id, under the node that holds it. */
+function owners(map) {
+    const nodes = map.columns.flat().flatMap((group) => group.nodes);
+    return new Map(nodes.flatMap((node) => [node.id, ...(node.rows ?? []).map((row) => row.id)].map((id) => [id, node])));
+}
+/** The nodes a link joins: a link to a profile's section joins the profile. */
+export function mapLinkEnds(map) {
+    const held = owners(map);
+    return map.links.flatMap((link) => {
+        const from = held.get(link.from)?.id;
+        const to = held.get(link.to)?.id;
+        return from !== undefined && to !== undefined ? [{ link, from, to }] : [];
+    });
+}
+/** `id` and every node a link joins it to. */
+export function mapNeighbours(map, id) {
+    return new Set([
+        id,
+        ...mapLinkEnds(map).flatMap(({ from, to }) => (from === id ? [to] : to === id ? [from] : [])),
+    ]);
+}
+/** The nodes whose name or note holds `query`, whatever its case: their ids. None for an empty query. */
+export function mapFound(map, query) {
+    const asked = query.trim().toLowerCase();
+    if (asked === '')
+        return [];
+    return map.columns
+        .flat()
+        .flatMap((group) => group.nodes)
+        .filter((node) => [node.label, node.long ?? '', node.note].some((text) => text.toLowerCase().includes(asked)))
+        .map((node) => node.id);
+}
+/**
+ * `id`'s family: the node, everything that feeds it, and everything it feeds, however many links
+ * away, with the links between them. Empty when the map has no such node. Several ids give their
+ * families together.
+ */
+export function mapFamily(map, id) {
+    const ids = typeof id === 'string' ? [id] : id;
+    const ends = mapLinkEnds(map);
+    const reached = (near, far) => {
+        const seen = new Set(ids);
+        const queue = [...ids];
+        for (let next = queue.pop(); next !== undefined; next = queue.pop()) {
+            for (const end of ends) {
+                if (end[near] !== next || seen.has(end[far]))
+                    continue;
+                seen.add(end[far]);
+                queue.push(end[far]);
+            }
+        }
+        return seen;
+    };
+    const family = new Set([...reached('to', 'from'), ...reached('from', 'to')]);
+    const columns = map.columns
+        .map((column) => column
+        .map((group) => ({ ...group, nodes: group.nodes.filter((node) => family.has(node.id)) }))
+        .filter((group) => group.nodes.length > 0))
+        .filter((column) => column.length > 0);
+    const kept = new Set(ends.filter(({ from, to }) => family.has(from) && family.has(to)).map(({ link }) => link));
+    return { columns, links: map.links.filter((link) => kept.has(link)) };
+}
+/** A link in words from each end: `[from's side, to's side]`, each before the other node's label. */
+const LINK_WORDS = {
+    serves: ['Serves', 'Served by'],
+    sets: ['Sets', 'Set by'],
+    runs: ['Runs', 'Runs on'],
+    allows: ['Allows', 'Allowed by'],
+    asks: ['Asks', 'Asked by'],
+    summarised: ['Summarised by', 'Summarises for'],
+};
+/** What joins a node to the rest, in words: "Runs on gemini-2.5-flash. Allows get_weather, find_plant." */
+export function mapLinkWords(map, id) {
+    const held = owners(map);
+    const said = new Map();
+    for (const { link, from, to } of mapLinkEnds(map)) {
+        if (from !== id && to !== id)
+            continue;
+        const words = LINK_WORDS[link.kind][from === id ? 0 : 1];
+        const other = held.get(from === id ? to : from)?.label;
+        if (other !== undefined)
+            said.set(words, [...(said.get(words) ?? []), other]);
+    }
+    return [...said].map(([words, others]) => `${words} ${others.join(', ')}.`).join(' ');
+}
+/** How many lines of its note a node shows: a tool's description and a shared setting's source run to two. */
+export function mapNoteLines(node) {
+    return node.kind === 'tool' || node.kind === 'shared' ? 2 : 1;
+}
+/** How finely a line is walked to see what it crosses, and how far apart lines going round keep. */
+const CURVE_STEPS = 24;
+const LANE_GAP = 8;
+/** How far a rail keeps from the column it is beside, and from the next rail. */
+const TURN_GAP = 2 * LANE_GAP;
+/** Each link whose ends stand `apart` or more from each other by `at`, as its span. */
+function mapSpans(map, at, apart) {
+    const fans = new Map();
+    const fan = (id, way) => `${id}:${String(way)}`;
+    const across = mapLinkEnds(map).flatMap(({ link }) => {
+        const [a, b] = [at(link.from), at(link.to)];
+        if (a === undefined || b === undefined || Math.abs(a - b) < apart)
+            return [];
+        const way = a < b ? 1 : -1;
+        for (const key of [fan(link.from, way), fan(link.to, -way)])
+            fans.set(key, (fans.get(key) ?? 0) + 1);
+        return [{ link, way }];
+    });
+    return across.map(({ link, way }) => {
+        const [out, into] = [fan(link.from, way), fan(link.to, -way)];
+        const leaves = (fans.get(out) ?? 0) >= (fans.get(into) ?? 0);
+        return { link, way, leaves, hub: leaves ? out : into };
+    });
+}
+/**
+ * Where everything on the map goes: the columns side by side from the top, each group under its
+ * heading, except a node in `moved`, which goes where it was put. A line leaves the side of a node
+ * that faces the other; between two nodes one above the other it bows out to the right, past what
+ * stands between them. Between two columns the lines that share an end run as one, and part beside
+ * the end fewer lines share, each end's lines along a rail of their own: two columns stand far enough
+ * apart for the rails between them. A line that would pass behind a node or a heading goes over or under only
+ * what is in its way, whichever is nearer. The map is large enough for every line.
+ */
+export function mapLayout(map, sizes, view = {}) {
+    const { node, card, columnGap, rowGap, heading, groupGap, padding, lineGap } = sizes;
+    const { moved = {}, widths = {}, detail = false } = view;
+    /** The column each node and section stands in, unless it was moved out of it. */
+    const columnOf = new Map();
+    map.columns.forEach((column, index) => {
+        for (const group of column)
+            for (const each of group.nodes)
+                if (!Object.hasOwn(moved, each.id))
+                    for (const id of [each.id, ...(each.rows ?? []).map((row) => row.id)])
+                        columnOf.set(id, index);
+    });
+    const put = (lefts) => {
+        const nodes = {};
+        const headings = [];
+        const boxes = [];
+        /** Where a line meets each node or section: the node's two sides and the height it joins at. */
+        const ports = new Map();
+        let right = 0;
+        let bottom = 0;
+        map.columns.forEach((column, index) => {
+            const x = lefts[index] ?? padding;
+            let y = padding;
+            column.forEach((group, at) => {
+                if (at > 0)
+                    y += groupGap;
+                headings.push({ label: group.label, x, y });
+                boxes.push({ id: `heading:${index}:${at}`, x, y, width: node.width, height: heading });
+                y += heading;
+                for (const each of group.nodes) {
+                    const rows = detail ? (each.rows ?? []) : [];
+                    // With detail a node's name is one row, as a token is; one with no note is that row alone.
+                    const noted = rows.length > 0 || each.note !== '';
+                    const full = detail && (rows.length > 0 || mapNoteLines(each) === 1) ? card.head : node.height;
+                    const head = detail && !noted ? card.row : full;
+                    const height = rows.length > 0 ? card.head + rows.length * card.row + card.foot : head;
+                    const width = Math.min(widths[each.id] ?? node.width, node.width);
+                    const put = Object.hasOwn(moved, each.id) ? moved[each.id] : undefined;
+                    const place = put ? { x: Math.max(put.x, 0), y: Math.max(put.y, 0) } : { x, y };
+                    nodes[each.id] = { ...place, height };
+                    boxes.push({ id: each.id, ...place, width, height });
+                    const port = {
+                        left: place.x,
+                        right: place.x + width,
+                        y: place.y + (detail ? card.row : head) / 2,
+                    };
+                    ports.set(each.id, port);
+                    for (const [line, row] of (each.rows ?? []).entries())
+                        ports.set(row.id, detail ? { ...port, y: place.y + card.head + line * card.row + card.row / 2 } : port);
+                    right = Math.max(right, place.x + node.width);
+                    bottom = Math.max(bottom, place.y + height);
+                    // A moved node leaves its place in the column open, so the rest hold still.
+                    y += height + rowGap;
+                }
+                y -= rowGap;
+            });
+        });
+        return { nodes, headings, boxes, ports, right, bottom };
+    };
+    /** Where a line between two columns starts and ends, and the side its rails are counted from, and which way. */
+    const reach = (span, a, b) => {
+        const { way, leaves } = span;
+        const start = { x: way > 0 ? a.right + lineGap : a.left - lineGap, y: a.y };
+        const end = { x: way > 0 ? b.left - lineGap : b.right + lineGap, y: b.y };
+        const fromSide = way > 0 ? Math.max(a.left + node.width, a.right) + lineGap : start.x;
+        const toSide = way > 0 ? end.x : Math.max(b.left + node.width, b.right) + lineGap;
+        const side = leaves ? toSide : fromSide;
+        const into = leaves ? -way : way;
+        return {
+            start,
+            end,
+            side,
+            into,
+            room: Math.abs(toSide - fromSide),
+            strip: `${String(side)}:${String(into)}`,
+        };
+    };
+    /**
+     * The rail each end's lines part on, counted from the side of the column they part beside, and how
+     * many rails each side holds. Two ends share a rail where neither's lines reach the other's.
+     */
+    const railed = (ports) => {
+        const spans = new Map(mapSpans(map, (id) => ports.get(id)?.left, node.width).map((span) => [span.link, span]));
+        const strips = new Map();
+        for (const span of spans.values()) {
+            const a = ports.get(span.link.from);
+            const b = ports.get(span.link.to);
+            if (!a || !b || a.y === b.y)
+                continue;
+            const { strip } = reach(span, a, b);
+            const ends = strips.get(strip) ?? new Map();
+            const beside = span.leaves ? span.link.to : span.link.from;
+            const end = ends.get(span.hub) ?? { y: span.leaves ? a.y : b.y, joins: [], beside };
+            end.joins.push(span.leaves ? b.y : a.y);
+            strips.set(strip, ends.set(span.hub, end));
+        }
+        const rails = new Map();
+        const held = new Map();
+        for (const [strip, ends] of strips) {
+            const mean = (all) => all.reduce((sum, y) => sum + y, 0) / all.length;
+            const all = [...ends.values()];
+            const down = mean(all.flatMap((end) => end.joins)) >= mean(all.map((end) => end.y));
+            const taken = [];
+            // The end nearest what the strip joins takes the first rail, so its trunk crosses the fewest.
+            for (const [hub, end] of [...ends].sort(([, one], [, other]) => down ? one.y - other.y : other.y - one.y)) {
+                const low = Math.min(end.y, ...end.joins) - LANE_GAP;
+                const high = Math.max(end.y, ...end.joins) + LANE_GAP;
+                const free = taken.findIndex((spansOf) => spansOf.every((each) => high < each.low || low > each.high));
+                const rail = free < 0 ? taken.length : free;
+                taken[rail] = [...(taken[rail] ?? []), { low, high }];
+                rails.set(`${strip}:${hub}`, rail);
+            }
+            const [first] = all;
+            if (first)
+                held.set(strip, {
+                    count: taken.length,
+                    beside: first.beside,
+                    into: Number(strip.split(':')[1]),
+                });
+        }
+        return { spans, rails, held };
+    };
+    // Heights do not turn on where the columns stand: lay them out once to count each side's rails, then
+    // give each pair of columns the room for both sides' rails.
+    const even = map.columns.map((_, index) => padding + index * (node.width + columnGap));
+    const rooms = map.columns.map(() => 0);
+    for (const { count, beside, into } of railed(put(even).ports).held.values()) {
+        const column = columnOf.get(beside);
+        if (column === undefined)
+            continue;
+        const after = into > 0 ? column : column - 1;
+        if (after >= 0 && after < rooms.length)
+            rooms[after] = (rooms[after] ?? 0) + count + 1;
+    }
+    const lefts = [padding];
+    for (const [index, held] of rooms.entries())
+        lefts.push((lefts[index] ?? padding) + node.width + Math.max(columnGap, held * TURN_GAP));
+    const laidOut = put(lefts);
+    const { nodes, headings, boxes, ports } = laidOut;
+    let { right, bottom } = laidOut;
+    const { spans, rails } = railed(ports);
+    const gap = columnGap / 2;
+    /** How far a line going round keeps from what it goes round. */
+    const clear = Math.max(rowGap / 2, lineGap);
+    /** The lanes lines already go round in: the next one keeps `LANE_GAP` clear of each. */
+    const laid = [];
+    /** The lane the lines of one end take round a column: they go round as one. */
+    const lanes = new Map();
+    const widest = Math.max(columnGap, ...rooms.map((held) => held * TURN_GAP));
+    const lines = mapLinkEnds(map).flatMap(({ link, from, to }) => {
+        const a = ports.get(link.from);
+        const b = ports.get(link.to);
+        if (!a || !b)
+            return [];
+        const others = boxes.filter((box) => box.id !== from && box.id !== to);
+        if (Math.abs(a.left - b.left) < node.width) {
+            const ax = a.right + lineGap;
+            const bx = b.right + lineGap;
+            const beside = others.filter((box) => box.y < Math.max(a.y, b.y) &&
+                box.y + box.height > Math.min(a.y, b.y) &&
+                box.x < Math.max(ax, bx) + gap &&
+                box.x + box.width > Math.min(a.left, b.left));
+            const bow = Math.max(ax, bx, ...beside.map((box) => box.x + box.width)) + gap;
+            right = Math.max(right, bow);
+            return [{ link, from, to, d: mapCurve({ x: ax, y: a.y }, { x: bx, y: b.y }, bow).d }];
+        }
+        const span = spans.get(link);
+        if (!span)
+            return [];
+        const { way, leaves, hub } = span;
+        const { start, end, side, into, room, strip } = reach(span, a, b);
+        // The lines of one end part on a rail beside the end fewer lines share.
+        const step = Math.min((1 + (rails.get(`${strip}:${hub}`) ?? 0)) * TURN_GAP, Math.max(room - TURN_GAP, 0));
+        const rail = side + into * step;
+        const curve = room < 2 * TURN_GAP ? mapCurve(start, end) : mapRail(start, end, rail, LANE_GAP);
+        const near = (box, y) => y > box.y - clear && y < box.y + box.height + clear;
+        const crossed = Math.abs(end.x - start.x) < widest + columnGap
+            ? []
+            : others.filter((box) => Array.from({ length: CURVE_STEPS - 1 }, (_, step) => curve.at((step + 1) / CURVE_STEPS)).some((point) => point.x > box.x && point.x < box.x + box.width && near(box, point.y)));
+        if (crossed.length === 0)
+            return [{ link, from, to, d: curve.d }];
+        const [low, high] = [Math.min(start.x, end.x), Math.max(start.x, end.x)];
+        /** The lane on one side of what the line crossed, and of whatever stands in that lane's way. */
+        const lane = (side) => {
+            const around = [...crossed];
+            for (;;) {
+                const y = side < 0
+                    ? Math.min(...around.map((box) => box.y)) - clear
+                    : Math.max(...around.map((box) => box.y + box.height)) + clear;
+                const more = [...others, ...laid].filter((box) => !around.includes(box) && box.x < high && box.x + box.width > low && near(box, y));
+                if (more.length === 0)
+                    return y;
+                around.push(...more);
+            }
+        };
+        const far = (y) => Math.abs(a.y - y) + Math.abs(b.y - y);
+        const shared = `${hub}:${strip}`;
+        const pick = () => {
+            const [over, under] = [lane(-1), lane(1)];
+            const y = over >= 0 && far(over) <= far(under) ? over : under;
+            laid.push({
+                id: '',
+                x: low,
+                y: y - LANE_GAP + clear,
+                width: high - low,
+                height: 2 * (LANE_GAP - clear),
+            });
+            lanes.set(shared, y);
+            return y;
+        };
+        const y = lanes.get(shared) ?? pick();
+        bottom = Math.max(bottom, y);
+        // Round a column on rails too: out beside its own end, back in beside the other.
+        const out = leaves ? start.x + way * TURN_GAP : rail;
+        const back = leaves ? rail : end.x - way * TURN_GAP;
+        const mid = { x: (out + back) / 2, y };
+        const d = mapRail(start, mid, out, LANE_GAP).d +
+            mapRail(mid, end, back, LANE_GAP).d.replace(/^M \S+ \S+/, '');
+        return [{ link, from, to, d }];
+    });
+    return {
+        width: Math.max((lefts[Math.max(map.columns.length - 1, 0)] ?? padding) + node.width, right) +
+            padding,
+        height: Math.max(bottom, padding) + padding,
+        nodes,
+        headings,
+        lines,
+    };
+}

package/media-accept.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A kind's wildcard (`image/*`, …) means every type of that kind, since the kernel rejects
+ * unknown types at ingress anyway. A draft stores the canonical list (a wildcard stands alone for
+ * its kind); a picker shows the expanded list, so every covered type reads as selected.
+ */
+import { type MediaInputKind } from '@theoremjs/agents/schema';
+export interface AcceptSection {
+    kind: MediaInputKind;
+    wildcard?: string;
+    mimes: string[];
+}
+export declare function acceptSections(options: readonly string[]): AcceptSection[];
+/** Each wildcard brings every type it covers. */
+export declare function expandAccept(accept: readonly string[], sections: readonly AcceptSection[]): string[];
+/**
+ * Picking a wildcard takes every type of its kind; unpicking it clears the kind; unpicking one
+ * type under a wildcard keeps the rest; picking every type of a kind collapses to its wildcard.
+ */
+export declare function nextAccept(previous: readonly string[], selected: readonly string[], sections: readonly AcceptSection[]): string[];

package/media-accept.js

@@ -0,0 +1,65 @@
+/**
+ * A kind's wildcard (`image/*`, …) means every type of that kind, since the kernel rejects
+ * unknown types at ingress anyway. A draft stores the canonical list (a wildcard stands alone for
+ * its kind); a picker shows the expanded list, so every covered type reads as selected.
+ */
+import { MEDIA_INPUT_KINDS } from '@theoremjs/agents/schema';
+export function acceptSections(options) {
+    const sections = new Map();
+    const section = (kind) => {
+        const existing = sections.get(kind);
+        if (existing)
+            return existing;
+        const created = { kind, mimes: [] };
+        sections.set(kind, created);
+        return created;
+    };
+    for (const mime of options) {
+        const kind = MEDIA_INPUT_KINDS[mime] ?? wildcardKind(mime);
+        if (!kind)
+            continue;
+        if (mime.endsWith('/*'))
+            section(kind).wildcard = mime;
+        else
+            section(kind).mimes.push(mime);
+    }
+    return [...sections.values()];
+}
+/** Each wildcard brings every type it covers. */
+export function expandAccept(accept, sections) {
+    const covered = sections.flatMap(({ wildcard, mimes }) => wildcard && accept.includes(wildcard) ? mimes : []);
+    return [...new Set([...accept, ...covered])];
+}
+/**
+ * Picking a wildcard takes every type of its kind; unpicking it clears the kind; unpicking one
+ * type under a wildcard keeps the rest; picking every type of a kind collapses to its wildcard.
+ */
+export function nextAccept(previous, selected, sections) {
+    const next = [];
+    for (const { wildcard, mimes } of sections) {
+        const picked = mimes.filter((mime) => selected.includes(mime));
+        if (!wildcard) {
+            next.push(...picked);
+            continue;
+        }
+        const had = previous.includes(wildcard);
+        const has = selected.includes(wildcard);
+        if (has && !had)
+            next.push(wildcard);
+        else if (had && !has)
+            continue;
+        else if (picked.length === mimes.length)
+            next.push(wildcard);
+        else
+            next.push(...picked);
+    }
+    const known = new Set(sections.flatMap(({ wildcard, mimes }) => (wildcard ? [wildcard, ...mimes] : mimes)));
+    return [...next, ...selected.filter((mime) => !known.has(mime))];
+}
+function wildcardKind(mime) {
+    if (!mime.endsWith('/*'))
+        return undefined;
+    const prefix = mime.slice(0, -1);
+    const concrete = Object.keys(MEDIA_INPUT_KINDS).find((mime) => mime.startsWith(prefix));
+    return concrete ? MEDIA_INPUT_KINDS[concrete] : undefined;
+}

package/mod.d.ts

@@ -0,0 +1,39 @@
+export { type StudioAsks, type WriteAsk, writeAsk, writeAskLine } from './asks.ts';
+export { KNOWN_GEMINI_EMBEDDING_MODELS, KNOWN_OPENROUTER_EMBEDDING_MODELS, } from './browser-connection.ts';
+export { type CompiledStudio, compileStudio, credentialHeaderProblem, credentialUrlProblem, type StudioCompileResult, type StudioIssue, type StudioProfileDefinition, type StudioTurnProfileDefinition, } from './compile.ts';
+export { type CompiledWorkspace, compileWorkspace, type WorkspaceCompileResult, workspaceRunAgent, } from './compile-workspace.ts';
+export { DEMO_ALLOWED_HOSTS, DEMO_CONCIERGE_SYSTEM, DEMO_HTTP_SAMPLE_INPUT, demoHttpSampleInput, demoInputsSpec, demoToolSpecs, } from './concierge-demo.ts';
+export { agentToolTarget, COMPACTION_DRAFT_DEFAULTS, createBlankDraft, type DecisionCriterionDraft, type DecisionDraft, type DecisionImageDraft, type DecisionQuestionDraft, type DecisionQuestionType, defaultModelBinding, defaultToolSpec, draftAllows, draftFacets, draftKey, type EffortDraft, EXAMPLE_DECISION_STATE, EXAMPLE_EMBEDDING_QUERY, EXAMPLE_EMBEDDING_TEXT, EXAMPLE_SPAN_DECISION_STATE, exampleDecisionDraft, excludeFacet, type GuardrailsDraft, type IdentityDraft, type ImageDraft, type ImageReferenceDraft, INLINE_LABELS, type InputsDraft, type ItemRuleOnFail, includableFacets, includeFacet, type LabelsDraft, type LiveDraft, type ModelBindingDraft, type ModelsDraft, newCriteria, newDecisionImage, newDecisionQuestion, newModelBinding, newOwnDetector, newPattern, newToolSpec, type ObservabilityDraft, type OutputsDraft, type OwnDetectorDraft, type PatternDraft, type PatternSourceDraft, plantsCanary, removeModelBinding, type SpeechDraft, STUDIO_PROFILE_TYPES, type StudioDraft, type StudioProfileType, type StudioTurnProfileType, setProfileType, type ToolSpecDraft, type ToolsDraft, type TurnBehaviourDraft, takesContinueInstruction, updateModelBinding, } from './draft.ts';
+export { addArchitectExample, createArchitectWorkspace, createConsoleExampleDraft, createDecisionExampleDraft, createExampleDraft, createGeminiEmbeddingExampleDraft, createLiveExampleDraft, createNarratorExampleDraft, createSpanExampleDraft, DECISION_EXAMPLE_AGENT_ID, DECISION_EXAMPLE_STATE, decisionExampleAssets, } from './example.ts';
+export { EXAMPLE_EMBEDDING_FILES } from './example-embedding-files.ts';
+export type { GuardrailProbe, GuardrailProbeAnswer, GuardrailProbeDraft, GuardrailProbeResult, ProbeBoundary, ProbeBoundaryNote, ProbeStatus, } from './guardrail-probe.ts';
+export { PROBE_BOUNDARIES, PROBE_BOUNDARY_NOTES, PROBE_STATUSES, PROBE_TEXT_LIMIT, probeDraft, probeRefusal, runGuardrailProbe, runGuardrailProbes, } from './guardrail-probe.ts';
+export { unheldProblem } from './held-credentials.ts';
+export { type LentBinding, type LentDecisionLimits, type LentHolds, type LentKeys, type LentModel, lentCompression, type ModelBindingViolation, type ModelPicks, type ModelProfileType, type ModelStart, ON_OWN_KEYS, type StudioRunsOn, studioNetworkNote, studioTaintNote, } from './lent-keys.ts';
+export { type DiffLine, lineDiff } from './line-diff.ts';
+export type { StudioLiveDraftMessage } from './live-connection.ts';
+export { studioLiveConnection, studioPageTools } from './live-connection.ts';
+export { type MapGroup, type MapLayout, type MapLine, type MapLink, type MapLinkKind, type MapNode, type MapNodeKind, type MapPlace, type MapRow, type MapSizes, type MapView, mapFamily, mapFound, mapLayout, mapLinkEnds, mapLinkWords, mapNeighbours, mapNoteLines, type WorkspaceMap, workspaceMap, } from './map.ts';
+export { type AcceptSection, acceptSections, expandAccept, nextAccept } from './media-accept.ts';
+export { type NodeOrigins, nodeOrigins, openOutcome, originLabel, originPlace, originShortLabel, originWay, rowOrigin, } from './origins.ts';
+export { firstServed, isGoogleRoute, isOpenRouterRoute, isProviderBuiltinId, modelBindingViolation, STUDIO_TRACE_DESTINATION, type StudioConnectionMode, startingBinding, studioRunsProvider, } from './policy.ts';
+export { PROBE_BATTERY, type ProbeBatteryCase } from './probe-battery.ts';
+export { type ConnectionField, connectionFields, definitionFactory, definitionOf, definitionOfFactory, kernelDefinition, kernelDefinitions, LOCAL_PROVIDER_ID, localProviderAddress, type ModelRoute, modelRoute, modelSlots, onStudioLocal, optionAt, type ProtocolOptionField, type ProviderProblem, protocolOptionFields, providerProblems, registerStudioProvider, STUDIO_PROVIDERS, type StudioProvider, servedProtocols, servesProfileType, takesKey, withOption, } from './providers.ts';
+export { type AgentKeyOf, type ProviderSourceRead, readProviderSource, readStudioSource, type StudioSourceError, type StudioSourceRead, type StudioSourceSpan, } from './read-source.ts';
+export type { AgentToolRegistration, FunctionToolRegistration, HttpToolRegistration, McpToolRegistration, StructuredRegistration, ToolRegistration, } from './registrations.ts';
+export { bindingSlots, defaultEffortRequired, defaultModelRequired, inputLimitsRequired, keySlotUnset, } from './requirements.ts';
+export { clearStudioRunPayload, createStudioRunId, keptStudioRunIds, loadStudioRunPayload, readStudioRunIdFromUrl, STUDIO_RUN_INDEX_KEY, STUDIO_RUN_PAYLOAD_CAP, STUDIO_RUN_PAYLOAD_KEY, STUDIO_RUN_PAYLOAD_KEY_PREFIX, type StudioRunIndex, type StudioRunIndexEntry, type StudioRunPayload, saveStudioRunPayload, studioRunPayloadKey, upsertStudioRunIndex, } from './run-payload.ts';
+export type { StudioDependency } from './runtime-scope.ts';
+export { sectionNote } from './section-notes.ts';
+export { type Ask, type AskPlace, askParts, reachesOthers, type SharedCarry, type SharedReach, type SharedSites, type SharedSnapshot, sharedAsk, sharedSnapshot, shortPlace, type ToolReach, type ToolSnapshot, toolReach, toolSnapshot, withSharedCarry, withToolCarry, } from './shared-carry.ts';
+export { type SharedEntry, sharedAt, sharedEntries, sharedNodeId, sharedOpens, } from './shared-settings.ts';
+export { agentModulePath, importSpecifier, type ProjectCode, providerSource, type SourceFile, studioSource, workspaceSource, } from './source.ts';
+export { sampleToolInput, stubOutputFromSchema } from './stub.ts';
+export { DEFAULT_TOOL_INPUT_SCHEMA, DEFAULT_TOOL_OUTPUT_SCHEMA, parseJsonSchema, sampleFromJsonSchema, zodFromJsonSchema, } from './tool-schema.ts';
+export { registerStudioTools, type StudioToolHandler, type StudioToolHandlers } from './tools.ts';
+export { createStudioTraceRouter, STUDIO_RUN_METADATA_KEY, type StudioTraceLine, type StudioTraceRoute, type StudioTraceRouter, } from './traces.ts';
+export type { StudioSteerLine, StudioTransportOptions } from './transport.ts';
+export { clearStaleStudioRuns, createStudioDecisionTransport, createStudioEmbeddingTransport, createStudioHostTransport, createStudioTransport, studioInterface, studioRunDefines, } from './transport.ts';
+export { modelBindingNodeId, providerIdOf, providerNodeId, type StudioNodeRef, type StudioTreeNode, studioNodeRef, studioTree, toolSpecKeyOf, toolSpecNodeId, } from './tree.ts';
+export type { StudioInputsSpec, StudioToolSeed, StudioToolSpecSeed } from './types.ts';
+export { type AgentDraft, type AgentToolsDraft, addAgent, addProvider, agentDraft, agentNodeId, atStart, createBlankWorkspace, duplicateAgent, editedSince, type FileConflict, type FilesMerge, type FileUpdate, filesPrint, libraryDraft, mergedWithFiles, modelSharers, newProvider, providersAtStart, providerUse, rebased, removeAgent, removeLibraryTool, removeProvider, renameProvider, reopened, resetAgent, resetAll, resetLibraryTool, resetProvider, type SettingPath, STUDIO_WORKSPACE_VERSION, type StudioWorkspace, scopedNodeId, setToolAllowed, startedHere, type WorkspaceNodeRef, type WorkspaceStarts, type WorkspaceTree, withAgentDraft, withFilesChosen, withLibraryDraft, withProvider, workspaceFromDraft, workspaceNodeRef, workspaceTree, } from './workspace.ts';