@kubohiroya/turbowarp-plus-editor-project-model 0.1.1 → 0.2.0

package/src/project-search-replace.ts

@@ -0,0 +1,189 @@
+import {literalSearchPattern, type ProjectSearchResult, type SearchProject, type SearchResult} from './project-search.ts';
+
+type Field = {
+    getValue(): unknown;
+    setValue(value: string): void;
+    callValidator(value: string): unknown;
+    getOptions?(): ReadonlyArray<readonly [unknown, unknown]>;
+};
+type Comment = {getText(): string; setText(value: string): void};
+type Block = {
+    isEditable(): boolean;
+    getField(name: string): Field | undefined;
+    comment?: Comment;
+    mutationToDom(): Element;
+};
+type RenameEvent = {type: string; varId?: string; newName?: string};
+export type ReplaceWorkspace = {
+    options: {readOnly: boolean};
+    isDragging(): boolean;
+    getBlockById(id: string): Block | null;
+    getCommentById(id: string): Comment | null;
+    getVariableById(id: string): {name: string} | null;
+    renameVariableById(id: string, name: string): void;
+    addChangeListener(listener: (event: RenameEvent) => void): void;
+};
+export type ReplaceBlockly = {
+    FieldTextInput: abstract new (...args: never[]) => Field;
+    FieldDropdown: abstract new (...args: never[]) => Field;
+    FieldNumber: abstract new (...args: never[]) => Field;
+    Procedures: {
+        getPrototypeBlock(name: string, workspace: ReplaceWorkspace): Block | null;
+        mutateCallersAndPrototype(name: string, workspace: ReplaceWorkspace, mutation: Element): void;
+    };
+};
+export type ReplaceOutcome = 'applied' | 'staged' | 'stale' | 'conflict' | 'invalid' | 'read-only';
+
+function spliceMatch(value: string, pattern: RegExp, replacement: string) {
+    const match = pattern.exec(value);
+    if (match) return value.slice(0, match.index) + replacement + value.slice(match.index + match[0].length);
+}
+
+function replaceProcedureLabel(name: string, pattern: RegExp, replacement: string) {
+    if (/%[sbn]/.test(replacement)) return;
+    const parts = name.split(/(%[sbn])/);
+    for (let i = 0; i < parts.length; i += 2) {
+        const changed = spliceMatch(parts[i], pattern, replacement);
+        if (changed === undefined) continue;
+        parts[i] = changed;
+        const next = parts.join('');
+        if (JSON.stringify(next.match(/%[sbn]/g)) === JSON.stringify(name.match(/%[sbn]/g))) return next;
+        return;
+    }
+}
+
+export function replacementText(result: SearchResult, query: string, replacement: string) {
+    if (!query.trim()) return;
+    if (result.kind === 'yaml') return replacement !== result.range.expectedText ? replacement : undefined;
+    const edit = result.edit;
+    if (!edit) return;
+    const pattern = literalSearchPattern(query, 'iu');
+    const source = edit.type === 'name' || edit.type === 'procedure' ? edit.name : edit.type === 'comment' ? edit.text : edit.value;
+    const next = edit.type === 'procedure' ? replaceProcedureLabel(source, pattern, replacement) :
+        spliceMatch(source, pattern, replacement);
+    return next !== source ? next : undefined;
+}
+
+const watchedBroadcasts = new WeakMap<ReplaceWorkspace, Set<string>>();
+function maintainBroadcastReferences(project: SearchProject, workspace: ReplaceWorkspace, id: string) {
+    let ids = watchedBroadcasts.get(workspace);
+    if (!ids) {
+        const watched = new Set<string>();
+        watchedBroadcasts.set(workspace, watched);
+        ids = watched;
+        workspace.addChangeListener(event => {
+            if (event.type !== 'var_rename' || !event.varId || !watched.has(event.varId)) return;
+            const variable = project.targets.find(target => target.isStage)?.variables[event.varId];
+            if (variable?.type !== 'broadcast_msg' || variable.name !== event.newName || variable.value === variable.name) return;
+            variable.value = variable.name;
+            for (const blocks of new Set(project.targets.map(target => target.blocks))) {
+                const pending = [...blocks.getScripts()];
+                const seen = new Set<string>();
+                while (pending.length) {
+                    const id = pending.pop();
+                    if (!id || seen.has(id)) continue;
+                    seen.add(id);
+                    const block = blocks.getBlock(id);
+                    if (!block) continue;
+                    const field = block.fields?.BROADCAST_OPTION;
+                    if (field?.id === event.varId) field.value = variable.name;
+                    if (block.next) pending.push(block.next);
+                    for (const input of Object.values(block.inputs ?? {})) {
+                        if (input.block) pending.push(input.block);
+                        if (input.shadow) pending.push(input.shadow);
+                    }
+                }
+            }
+            project.resetAllCaches?.();
+            project.emitProjectChanged?.();
+        });
+    }
+    ids.add(id);
+}
+
+function validName(value: string) {
+    return Boolean(value.trim()) && value === value.trim() && !/[\u0000-\u001f\u007f]/u.test(value);
+}
+
+/** Rename a message from the message section, where no block result carries the edit. */
+export function renameProjectMessage(project: SearchProject, workspace: ReplaceWorkspace,
+    id: string, next: string): ReplaceOutcome {
+    if (workspace.options.readOnly || workspace.isDragging()) return 'read-only';
+    const owner = project.targets.find(target => Object.hasOwn(target.variables, id));
+    const variable = owner?.variables[id];
+    if (variable?.type !== 'broadcast_msg' || workspace.getVariableById(id)?.name !== variable.name) return 'stale';
+    if (!validName(next)) return 'invalid';
+    const match = next.toLocaleLowerCase();
+    if (project.targets.some(target => Object.entries(target.variables).some(([other, candidate]) =>
+        other !== id && candidate.type === 'broadcast_msg' && candidate.name.toLocaleLowerCase() === match))) {
+        return 'conflict';
+    }
+    maintainBroadcastReferences(project, workspace, id);
+    workspace.renameVariableById(id, next);
+    return workspace.getVariableById(id)?.name === next ? 'applied' : 'conflict';
+}
+
+export function applyProjectSearchReplacement(project: SearchProject, workspace: ReplaceWorkspace,
+    Blockly: ReplaceBlockly, result: ProjectSearchResult, next: string): ReplaceOutcome {
+    if (workspace.options.readOnly || workspace.isDragging() || !result.edit) return 'read-only';
+    const {target, edit} = result;
+    if (!project.targets.includes(target) || ('block' in result && target.blocks.getBlock(result.block.id) !== result.block)) return 'stale';
+    if (edit.type === 'comment' && result.kind === 'comment') {
+        const current = target.comments?.[result.commentId];
+        if (current !== result.comment || current.text !== edit.text) return 'stale';
+        const comment = current.blockId ? workspace.getBlockById(current.blockId)?.comment : workspace.getCommentById(result.commentId);
+        if (!comment || comment.getText() !== edit.text) return 'stale';
+        comment.setText(next);
+        return 'applied';
+    }
+    if (edit.type === 'name') {
+        if (!('block' in result)) return 'stale';
+        const fieldName = result.kind === 'variable' ? 'VARIABLE' : result.kind === 'list' ? 'LIST' : 'BROADCAST_OPTION';
+        const field = result.block.fields?.[fieldName] ??
+            target.blocks.getBlock(result.block.inputs?.BROADCAST_INPUT?.block)?.fields?.[fieldName];
+        if (field?.id !== edit.id) return 'stale';
+        const variable = edit.owner.variables[edit.id];
+        const model = workspace.getVariableById(edit.id);
+        if (!project.targets.includes(edit.owner) || !variable || variable.name !== edit.name || model?.name !== edit.name) return 'stale';
+        if (!validName(next) || variable.isCloud) return 'invalid';
+        const scope = edit.owner.isStage ? project.targets.filter(target => target.isOriginal) :
+            project.targets.filter(target => target === edit.owner || target.isStage);
+        const match = next.toLocaleLowerCase();
+        if (scope.some(target => Object.entries(target.variables).some(([id, candidate]) =>
+            id !== edit.id && (candidate.type ?? '') === edit.variableType && candidate.name.toLocaleLowerCase() === match))) return 'conflict';
+        if (edit.variableType === 'broadcast_msg') maintainBroadcastReferences(project, workspace, edit.id);
+        workspace.renameVariableById(edit.id, next);
+        return workspace.getVariableById(edit.id)?.name === next ? 'applied' : 'conflict';
+    }
+    if (edit.type === 'procedure') {
+        if (!('block' in result)) return 'stale';
+        const procedure = result.block.mutation?.proccode ??
+            target.blocks.getBlock(result.block.inputs?.custom_block?.block)?.mutation?.proccode;
+        if (procedure !== edit.name) return 'stale';
+        if (!validName(next) || !next.replace(/%[sbn]/g, '').trim()) return 'invalid';
+        const prototype = Blockly.Procedures.getPrototypeBlock(edit.name, workspace);
+        if (!prototype) return 'stale';
+        if (next !== edit.name && Blockly.Procedures.getPrototypeBlock(next, workspace)) return 'conflict';
+        const mutation = prototype.mutationToDom();
+        mutation.setAttribute('proccode', next);
+        Blockly.Procedures.mutateCallersAndPrototype(edit.name, workspace, mutation);
+        return 'applied';
+    }
+    if (edit.type === 'field' && 'block' in result) {
+        const {id, field: name, value} = edit;
+        if (id !== result.block.id && !Object.values(result.block.inputs ?? {}).some(input => input.block === id)) return 'stale';
+        const block = workspace.getBlockById(id);
+        const field = block?.getField(name);
+        if (!field || String(field.getValue()) !== value || String(target.blocks.getBlock(id)?.fields?.[name]?.value) !== value) return 'stale';
+        const text = Boolean(field instanceof Blockly.FieldTextInput);
+        const dropdown = Boolean(field instanceof Blockly.FieldDropdown);
+        if (!block?.isEditable() || !(text || dropdown)) return 'read-only';
+        if (field instanceof Blockly.FieldNumber && (!next.trim() || !Number.isFinite(Number(next)))) return 'invalid';
+        if (dropdown && !field.getOptions?.().some(option => String(option[1]) === next)) return 'invalid';
+        const validated = field.callValidator(next);
+        if (validated === null || (validated !== undefined && String(validated) !== next)) return 'invalid';
+        field.setValue(next);
+        return String(field.getValue()) === next ? 'applied' : 'invalid';
+    }
+    return 'read-only';
+}

