@hypit/hypit 0.1.4 → 0.1.5

package/packages/studio/INSPECTOR.md

@@ -18,7 +18,20 @@ its color is How, and the object's frame is Where. One field has one owner and o
 ## Controls describe the editing task
 
 `bindings` exposes actual author endpoints; `inspector` chooses which to show. A resolved field is
-shown only when its binding is writable. The finite controls are independent of the three domains:
+shown when selected by the Companion, including read-only bindings. The interface orders available
+domains as Where, When, How. Read-only values and editable controls share the same sections.
+
+A projected entity may supply a few computed `inspector` facts without binding them to Source:
+
+```ts
+inspector: [{ id: "range", label: "Range", domain: "when",
+  section: { id: "placement", label: "Placement" }, value: "15–105", unit: "f" }]
+```
+
+The resolved DTO carries an `edit: { language, source }` only for writable author fields.
+The UI uses plain selectable text otherwise; the server requires that endpoint for writes.
+Choose facts that explain the selected object or its controls. Component headers organize lanes;
+the selected entities own their details. The finite controls are independent of the three domains:
 
 | Control | Use |
 | --- | --- |
@@ -30,7 +43,7 @@ shown only when its binding is writable. The finite controls are independent of
 | `list` | An ordered value described by an array schema, such as a palette or repeated settings. |
 | `record` | Named values described by an object schema, such as one shadow's parameters. |
 
-Lists and records retain Apply/Reset drafts. Their schema owns value shape. There is no separate
+Lists and records save complete, valid values when editing ends. Incomplete edits show a completion hint; their schema owns value shape. There is no separate
 palette database, font control protocol, generic CSS editor, or component-supplied DOM renderer.
 Use text for an expression whose parts cannot meaningfully be edited as one number.
 

package/packages/studio/README.md

@@ -72,14 +72,78 @@ transient processing require the selected Runtime.
 
 ## Opening and editing a session
 
