@vsceasy/cli 0.1.8 → 0.1.10

package/dist/lib/config.d.ts

@@ -1,6 +1,8 @@
 export interface VsceasyConfig {
     publisher?: string;
     commandPrefix?: string;
+    /** Extension shape. Omitted for legacy 'ui' projects. */
+    type?: 'ui' | 'language' | 'empty';
     ui?: 'react';
     defaultIcon?: string;
     defaultCategory?: string;

package/dist/lib/contributesMerge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deep-merge helper for `contributes.extra.json`.
+ *
+ * This is the source of truth for the merge algorithm used by the scaffolded
+ * project's `scripts/gen.ts`. The template (`templates/react/scripts/gen.ts`)
+ * carries an inline copy because it must run standalone with no dependency on
+ * this package — keep the two in sync. This module exists so the algorithm is
+ * unit-testable in-process (no subprocess).
+ */
+/** Keys gen.ts owns — never overridden by contributes.extra.json. */
+export declare const GEN_OWNED_KEYS: Set<string>;
+export declare function isPlainObject(v: unknown): v is Record<string, any>;
+export declare function deepMerge(base: any, override: any): any;
+/**
+ * Merge `extra` into `contributes` in place. gen-owned keys present in `extra`
+ * are ignored so gen.ts stays authoritative for them.
+ */
+export declare function applyExtraContributes(contributes: Record<string, any>, extra: Record<string, any> | null | undefined): Record<string, any>;

package/dist/lib/crud/parseModel.d.ts

@@ -1,8 +1,18 @@
+export interface ParsedRelation {
+    /** FK field on this model (e.g. `categoryId`). */
+    field: string;
+    /** Related model name (e.g. `Category`). */
+    model: string;
+    /** Field on the related model to show in the picker. */
+    label?: string;
+}
 export interface ParsedField {
     name: string;
     /** Raw TS type as written in the interface (e.g. `string`, `number`, `'a' | 'b'`, `Date`). */
     type: string;
     optional: boolean;
+    /** Set when this field is a foreign key declared via `<Name>Relations`. */
+    relation?: ParsedRelation;
 }
 export interface ParsedModel {
     /** PascalCase interface name. */
@@ -19,6 +29,8 @@ export interface ParsedModel {
     indexes: string[];
     /** Ordered field list from the interface body. */
     fields: ParsedField[];
+    /** FK field → relation metadata, keyed by FK field name. */
+    relations: Record<string, ParsedRelation>;
     /** Absolute path the model was read from. */
     path: string;
 }

package/dist/lib/helper/add.d.ts

@@ -1,4 +1,4 @@
-export type HelperKind = 'secrets' | 'config' | 'state' | 'notifications' | 'cache';
+export type HelperKind = 'secrets' | 'config' | 'state' | 'notifications' | 'cache' | 'colorize';
 export declare const HELPER_KINDS: HelperKind[];
 export interface AddHelperOptions {
     kind: HelperKind;

package/dist/lib/model/add.d.ts

@@ -1,3 +1,9 @@
+export interface FieldRelation {
+    /** PascalCase name of the related model (e.g. `Category`). */
+    model: string;
+    /** Field on the related model to show in pickers. Default: first string field, else its pk. */
+    label?: string;
+}
 export interface ModelField {
     name: string;
     /** Raw TS type. e.g. `string`, `number`, `string | null`, `Date`, `'a' | 'b'`. */
@@ -8,6 +14,12 @@ export interface ModelField {
     primaryKey?: boolean;
     /** Add to entity `indexes` (speeds up findOne by this field). */
     indexed?: boolean;
+    /**
+     * ManyToOne relation. When set, the field is emitted as a `<name>Id: string`
+     * foreign key and recorded in the model's relation metadata so `crud add`
+     * renders a populated dropdown. Authored as `name:ref(Model)` in the spec.
+     */
+    relation?: FieldRelation;
 }
 export interface AddModelOptions {
     name: string;
@@ -23,5 +35,11 @@ export interface AddModelResult {
     created: string[];
     primaryKey: string;
     indexes: string[];
+    /** Foreign-key fields and the models they point at. */
+    relations: Array<{
+        field: string;
+        model: string;
+        label?: string;
+    }>;
 }
 export declare function addModel(opts: AddModelOptions): AddModelResult;

package/dist/lib/model/parseFields.d.ts

@@ -1,4 +1,4 @@
-import type { ModelField } from './add';
+import type { ModelField, FieldRelation } from './add';
 /**
  * Parse a compact model field spec into `ModelField[]`.
  *
@@ -7,8 +7,14 @@ import type { ModelField } from './add';
  *   `!` after type → primaryKey
  *   `@` after type → indexed
  *
- * Example: `id:string!,name:string,email?:string@,score:number`
+ * Relations use `name:ref(Model)` or `name:ref(Model, label=field)`:
+ *   category:ref(Category)             → FK categoryId, dropdown of Category rows
+ *   category:ref(Category, label=name) → show Category.name in the dropdown
+ *
+ * Example: `id:string!,name:string,email?:string@,category:ref(Category)`
  */
 export declare function parseFieldsSpec(spec: string): ModelField[];
-/** Parse a single `name[?]:type[!][@]` line. Throws on malformed input. */
+/** Parse a single `name[?]:type[!][@]` line (or `name:ref(Model)`). Throws on malformed input. */
 export declare function parseFieldLine(raw: string): ModelField;
+/** Parse `ref(Model)` / `ref(Model, label=field)`. Returns null when not a ref. */
+export declare function parseRef(type: string): FieldRelation | null;

package/dist/lib/scaffold.d.ts

@@ -1,4 +1,5 @@
 export type ScaffoldPreset = 'minimal' | 'full';
+export type ScaffoldType = 'ui' | 'language' | 'empty';
 export interface ScaffoldOptions {
     name: string;
     displayName: string;
@@ -7,6 +8,9 @@ export interface ScaffoldOptions {
     ui: 'react';
     targetDir: string;
     templatesRoot: string;
+    /** Extension shape. Default: 'ui'. */
+    type?: ScaffoldType;
+    /** UI preset — only used when type === 'ui'. */
     preset?: ScaffoldPreset;
 }
 export declare function scaffold(opts: ScaffoldOptions): Promise<void>;

package/dist/lib/templatesData.d.ts

@@ -1,2 +1,2 @@
-export declare const TEMPLATES_VERSION = "0.1.8";
+export declare const TEMPLATES_VERSION = "0.1.10";
 export declare const TEMPLATE_FILES: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vsceasy/cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Build VS Code extensions fast — React UI + typed RPC bridge between extension and webview + file-based routing for panels, commands, menus, tree views, and subpanels.",
   "main": "dist/index.js",
   "scripts": {

package/templates/_assets/language/README.language.md

@@ -0,0 +1,39 @@
+## {{displayName}} language support
+
+This extension was scaffolded with `vsceasy create --type language`. It provides
+editor support for `.{{langId}}` files:
+
+- **Syntax highlighting** — TextMate grammar in `syntaxes/{{langId}}.tmLanguage.json`
+- **Language configuration** — comments, brackets, auto-closing pairs, folding in
+  `language-configuration.json`
+- **Snippets** — `snippets/{{langId}}.json`
+- **File icon** (opt-in) — `fileicons/{{langId}}-icon-theme.json`
+
+### How contributions are wired
+
+`vsceasy`'s `scripts/gen.ts` regenerates the generated parts of
+`package.json#contributes` (commands, views…) on every build. Language
+contributions are **not** generated — they live in **`contributes.extra.json`**
+at the project root and are deep-merged into `package.json` by `gen.ts`. Edit
+`contributes.extra.json` to change languages / grammars / snippets / iconThemes,
+then run `bun run gen`.
+
+### File icon is opt-in
+
+VS Code file icons are provided by an **icon theme**, which is global: activating
+it replaces *all* file icons in the workbench, not just `.{{langId}}`. This
+extension ships a `{{displayName}} Icons` theme but does **not** force it. To use
+it: `Preferences: File Icon Theme` → pick `{{displayName}} Icons`. If you don't
+want to override every icon, leave it unselected — highlighting, config and
+snippets work regardless.
+
+### Develop
+
+```sh
+bun install
+bun run gen        # sync package.json#contributes
+bun run package    # build a .vsix
+```
+
+Press `F5` (or run `bun run launch`) to open an Extension Development Host and
+open a `.{{langId}}` file to see highlighting.

package/templates/_assets/language/contributes.extra.json

@@ -0,0 +1,40 @@
+{
+  "languages": [
+    {
+      "id": "{{langId}}",
+      "aliases": ["{{displayName}}", "{{langId}}"],
+      "extensions": [".{{langId}}"],
+      "configuration": "./language-configuration.json"
+    }
+  ],
+  "grammars": [
+    {
+      "language": "{{langId}}",
+      "scopeName": "{{scopeName}}",
+      "path": "./syntaxes/{{langId}}.tmLanguage.json"
+    }
+  ],
+  "snippets": [
+    {
+      "language": "{{langId}}",
+      "path": "./snippets/{{langId}}.json"
+    }
+  ],
+  "iconThemes": [
+    {
+      "id": "{{langId}}-icons",
+      "label": "{{displayName}} Icons",
+      "path": "./fileicons/{{langId}}-icon-theme.json"
+    }
+  ],
+  "configuration": {
+    "title": "{{displayName}}",
+    "properties": {
+      "{{commandPrefix}}.colorize": {
+        "type": "boolean",
+        "default": true,
+        "markdownDescription": "Automatically apply distinct section colors to `.{{langId}}` files (scoped to `{{scopeName}}`, so other languages are unaffected). Turn off to keep your theme's default colors."
+      }
+    }
+  }
+}

package/templates/_assets/language/fileicons/{{langId}}-icon-theme.json

@@ -0,0 +1,13 @@
+{
+  "iconDefinitions": {
+    "{{langId}}_file": {
+      "iconPath": "../icons/{{langId}}.svg"
+    }
+  },
+  "languageIds": {
+    "{{langId}}": "{{langId}}_file"
+  },
+  "fileExtensions": {
+    "{{langId}}": "{{langId}}_file"
+  }
+}

package/templates/_assets/language/icons/{{langId}}.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32">
+  <path fill="#8a8a8a" d="M6 3h14l6 6v20a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1z"/>
+  <path fill="#5a5a5a" d="M20 3l6 6h-6z"/>
+  <text x="16" y="22" font-family="monospace" font-size="9" font-weight="bold" fill="#fff" text-anchor="middle">{{langExt}}</text>
+</svg>

package/templates/_assets/language/language-configuration.json

@@ -0,0 +1,30 @@
+{
+  "comments": {
+    "lineComment": "#"
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "\"", "close": "\"", "notIn": ["string"] },
+    { "open": "'", "close": "'", "notIn": ["string"] }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""],
+    ["'", "'"]
+  ],
+  "folding": {
+    "markers": {
+      "start": "^\\s*#\\s*region\\b",
+      "end": "^\\s*#\\s*endregion\\b"
+    }
+  }
+}

package/templates/_assets/language/snippets/{{langId}}.json

@@ -0,0 +1,12 @@
+{
+  "Section": {
+    "prefix": "section",
+    "body": ["[${1:name}]", "$0"],
+    "description": "A {{displayName}} section"
+  },
+  "Key/Value": {
+    "prefix": "kv",
+    "body": ["${1:key} = ${2:value}"],
+    "description": "A key/value pair"
+  }
+}

package/templates/_assets/language/src/colorize.ts

@@ -0,0 +1,31 @@
+import type * as vscode from 'vscode';
+import { applyTokenColors, removeTokenColors, type TokenColorRule } from './helpers/colorize';
+
+/** Root TextMate scope of this language — rules are applied only to these files. */
+export const SCOPE = '{{scopeName}}';
+
+/**
+ * Default token colors for {{displayName}}, emphasizing each construct. Edit
+ * freely — they are applied to `[{{scopeName}}]` only, so other languages keep
+ * the user's theme. Scope names must match your grammar
+ * (syntaxes/{{langId}}.tmLanguage.json).
+ */
+export const RULES: TokenColorRule[] = [
+  { scope: 'comment.line.number-sign.{{langId}}', settings: { foreground: '#6b7a6e', fontStyle: 'italic' } },
+  { scope: 'string.quoted.double.basic.{{langId}}', settings: { foreground: '#98c379' } },
+  { scope: 'string.quoted.single.literal.{{langId}}', settings: { foreground: '#98c379' } },
+  { scope: 'constant.numeric.{{langId}}', settings: { foreground: '#d19a66' } },
+];
+
+export async function applyColors(vscodeNs: typeof vscode): Promise<void> {
+  await applyTokenColors(SCOPE, RULES);
+}
+
+export async function removeColors(vscodeNs: typeof vscode): Promise<void> {
+  await removeTokenColors(SCOPE);
+}
+
+/** True when the user has opted in (default) to automatic coloring. */
+export function colorizeEnabled(vscodeNs: typeof vscode): boolean {
+  return vscodeNs.workspace.getConfiguration('{{commandPrefix}}').get<boolean>('colorize', true);
+}

package/templates/_assets/language/src/commands/applyColors.ts

@@ -0,0 +1,11 @@
+import { defineCommand } from '../shared/vsceasy';
+import { applyColors } from '../colorize';
+
+export default defineCommand({
+  id: 'applyColors',
+  title: '{{displayName}}: Apply Colors',
+  run: async (vscode) => {
+    await applyColors(vscode);
+    vscode.window.showInformationMessage('{{displayName}} colors applied.');
+  },
+});

package/templates/_assets/language/src/commands/removeColors.ts

@@ -0,0 +1,11 @@
+import { defineCommand } from '../shared/vsceasy';
+import { removeColors } from '../colorize';
+
+export default defineCommand({
+  id: 'removeColors',
+  title: '{{displayName}}: Remove Colors',
+  run: async (vscode) => {
+    await removeColors(vscode);
+    vscode.window.showInformationMessage('{{displayName}} colors removed.');
+  },
+});

package/templates/_assets/language/src/extension/extension.ts

@@ -0,0 +1,25 @@
+import { bootstrap } from '../shared/vsceasy';
+import { registry } from './_registry';
+import { applyColors, removeColors, colorizeEnabled } from '../colorize';
+
+export const activate = bootstrap(registry, {
+  onActivate: [
+    async (context, vscode) => {
+      // Auto-apply scoped token colors on activate when opted in (default).
+      // Scoped to {{scopeName}} only — other languages are untouched.
+      if (colorizeEnabled(vscode)) {
+        await applyColors(vscode);
+      }
+      // React to the user toggling `{{commandPrefix}}.colorize` at runtime.
+      context.subscriptions.push(
+        vscode.workspace.onDidChangeConfiguration(async (e) => {
+          if (!e.affectsConfiguration('{{commandPrefix}}.colorize')) return;
+          if (colorizeEnabled(vscode)) await applyColors(vscode);
+          else await removeColors(vscode);
+        }),
+      );
+    },
+  ],
+});
+
+export function deactivate() {}

package/templates/_assets/language/src/helpers/colorize.ts

@@ -0,0 +1,70 @@
+import * as vscode from 'vscode';
+
+/**
+ * Apply theme-independent token colors to a single TextMate scope (e.g. a
+ * language's root scope like `{{scopeName}}`), written to the user's
+ * `editor.tokenColorCustomizations`. Because the rules are keyed by
+ * `[<scope>]`, only files in that scope are recolored — every other language
+ * keeps the active theme's colors.
+ *
+ * Rules are tagged with a marker so {@link removeTokenColors} can strip exactly
+ * the ones this extension added, preserving any the user wrote by hand.
+ */
+
+export interface TokenColorRule {
+  /** Comma-separated TextMate scopes, e.g. 'entity.name.section.foo, comment.line.foo'. */
+  scope: string;
+  settings: { foreground?: string; background?: string; fontStyle?: string };
+}
+
+type TaggedRule = TokenColorRule & { [MARK]?: true };
+
+/** Marker key identifying rules this extension wrote (vs. the user's own). */
+const MARK = '{{commandPrefix}}Colorize';
+const SECTION = 'editor.tokenColorCustomizations';
+
+const blockKey = (scope: string) => `[${scope}]`;
+
+/**
+ * Merge `rules` into `editor.tokenColorCustomizations["[<scope>]"].textMateRules`,
+ * preserving the user's own rules and other scope keys. Idempotent — re-applying
+ * replaces only previously-applied rules from this extension.
+ */
+export async function applyTokenColors(
+  scope: string,
+  rules: TokenColorRule[],
+  target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Global,
+): Promise<void> {
+  const cfg = vscode.workspace.getConfiguration();
+  const current = (cfg.get<Record<string, any>>(SECTION) ?? {}) as Record<string, any>;
+  const key = blockKey(scope);
+  const block = (current[key] ?? {}) as { textMateRules?: TaggedRule[] };
+  const existing = Array.isArray(block.textMateRules) ? block.textMateRules : [];
+  const userRules = existing.filter((r) => !r[MARK]);
+  const ours: TaggedRule[] = rules.map((r) => ({ ...r, [MARK]: true }));
+  const next = { ...current, [key]: { ...block, textMateRules: [...userRules, ...ours] } };
+  await cfg.update(SECTION, next, target);
+}
+
+/** Remove only the rules this extension added for `scope`; leave the rest intact. */
+export async function removeTokenColors(
+  scope: string,
+  target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Global,
+): Promise<void> {
+  const cfg = vscode.workspace.getConfiguration();
+  const current = cfg.get<Record<string, any>>(SECTION);
+  const key = blockKey(scope);
+  if (!current || !current[key]) return;
+  const block = current[key] as { textMateRules?: TaggedRule[] };
+  const userRules = (block.textMateRules ?? []).filter((r) => !r[MARK]);
+
+  const nextBlock: Record<string, unknown> = { ...block };
+  if (userRules.length) nextBlock.textMateRules = userRules;
+  else delete nextBlock.textMateRules;
+
+  const next = { ...current };
+  if (Object.keys(nextBlock).length) next[key] = nextBlock;
+  else delete next[key];
+
+  await cfg.update(SECTION, Object.keys(next).length ? next : undefined, target);
+}

package/templates/_assets/language/syntaxes/{{langId}}.tmLanguage.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "{{displayName}}",
+  "scopeName": "{{scopeName}}",
+  "patterns": [
+    { "include": "#comments" },
+    { "include": "#strings" },
+    { "include": "#numbers" }
+  ],
+  "repository": {
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.line.number-sign.{{langId}}",
+          "match": "#.*$"
+        }
+      ]
+    },
+    "strings": {
+      "patterns": [
+        {
+          "name": "string.quoted.double.{{langId}}",
+          "begin": "\"",
+          "end": "\"",
+          "patterns": [
+            { "name": "constant.character.escape.{{langId}}", "match": "\\\\." }
+          ]
+        },
+        {
+          "name": "string.quoted.single.{{langId}}",
+          "begin": "'",
+          "end": "'"
+        }
+      ]
+    },
+    "numbers": {
+      "patterns": [
+        {
+          "name": "constant.numeric.{{langId}}",
+          "match": "\\b[0-9]+(\\.[0-9]+)?\\b"
+        }
+      ]
+    }
+  }
+}

package/templates/_generators/crud/formApp.tsx.tpl

@@ -22,6 +22,7 @@ export function App() {
   const [editingId, setEditingId] = useState<{{Name}}['{{primaryKey}}'] | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [saving, setSaving] = useState(false);
+{{relationOptionsState}}
 
   const load = useCallback(async (initial: boolean) => {
     // The list stashes a row id before revealing this panel. Pull it (the host
@@ -59,6 +60,7 @@ export function App() {
       document.removeEventListener('visibilitychange', onVisible);
     };
   }, [load]);
+{{relationOptionsLoad}}
 
   const onChange = <K extends keyof FormState>(k: K, v: FormState[K]) => {
     setForm((f) => ({ ...f, [k]: v }));

package/templates/_generators/crud/formPanel.ts.tpl

@@ -3,7 +3,7 @@ import { {{Name}}Service } from '../services/{{Name}}Service';
 import { takePending{{Name}}Id } from '../services/{{name}}FormNav';
 import type { {{Name}}FormApi } from '../shared/api';
 import type { {{Name}} } from '../models/{{Name}}';
-
+{{relationImports}}
 export default definePanel<{{Name}}FormApi>({
   title: '{{title}}',
   column: 'beside',
@@ -25,7 +25,7 @@ export default definePanel<{{Name}}FormApi>({
       void vscode.commands.executeCommand('{{prefix}}.open{{Plural}}List');
       return saved;
     },
-    async cancel() {
+{{relationOptionsHandler}}    async cancel() {
       // No-op — webview closes itself.
     },
   }),

package/templates/_generators/helper/colorize.ts.tpl

@@ -0,0 +1,85 @@
+import * as vscode from 'vscode';
+
+/**
+ * Apply theme-independent token colors to a single TextMate scope (e.g. a
+ * language's root scope like `source.toml`), written to the user's
+ * `editor.tokenColorCustomizations`. Because the rules are keyed by
+ * `[<scope>]`, only files in that scope are recolored — every other language
+ * keeps the active theme's colors.
+ *
+ * Rules are tagged with a marker so {@link removeTokenColors} can strip exactly
+ * the ones this extension added, preserving any the user wrote by hand.
+ *
+ * Typical use — auto-apply on activate behind an opt-out setting:
+ *
+ *   // extension.ts (onActivate hook)
+ *   if (config.get<boolean>('colorize', true)) {
+ *     await applyTokenColors('source.{{commandPrefix}}', MY_RULES);
+ *   }
+ *   vscode.workspace.onDidChangeConfiguration(async (e) => {
+ *     if (!e.affectsConfiguration('{{commandPrefix}}.colorize')) return;
+ *     if (config.get<boolean>('colorize', true)) await applyTokenColors('source.{{commandPrefix}}', MY_RULES);
+ *     else await removeTokenColors('source.{{commandPrefix}}');
+ *   });
+ *
+ * Declare the opt-out in package.json#contributes.configuration:
+ *   "{{commandPrefix}}.colorize": { "type": "boolean", "default": true }
+ */
+
+export interface TokenColorRule {
+  /** Comma-separated TextMate scopes, e.g. 'entity.name.section.foo, comment.line.foo'. */
+  scope: string;
+  settings: { foreground?: string; background?: string; fontStyle?: string };
+}
+
+type TaggedRule = TokenColorRule & { [MARK]?: true };
+
+/** Marker key identifying rules this extension wrote (vs. the user's own). */
+const MARK = '{{commandPrefix}}Colorize';
+const SECTION = 'editor.tokenColorCustomizations';
+
+const blockKey = (scope: string) => `[${scope}]`;
+
+/**
+ * Merge `rules` into `editor.tokenColorCustomizations["[<scope>]"].textMateRules`,
+ * preserving the user's own rules and other scope keys. Idempotent — re-applying
+ * replaces only previously-applied rules from this extension.
+ */
+export async function applyTokenColors(
+  scope: string,
+  rules: TokenColorRule[],
+  target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Global,
+): Promise<void> {
+  const cfg = vscode.workspace.getConfiguration();
+  const current = (cfg.get<Record<string, any>>(SECTION) ?? {}) as Record<string, any>;
+  const key = blockKey(scope);
+  const block = (current[key] ?? {}) as { textMateRules?: TaggedRule[] };
+  const existing = Array.isArray(block.textMateRules) ? block.textMateRules : [];
+  const userRules = existing.filter((r) => !r[MARK]);
+  const ours: TaggedRule[] = rules.map((r) => ({ ...r, [MARK]: true }));
+  const next = { ...current, [key]: { ...block, textMateRules: [...userRules, ...ours] } };
+  await cfg.update(SECTION, next, target);
+}
+
+/** Remove only the rules this extension added for `scope`; leave the rest intact. */
+export async function removeTokenColors(
+  scope: string,
+  target: vscode.ConfigurationTarget = vscode.ConfigurationTarget.Global,
+): Promise<void> {
+  const cfg = vscode.workspace.getConfiguration();
+  const current = cfg.get<Record<string, any>>(SECTION);
+  const key = blockKey(scope);
+  if (!current || !current[key]) return;
+  const block = current[key] as { textMateRules?: TaggedRule[] };
+  const userRules = (block.textMateRules ?? []).filter((r) => !r[MARK]);
+
+  const nextBlock: Record<string, unknown> = { ...block };
+  if (userRules.length) nextBlock.textMateRules = userRules;
+  else delete nextBlock.textMateRules;
+
+  const next = { ...current };
+  if (Object.keys(nextBlock).length) next[key] = nextBlock;
+  else delete next[key];
+
+  await cfg.update(SECTION, Object.keys(next).length ? next : undefined, target);
+}

package/templates/_generators/model/model.ts.tpl

@@ -14,4 +14,4 @@ export const {{Plural}} = defineEntity<{{Name}}>('{{collection}}', {
  *   import { {{Plural}}Repo } from '../models/{{Name}}';
  *   await {{Plural}}Repo().insert({ ... });
  */
-export const {{Plural}}Repo = () => db()({{Plural}});
+export const {{Plural}}Repo = () => db()({{Plural}});{{relationsBlock}}