package/src/project-search.ts

@@ -0,0 +1,328 @@
+// The judgement for broadcast blocks lives in project-messages, which the layout's message
+// section also uses, so the section and this search agree.
+import {messageReference} from './project-messages.ts';
+
+type Field = {id?: string; value: unknown};
+type Block = {
+    id: string;
+    opcode: string;
+    next?: string;
+    shadow?: boolean;
+    fields?: Record<string, Field>;
+    inputs?: Record<string, {block?: string; shadow?: string}>;
+    mutation?: {proccode?: string; blockInfo?: {text?: string}};
+};
+type Asset = {name: string};
+type Comment = {text: string; blockId?: string | null};
+type Variable = {name: string; type?: string; isCloud?: boolean; value?: unknown};
+type Target = {
+    id: string;
+    isStage: boolean;
+    isOriginal: boolean;
+    getName(): string;
+    getCostumes(): Asset[];
+    getSounds(): Asset[];
+    variables: Record<string, Variable>;
+    comments?: Record<string, Comment>;
+    // The VM answers `undefined` for a missing id, including an input with no block.
+    blocks: {getScripts(): string[]; getBlock(id: string | undefined): Block | undefined};
+};
+export type SearchProject = {
+    targets: Target[];
+    getLabelForOpcode?(opcode: string): {category?: string; label?: string} | undefined;
+    resetAllCaches?(): void;
+    emitProjectChanged?(): void;
+    on?(event: 'PROJECT_CHANGED', listener: () => void): void;
+    removeListener?(event: 'PROJECT_CHANGED', listener: () => void): void;
+};
+type BlockKind = 'block' | 'variable' | 'list' | 'message' | 'argument' | 'extension';
+type AssetKind = 'costume' | 'backdrop' | 'sound';
+export type SearchKind = BlockKind | AssetKind | 'comment' | 'yaml';
+export type VariableAccess = 'read' | 'write';
+export type VariableSearch = {ownerId: string; variableId: string; access: VariableAccess};
+export const variableAccessLabels = {
+    read: ['読み取り', 'Read'],
+    write: ['変更', 'Write']
+} as const;
+export type SearchEdit =
+    | {type: 'field'; id: string; field: string; value: string}
+    | {type: 'name'; id: string; owner: Target; name: string; variableType: string}
+    | {type: 'procedure'; name: string}
+    | {type: 'comment'; text: string};
+export type ProjectSearchResult = {label: string; target: Target; detail?: string; edit?: SearchEdit} & (
+    {kind: BlockKind; block: Block; variableAccess?: VariableAccess} | {kind: AssetKind; asset: Asset} |
+    {kind: 'comment'; comment: Comment; commentId: string}
+);
+export type YamlSearchDocument = {reference: {providerId: string; documentId: string}; filename: string; source: string};
+export type YamlSearchResult = {
+    kind: 'yaml'; document: YamlSearchDocument; label: string; detail: string;
+    range: {start: number; end: number; expectedText: string};
+};
+export type SearchResult = ProjectSearchResult | YamlSearchResult;
+export const literalSearchPattern = (query: string, flags: string) =>
+    new RegExp(query.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+
+const headings: Record<Exclude<SearchKind, 'yaml'>, [string, string]> = {
+    block: ['ブロック', 'Blocks'],
+    variable: ['変数の使用箇所', 'Variable uses'],
+    list: ['リストの使用箇所', 'List uses'],
+    message: ['メッセージの送受信', 'Broadcasts'],
+    argument: ['ブロックの引数値', 'Block argument values'],
+    extension: ['機能拡張の使用箇所', 'Extension uses'],
+    comment: ['コメント', 'Comments'],
+    costume: ['コスチューム', 'Costumes'],
+    backdrop: ['背景', 'Backdrops'],
+    sound: ['音', 'Sounds']
+};
+
+function* walkBlocks(target: Target) {
+    const pending = target.blocks.getScripts().slice().reverse();
+    const seen = new Set<string>();
+    while (pending.length) {
+        const id = pending.pop()!;
+        if (seen.has(id)) continue;
+        seen.add(id);
+        const block = target.blocks.getBlock(id);
+        if (!block || block.shadow) continue;
+        const inputs: [string, Block][] = [];
+        for (const [key, input] of Object.entries(block.inputs ?? {})) {
+            const child = input.block && target.blocks.getBlock(input.block);
+            if (child) inputs.push([key, child]);
+        }
+        if (block.next) pending.push(block.next);
+        for (let i = inputs.length - 1; i >= 0; i--) {
+            if (!inputs[i][1].shadow) pending.push(inputs[i][1].id);
+        }
+        yield {block, inputs};
+    }
+}
+
+const stageProperties = new Set(['background #', 'backdrop #', 'backdrop name', 'volume']);
+const spriteProperties = new Set(['x position', 'y position', 'direction', 'costume #', 'costume name', 'size', 'volume']);
+
+const listAccesses = new Map<string, VariableAccess>([
+    ['data_listcontents', 'read'], ['data_itemoflist', 'read'], ['data_itemnumoflist', 'read'],
+    ['data_lengthoflist', 'read'], ['data_listcontainsitem', 'read'],
+    ['data_addtolist', 'write'], ['data_deleteoflist', 'write'], ['data_deletealloflist', 'write'],
+    ['data_insertatlist', 'write'], ['data_replaceitemoflist', 'write']
+]);
+
+function variableAccess(target: Target, block: Block, inputs: [string, Block][],
+    stage: Target | undefined, sprites: ReadonlyMap<string, Target>):
+    {owner: Target; variableId: string; access: VariableAccess} | undefined {
+    if (block.opcode === 'sensing_of') {
+        const menu = inputs.find(([key]) => key === 'OBJECT')?.[1];
+        if (!menu?.shadow || menu.opcode !== 'sensing_of_object_menu') return;
+        const object = menu.fields?.OBJECT?.value;
+        const name = block.fields?.PROPERTY?.value;
+        if (typeof object !== 'string' || typeof name !== 'string') return;
+        const owner = object === '_stage_' ? stage : sprites.get(object);
+        if (!owner || (owner.isStage ? stageProperties : spriteProperties).has(name)) return;
+        const variableId = Object.keys(owner.variables).find(id => {
+            const variable = owner.variables[id];
+            return variable.type === '' && variable.name === name;
+        });
+        if (variableId) return {owner, variableId, access: 'read'};
+        return;
+    }
+    const listAccess = listAccesses.get(block.opcode);
+    const access = listAccess ?? (block.opcode === 'data_variable' ? 'read' :
+        block.opcode === 'data_setvariableto' || block.opcode === 'data_changevariableby' ? 'write' : undefined);
+    const variableId = block.fields?.[listAccess ? 'LIST' : 'VARIABLE']?.id;
+    if (!access || !variableId) return;
+    const owner = Object.hasOwn(target.variables, variableId) ? target : stage;
+    if (owner?.variables[variableId]?.type === (listAccess ? 'list' : '')) return {owner, variableId, access};
+}
+
+const originalSprites = (project: SearchProject) =>
+    new Map(project.targets.filter(target => target.isOriginal && !target.isStage).map(target => [target.getName(), target]));
+
+export function countVariableAccesses(project: SearchProject, ownerId: string) {
+    const stage = project.targets.find(target => target.isStage);
+    const sprites = originalSprites(project);
+    const counts = new Map<string, Record<VariableAccess, number>>();
+    for (const target of project.targets) {
+        if (!target.isOriginal) continue;
+        for (const {block, inputs} of walkBlocks(target)) {
+            const use = variableAccess(target, block, inputs, stage, sprites);
+            if (use?.owner.id !== ownerId) continue;
+            const count = counts.get(use.variableId) ?? {read: 0, write: 0};
+            count[use.access]++;
+            counts.set(use.variableId, count);
+        }
+    }
+    return counts;
+}
+
+export function searchProject(project: SearchProject, messages: Record<string, string>, query: string, japanese: boolean,
+    kinds: ReadonlySet<SearchKind> = new Set(Object.keys(headings) as SearchKind[]), variableSearch?: VariableSearch) {
+    const groups = new Map(Object.entries(headings).map(([kind, titles]) => [
+        kind as SearchKind, {kind: kind as SearchKind, title: titles[japanese ? 0 : 1], results: [] as ProjectSearchResult[]}
+    ]));
+    const search = query.trim().toLocaleLowerCase();
+    if (!search && !variableSearch) return [];
+
+    const stage = project.targets.find(target => target.isStage);
+    const sprites = variableSearch || kinds.has('variable') ? originalSprites(project) : undefined;
+    const searchBlocks = variableSearch || (['block', 'variable', 'list', 'message', 'argument', 'extension'] as const)
+        .some(kind => kinds.has(kind));
+    const templates = new Map<string, {text: string; extension?: string}>();
+    const matches = (value: string) => value.toLocaleLowerCase().includes(search);
+    const describeOpcode = (opcode: string) => {
+        const cached = templates.get(opcode);
+        if (cached) return cached;
+        const key = opcode.toUpperCase();
+        const alternate = key.replace(/^OPERATOR_/, 'OPERATORS_').replace(/_AS_CLONE$/, 'ASCLONE');
+        const vmLabel = project.getLabelForOpcode?.(opcode);
+        const vmText = vmLabel?.label;
+        const separator = vmLabel?.category === 'extension' ? vmText?.indexOf(': ') ?? -1 : -1;
+        const template = {
+            text: messages[key] ?? messages[alternate] ??
+                (vmText && separator > 0 ? vmText.slice(separator + 2) : vmText) ?? opcode.replaceAll('_', ' '),
+            extension: vmText && separator > 0 ? vmText.slice(0, separator) : undefined
+        };
+        templates.set(opcode, template);
+        return template;
+    };
+    const fieldText = (target: Target, key: string, field: Field) => {
+        const variable = field.id && (key === 'VARIABLE' || key === 'LIST') ?
+            target.variables[field.id] ?? stage?.variables[field.id] : undefined;
+        return String(variable?.name ?? field.value ?? '');
+    };
+    const describe = (target: Target, block: Block, inputs: [string, Block][], template: string) => {
+        const values = [
+            ...Object.entries(block.fields ?? {}).map(([key, field]) => fieldText(target, key, field)),
+            ...inputs.filter(([key]) => !key.startsWith('SUBSTACK')).map(([, child]) =>
+                child.shadow ? Object.values(child.fields ?? {}).map(field => String(field.value ?? '')).join(' ') :
+                    Object.entries(child.fields ?? {}).map(([key, field]) => fieldText(target, key, field)).join(' ') || '…')
+        ];
+        if (block.opcode === 'event_whenflagclicked') values.unshift(japanese ? '緑の旗' : 'green flag');
+        if (/%\d+/.test(template)) return template.replace(/%(\d+)/g, (_, index) => values[Number(index) - 1] ?? '…').trim();
+        return [template, ...values].filter(Boolean).join(' ');
+    };
+
+    for (const target of project.targets) {
+        if (!target.isOriginal) continue;
+        for (const {block, inputs} of searchBlocks ? walkBlocks(target) : []) {
+            const use = sprites && variableAccess(target, block, inputs, stage, sprites);
+            if (variableSearch && (!use || use.owner.id !== variableSearch.ownerId ||
+                use.variableId !== variableSearch.variableId || use.access !== variableSearch.access)) continue;
+
+            const variable = block.fields?.VARIABLE;
+            const list = block.fields?.LIST;
+            const message = messageReference(target, block, stage);
+            const kind = variable ? 'variable' : list ? 'list' : 'message';
+            const reference = variable ?? list ?? (message && {id: message.id, value: message.fieldValue});
+            const name = variable || list ? fieldText(target, variable ? 'VARIABLE' : 'LIST', reference!) : message?.name;
+            const opcode = describeOpcode(block.opcode);
+            const procedure = block.mutation?.proccode ??
+                inputs.find(([key]) => key === 'custom_block')?.[1].mutation?.proccode;
+            const customLabel = block.mutation?.blockInfo?.text;
+            const template = procedure ? procedure.replace(/%[sbn]/g, '…') :
+                typeof customLabel === 'string' ? customLabel : opcode.text;
+            const label = procedure ? template : describe(target, block, inputs, template);
+            const add = (kind: BlockKind, label: string, detail?: string, edit?: SearchEdit, access?: VariableAccess) =>
+                groups.get(kind)!.results.push({kind, target, block, label, detail, edit, variableAccess: access});
+            if (variableSearch && use) {
+                add(list ? 'list' : 'variable', label, use.owner.variables[use.variableId].name, undefined, use.access);
+                continue;
+            }
+            if (kinds.has('block') && (matches(template) || matches(block.opcode) ||
+                (block.opcode === 'event_whenflagclicked' && matches(japanese ? '緑の旗' : 'green flag')))) {
+                add('block', label, undefined, procedure ? {type: 'procedure', name: procedure} : undefined);
+            }
+            if (kinds.has(kind) && name && matches(name)) {
+                const referenceId = reference?.id;
+                const owner = referenceId &&
+                    (target.variables[referenceId] ? target : stage?.variables[referenceId] ? stage : undefined);
+                const scope = (variable || list) && owner &&
+                    (owner.isStage ? (japanese ? '全体' : 'Global') : (japanese ? 'このスプライト' : 'Local'));
+                const model = owner && referenceId ? owner.variables[referenceId] : undefined;
+                const edit = owner && referenceId && model && !model.isCloud ? {
+                    type: 'name' as const, id: referenceId, owner, name: model.name,
+                    variableType: model.type ?? (list ? 'list' : message ? 'broadcast_msg' : '')
+                } : undefined;
+                add(kind, name, scope || label, edit, use?.access);
+            } else if (use && !variable && !list && kinds.has('variable') && matches(use.owner.variables[use.variableId].name)) {
+                add('variable', use.owner.variables[use.variableId].name, label, undefined, use.access);
+            }
+            if (kinds.has('extension') && opcode.extension && matches(opcode.extension)) add('extension', opcode.extension, label);
+            if (kinds.has('argument')) {
+                const addArguments = (owner: Block) => {
+                    for (const [key, field] of Object.entries(owner.fields ?? {})) {
+                        if (field === reference || (message && key === 'BROADCAST_OPTION')) continue;
+                        const value = String(field.value ?? '');
+                        if (value && matches(value)) add('argument', value, label,
+                            {type: 'field', id: owner.id, field: key, value});
+                    }
+                };
+                addArguments(block);
+                for (const [, child] of inputs) {
+                    if (child.shadow) addArguments(child);
+                }
+            }
+        }
+        if (variableSearch) continue;
+
+        if (kinds.has('comment')) {
+            for (const [commentId, comment] of Object.entries(target.comments ?? {})) {
+                if (matches(comment.text)) groups.get('comment')!.results.push({
+                    kind: 'comment', target, comment, commentId, label: comment.text, edit: {type: 'comment', text: comment.text}
+                });
+            }
+        }
+
+        const assets: [AssetKind, Asset[]][] = [
+            [target.isStage ? 'backdrop' : 'costume', target.getCostumes()],
+            ['sound', target.getSounds()]
+        ];
+        for (const [kind, items] of assets) {
+            if (!kinds.has(kind)) continue;
+            for (const asset of items) {
+                if (matches(asset.name)) groups.get(kind)!.results.push({kind, asset, label: asset.name, target});
+            }
+        }
+    }
+    return [...groups.values()].filter(group => group.results.length);
+}
+
+export function searchYamlDocuments(documents: readonly YamlSearchDocument[], query: string, japanese: boolean) {
+    const results: YamlSearchResult[] = [];
+    const search = query.trim();
+    if (!search) return results;
+    const pattern = literalSearchPattern(search, 'giu');
+    const seen = new Set<string>();
+    const duplicates = new Set<string>();
+    for (const {filename} of documents) {
+        if (seen.has(filename)) duplicates.add(filename);
+        seen.add(filename);
+    }
+    for (const document of documents) {
+        let line = 1;
+        let lineStart = 0;
+        let newline = document.source.indexOf('\n');
+        for (const match of document.source.matchAll(pattern)) {
+            const start = match.index;
+            const end = start + match[0].length;
+            while (newline >= 0 && newline < start) {
+                line++;
+                lineStart = newline + 1;
+                newline = document.source.indexOf('\n', lineStart);
+            }
+            const column = start - lineStart + 1;
+            const nextNewline = document.source.indexOf('\n', end);
+            const before = Math.max(lineStart, start - 48);
+            const lineEnd = nextNewline < 0 ? document.source.length : nextNewline;
+            const after = Math.min(lineEnd, end + 48);
+            const position = japanese ? `${line} 行 ${column} 列` : `Line ${line}, column ${column}`;
+            const identity = duplicates.has(document.filename) ?
+                `${document.reference.providerId}/${document.reference.documentId}` : '';
+            results.push({
+                kind: 'yaml', document, label: `${before > lineStart ? '…' : ''}${document.source.slice(before, after)}${after < lineEnd ? '…' : ''}`,
+                detail: [position, identity].filter(Boolean).join(' · '),
+                range: {start, end, expectedText: match[0]}
+            });
+        }
+    }
+    return results;
+}

package/src/sprite-variable-edit.ts

@@ -1,9 +1,12 @@
+type VariableType = '' | 'list';
+
 export type SpriteVariableEdit =
-    {type: 'create'; name: string} |
+    {type: 'create'; name: string; variableType?: ''; isCloud?: boolean} |
+    {type: 'create'; name: string; variableType: 'list'; isCloud?: false} |
     {type: 'rename'; id: string; name: string} |
     {type: 'delete'; id: string};
 
-export type SpriteVariableEditError = 'emptyName' | 'duplicateName' | 'inUse' | 'unavailable';
+export type SpriteVariableEditError = 'emptyName' | 'duplicateName' | 'inUse' | 'unavailable' | 'cloudLimit';
 
 type Variable = {name: string; type: string; isCloud?: boolean};
 type Block = {
@@ -12,7 +15,7 @@ type Block = {
     inputs: Record<string, {block: string | null; shadow: string | null}>;
 };
 type VariableEvent =
-    {type: 'var_create'; varId: string; varName: string; varType: ''; isLocal: boolean; isCloud: false} |
+    {type: 'var_create'; varId: string; varName: string; varType: VariableType; isLocal: boolean; isCloud: boolean} |
     {type: 'var_rename'; varId: string; newName: string} |
     {type: 'var_delete'; varId: string};
 type VariableTarget = {
@@ -33,12 +36,88 @@ type VariableProject = {
         targets: readonly VariableTarget[];
         getEditingTarget(): VariableTarget | null;
         getTargetForStage(): VariableTarget | null;
+        canAddCloudVariable?(): boolean;
     };
     refreshWorkspace(): void;
 };
 
+export type SpriteListItem = string | number | boolean;
+export type SpriteVariableValue = string | number | readonly SpriteListItem[];
+
+type VariableValue = {id: string; name: string; type: string; value: unknown; isCloud?: boolean; _monitorUpToDate?: boolean};
+
+export function readSpriteVariable(variable: VariableValue) {
+    const {id, name, type, value, isCloud} = variable;
+    if (type === 'list' && Array.isArray(value)) return {id, name, value: value as readonly SpriteListItem[]};
+    if (type === '' && (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean')) {
+        return {id, name, value: typeof value === 'boolean' ? String(value) : value, isCloud};
+    }
+}
+
+export function writeSpriteVariableValue(vm: {
+    runtime: {getTargetById(id: string): {variables: Record<string, VariableValue>} | undefined};
+    setVariableValue(targetId: string, variableId: string, value: SpriteVariableValue): boolean;
+}, targetId: string, id: string, value: SpriteVariableValue) {
+    const variable = vm.runtime.getTargetById(targetId)?.variables[id];
+    const list = typeof value === 'object';
+    if (!variable || variable.type !== (list ? 'list' : '') || !vm.setVariableValue(targetId, id, value)) return false;
+    if (list) variable._monitorUpToDate = false;
+    return true;
+}
+
 export const cloudVariablePrefix = '☁ ';
 
+type VariableMonitorBlock = {
+    id: string;
+    opcode: string;
+    isMonitored?: boolean;
+    targetId: string | null;
+};
+
+type VariableMonitorRuntime = {
+    getTargetById(id: string): VariableTarget | undefined;
+    getMonitorState(): {get(id: string): {visible: boolean} | undefined};
+    monitorBlocks: {
+        getBlock(id: string): VariableMonitorBlock | undefined;
+        createBlock(block: VariableMonitorBlock & {
+            fields: Record<string, {id: string; name: string; value: string; variableType: '' | 'list'}>;
+            inputs: Record<string, never>;
+            next: null;
+            parent: null;
+            topLevel: true;
+            shadow: false;
+            x: number;
+            y: number;
+        }): void;
+        changeBlock(change: {id: string; element: 'checkbox'; value: boolean}): void;
+    };
+    emitProjectChanged(): void;
+};
+
+export function showSpriteVariableOnStage(runtime: VariableMonitorRuntime, targetId: string, id: string, visible: boolean) {
+    const owner = runtime.getTargetById(targetId);
+    const variable = owner?.variables[id];
+    if (!owner?.isOriginal || !variable || !['', 'list'].includes(variable.type) ||
+        Boolean(runtime.getMonitorState().get(id)?.visible) === visible) return;
+    const list = variable.type === 'list';
+    const opcode = list ? 'data_listcontents' : 'data_variable';
+    const field = list ? 'LIST' : 'VARIABLE';
+    const {monitorBlocks} = runtime;
+    let block = monitorBlocks.getBlock(id);
+    if (!block) {
+        monitorBlocks.createBlock({
+            id, opcode, targetId: owner.isStage ? null : owner.id, inputs: {},
+            fields: {[field]: {id, name: field, value: variable.name, variableType: list ? 'list' : ''}},
+            next: null, parent: null, topLevel: true, shadow: false, x: 0, y: 0
+        });
+        block = monitorBlocks.getBlock(id);
+    }
+    if (block?.opcode !== opcode) return;
+    block.isMonitored = !visible;
+    monitorBlocks.changeBlock({id, element: 'checkbox', value: visible});
+    runtime.emitProjectChanged();
+}
+
 function isUsed(target: VariableTarget, targets: readonly VariableTarget[], id: string, name: string) {
     const targetName = target.isStage ? '_stage_' : target.getName();
     return targets.some(({blocks}) => {
@@ -65,18 +144,26 @@ export function editSpriteVariable(vm: VariableProject, targetId: string, edit:
         if (isUsed(target, runtime.targets, edit.id, variable!.name)) return 'inUse';
         target.blocks.blocklyListen({type: 'var_delete', varId: edit.id});
     } else {
-        const name = edit.name.trim();
+        const variableType = edit.type === 'create' ? edit.variableType ?? '' : '';
+        const cloud = edit.type === 'create' ? variableType === '' && edit.isCloud === true : variable?.isCloud === true;
+        const name = (cloud && edit.name.startsWith(cloudVariablePrefix) ?
+            edit.name.slice(cloudVariablePrefix.length) : edit.name).trim();
         if (!name) return 'emptyName';
-        const fullName = variable?.isCloud && !name.startsWith(cloudVariablePrefix) ? cloudVariablePrefix + name : name;
+        const fullName = cloud ? cloudVariablePrefix + name : name;
         if (fullName === variable?.name) return;
         const scope = target.isStage ? runtime.targets.filter(item => item.isStage || item.isOriginal) :
             [target, runtime.getTargetForStage()];
-        if (scope.some(owner => owner && Object.values(owner.variables).some(item => item.type === '' && item.name === fullName))) {
+        if (scope.some(owner => owner && Object.values(owner.variables).some(item =>
+            item.type === variableType && item.name === fullName))) {
             return 'duplicateName';
         }
         if (edit.type === 'create') {
+            if (cloud && !target.isStage) return 'unavailable';
+            if (cloud && !runtime.canAddCloudVariable?.()) return 'cloudLimit';
             const varId = Array.from(crypto.getRandomValues(new Uint32Array(4)), value => value.toString(16).padStart(8, '0')).join('');
-            target.blocks.blocklyListen({type: 'var_create', varId, varName: fullName, varType: '', isLocal: !target.isStage, isCloud: false});
+            target.blocks.blocklyListen({
+                type: 'var_create', varId, varName: fullName, varType: variableType, isLocal: !target.isStage, isCloud: cloud
+            });
         } else {
             target.blocks.blocklyListen({type: 'var_rename', varId: edit.id, newName: fullName});
         }