+The CLI prints the actual session URL and its direct `#comments` URL after the server chooses a port.
+Open the latter to review the current composition before export. Browser playback creates no export
+Build or encoded video; an export remains a separate Run execution when the user wants the file.
+
+The top-right **Studio / Comments** tabs change the layout around the same composition player.
+Comments gives the picture the available height with a notes column on the right. Click the picture
+to play or pause; the wider progress control seeks, with a hovered-frame preview that leaves the
+main playhead alone. The hover picture uses one lazy, muted instance of the current preview document,
+released when leaving Comments. It needs no Build or thumbnail files.
+
+Studio retains picture selection and its right-click menu for overlapping Companion entities.
+Comments uses viewing controls without selecting objects. Switching views preserves the composition
+time and Studio's selection; comments themselves only refer to a time and the user's words.
+
+### Comments are project files
+
+Studio saves comments in `<workspace>/FEEDBACK.json`, creating it on the first saved comment.
+This path is Studio's project-file convention, rooted in the resolved workspace; it is independent
+of the Runtime, Result repository and Agent implementation.
+Each comment records its reviewed Run relative to that workspace, so the file can hold notes for
+several Runs while the UI shows the current Run. Times are seconds, including fractional seconds:
+
+```json
+{
+  "comments": [
+    {
+      "id": "caption-size",
+      "run": "runs/main.svrun",
+      "at": 12.5,
+      "text": "Make this caption larger.",
+      "resolved": false
+    }
+  ]
+}
+```
+
+`id`, `run`, `at` and `text` are required. `resolved` defaults to false; setting it to true marks
+the comment complete, and false reopens it. Deleting removes the entry. Following a note seeks to
+its saved time; a changed composition can show something different at that time.
+
+Focusing the comment composer pauses the picture and captures the current frame. The time chip
+captures a new time. The draft keeps its time while the user writes. Click a saved timestamp to
+revisit it. Comments can be edited, completed, reopened and deleted from the UI or by editing the file.
+The list is ordered by timestamp. Its `#1`, `#2` labels follow submission order within the current
+Run (the file's array order) and appear beside the completion control. Changing a timestamp or
+filtering Open/Done preserves those numbers; deleting a note closes its gap in the numbering.
+The stored `id` remains the stable identity. Clicking a note's text or time seeks
+to its frame. The composer has an icon-only send control; emoji and drawing buttons are inactive placeholders.
+Clicking outside the selected note clears its highlight without discarding an edit. Enter sends a
+new note or saves an edited one; Shift+Enter or Alt+Enter inserts a line break. IME confirmation stays
+with the text input rather than submitting the comment.
+
+File changes refresh comments through filesystem events, without polling or recompiling the video.
+Studio reads the file afresh for each edit, preserves unrelated notes and project-added fields, and
+rejects an edit to a comment that has changed since it was displayed. An invalid manually edited
+file remains intact and its error is shown. Unsent text stays in the browser. Agent notification is
+a separate, planned connection; **Send comment** currently saves the note only.
+
+### Composition editing
+
 The selected targets must reach one Film and its resolved time source. Studio rejects several
-distinct Films in one view; use separate Runs/sessions for those. A SemanticTrack supplies the
-Script lane and performance timing, including wordless Segments with media spans. A declared
-ProgramSpace supplies authored animation time without a Script lane. Both show their component
-tracks and use the same rendering and parameter-editing machinery. When the snapshot contains
-a semantic timeline, its lane and label stay pinned directly below the time ruler while
-component tracks scroll. Its presence follows the resolved semantic timeline, including
-wordless content, rather than a component name or the presence of spoken words.
+distinct Films in one view; use separate Runs/sessions for those. A Timeline supplies the
+placed material and semantic timing, including wordless Segments. The ruler always shows program
+time. When placed Segments are present, its left Timeline header spans the time ticks and the
+Segment, Word and Selection/Moment bands. Empty Word or marker bands are omitted based on the
+whole work, not the visible window or playhead. With no Segments, only the ordinary time ruler remains.
+The complete ruler area stays pinned while component tracks scroll.
+
+Semantic objects retain declaration-order drawing within each band. Their fine borders distinguish
+adjacent and overlapping intervals without inventing time gaps. Selection raises an object above
+its peers; playback highlighting changes color without changing that order. Right-click an overlap
+to choose a covered object. These are editor presentation rules, independent of Film paint order.
 
 Open the URL printed by Vite. Studio requests port 5179 by default, accepts `--port`,
 and Vite can choose another available port when it is occupied. Reuse that process
@@ -90,11 +154,14 @@ package code or imports that introduce new packages. Browser refresh does not re
 server-side package modules.
 
 The Source pane can edit the selected `.svml`, `.svs` or `.svrun` file. The Inspector
-shows project facts when no entity is selected and only declared writable fields for
+shows project facts when no entity is selected and declared facts and author fields for
 the selected entity. A reference can resolve to a shared Frame or Recipe, so one edit
-may affect several consumers. Structured fields use Apply/Reset for their local draft.
+may affect several consumers. Structured fields save together when editing ends and the value is complete; missing required values stay in the editor with a completion hint.
 Check save status; source conflicts reject stale edits rather than overwrite newer files.
 
+The Timeline owns the editor's complete range; displayed objects do not extend it. Take placement
+and complete extent are reference information in Studio.
+
 Timeline gestures use explicit temporal authority. Moving a shared Selection or
 Moment edits Script and moves its consumers after recompilation. A parameter-based
 handle edits its exact authored parameter. Fixed or derived values with no supported
@@ -137,12 +204,11 @@ at runtime. Ship the Companion's compiled JavaScript with its component package.
 The companion owns what its Track means: matching, required same-Surface values,
 entities, lane range, finite chrome, title and ordered text/material layers,
 source bindings, Inspector fields and executed temporal lineage. Inspector fields
-select real writable bindings and organize them under the Studio-owned
-`Where / How / When` domains, optional companion-owned pages and sections. A
+select real bindings or package-owned facts and organize them under the Studio-owned
+`Where / When / How` domains, optional companion-owned pages and sections. A
 source binding is never shown merely because Studio can reach it. Material layers carry a
-Resource id or Surface identity, never a Studio HTTP URL. Studio always owns
-time formatting and transport resolution, so chrome and material cannot hide a
-title or its time.
+Resource id or Surface identity, never a Studio HTTP URL. Studio owns time formatting and transport resolution. Compact chrome shows one primary label;
+computed time remains available in its tooltip rather than competing with that label.
 Studio owns session-wide behavior and chrome: Companion assembly, single-row overlap display,
 fallback defaults, selection treatment, playback, zoom,
 scrolling, the finite Inspector control set and source mutation transport. A
@@ -184,3 +250,11 @@ semantics.
 
 Read [`@hypit/studio-adapter`](../studio-adapter/README.md) for the Companion ABI,
 project activation example, value projection and Inspector declarations.
+
+## Composition audio preview
+
+The preview consumes generic AudioClips: source sampling, fixed gain, program-sample gain envelopes,
+audibility regions and target-relative fades. Web Audio gain nodes schedule the independent factors
+on the same clock, including silence and amplification above unity. Visual video elements stay muted;
+the Film's selected AudioTracks own composition sound. Seeking is silent. This path is independent of
+which component emitted a clip.

package/packages/studio/package.json

@@ -12,34 +12,35 @@
     "@hypit/build-result": "workspace:*",
     "@hypit/caption-fine-studio": "workspace:*",
     "@hypit/cli": "workspace:*",
+    "@hypit/comment-sticker-studio": "workspace:*",
     "@hypit/compiler-node": "workspace:*",
     "@hypit/component-kit": "workspace:*",
     "@hypit/composition": "workspace:*",
-    "@hypit/comment-sticker-studio": "workspace:*",
     "@hypit/core": "workspace:*",
-    "@hypit/driver-node": "workspace:*",
     "@hypit/deck-track-studio": "workspace:*",
+    "@hypit/driver-node": "workspace:*",
     "@hypit/elaborator": "workspace:*",
     "@hypit/film-studio": "workspace:*",
     "@hypit/hyperframes": "workspace:*",
     "@hypit/markup": "workspace:*",
     "@hypit/media-track-studio": "workspace:*",
-    "@hypit/narrative": "workspace:*",
     "@hypit/package-loader-node": "workspace:*",
+    "@hypit/performance-studio": "workspace:*",
+    "@hypit/sound-studio": "workspace:*",
     "@hypit/program-space": "workspace:*",
+    "@hypit/project-context-node": "workspace:*",
     "@hypit/protocol": "workspace:*",
     "@hypit/ranking-studio": "workspace:*",
     "@hypit/run": "workspace:*",
     "@hypit/runtime": "workspace:*",
     "@hypit/runtime-host-node": "workspace:*",
-    "@hypit/script-studio": "workspace:*",
     "@hypit/screen-overlay-studio": "workspace:*",
+    "@hypit/script-studio": "workspace:*",
     "@hypit/speech": "workspace:*",
-    "@hypit/semantic-track": "workspace:*",
+    "@hypit/studio-adapter": "workspace:*",
     "@hypit/svs": "workspace:*",
     "@hypit/temporal": "workspace:*",
-    "@hypit/studio-adapter": "workspace:*",
-    "@hypit/speech-track-studio": "workspace:*",
+    "@hypit/timeline": "workspace:*",
     "@hypit/typography-track-studio": "workspace:*",
     "@hypit/validation": "workspace:*",
     "@hypit/video-cli": "workspace:*",

package/packages/studio/src/companion-assembly.ts

@@ -34,6 +34,7 @@ export async function loadStudioCompanionRegistry(input: {
     {
       films: contributions.flatMap((item) => item.films),
       scripts: contributions.flatMap((item) => item.scripts),
+      parameters: contributions.flatMap((item) => item.parameters),
     },
   );
 }

package/packages/studio/src/domain.ts

@@ -33,7 +33,7 @@ export type StudioDomain = {
 
 /**
  * Assemble Studio from the same recursive package selection as the official CLI.
- * The application owns this video-domain view; packages never register Studio metadata.
+ * The application assembles the video-domain view; selected packages contribute Studio Companions through host facets.
  */
 export async function loadStudioDomain(input: {
   readonly run: string;

package/packages/studio/src/fallback-companions.ts

@@ -1,7 +1,7 @@
 import type { StudioTrackCompanion, StudioTrackCompanionContext, StudioEntityDraft } from "@hypit/studio-adapter";
 import { artifactPreview, previewLayer, temporalLineageFor, temporalSemanticSource } from "@hypit/studio-adapter";
 import { compositionTypes } from "@hypit/composition";
-import { semanticTrackTypes } from "@hypit/semantic-track";
+import { timelineTypes } from "@hypit/timeline";
 
 type TerminalVisualTrack = {
   readonly presents?: readonly {
@@ -79,8 +79,8 @@ function projectTerminalAudio(context: StudioTrackCompanionContext): readonly St
 /** Cross-domain terminal protocols understood even when no Companion is installed. */
 export const fallbackStudioTrackCompanions: readonly StudioTrackCompanion[] = [
   {
-    id: "@hypit/studio#semantic-track", role: "semantic-track", output: { type: semanticTrackTypes.track },
-    family: "semantic", tone: "teal", label: "Semantic", icon: "brand",
+    id: "@hypit/studio#timeline", role: "timeline", output: { type: timelineTypes.track },
+    family: "semantic", tone: "teal", label: "Timeline", icon: "brand",
     lane: { heightPx: 45 },
   },
   {

package/packages/studio/src/feedback-server.ts

@@ -0,0 +1,51 @@
+import { watch } from "node:fs";
+import { relative } from "node:path";
+import type { Plugin } from "vite";
+import { createFeedbackStore, FeedbackConflict } from "./feedback-store.js";
+import { readFeedbackMutation } from "./feedback.js";
+import type { FeedbackDocument, FeedbackView } from "./feedback.js";
+
+/** Review storage is separate from compilation, Results and Agent delivery. */
+export function studioFeedbackPlugin(workspaceRoot: string, runPath: string): Plugin {
+  const store = createFeedbackStore(workspaceRoot);
+  const run = relative(workspaceRoot, runPath).replaceAll("\\", "/");
+  const view = (document: FeedbackDocument): FeedbackView => ({
+    file: "FEEDBACK.json", run, comments: document.comments.filter((comment) => comment.run === run),
+  });
+  return {
+    name: "hypit-studio-feedback",
+    configureServer(server) {
+      const watcher = watch(workspaceRoot, (_event, filename) => {
+        if (filename === null || filename.toString() === "FEEDBACK.json") {
+          server.ws.send({ type: "custom", event: "studio:feedback-changed", data: {} });
+        }
+      });
+      server.httpServer?.once("close", () => watcher.close());
+      server.middlewares.use((request, response, next) => {
+        if (new URL(request.url ?? "/", "http://studio.hypit.local").pathname !== "/__studio/feedback") return next();
+        response.setHeader("content-type", "application/json; charset=utf-8");
+        response.setHeader("cache-control", "no-store");
+        void (async () => {
+          try {
+            if (request.method === "GET") {
+              response.end(JSON.stringify(view(await store.read())));
+              return;
+            }
+            if (request.method !== "POST") { response.statusCode = 405; response.end(); return; }
+            const chunks: Buffer[] = [];
+            for await (const chunk of request) chunks.push(Buffer.from(chunk));
+            const mutation = readFeedbackMutation(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            const comment = mutation.type === "delete" ? mutation.before : mutation.comment;
+            if (comment.run !== run) throw new Error("The comment belongs to another Run.");
+            const result = view(await store.mutate(mutation));
+            response.end(JSON.stringify(result));
+            server.ws.send({ type: "custom", event: "studio:feedback-changed", data: {} });
+          } catch (error) {
+            response.statusCode = error instanceof FeedbackConflict ? 409 : 400;
+            response.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+          }
+        })();
+      });
+    },
+  };
+}

package/packages/studio/src/feedback-store.ts

@@ -0,0 +1,66 @@
+import { isDeepStrictEqual } from "node:util";
+import { randomUUID } from "node:crypto";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readFeedbackDocument } from "./feedback.js";
+import type { FeedbackDocument, FeedbackMutation } from "./feedback.js";
+
+export class FeedbackConflict extends Error {}
+
+/** The file is authoritative; every operation reads it afresh and edits one note. */
+export function createFeedbackStore(workspaceRoot: string) {
+  const path = join(workspaceRoot, "FEEDBACK.json");
+  let pending: Promise<unknown> = Promise.resolve();
+  const readText = async (): Promise<string | undefined> => {
+    try { return await readFile(path, "utf8"); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+      throw error;
+    }
+  };
+  const decode = (text: string | undefined): FeedbackDocument => text === undefined
+    ? { comments: [] } : readFeedbackDocument(JSON.parse(text));
+
+  const apply = async (mutation: FeedbackMutation): Promise<FeedbackDocument> => {
+    const previous = await readText();
+    const document = decode(previous);
+    const comments = [...document.comments];
+    if (mutation.type === "add") {
+      if (comments.some((comment) => comment.id === mutation.comment.id)) throw new FeedbackConflict("This comment already exists.");
+      comments.push(mutation.comment);
+    } else {
+      const index = comments.findIndex((comment) => comment.id === mutation.before.id);
+      if (index < 0 || !isDeepStrictEqual(comments[index], mutation.before)) {
+        throw new FeedbackConflict("This comment changed outside this view. Your unsaved text is kept in the editor; reopen the comment to edit its latest version.");
+      }
+      if (mutation.type === "delete") comments.splice(index, 1);
+      else {
+        if (mutation.comment.id !== mutation.before.id || mutation.comment.run !== mutation.before.run) {
+          throw new Error("Editing a comment preserves its id and Run.");
+        }
+        comments[index] = mutation.comment;
+      }
+    }
+    const next = { ...document, comments };
+    const temporary = join(workspaceRoot, `.FEEDBACK.${randomUUID()}.tmp`);
+    try {
+      await writeFile(temporary, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+      if (await readText() !== previous) throw new FeedbackConflict("FEEDBACK.json changed while saving. Your draft is kept; please try again.");
+      await rename(temporary, path);
+    } finally {
+      await unlink(temporary).catch((error: NodeJS.ErrnoException) => { if (error.code !== "ENOENT") throw error; });
+    }
+    return next;
+  };
+
+  return {
+    path,
+    read: async (): Promise<FeedbackDocument> => decode(await readText()),
+    mutate(mutation: FeedbackMutation): Promise<FeedbackDocument> {
+      // Serialize browser submissions, without keeping a second copy of the document.
+      const result = pending.then(() => apply(mutation));
+      pending = result.catch(() => undefined);
+      return result;
+    },
+  };
+}

package/packages/studio/src/feedback.ts

@@ -0,0 +1,60 @@
+/** Project-owned review notes. Times are seconds in the reviewed Run. */
+export type FeedbackComment = {
+  readonly id: string;
+  readonly run: string;
+  readonly at: number;
+  readonly text: string;
+  readonly resolved?: boolean;
+};
+
+export type FeedbackDocument = { readonly comments: readonly FeedbackComment[] };
+export type FeedbackView = FeedbackDocument & { readonly file: string; readonly run: string };
+export type FeedbackMutation =
+  | { readonly type: "add"; readonly comment: FeedbackComment }
+  | { readonly type: "replace"; readonly before: FeedbackComment; readonly comment: FeedbackComment }
+  | { readonly type: "delete"; readonly before: FeedbackComment };
+
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function nonempty(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function time(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+export function readFeedbackComment(value: unknown): FeedbackComment {
+  if (!record(value) || !nonempty(value.id) || !nonempty(value.run) || !nonempty(value.text) || !time(value.at)) {
+    throw new Error("Each comment needs an id, run, non-empty text and a non-negative time in seconds.");
+  }
+  if (value.resolved !== undefined && typeof value.resolved !== "boolean") throw new Error("Comment resolved must be true or false.");
+  // Preserve any project-added fields when Studio edits this document.
+  return value as FeedbackComment;
+}
+
+export function readFeedbackDocument(value: unknown): FeedbackDocument {
+  if (!record(value) || !Array.isArray(value.comments)) throw new Error("FEEDBACK.json needs a comments array.");
+  const ids = new Set<string>();
+  for (const entry of value.comments) {
+    const comment = readFeedbackComment(entry);
+    if (ids.has(comment.id)) throw new Error(`Duplicate comment id: ${comment.id}`);
+    ids.add(comment.id);
+  }
+  return value as FeedbackDocument;
+}
+
+export function readFeedbackMutation(value: unknown): FeedbackMutation {
+  if (!record(value)) throw new Error("Expected a comment operation.");
+  if (value.type === "add") return { type: "add", comment: readFeedbackComment(value.comment) };
+  if (value.type === "delete") return { type: "delete", before: readFeedbackComment(value.before) };
+  if (value.type === "replace") return { type: "replace", before: readFeedbackComment(value.before), comment: readFeedbackComment(value.comment) };
+  throw new Error("Unknown comment operation.");
+}
+
+export function feedbackClock(seconds: number): string {
+  const ticks = Math.round(seconds * 100);
+  return `${String(Math.floor(ticks / 6000)).padStart(2, "0")}:${String(Math.floor(ticks / 100) % 60).padStart(2, "0")}.${String(ticks % 100).padStart(2, "0")}`;
+}

package/packages/studio/src/parameter-values.ts

@@ -1,6 +1,6 @@
 import type { CanonicalValue, ValueSchema } from "@hypit/protocol";
 import { formatSvsValue } from "@hypit/svs";
-import type { StudioInspectorField, StudioParameterOption, StudioNumberPresentation } from "@hypit/studio-adapter";
+import type { StudioInspectorField, StudioParameterControl, StudioParameterOption, StudioNumberPresentation } from "@hypit/studio-adapter";
 
 export const parameterOption = (option: StudioParameterOption): Exclude<StudioParameterOption, string> =>
   typeof option === "string" ? { value: option, label: option } : option;
@@ -119,3 +119,45 @@ export function serializeParameterValue(value: CanonicalValue, language: "svml"
   if (typeof value === "number" || typeof value === "boolean") return String(value);
   throw new Error(`${language.toUpperCase()} parameter bindings currently accept scalar values only.`);
 }
+
+/** Record alternatives are selected by an explicitly literal-valued field. */
+export function parameterRecordVariants(schema: ValueSchema): readonly {
+  key: string; value: CanonicalValue; schema: Extract<ValueSchema, { kind: "object" }>;
+}[] {
+  if (schema.kind !== "oneOf" || !schema.variants.every(variant => variant.kind === "object")) return [];
+  const records = schema.variants as readonly Extract<ValueSchema, { kind: "object" }>[];
+  const key = Object.keys(records[0]?.fields ?? {}).find(name => records.every(record => record.fields[name]?.schema.kind === "literal")
+    && new Set(records.map(record => JSON.stringify((record.fields[name]!.schema as { value: CanonicalValue }).value))).size === records.length);
+  return key === undefined ? [] : records.map(record => ({ key, value: (record.fields[key]!.schema as { value: CanonicalValue }).value, schema: record }));
+}
+
+export function parameterRecordSchema(schema: ValueSchema, value: CanonicalValue): Extract<ValueSchema, { kind: "object" }> | undefined {
+  if (schema.kind === "object") return schema;
+  if (value === null || Array.isArray(value) || typeof value !== "object") return undefined;
+  return parameterRecordVariants(schema).find(variant => (value as Readonly<Record<string, CanonicalValue>>)[variant.key] === variant.value)?.schema;
+}
+
+/** Replace only a Companion-declared group; unrelated attributes and child content survive. */
+export function serializeAttributeGroup(field: StudioInspectorField, value: CanonicalValue): string {
+  const group = field.edit?.attributes;
+  if (!group || value === null || Array.isArray(value) || typeof value !== "object") throw new Error("Expected an attribute record.");
+  const entries = Object.entries(value);
+  if (entries.some(([name]) => !Object.hasOwn(group.ranges, name))) throw new Error("Attribute is outside this group.");
+  let text = field.edit!.source.preimage;
+  const ranges = Object.values(group.ranges).filter((range): range is NonNullable<typeof range> => range !== null);
+  for (const range of ranges.sort((a, b) => b.start - a.start)) text = text.slice(0, range.start) + text.slice(range.end);
+  const attributes = entries.map(([name, held]) => ` ${name}="${serializeParameterValue(held, field.edit!.language)}"`).join("");
+  return text.slice(0, group.insertionOffset) + attributes + text.slice(group.insertionOffset);
+}
+
+export function parameterControlForSchema(schema: ValueSchema | undefined): StudioParameterControl | undefined {
+  if (schema === undefined) return undefined;
+  if (schema.kind === "boolean") return "boolean";
+  if (schema.kind === "number") return "number";
+  if (schema.kind === "string") return schema.enum === undefined
+    ? schema.format === "color" ? "color" : "text"
+    : "select";
+  if (schema.kind === "array") return "list";
+  if (schema.kind === "object" || parameterRecordVariants(schema).length > 0) return "record";
+  return undefined;
+}