diff --git a/docs/guides/migration.en.md b/docs/guides/migration.en.md
index 5de73dde43..85d01ceaff 100644
--- a/docs/guides/migration.en.md
+++ b/docs/guides/migration.en.md
@@ -1177,6 +1177,44 @@ Handled by `badge-signals`: the `compact` and `outline` reads are rewritten, the
 
 Handled by `checkbox-signals`: the one-way input reads are rewritten, the rest is reported.
 
+#### Code block
+
+`maxHeight` was published as `InputSignal<number>` over an `undefined!` default, so a code block with no `[maxHeight]` binding reported `undefined` from a non-nullable type:
+
+```ts
+const height: number = codeBlock.maxHeight(); // held undefined
+if (codeBlock.maxHeight() > 0) { … }          // NaN comparison, never true
+```
+
+It reports `number | undefined` now, and a value that is not cleanly numeric — a valueless `maxHeight` attribute, `'200px'` — reports `undefined` rather than `NaN`. `[maxHeight]="undefined"` used to hand back `NaN`; that is the one runtime change. The call sites that were quietly wrong now fail to compile.
+
+`KbqCodeBlockHighlight.file` was a write-only required input: a setter with no getter that kicked off highlighting as a side effect. It is a required signal input driven by an effect now, so it can finally be read — and a programmatic write no longer compiles.
+
+**`KbqCodeBlock` has no decorator inputs left.** `softWrap`, `viewAll`, `canDownload`, `files`, `activeFileIndex` and `hideTabs` are `WritableSignal`s over a backing `input()` that carries the `booleanAttribute` / `numberAttribute` transform. Template bindings are untouched — `[softWrap]`, `[(viewAll)]` and a valueless `<kbq-code-block softWrap>` all keep working — but a programmatic read becomes a call and a write becomes `.set(…)`. A `model()` would have been the obvious shape; `ModelOptions` carries no `transform`, and dropping the transform would make a valueless attribute pass the empty string and silently turn the feature off.
+
+| Pattern                                     | Manual migration                                                    |
+| ------------------------------------------- | ------------------------------------------------------------------- |
+| `.softWrap` / `.viewAll` / `.canDownload`   | Read as a call — rewritten for you                                  |
+| `.files` / `.activeFileIndex` / `.hideTabs` | Read as a call — rewritten for you                                  |
+| `.softWrap = …`                             | `.softWrap.set(…)` — rewritten for you; a compound form is reported |
+| `.canLoad = …` / `.codeFiles = …`           | Bind the attribute; both are backing inputs now                     |
+| `.maxHeight()`                              | `?? 0` for the common reading, or handle the unset state explicitly |
+| `.file = …` on a `KbqCodeBlockHighlight`    | Bind `[file]`; the value is readable as `file()` now                |
+
+**The `max-height` applied while `viewAll` is off is a `computed`.** It was a getter read from a `[style.max-height.px]` binding, so it only re-evaluated when something else marked the view dirty.
+
+**`hideTabs` reports what was bound; `tabsHidden()` is what the header does.** The rule that a single file without a filename hides the bar is derived now instead of being written into `hideTabs`, so a read of `hideTabs` no longer folds it in. `tabsHidden` is public for exactly that reading.
+
+**`canLoad` and `codeFiles` fill in rather than write.** The deprecated aliases used to write into `canDownload` and `files`, so which of each pair won depended on the order they sat in the template. Either attribute now turns the download button on, and `codeFiles` applies while `files` is empty.
+
+**An `activeFileIndex` outside `files` renders the first file, and an empty `files` renders no code at all.** Both used to reach `files[activeFileIndex]` and throw on the undefined result — `<kbq-code-block />` and `[files]="[]"` were enough. The index itself is left as bound: resetting it wrote `activeFileIndexChange` back into a `[(activeFileIndex)]` while the parent was still updating, which handed the parent the wrong file and, in the other binding order, `NG0100`.
+
+**`hideTabs` is derived instead of written.** A single file with no `filename` still hides the tab bar, but the component no longer writes `true` into its own input to do it: the write latched the bar off for the life of the component, so naming the files later never brought it back and every file past the first stayed unreachable, and it re-emitted `hideTabsChange` on every `files` assignment. Two consequences: `[hideTabs]="false"` no longer shows the bar for a lone unnamed file — the rule wins, as the API has always documented — and reading `hideTabs` reports what the header does, while `hideTabsChange` fires only when the binding itself changes.
+
+**A disabled `@media print` rule aside, printing is unaffected**, but two long-standing leaks are gone: a failed `highlight.js` load no longer latches `pending` on for the life of the page, and the line-numbers plugin installs its `<style>` and its `copy` listener once instead of once per code block.
+
+Handled by `code-block-signals`: the reads and the plain writes are rewritten, the rest is reported.
+
 #### Loader overlay
 
 `text` and `caption` were the two inputs the automated signal migration skipped — it saw them read inside `@if` blocks and would not risk the narrowing. They are `input()` now, and honest about being optional: both were declared `string` over a field with no initializer, so an overlay that bound neither reported `undefined` from a non-nullable type.
diff --git a/docs/guides/migration.ru.md b/docs/guides/migration.ru.md
index 79d5c8c846..dd19d495bb 100644
--- a/docs/guides/migration.ru.md
+++ b/docs/guides/migration.ru.md
@@ -1181,6 +1181,44 @@ badge.badgeColor; // 'kbq-badge_error'
 
 Закрывается схематиком `checkbox-signals`: чтения односторонних входов переписываются, остальное сообщается в отчёте.
 
+#### Code block
+
+`maxHeight` был опубликован как `InputSignal<number>` поверх значения по умолчанию `undefined!`, поэтому блок кода без привязки `[maxHeight]` возвращал `undefined` из ненулевого типа:
+
+```ts
+const height: number = codeBlock.maxHeight(); // содержал undefined
+if (codeBlock.maxHeight() > 0) { … }          // сравнение с NaN, никогда не истинно
+```
+
+Теперь он возвращает `number | undefined`, а значение, которое не приводится к числу начисто — атрибут `maxHeight` без значения, `'200px'` — возвращает `undefined`, а не `NaN`. `[maxHeight]="undefined"` раньше давал `NaN`; это единственное изменение в рантайме. Места вызова, которые и так были неправильными, перестали компилироваться.
+
+`KbqCodeBlockHighlight.file` был входом только на запись: сеттер без геттера, который побочным эффектом запускал подсветку. Теперь это обязательный сигнальный вход, которым управляет `effect`, поэтому его наконец можно прочитать — а программная запись больше не компилируется.
+
+**У `KbqCodeBlock` не осталось входов на декораторе `@Input`.** `softWrap`, `viewAll`, `canDownload`, `files`, `activeFileIndex` и `hideTabs` - это `WritableSignal` поверх backing-входа, который несёт трансформацию `booleanAttribute` / `numberAttribute`. Привязки в шаблоне не меняются: `[softWrap]`, `[(viewAll)]` и бесзначный `<kbq-code-block softWrap>` работают как раньше. Меняется программный доступ: чтение становится вызовом, запись - `.set(…)`. `model()` был бы очевидной формой, но `ModelOptions` не несёт `transform`, а без него бесзначный атрибут передаёт пустую строку и молча выключает возможность.
+
+| Что было                                    | Как мигрировать вручную                                                |
+| ------------------------------------------- | ---------------------------------------------------------------------- |
+| `.softWrap` / `.viewAll` / `.canDownload`   | Читать как вызов - переписывается за вас                               |
+| `.files` / `.activeFileIndex` / `.hideTabs` | Читать как вызов - переписывается за вас                               |
+| `.softWrap = …`                             | `.softWrap.set(…)` - переписывается за вас; составная форма сообщается |
+| `.canLoad = …` / `.codeFiles = …`           | Привязать атрибут: оба стали backing-входами                           |
+| `.maxHeight()`                              | `?? 0` для обычного чтения либо явная обработка незаданного значения   |
+| `.file = …` у `KbqCodeBlockHighlight`       | Привязать `[file]`; значение теперь читается как `file()`              |
+
+**`max-height`, который применяется, пока `viewAll` выключен, стал `computed`.** Это был геттер, читаемый из привязки `[style.max-height.px]`, поэтому он пересчитывался только тогда, когда представление помечал грязным кто-то другой.
+
+**`hideTabs` возвращает привязанное значение, а `tabsHidden()` - то, что происходит с заголовком.** Правило «единственный файл без `filename` прячет панель» теперь выводится, а не записывается в `hideTabs`, поэтому чтение самого входа его больше не подмешивает. `tabsHidden` публичен именно ради этого чтения.
+
+**`canLoad` и `codeFiles` теперь подставляются, а не пишут.** Устаревшие алиасы писали в `canDownload` и `files`, поэтому побеждал тот из пары, который стоял в шаблоне позже. Теперь любой из двух атрибутов включает кнопку скачивания, а `codeFiles` применяется, пока `files` пуст.
+
+**`activeFileIndex` за пределами `files` показывает первый файл, а пустой `files` не показывает кода вообще.** Раньше оба случая доходили до `files[activeFileIndex]` и падали на неопределённом результате — хватало `<kbq-code-block />` или `[files]="[]"`. Сам индекс остаётся таким, каким его привязали: сброс писал `activeFileIndexChange` обратно в `[(activeFileIndex)]`, пока родитель ещё обновлялся, и тот получал не тот файл, а при другом порядке привязок — `NG0100`.
+
+**`hideTabs` теперь выводится, а не записывается.** Единственный файл без `filename` по-прежнему прячет панель вкладок, но компонент больше не пишет для этого `true` в собственный вход: запись защёлкивала панель на всю жизнь компонента, поэтому позже названные файлы её не возвращали и все файлы кроме первого оставались недоступны, а `hideTabsChange` срабатывал на каждое присваивание `files`. Отсюда два следствия: `[hideTabs]="false"` больше не показывает панель для одинокого безымянного файла — правило побеждает, как и обещало описание входа, — а чтение `hideTabs` возвращает то, что происходит с заголовком, тогда как `hideTabsChange` срабатывает только при изменении самой привязки.
+
+**Помимо этого закрыты две давние утечки:** неудачная загрузка `highlight.js` больше не оставляет `pending` включённым до конца жизни страницы, а плагин нумерации строк ставит свой `<style>` и слушатель `copy` один раз, а не на каждый блок кода.
+
+Закрывается схематиком `code-block-signals`: чтения и простые записи переписываются, остальное сообщается в отчёте.
+
 #### Loader overlay
 
 `text` и `caption` — те два входа, которые автоматическая миграция на сигналы пропустила: они читаются внутри блоков `@if`, и миграция не стала рисковать сужением типов. Теперь это `input()`, и они честно необязательные: оба были объявлены как `string` поверх поля без инициализатора, поэтому оверлей без обеих привязок возвращал `undefined` из ненулевого типа.
diff --git a/packages/components/code-block/code-block-highlight.ts b/packages/components/code-block/code-block-highlight.ts
index c7a4ca1e0d..223041d4a7 100644
--- a/packages/components/code-block/code-block-highlight.ts
+++ b/packages/components/code-block/code-block-highlight.ts
@@ -2,9 +2,9 @@ import { DOCUMENT } from '@angular/common';
 import {
     booleanAttribute,
     Directive,
+    effect,
     inject,
     InjectionToken,
-    Input,
     input,
     isDevMode,
     numberAttribute,
@@ -95,6 +95,7 @@ export class KbqCodeBlockHighlight {
     private readonly window = inject(KBQ_WINDOW);
     private readonly config = inject(KBQ_CODE_BLOCK_HIGHLIGHT_JS_CONFIG, { optional: true });
     private hljs: HLJSApi | null = null;
+    private hljsLoading: Promise<boolean> | null = null;
     private readonly _pending = signal(false);
 
     /**
@@ -105,17 +106,36 @@ export class KbqCodeBlockHighlight {
     readonly pending = this._pending.asReadonly();
 
     /** The code file. */
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input({ required: true })
-    set file(file: KbqCodeBlockFile) {
-        if (!this.window) return;
+    readonly file = input.required<KbqCodeBlockFile>();
 
-        if (!this.hljs) {
-            this.load(this.config ?? {}).then(() => this.highlight(file));
-        } else {
-            this.highlight(file);
-        }
+    constructor() {
+        effect((onCleanup) => {
+            const file = this.file();
+            // Captured here rather than read inside `highlight()`: on the load path that read happens in a
+            // microtask, where nothing is tracked, so the effect's dependencies would otherwise depend on
+            // which branch had run before.
+            const lineNumbers = { startFrom: this.startFrom(), singleLine: this.singleLine() };
+
+            if (!this.window) return;
+
+            if (this.hljs) {
+                this.highlight(file, lineNumbers);
+
+                return;
+            }
+
+            // A `file` that arrives while highlight.js is still loading must not start a second load,
+            // and must not highlight through a directive that has gone away in the meantime.
+            let cancelled = false;
+
+            onCleanup(() => (cancelled = true));
+
+            this.loadOnce().then((loaded) => {
+                if (loaded && !cancelled) {
+                    this.highlight(file, lineNumbers);
+                }
+            });
+        });
     }
 
     /** The starting line number. */
@@ -124,27 +144,54 @@ export class KbqCodeBlockHighlight {
     /** Whether to display line numbers for single line code block. */
     readonly singleLine = input<boolean, unknown>(false, { transform: booleanAttribute });
 
-    private async load({ core, languages }: KbqCodeBlockHighlightJsConfig): Promise<void> {
+    /**
+     * Loads highlight.js at most once, so overlapping `file` changes share a single import. The result is
+     * reported rather than thrown: the caller is an effect, where a rejection has nowhere to go and
+     * escapes as an uncaught error on every attempt.
+     */
+    private loadOnce(): Promise<boolean> {
+        this.hljsLoading ??= this.load(this.config ?? {}).then((loaded) => {
+            // Let a later file change try again rather than latching the failure.
+            if (!loaded) this.hljsLoading = null;
+
+            return loaded;
+        });
+
+        return this.hljsLoading;
+    }
+
+    private async load({ core, languages }: KbqCodeBlockHighlightJsConfig): Promise<boolean> {
         this._pending.set(true);
 
-        const loader = core ?? defaultHljsLoader;
-        const { default: instance } = await loader();
+        try {
+            const loader = core ?? defaultHljsLoader;
+            const { default: instance } = await loader();
 
-        if (languages) {
-            await Promise.all(
-                Object.entries(languages).map(async ([name, loader]) => {
-                    const { default: language } = await loader();
+            if (languages) {
+                await Promise.all(
+                    Object.entries(languages).map(async ([name, loader]) => {
+                        const { default: language } = await loader();
 
-                    instance.registerLanguage(name, language);
-                })
-            );
-        }
+                        instance.registerLanguage(name, language);
+                    })
+                );
+            }
 
-        this.hljs = instance;
-        this.initLineNumbersPlugin(instance);
+            this.hljs = instance;
+            this.initLineNumbersPlugin(instance);
+
+            return true;
+        } catch (error) {
+            // Only `highlight()` clears this, and it never runs when the load fails: a latched `pending`
+            // leaves every `scrollTo()` waiting on a signal that will not flip again.
+            this._pending.set(false);
+            this.warn('[KbqCodeBlock] Failed to load highlight.js.', error);
+
+            return false;
+        }
     }
 
-    private highlight(file: KbqCodeBlockFile): void {
+    private highlight(file: KbqCodeBlockFile, lineNumbers: { startFrom: number; singleLine: boolean }): void {
         this._pending.set(true);
 
         let { language } = file;
@@ -174,10 +221,7 @@ export class KbqCodeBlockHighlight {
         }
 
         const safeHTML = this.domSanitizer.sanitize(SecurityContext.HTML, highlightedHTML);
-        const highlightedHTMLWithLineNumbers = this.window['hljs'].lineNumbersValue(safeHTML, {
-            startFrom: this.startFrom(),
-            singleLine: this.singleLine()
-        });
+        const highlightedHTMLWithLineNumbers = this.window['hljs'].lineNumbersValue(safeHTML, lineNumbers);
 
         this.renderer.setAttribute(this.nativeElement, 'data-language', highlightedLanguage!);
         this.renderer.setProperty(this.nativeElement, 'innerHTML', highlightedHTMLWithLineNumbers);
@@ -197,6 +241,12 @@ export class KbqCodeBlockHighlight {
         if (!this.window) return;
 
         this.window['hljs'] = instance;
+
+        // The plugin appends a `<style>` to `<head>` and registers a document-level `copy` listener, and
+        // removes neither. Every directive resolves the same module-cached instance, so installing once
+        // per instance keeps a page full of code blocks down to one of each.
+        if ('lineNumbersValue' in instance) return;
+
         this.highlightJSLineNumbersPlugin(this.document, this.window);
     }
 
diff --git a/packages/components/code-block/code-block.html b/packages/components/code-block/code-block.html
index 108e13502c..a0723e29a9 100644
--- a/packages/components/code-block/code-block.html
+++ b/packages/components/code-block/code-block.html
@@ -1,14 +1,12 @@
-@let file = files[activeFileIndex];
-
 <div class="kbq-code-block__header" [kbqOverflowShadowTop]="codeBlockContent">
-    @if (!hideTabs) {
+    @if (!tabsHidden()) {
         <div class="kbq-code-block__header-tabs">
             <div kbqTabNavBar transparent [tabNavPanel]="tabPanel">
-                @for (file of files; track file) {
+                @for (file of files(); track file) {
                     <!-- Mark tab-link as readonly if only single file present -->
                     <div
                         kbqTabLink
-                        [active]="$count > 1 && activeFileIndex === $index"
+                        [active]="$count > 1 && renderedFileIndex() === $index"
                         [style.pointer-events]="$count === 1 ? 'none' : null"
                         (click)="onSelectedTabChange($index)"
                     >
@@ -34,11 +32,11 @@
                     [color]="componentColor.Contrast"
                     [kbqStyle]="buttonStyle.Transparent"
                     [kbqTooltip]="
-                        softWrap ? localeConfiguration.softWrapOffTooltip : localeConfiguration.softWrapOnTooltip
+                        softWrap() ? localeConfiguration.softWrapOffTooltip : localeConfiguration.softWrapOnTooltip
                     "
                     (click)="toggleSoftWrap()"
                 >
-                    @if (softWrap) {
+                    @if (softWrap()) {
                         <i kbq-icon="kbq-text-overflow_16"></i>
                     } @else {
                         <i kbq-icon="kbq-text-wrap_16"></i>
@@ -46,7 +44,7 @@
                 </button>
             }
 
-            @if (canDownload) {
+            @if (canDownload()) {
                 <button
                     kbq-button
                     class="kbq-code-block__actionbar__download-button"
@@ -75,7 +73,7 @@
                 </div>
             }
 
-            @if (file.link) {
+            @if (activeFile()?.link) {
                 <button
                     kbq-button
                     class="kbq-code-block__actionbar__link-button"
@@ -102,19 +100,21 @@
     kbqOverflowShadowContainer
     kbqTabNavPanel
     class="kbq-code-block__main"
-    [style.max-height.px]="calculatedMaxHeight"
+    [style.max-height.px]="calculatedMaxHeight()"
     [tabIndex]="codeContentTabIndex"
 >
-    <pre
-        #codeBlockPre
-        class="kbq-code-block__pre"
-    ><code kbqCodeBlockHighlight class="kbq-code-block__code" [file]="file">{{ file.content }}</code></pre>
+    @if (activeFile(); as file) {
+        <pre
+            #codeBlockPre
+            class="kbq-code-block__pre"
+        ><code kbqCodeBlockHighlight class="kbq-code-block__code" [file]="file">{{ file.content }}</code></pre>
+    }
 
     @if (contentExceedsMaxHeight()) {
         <div
             class="kbq-code-block__view-all"
-            [class.kbq-code-block__view-all_collapsed]="!viewAll"
-            [class.kbq-code-block__view-all_expanded]="viewAll"
+            [class.kbq-code-block__view-all_collapsed]="!viewAll()"
+            [class.kbq-code-block__view-all_expanded]="viewAll()"
         >
             <div class="kbq-code-block__view-all__wrapper">
                 <button
@@ -125,7 +125,7 @@
                     (click)="toggleViewAll()"
                     (keydown.enter)="onViewAllEnterKeydown($event)"
                 >
-                    @if (viewAll) {
+                    @if (viewAll()) {
                         <i kbq-icon="kbq-chevron-up_16"></i>
                         {{ localeConfiguration.viewLessText }}
                     } @else {
diff --git a/packages/components/code-block/code-block.spec.ts b/packages/components/code-block/code-block.spec.ts
index 25a3da863e..f5a28364ff 100644
--- a/packages/components/code-block/code-block.spec.ts
+++ b/packages/components/code-block/code-block.spec.ts
@@ -80,12 +80,78 @@ const getViewAllButtonElement = (debugElement: DebugElement): HTMLButtonElement
     return debugElement.nativeElement.querySelector('.kbq-code-block__view-all__button');
 };
 
+const getCodeElement = (debugElement: DebugElement): HTMLElement => {
+    return debugElement.nativeElement.querySelector('.kbq-code-block__code');
+};
+
 const mockPreHeight = (debugElement: DebugElement, height: number): void => {
     const pre: HTMLElement = debugElement.nativeElement.querySelector('.kbq-code-block__pre');
 
     Object.defineProperty(pre, 'offsetHeight', { get: () => height, configurable: true });
 };
 
+@Component({
+    imports: [KbqCodeBlockModule],
+    template: `
+        <kbq-code-block [files]="files" />
+    `,
+    changeDetection: ChangeDetectionStrategy.Default
+})
+class PlainCodeBlock {
+    files: KbqCodeBlockFile[] = [{ language: 'html', filename: 'index.html', content: '<div>koobiq</div>' }];
+}
+
+@Component({
+    imports: [KbqCodeBlockModule],
+    template: `
+        <kbq-code-block softWrap canDownload [files]="files" />
+    `,
+    changeDetection: ChangeDetectionStrategy.Default
+})
+class ValuelessAttributesCodeBlock {
+    files: KbqCodeBlockFile[] = [{ content: 'koobiq', filename: 'index.html' }];
+}
+
+@Component({
+    imports: [KbqCodeBlockModule],
+    template: `
+        <kbq-code-block [codeFiles]="codeFiles" [canLoad]="true" [files]="files" />
+    `,
+    changeDetection: ChangeDetectionStrategy.Default
+})
+class DeprecatedAliasesCodeBlock {
+    codeFiles: KbqCodeBlockFile[] = [{ content: 'from codeFiles', filename: 'deprecated.html' }];
+    files: KbqCodeBlockFile[] = [];
+}
+
+@Component({
+    imports: [KbqCodeBlockModule],
+    template: `
+        <kbq-code-block [files]="files" (hideTabsChange)="emissions.push($event)" />
+    `,
+    changeDetection: ChangeDetectionStrategy.Default
+})
+class HideTabsCodeBlock {
+    files: KbqCodeBlockFile[] = [{ content: 'one' }];
+    readonly emissions: boolean[] = [];
+}
+
+@Component({
+    imports: [KbqCodeBlockModule],
+    template: `
+        <kbq-code-block [files]="files" [(activeFileIndex)]="index" />
+    `,
+    changeDetection: ChangeDetectionStrategy.Default
+})
+class TwoWayCodeBlock {
+    files: KbqCodeBlockFile[] = [
+        { language: 'html', filename: 'a.html', content: '<div>a</div>' },
+        { language: 'html', filename: 'b.html', content: '<div>b</div>' },
+        { language: 'html', filename: 'c.html', content: '<div>c</div>' }
+    ];
+    index = 2;
+}
+
 @Component({
     imports: [KbqCodeBlockModule],
     template: `
@@ -289,23 +355,54 @@ describe(KbqCodeBlock.name, () => {
         expect(codeBlock.classes['kbq-code-block_hide-tabs']).toBeTruthy();
     });
 
-    it('should NOT hide tabs for single file without filename when set outside', () => {
+    it('should keep tabs hidden for a single file without filename whatever hideTabs is bound to', () => {
         const fixture = createComponent(BaseCodeBlock);
         const { debugElement, componentInstance } = fixture;
-
-        // simulate the absence of input property
-        componentInstance.hideTabs = undefined as any;
         const codeBlock = geCodeBlockDebugElement(debugElement);
 
+        componentInstance.files = [{ content: '<div>koobiq</div>', language: 'html' }];
+        componentInstance.hideTabs = false;
         fixture.detectChanges();
 
-        expect(codeBlock.classes['kbq-code-block_hide-tabs']).toBeFalsy();
-        expect(getTabNavBarDebugElement(debugElement)).toBeTruthy();
+        // The rule is derived, so it no longer depends on whether `[files]` or `[hideTabs]` is written
+        // first - the order the two attributes happen to sit in the consumer's template used to decide it.
+        expect(getTabNavBarDebugElement(debugElement)).toBeFalsy();
+        expect(codeBlock.classes['kbq-code-block_hide-tabs']).toBeTruthy();
+    });
+
+    it('should bring the tabs back once the files are named', () => {
+        const fixture = createComponent(BaseCodeBlock);
+        const { debugElement, componentInstance } = fixture;
+
         componentInstance.files = [{ content: '<div>koobiq</div>', language: 'html' }];
-        componentInstance.hideTabs = false;
         fixture.detectChanges();
+
+        expect(getTabNavBarDebugElement(debugElement)).toBeFalsy();
+
+        // Writing the rule into `hideTabs` latched it: naming the files never brought the bar back, and
+        // every file past the first stayed unreachable.
+        componentInstance.files = [
+            { content: '<div>a</div>', filename: 'a.html' },
+            { content: '<div>b</div>', filename: 'b.html' }
+        ];
+        fixture.detectChanges();
+
         expect(getTabNavBarDebugElement(debugElement)).toBeTruthy();
-        expect(codeBlock.classes['kbq-code-block_hide-tabs']).toBeFalsy();
+    });
+
+    it('should not re-emit hideTabsChange on every files assignment', () => {
+        const fixture = createComponent(HideTabsCodeBlock);
+        const { componentInstance } = fixture;
+
+        fixture.detectChanges();
+
+        componentInstance.files = [{ content: 'one' }];
+        fixture.detectChanges();
+
+        componentInstance.files = [{ content: 'two' }];
+        fixture.detectChanges();
+
+        expect(componentInstance.emissions).toEqual([]);
     });
 
     it('should set activeFileIndex', () => {
@@ -788,6 +885,32 @@ describe(KbqCodeBlock.name, () => {
             expect(mockCore.highlight).toHaveBeenCalled();
         }));
 
+        it('should clear pending when the hljs core fails to load', waitForAsync(async () => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+            try {
+                const fixture = createComponent(BaseCodeBlock, [
+                    kbqCodeBlockHighlightJsConfigProvider({
+                        core: async () => {
+                            throw new Error('offline');
+                        }
+                    })
+                ]);
+                const highlight = fixture.debugElement
+                    .query(By.directive(KbqCodeBlockHighlight))
+                    .injector.get(KbqCodeBlockHighlight);
+
+                await fixture.whenStable();
+
+                // Only `highlight()` used to clear it, and that never runs when the load fails: everything
+                // waiting on `pending` - `scrollTo`, the overflow gate - stalled for the rest of the page.
+                expect(highlight.pending()).toBe(false);
+                expect(warn).toHaveBeenCalled();
+            } finally {
+                warn.mockRestore();
+            }
+        }));
+
         it('should call registerLanguage for each provided language', waitForAsync(async () => {
             const mockCore = buildMockCore();
             const typescriptLoader = jest.fn().mockResolvedValue({ default: jest.fn() });
@@ -939,4 +1062,189 @@ describe(KbqCodeBlock.name, () => {
             expect(scrollSpy).toHaveBeenCalledWith({ top: 100 });
         }));
     });
+    it('should report undefined for a maxHeight bound to undefined', () => {
+        const fixture = createComponent(BaseCodeBlock);
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        fixture.detectChanges();
+
+        // The binding runs the transform over `undefined`, which `numberAttribute` alone turns into NaN.
+        expect(codeBlock.maxHeight()).toBeUndefined();
+    });
+
+    it('should report undefined for a maxHeight that is never bound', () => {
+        const fixture = createComponent(PlainCodeBlock);
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        fixture.detectChanges();
+
+        expect(codeBlock.maxHeight()).toBeUndefined();
+    });
+
+    it('should report undefined for a maxHeight that is not a number', () => {
+        const fixture = createComponent(BaseCodeBlock);
+        const { componentInstance } = fixture;
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        componentInstance.maxHeight = '200px' as never;
+        fixture.detectChanges();
+
+        expect(codeBlock.maxHeight()).toBeUndefined();
+    });
+
+    it('should drop the calculated max height once viewAll is on', () => {
+        const fixture = createComponent(BaseCodeBlock);
+        const { componentInstance } = fixture;
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        componentInstance.maxHeight = 200;
+        fixture.detectChanges();
+
+        const main = fixture.nativeElement.querySelector('.kbq-code-block__main') as HTMLElement;
+
+        expect(codeBlock.maxHeight()).toBe(200);
+        expect(main.style.maxHeight).toBe('200px');
+
+        codeBlock.toggleViewAll();
+        fixture.detectChanges();
+
+        expect(main.style.maxHeight).toBe('');
+    });
+
+    it('should expose the highlighted file on the highlight directive', () => {
+        const fixture = createComponent(BaseCodeBlock);
+
+        fixture.detectChanges();
+
+        const highlight = fixture.debugElement
+            .query(By.directive(KbqCodeBlockHighlight))
+            .injector.get(KbqCodeBlockHighlight);
+
+        expect(highlight.file().filename).toBe('index.html');
+
+        fixture.componentInstance.activeFileIndex = 1;
+        fixture.detectChanges();
+
+        expect(highlight.file().filename).toBe('main.ts');
+    });
+    it('should arm the overflow gate for a maxHeight that arrives after init', () => {
+        const mockResizeObserver = new MockSharedResizeObserver();
+        const fixture = createComponent(BaseCodeBlock, [
+            { provide: SharedResizeObserver, useValue: mockResizeObserver }
+        ]);
+        const { componentInstance, debugElement } = fixture;
+
+        fixture.detectChanges();
+        mockPreHeight(debugElement, 500);
+
+        expect(getViewAllButtonElement(debugElement)).toBeNull();
+
+        // The gate used to be armed once, from `ngAfterViewInit`, so a limit bound later clipped the
+        // content with no way to expand it and no way in from the keyboard.
+        componentInstance.maxHeight = 200;
+        fixture.detectChanges();
+
+        expect(getViewAllButtonElement(debugElement)).toBeInstanceOf(HTMLButtonElement);
+
+        componentInstance.maxHeight = 1000;
+        fixture.detectChanges();
+
+        expect(getViewAllButtonElement(debugElement)).toBeNull();
+    });
+
+    it('should render the first file when the active index falls outside the file list', () => {
+        const fixture = createComponent(BaseCodeBlock);
+        const { componentInstance } = fixture;
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        componentInstance.activeFileIndex = 2;
+        fixture.detectChanges();
+
+        expect(codeBlock.activeFileIndex()).toBe(2);
+
+        componentInstance.files = componentInstance.files.slice(0, 2);
+        fixture.detectChanges();
+
+        // The render falls back rather than writing the index back: resetting it from inside the `files`
+        // setter clobbered whatever the parent had put into `[(activeFileIndex)]` in the same tick.
+        expect(codeBlock.activeFileIndex()).toBe(2);
+        expect(getCodeElement(fixture.debugElement).textContent).toContain(componentInstance.files[0].content);
+    });
+
+    it('should not write the active index back while the parent is updating', () => {
+        const fixture = createComponent(TwoWayCodeBlock);
+        const { componentInstance } = fixture;
+
+        fixture.detectChanges();
+
+        expect(componentInstance.index).toBe(2);
+
+        componentInstance.files = componentInstance.files.slice(0, 2);
+        componentInstance.index = 1;
+        fixture.detectChanges();
+
+        expect(componentInstance.index).toBe(1);
+        expect(getCodeElement(fixture.debugElement).textContent).toContain(componentInstance.files[1].content);
+    });
+
+    it('should treat a valueless boolean attribute as true', () => {
+        const fixture = createComponent(ValuelessAttributesCodeBlock);
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        fixture.detectChanges();
+
+        // The whole point of the backing input: `booleanAttribute` turns the empty string a valueless
+        // attribute passes into `true`, which a `model()` could not do.
+        expect(codeBlock.softWrap()).toBe(true);
+        expect(codeBlock.canDownload()).toBe(true);
+    });
+
+    it('should turn the download button on through the deprecated canLoad attribute', () => {
+        const fixture = createComponent(DeprecatedAliasesCodeBlock);
+        const { debugElement } = fixture;
+        const codeBlock = geCodeBlockDebugElement(debugElement).componentInstance as KbqCodeBlock;
+
+        fixture.detectChanges();
+
+        expect(codeBlock.canDownload()).toBe(true);
+        expect(getDownloadButtonElement(debugElement)).toBeInstanceOf(HTMLButtonElement);
+    });
+
+    it('should fall back to the deprecated codeFiles input while files is empty', () => {
+        const fixture = createComponent(DeprecatedAliasesCodeBlock);
+        const { componentInstance, debugElement } = fixture;
+        const codeBlock = geCodeBlockDebugElement(debugElement).componentInstance as KbqCodeBlock;
+
+        fixture.detectChanges();
+
+        expect(codeBlock.files()).toEqual(componentInstance.codeFiles);
+        expect(getCodeElement(debugElement).textContent).toContain(componentInstance.codeFiles[0].content);
+
+        // `files` used to be written by the `codeFiles` setter, so whichever came last in the template won.
+        componentInstance.files = [{ content: 'from files', filename: 'files.html' }];
+        fixture.detectChanges();
+
+        expect(codeBlock.files()).toEqual(componentInstance.files);
+    });
+
+    it('should render nothing rather than crash on an empty file list', () => {
+        const fixture = createComponent(PlainCodeBlock);
+
+        fixture.componentInstance.files = [];
+
+        expect(() => fixture.detectChanges()).not.toThrow();
+        expect(fixture.nativeElement.querySelector('.kbq-code-block__pre')).toBeNull();
+    });
+
+    it('should fall back to the first file for an active index that is not a number', () => {
+        const fixture = createComponent(BaseCodeBlock);
+        const { componentInstance } = fixture;
+        const codeBlock = geCodeBlockDebugElement(fixture.debugElement).componentInstance as KbqCodeBlock;
+
+        // `numberAttribute` turns an unset `index?: number` into NaN, which walked past every range guard.
+        componentInstance.activeFileIndex = undefined as never;
+
+        expect(() => fixture.detectChanges()).not.toThrow();
+        expect(codeBlock.activeFileIndex()).toBe(0);
+    });
 });
diff --git a/packages/components/code-block/code-block.ts b/packages/components/code-block/code-block.ts
index 83c5f44d6f..87f45924ca 100644
--- a/packages/components/code-block/code-block.ts
+++ b/packages/components/code-block/code-block.ts
@@ -19,14 +19,15 @@ import {
     inject,
     InjectionToken,
     Injector,
-    Input,
     input,
+    linkedSignal,
     numberAttribute,
     output,
     Provider,
     SecurityContext,
     signal,
     TemplateRef,
+    untracked,
     viewChild,
     ViewEncapsulation
 } from '@angular/core';
@@ -131,11 +132,11 @@ export class KbqCodeBlockTabLinkContent {}
         '[class.kbq-code-block_filled]': 'filled()',
         '[class.kbq-code-block_outline]': '!filled()',
         '[class.kbq-code-block_hide-line-numbers]': '!lineNumbers()',
-        '[class.kbq-code-block_hide-tabs]': 'hideTabs',
+        '[class.kbq-code-block_hide-tabs]': 'tabsHidden()',
         '[class.kbq-code-block_no-border]': 'noBorder() || filled()',
         '[class.kbq-code-block_show-actionbar]': 'actionbarVisible()',
-        '[class.kbq-code-block_soft-wrap]': 'softWrap',
-        '[class.kbq-code-block_view-all]': 'viewAll'
+        '[class.kbq-code-block_soft-wrap]': 'softWrap()',
+        '[class.kbq-code-block_view-all]': 'viewAll()'
     },
     exportAs: 'kbqCodeBlock'
 })
@@ -152,10 +153,10 @@ export class KbqCodeBlock implements AfterViewInit {
     readonly scrollableCodeContent = viewChild.required(CdkScrollable);
 
     /** @docs-private */
-    private readonly highlight = viewChild.required(KbqCodeBlockHighlight);
+    private readonly highlight = viewChild(KbqCodeBlockHighlight);
 
     /** @docs-private */
-    private readonly preElementRef = viewChild.required<ElementRef<HTMLElement>>('codeBlockPre');
+    private readonly preElementRef = viewChild<ElementRef<HTMLElement>>('codeBlockPre');
 
     /** @docs-private */
     protected readonly contentExceedsMaxHeight = signal(false);
@@ -173,23 +174,36 @@ export class KbqCodeBlock implements AfterViewInit {
     /** Added soft wrap toggle button.  */
     readonly canToggleSoftWrap = input<boolean, unknown>(false, { transform: booleanAttribute });
 
+    /**
+     * Backing input of `softWrap`. Bind through the `softWrap` attribute; read and write the signal.
+     *
+     * `model()` cannot carry the `booleanAttribute` transform a valueless attribute needs, and an input
+     * is read-only while `toggleSoftWrap()` writes this as well as the binding - hence the pair.
+     *
+     * @docs-private
+     */
+    readonly softWrapInput = input(false, { alias: 'softWrap', transform: booleanAttribute });
+
     /** Whether sequences of whitespace should be preserved. */
-    // TODO: Skipped for migration because:
-    //  Your application code writes to the input. This prevents migration.
-    @Input({ transform: booleanAttribute }) softWrap: boolean = false;
+    readonly softWrap = linkedSignal(() => this.softWrapInput());
 
     /**
      * Output to support two-way binding on `[(softWrap)]` property.
      */
     readonly softWrapChange = output<boolean>();
 
+    /**
+     * Backing input of `viewAll`, in the same shape as `softWrapInput`.
+     *
+     * @docs-private
+     */
+    readonly viewAllInput = input(false, { alias: 'viewAll', transform: booleanAttribute });
+
     /**
      * Allows to view all the code, otherwise it will be hidden.
      * Works only with `maxHeight` property.
      */
-    // TODO: Skipped for migration because:
-    //  Your application code writes to the input. This prevents migration.
-    @Input({ transform: booleanAttribute }) viewAll: boolean = false;
+    readonly viewAll = linkedSignal(() => this.viewAllInput());
 
     /**
      * Output to support two-way binding on `[(viewAll)]` property.
@@ -200,31 +214,43 @@ export class KbqCodeBlock implements AfterViewInit {
      * Maximum height of the code block content, other parts will be hidden.
      * Can be toggled by `viewAll` property.
      */
-    readonly maxHeight = input<number, unknown>(undefined!, { transform: numberAttribute });
+    readonly maxHeight = input<number | undefined, unknown>(undefined, {
+        transform: (value) => {
+            const parsed = numberAttribute(value);
+
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+    });
 
     /**
      * @docs-private
      */
-    protected get calculatedMaxHeight(): number | null {
-        return this.maxHeight() > 0 && !this.viewAll ? this.maxHeight() : null;
-    }
+    protected readonly calculatedMaxHeight = computed<number | null>(() => {
+        const maxHeight = this.maxHeight();
+
+        return maxHeight && maxHeight > 0 && !this.viewAll() ? maxHeight : null;
+    });
 
     /**
+     * Backing input of the deprecated `canLoad` attribute.
+     *
      * @deprecated Will be removed in next major release, use `canDownload` instead.
+     * @docs-private
+     */
+    readonly canLoadInput = input(false, { alias: 'canLoad', transform: booleanAttribute });
+
+    /**
+     * Backing input of `canDownload`.
      *
      * @docs-private
      */
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input({ transform: booleanAttribute })
-    set canLoad(value: boolean) {
-        this.canDownload = value;
-    }
+    readonly canDownloadInput = input(false, { alias: 'canDownload', transform: booleanAttribute });
 
-    /** Added download code button. */
-    // TODO: Skipped for migration because:
-    //  Your application code writes to the input. This prevents migration.
-    @Input({ transform: booleanAttribute }) canDownload: boolean = false;
+    /**
+     * Added download code button. Either attribute turns it on: `canLoad` used to write into
+     * `canDownload`, and which of the two won depended on the order they sat in the template.
+     */
+    readonly canDownload = linkedSignal(() => this.canDownloadInput() || this.canLoadInput());
 
     /** Added copy code button. */
     readonly canCopy = input<boolean, unknown>(true, { transform: booleanAttribute });
@@ -235,45 +261,72 @@ export class KbqCodeBlock implements AfterViewInit {
     });
 
     /**
+     * Backing input of the deprecated `codeFiles` attribute.
+     *
      * @deprecated Will be removed in next major release, use `files` instead.
+     * @docs-private
      */
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input()
-    set codeFiles(files: KbqCodeBlockFile[]) {
-        this.files = files;
-    }
+    readonly codeFilesInput = input<KbqCodeBlockFile[]>([], { alias: 'codeFiles' });
+
+    /**
+     * Backing input of `files`.
+     *
+     * @docs-private
+     */
+    readonly filesInput = input<KbqCodeBlockFile[]>([], { alias: 'files' });
 
     /**
      * @TODO Mark as `required`, after removing `codeFiles`
      *
-     * Files to display.
+     * Files to display. `codeFiles` fills in while `files` is empty: the deprecated attribute used to
+     * write into the same field, and which of the two won depended on the order in the template.
      */
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input()
-    get files(): KbqCodeBlockFile[] {
-        return this._files;
-    }
+    readonly files = linkedSignal(() => {
+        const files = this.filesInput();
 
-    set files(files: KbqCodeBlockFile[]) {
-        this._files = files;
+        return files.length > 0 ? files : this.codeFilesInput();
+    });
 
-        if (this._files.length < this.activeFileIndex) {
-            this.onSelectedTabChange(0);
-        }
+    /**
+     * Backing input of `activeFileIndex`. `numberAttribute` yields NaN for anything not cleanly numeric,
+     * and an unbound `index?: number` reaches it as `undefined`, so the transform floors both at 0 rather
+     * than letting NaN through a signal typed `number`.
+     *
+     * @docs-private
+     */
+    readonly activeFileIndexInput = input(0, {
+        alias: 'activeFileIndex',
+        transform: (value: unknown) => {
+            const index = numberAttribute(value);
 
-        if (this._files.length === 1 && !this._files[0].filename) {
-            this.hideTabs = true;
+            return Number.isInteger(index) && index >= 0 ? index : 0;
         }
-    }
-
-    private _files: KbqCodeBlockFile[] = [];
+    });
 
     /** Defines which file (index) is active. */
-    // TODO: Skipped for migration because:
-    //  Your application code writes to the input. This prevents migration.
-    @Input({ transform: numberAttribute }) activeFileIndex = 0;
+    readonly activeFileIndex = linkedSignal(() => this.activeFileIndexInput());
+
+    /**
+     * Index of the file actually rendered. `files` and `activeFileIndex` are written one after the other,
+     * so either order leaves the pair briefly inconsistent: the render falls back to the first file rather
+     * than resetting the input, which would write back into a `[(activeFileIndex)]` mid-update.
+     *
+     * @docs-private
+     */
+    protected readonly renderedFileIndex = computed(() => {
+        const index = this.activeFileIndex();
+
+        return index < this.files().length ? index : 0;
+    });
+
+    /**
+     * The file being rendered, or `undefined` while `files` is empty.
+     *
+     * @docs-private
+     */
+    protected readonly activeFile = computed<KbqCodeBlockFile | undefined>(
+        () => this.files()[this.renderedFileIndex()]
+    );
 
     /**
      * Output to support two-way binding on `[(activeFileIndex)]` property.
@@ -284,23 +337,32 @@ export class KbqCodeBlock implements AfterViewInit {
     readonly noBorder = input<boolean, unknown>(false, { transform: booleanAttribute });
 
     /**
-     * Whether to hide header tabs.
-     * Always `true` if there is only one file without filename.
+     * Backing input of `hideTabs`.
+     *
+     * @docs-private
+     */
+    readonly hideTabsInput = input(false, { alias: 'hideTabs', transform: booleanAttribute });
+
+    /**
+     * Whether to hide header tabs. A single file without a filename hides them regardless - read
+     * `tabsHidden` for what the header actually does.
      * Makes actionbar floating if tabs are hidden.
      */
-    // TODO: Skipped for migration because:
-    //  Accessor inputs cannot be migrated as they are too complex.
-    @Input({ transform: booleanAttribute })
-    get hideTabs(): boolean {
-        return this._hideTabs();
-    }
+    readonly hideTabs = linkedSignal(() => this.hideTabsInput());
 
-    set hideTabs(value: boolean) {
-        this._hideTabs.set(value);
-        this.hideTabsChange.emit(value);
-    }
+    /**
+     * A lone file with no filename has nothing to label a tab with, so the bar is hidden whatever was
+     * bound. Derived rather than written into `hideTabs`: the write latched the bar off for the life of
+     * the component, so naming the files later never brought it back, and it re-emitted `hideTabsChange`
+     * on every `files` assignment.
+     *
+     * @docs-private
+     */
+    readonly tabsHidden = computed(() => {
+        const files = this.files();
 
-    private readonly _hideTabs = signal(false);
+        return this.hideTabs() || (files.length === 1 && !files[0].filename);
+    });
     private readonly actionbarHovered = signal(false);
 
     /**
@@ -345,7 +407,7 @@ export class KbqCodeBlock implements AfterViewInit {
 
         const element = this.scrollableCodeContent()?.getElementRef().nativeElement;
 
-        return element && this.hasScroll(element) && !this.calculatedMaxHeight;
+        return !this.calculatedMaxHeight() && !!element && this.hasScroll(element);
     }
 
     /**
@@ -379,7 +441,7 @@ export class KbqCodeBlock implements AfterViewInit {
             this.alwaysShowActionbar() ||
             this.platform.IOS ||
             this.platform.ANDROID ||
-            !this._hideTabs() ||
+            !this.tabsHidden() ||
             this.actionbarHovered()
     );
 
@@ -413,13 +475,13 @@ export class KbqCodeBlock implements AfterViewInit {
      * will be displayed.
      */
     toggleViewAll(): void {
-        this.viewAll = !this.viewAll;
+        this.viewAll.set(!this.viewAll());
 
-        if (!this.viewAll) {
+        if (!this.viewAll()) {
             this.scrollTo({ top: 0, behavior: 'instant' });
         }
 
-        this.viewAllChange.emit(this.viewAll);
+        this.viewAllChange.emit(this.viewAll());
     }
 
     /** Scrolls the code content to the specified position. */
@@ -448,8 +510,8 @@ export class KbqCodeBlock implements AfterViewInit {
      * the content will not be wrapped.
      */
     toggleSoftWrap(): void {
-        this.softWrap = !this.softWrap;
-        this.softWrapChange.emit(this.softWrap);
+        this.softWrap.set(!this.softWrap());
+        this.softWrapChange.emit(this.softWrap());
     }
 
     /**
@@ -461,9 +523,11 @@ export class KbqCodeBlock implements AfterViewInit {
      * @docs-private
      */
     protected onSelectedTabChange(index: number): void {
-        if (this.activeFileIndex !== index) {
-            this.activeFileIndex = index;
-            this.activeFileIndexChange.emit(this.activeFileIndex);
+        // Compared against the bound index rather than the rendered one: with an out-of-range binding the
+        // two differ, and clicking the tab that is already on screen has to bring the input back in range.
+        if (this.activeFileIndex() !== index) {
+            this.activeFileIndex.set(index);
+            this.activeFileIndexChange.emit(index);
             this.scrollTo({ top: 0, behavior: 'instant' });
         }
     }
@@ -472,7 +536,7 @@ export class KbqCodeBlock implements AfterViewInit {
     private trackHoverState(): void {
         effect(
             (onCleanup) => {
-                const hideTabs = this._hideTabs();
+                const hideTabs = this.tabsHidden();
                 const alwaysShowActionbar = this.alwaysShowActionbar();
 
                 this.actionbarHovered.set(false);
@@ -497,29 +561,44 @@ export class KbqCodeBlock implements AfterViewInit {
     private setupContentOverflowDetection(): void {
         if (!this.platform.isBrowser) return;
 
-        if (!this.maxHeight()) return;
+        // `maxHeight` is a signal, so the gate has to follow it: bound after init it used to leave the
+        // content clipped with neither the "view all" button nor a way in from the keyboard.
+        effect(
+            (onCleanup) => {
+                const preElement = this.preElementRef()?.nativeElement;
 
-        const checkOverflow = () => {
-            this.contentExceedsMaxHeight.set(this.preElementRef().nativeElement.offsetHeight > this.maxHeight());
-        };
+                this.measureContentOverflow();
 
-        checkOverflow();
+                if (!this.maxHeight() || !preElement) return;
 
-        const highlight = this.highlight();
+                const subscription = this.sharedResizeObserver
+                    .observe(preElement)
+                    .subscribe(() => this.measureContentOverflow());
 
-        if (highlight?.pending()) {
-            toObservable(highlight.pending, { injector: this.injector })
-                .pipe(
-                    filter((pending) => !pending),
-                    take(1)
-                )
-                .subscribe(checkOverflow);
-        }
+                onCleanup(() => subscription.unsubscribe());
+            },
+            { injector: this.injector }
+        );
+
+        // Half-rendered content answers for the wrong height, so the measurement is retaken once
+        // highlighting settles. Kept apart from the subscription above, which would otherwise be torn
+        // down and re-created on both edges of every `pending` flip.
+        effect(
+            () => {
+                this.highlight()?.pending();
 
-        this.sharedResizeObserver
-            .observe(this.preElementRef().nativeElement)
-            .pipe(takeUntilDestroyed(this.destroyRef))
-            .subscribe(checkOverflow);
+                untracked(() => this.measureContentOverflow());
+            },
+            { injector: this.injector }
+        );
+    }
+
+    /** @docs-private */
+    private measureContentOverflow(): void {
+        const maxHeight = this.maxHeight();
+        const preElement = this.preElementRef()?.nativeElement;
+
+        this.contentExceedsMaxHeight.set(!!maxHeight && !!preElement && preElement.offsetHeight > maxHeight);
     }
 
     /** Whether the element has scroll. */
@@ -551,7 +630,9 @@ export class KbqCodeBlock implements AfterViewInit {
      * @docs-private
      */
     protected copyCode(): void {
-        const file = this.files[this.activeFileIndex];
+        const file = this.activeFile();
+
+        if (!file) return;
 
         const copyButtonTooltip = this.copyButtonTooltip();
 
@@ -566,8 +647,11 @@ export class KbqCodeBlock implements AfterViewInit {
      * @docs-private
      */
     protected openLink(): void {
-        const file = this.files[this.activeFileIndex];
-        const safeURL = this.domSanitizer.sanitize(SecurityContext.URL, file.link!);
+        const file = this.activeFile();
+
+        if (!file?.link) return;
+
+        const safeURL = this.domSanitizer.sanitize(SecurityContext.URL, file.link);
 
         if (safeURL) {
             this.window.open(safeURL.toString(), '_blank');
@@ -583,7 +667,10 @@ export class KbqCodeBlock implements AfterViewInit {
      * @docs-private
      */
     protected downloadCode(): void {
-        const file = this.files[this.activeFileIndex];
+        const file = this.activeFile();
+
+        if (!file) return;
+
         const blob = new Blob([file.content], { type: 'text/plain' });
         const url = URL.createObjectURL(blob);
         const link = this.document.createElement('a');
diff --git a/packages/schematics/src/collection.json b/packages/schematics/src/collection.json
index 9c93faedaf..ff6c175b6b 100644
--- a/packages/schematics/src/collection.json
+++ b/packages/schematics/src/collection.json
@@ -218,6 +218,11 @@
             "description": "Migrates KbqCheckbox consumers to its finished signal-based API. Rewrites programmatic reads of the now-signal one-way inputs (id, clickAction, big, required, value, name, labelPosition) to calls on receivers typed KbqCheckbox, including reads via template reference variables on <kbq-checkbox> (external and inline templates). Warns on programmatic writes, on the template plumbing that became protected (inputId, inputElement, getAriaChecked, onInputClick, onInteractionEvent, onLabelTextChange) whether it is read from TypeScript or through a template reference, and on reads through a signal query, which need two calls. Reports the 0-based counter the CDK _IdGenerator brings - the id shape itself is unchanged for a default APP_ID - the [id]=null fallback on the host, the booleanAttribute transforms on checked/big/indeterminate, which coerce a bound 0 or empty string to true as well, the required default, and value reporting string | undefined. checked, disabled, indeterminate and tabIndex stay accessor inputs over the KbqCheckable signals and are not touched.",
             "factory": "./migrations/checkbox-signals/index",
             "schema": "./migrations/checkbox-signals/schema.json"
+        },
+        "code-block-signals": {
+            "description": "Migrates KbqCodeBlock consumers to its finished signal-based API: nothing on the component is a decorator input any more. Rewrites reads of softWrap, viewAll, canDownload, files, activeFileIndex and hideTabs to calls on receivers typed KbqCodeBlock, including reads through template reference variables on <kbq-code-block> (external and inline templates), and rewrites a plain write of any of them to .set(...) - all six are WritableSignals over a backing input, because ModelOptions carries no transform and every one of them needs booleanAttribute or numberAttribute to keep a valueless attribute working. Warns - without auto-fixing - on compound assignments and increments, which would need the receiver spelled twice, on the backing inputs and the deprecated canLoad and codeFiles aliases, which can no longer be written, and on reads through a signal query, which need two calls. Reports that maxHeight now reports number | undefined and never NaN, that KbqCodeBlockHighlight.file is a readable required input instead of a write-only setter, that hideTabs reports what was bound while tabsHidden() is what the header does, that canLoad and codeFiles now fill in for canDownload and files rather than writing into them, and that an out-of-range activeFileIndex renders the first file while an empty files renders no code instead of throwing.",
+            "factory": "./migrations/code-block-signals/index",
+            "schema": "./migrations/code-block-signals/schema.json"
         }
     }
 }
diff --git a/packages/schematics/src/migrations.json b/packages/schematics/src/migrations.json
index d818e10359..ed66f18348 100644
--- a/packages/schematics/src/migrations.json
+++ b/packages/schematics/src/migrations.json
@@ -180,6 +180,11 @@
             "version": "21.0.0-0",
             "description": "Migrates KbqCheckbox consumers to its finished signal-based API. Rewrites programmatic reads of the now-signal one-way inputs (id, clickAction, big, required, value, name, labelPosition) to calls on receivers typed KbqCheckbox, including reads via template reference variables on <kbq-checkbox> (external and inline templates). Warns on programmatic writes, on the template plumbing that became protected (inputId, inputElement, getAriaChecked, onInputClick, onInteractionEvent, onLabelTextChange) whether it is read from TypeScript or through a template reference, and on reads through a signal query, which need two calls. Reports the 0-based counter the CDK _IdGenerator brings - the id shape itself is unchanged for a default APP_ID - the [id]=null fallback on the host, the booleanAttribute transforms on checked/big/indeterminate, which coerce a bound 0 or empty string to true as well, the required default, and value reporting string | undefined. checked, disabled, indeterminate and tabIndex stay accessor inputs over the KbqCheckable signals and are not touched.",
             "factory": "./migrations/checkbox-signals/index"
+        },
+        "code-block-signals": {
+            "version": "21.0.0-0",
+            "description": "Migrates KbqCodeBlock consumers to its finished signal-based API: nothing on the component is a decorator input any more. Rewrites reads of softWrap, viewAll, canDownload, files, activeFileIndex and hideTabs to calls on receivers typed KbqCodeBlock, including reads through template reference variables on <kbq-code-block> (external and inline templates), and rewrites a plain write of any of them to .set(...) - all six are WritableSignals over a backing input, because ModelOptions carries no transform and every one of them needs booleanAttribute or numberAttribute to keep a valueless attribute working. Warns - without auto-fixing - on compound assignments and increments, which would need the receiver spelled twice, on the backing inputs and the deprecated canLoad and codeFiles aliases, which can no longer be written, and on reads through a signal query, which need two calls. Reports that maxHeight now reports number | undefined and never NaN, that KbqCodeBlockHighlight.file is a readable required input instead of a write-only setter, that hideTabs reports what was bound while tabsHidden() is what the header does, that canLoad and codeFiles now fill in for canDownload and files rather than writing into them, and that an out-of-range activeFileIndex renders the first file while an empty files renders no code instead of throwing.",
+            "factory": "./migrations/code-block-signals/index"
         }
     }
 }
diff --git a/packages/schematics/src/migrations/code-block-signals/README.md b/packages/schematics/src/migrations/code-block-signals/README.md
new file mode 100644
index 0000000000..a591903f35
--- /dev/null
+++ b/packages/schematics/src/migrations/code-block-signals/README.md
@@ -0,0 +1,81 @@
+# code-block-signals
+
+Migration schematic invoked automatically by `ng update @koobiq/components@21` (registered for
+`21.0.0-0`). Moves `KbqCodeBlock` consumers onto its finished signal-based API and reports what has no
+mechanical translation.
+
+## Background
+
+`maxHeight` was published as `InputSignal<number>` over an `undefined!` default, so a code block with
+no `[maxHeight]` binding reported `undefined` from a non-nullable type:
+
+```ts
+const height: number = codeBlock.maxHeight(); // held undefined
+if (codeBlock.maxHeight() > 0) { … }          // NaN comparison, never true
+```
+
+It reports `number | undefined` now, and a value that is not cleanly numeric — a valueless
+`maxHeight` attribute, `'200px'` — reports `undefined` rather than `NaN`. `[maxHeight]="undefined"`
+used to hand back `NaN`; that is the one runtime change. The call sites that were quietly wrong now
+fail to compile.
+
+`KbqCodeBlockHighlight.file` was a write-only required input: a setter with no getter that kicked off
+highlighting as a side effect. It is `input.required()` driven by an effect now, so it can finally be
+read — and a programmatic write no longer compiles.
+
+## What it rewrites
+
+`KbqCodeBlock` has no decorator inputs left. `softWrap`, `viewAll`, `canDownload`, `files`,
+`activeFileIndex` and `hideTabs` are `WritableSignal`s over a backing `input()`, so both directions
+are mechanical:
+
+| Before                      | After                          |
+| --------------------------- | ------------------------------ |
+| `block.softWrap`            | `block.softWrap()`             |
+| `block.activeFileIndex = 2` | `block.activeFileIndex.set(2)` |
+
+On receivers explicitly typed `KbqCodeBlock`, on the `inject()` / `viewChild()` initializer forms, and
+through template reference variables on `<kbq-code-block>` in external and inline templates. Reads that
+are already calls are left alone, so the schematic is idempotent.
+
+A `model()` would have been the obvious shape for the six, but `ModelOptions` carries no `transform`,
+and every one of them needs `booleanAttribute` or `numberAttribute` to keep a valueless attribute such
+as `<kbq-code-block softWrap>` working.
+
+## What it does _not_ do Narrowing `number | undefined` back to `number` is a decision — `?? 0`, a
+
+non-null assertion, or handling the unset state — and turning a `file` write into a `[file]` binding
+is a template edit.
+
+| Pattern                                  | Manual migration                                                    |
+| ---------------------------------------- | ------------------------------------------------------------------- |
+| `.maxHeight()` on a `KbqCodeBlock`       | `?? 0` for the common reading, or handle the unset state explicitly |
+| `.file = …` on a `KbqCodeBlockHighlight` | Bind `[file]`; the value is readable as `file()` now                |
+
+## Notes with no call site to point at
+
+- The `max-height` the code block applies while `viewAll` is off is a `computed`. It was a getter read
+  from a `[style.max-height.px]` binding, so it only re-evaluated when something else marked the view
+  dirty; it follows `maxHeight` and `viewAll` directly now.
+- `softWrap`, `viewAll`, `canDownload`, `activeFileIndex` and `files` are backed by signals. They are
+  accessor inputs with the same types and the same two-way outputs — they are written by the component
+  as well as by the binding, and a `model()` cannot carry the `booleanAttribute` /
+  `numberAttribute` transform they need. Four of the five were plain public fields before, so they are
+  no longer own properties: they do not appear in `Object.keys`, a spread or `JSON.stringify`, and a
+  subclass field of the same name shadows the accessor under `useDefineForClassFields`.
+- **`hideTabs` is derived rather than written.** A single file with no filename still hides the tab
+  bar, but the component no longer writes `true` into its own input to do it: the write latched the
+  bar off for good and re-emitted `hideTabsChange` on every `files` assignment. `[hideTabs]="false"`
+  no longer shows the bar for a lone unnamed file.
+- **An `activeFileIndex` outside `files` renders the first file, and an empty `files` renders no code
+  at all.** Both used to reach `files[activeFileIndex]` and throw on the undefined result. The index
+  itself is left as bound: resetting it wrote back into a `[(activeFileIndex)]` while the parent was
+  still updating.
+- A failed `highlight.js` load no longer latches `pending` on, and the line-numbers plugin installs
+  its `<style>` and its `copy` listener once instead of once per code block.
+
+## Running it manually
+
+```
+ng generate @koobiq/components:code-block-signals --project my-app
+```
diff --git a/packages/schematics/src/migrations/code-block-signals/data.ts b/packages/schematics/src/migrations/code-block-signals/data.ts
new file mode 100644
index 0000000000..33c68d5bff
--- /dev/null
+++ b/packages/schematics/src/migrations/code-block-signals/data.ts
@@ -0,0 +1,133 @@
+/**
+ * Data for the `code-block-signals` migration.
+ *
+ * `KbqCodeBlock` finished its move to signals: nothing on it is a decorator input any more.
+ *
+ * - `softWrap`, `viewAll`, `canDownload`, `files`, `activeFileIndex`, `hideTabs` → `WritableSignal`s over
+ *   a backing `input()`, so a read becomes a call and a plain write becomes `.set(…)` (auto-fixed)
+ * - `maxHeight` was already a signal input; only its type changed (warn)
+ * - `canLoad` and `codeFiles`, the deprecated write-only aliases, are backing inputs now: bind them, a
+ *   programmatic write no longer compiles (warn)
+ *
+ * A `model()` would have been the obvious shape for the six, but `ModelOptions` carries no `transform`,
+ * and every one of them needs `booleanAttribute` or `numberAttribute` to keep a valueless attribute
+ * (`<kbq-code-block softWrap>`) working. Hence the backing input plus a `linkedSignal` over it.
+ */
+
+/** Members whose value is unchanged; a read must become a call, a write must become `.set(…)`. */
+export const SIGNAL_MEMBERS: readonly string[] = [
+    'softWrap',
+    'viewAll',
+    'canDownload',
+    'files',
+    'activeFileIndex',
+    'hideTabs'
+];
+
+/**
+ * Members the migration reports rather than rewrites: `maxHeight` was already a signal input and only
+ * changed its type, and `KbqCodeBlockHighlight.file` turned from a write-only setter into a required
+ * input. Both are reported per file, because a summary line names no call site.
+ */
+export const REPORTED_MEMBERS: readonly string[] = ['maxHeight', 'file'];
+
+/** Signal-API methods reachable on a signal; a read followed by one is already migrated. */
+export const SIGNAL_API_METHODS: ReadonlySet<string> = new Set(['set', 'update', 'asReadonly', 'subscribe']);
+
+/** `exportAs` name a template reference has to carry to be the code block rather than some other directive. */
+export const CODE_BLOCK_EXPORT_AS = 'kbqCodeBlock';
+
+/** TypeScript type annotation that marks a receiver as a code block. */
+export const CODE_BLOCK_TYPE = 'KbqCodeBlock';
+
+/** Type annotation that marks a receiver as the highlight directive, whose `file` input also changed. */
+export const HIGHLIGHT_TYPE = 'KbqCodeBlockHighlight';
+
+/** Element selector whose template reference variables (`#ref`) point at a code block. */
+export const CODE_BLOCK_ELEMENT = 'kbq-code-block';
+
+/** Import specifier that marks a file as a code block consumer. */
+export const CODE_BLOCK_PACKAGE = '@koobiq/components/code-block';
+
+/**
+ * The backing inputs behind the six signals, plus the two deprecated aliases that used to be write-only
+ * setters. Public, because a `protected` input cannot be bound from a consumer's template, but they are
+ * `@docs-private` plumbing: read the signal that carries the attribute's own name instead.
+ */
+export const PLUMBING_MEMBERS: readonly string[] = [
+    'softWrapInput',
+    'viewAllInput',
+    'canDownloadInput',
+    'canLoadInput',
+    'filesInput',
+    'codeFilesInput',
+    'activeFileIndexInput',
+    'hideTabsInput'
+];
+
+/** Reported for a write the rewrite cannot translate on its own. */
+export const writeMessage = (members: Iterable<string>): string =>
+    `These writes were left untouched: ${[...members].join(', ')}. A plain \`x.softWrap = value\` is ` +
+    'rewritten to `x.softWrap.set(value)`, but a compound assignment (`||=`, `+=`) or an increment would ' +
+    'need the receiver spelled twice, and `canLoad` / `codeFiles` are backing inputs now, so writing them ' +
+    'no longer compiles at all - bind the attribute instead.';
+
+export const reportedMessage = (members: Iterable<string>): string =>
+    `These KbqCodeBlock members changed shape without changing name: ${[...members].join(', ')}. ` +
+    '`maxHeight` reports `number | undefined` instead of `number` and never NaN, so decide per call site ' +
+    'between `?? 0` and handling the unset state. `KbqCodeBlockHighlight.file` was a write-only setter ' +
+    'and is a required input now: bind `[file]`, and read it as `file()`.';
+
+export const plumbingMessage = (members: Iterable<string>): string =>
+    `These KbqCodeBlock members are backing inputs: ${[...members].join(', ')}. They exist to carry the ` +
+    'attribute and its transform, they are read-only, and they report what was bound rather than what the ' +
+    'component currently holds. Bind the attribute they alias - `softWrap`, `viewAll`, `canDownload`, ' +
+    '`canLoad`, `files`, `codeFiles`, `activeFileIndex`, `hideTabs` - and read the signal that carries ' +
+    "the attribute's own name.";
+
+/**
+ * Reported for a read through a signal query, which is a signal holding the component: the read needs two
+ * calls rather than one. Emitted from the AST pass rather than a regex, so it follows the same receiver
+ * resolution as the rewrite.
+ */
+export const signalQueryMessage = (member: string, required: boolean): string =>
+    `A signal query holds the component behind a call of its own, so reading \`${member}\` through it ` +
+    `needs two calls: \`this.codeBlock()${required ? '' : '?'}.${member}()\`.` +
+    (required ? '' : ' The query is optional, so keep the `?.`.') +
+    ' Those reads are left untouched - migrate them by hand.';
+
+/** Reported when a template renders the code block but cannot be parsed, so nothing in it was inspected. */
+export const UNPARSEABLE_TEMPLATE_MESSAGE =
+    'This template renders <kbq-code-block> but could not be parsed, so it was left untouched. Migrate ' +
+    'reads through its template reference variables by hand. If every template is reported this way, ' +
+    '`@angular/compiler` could not be loaded from this install.';
+
+/**
+ * Reported when a file names `KbqCodeBlock` in a type position the receiver pass cannot scope to a single
+ * identifier - a union, an array, a `QueryList<…>`, a cast, a return type - or reads a member in a shape
+ * the access pass cannot reach.
+ */
+export const UNRESOLVED_RECEIVER_MESSAGE =
+    'KbqCodeBlock is used here in a way this migration cannot resolve to a single receiver, so any signal ' +
+    'read through it was left untouched. Check these lines by hand:';
+
+/** Printed once per project, after the per-file reports. */
+export const SUMMARY = [
+    '  `maxHeight` reports `number | undefined` instead of `number`, and a value that is not cleanly ' +
+        "numeric - a valueless `maxHeight` attribute, `'200px'` - reports `undefined` rather than NaN. " +
+        'It was declared non-nullable over an `undefined!` default, so a block with no binding always ' +
+        'handed back `undefined` behind a `number` type.',
+    '  `KbqCodeBlockHighlight.file` was a write-only required input that started highlighting as a side ' +
+        'effect. It is a required signal input driven by an effect now, so it can finally be read - and a ' +
+        'programmatic write no longer compiles.',
+    '  Reading `hideTabs` reports what was bound. What the header actually does is `tabsHidden()`, which ' +
+        'adds the rule that a single file with no filename hides the bar; the component used to write that ' +
+        'rule into `hideTabs` itself, which latched the bar off for good.',
+    '  `canLoad` and `codeFiles` fill in for `canDownload` and `files` rather than writing into them: ' +
+        'either attribute turns the download button on, and `codeFiles` applies while `files` is empty. ' +
+        'Which of each pair won used to depend on the order they sat in the template.',
+    '  An `activeFileIndex` outside `files` renders the first file instead of the indexed one, and an ' +
+        'empty `files` renders no code at all. Both used to reach `files[activeFileIndex]` and throw on ' +
+        'the undefined result. The index itself is left alone: resetting it wrote back into ' +
+        '`[(activeFileIndex)]` while the parent was still updating.'
+];
diff --git a/packages/schematics/src/migrations/code-block-signals/index.spec.ts b/packages/schematics/src/migrations/code-block-signals/index.spec.ts
new file mode 100644
index 0000000000..ea8099bdba
--- /dev/null
+++ b/packages/schematics/src/migrations/code-block-signals/index.spec.ts
@@ -0,0 +1,272 @@
+import { workspaces } from '@angular-devkit/core';
+import { Tree } from '@angular-devkit/schematics';
+import { SchematicTestRunner } from '@angular-devkit/schematics/testing';
+import { getWorkspace } from '@schematics/angular/utility/workspace';
+import * as path from 'path';
+import { lastValueFrom } from 'rxjs';
+import { createTestApp } from '../../utils/testing';
+import codeBlockSignals from './index';
+import { Schema } from './schema';
+
+const collectionPath = path.join(__dirname, '../../collection.json');
+const SCHEMATIC_NAME = 'code-block-signals';
+
+describe(SCHEMATIC_NAME, () => {
+    let runner: SchematicTestRunner;
+    let appTree: Tree;
+    let projects: workspaces.ProjectDefinitionCollection;
+    let messages: string[];
+
+    beforeEach(async () => {
+        runner = new SchematicTestRunner('schematics', collectionPath);
+        appTree = await createTestApp(runner, { style: 'scss' });
+        const workspace = await getWorkspace(appTree);
+
+        projects = workspace.projects as unknown as workspaces.ProjectDefinitionCollection;
+
+        messages = [];
+        runner.logger.subscribe((entry) => messages.push(entry.message));
+    });
+
+    function paths(project: workspaces.ProjectDefinition) {
+        const root = `/${project.root}/src/app`;
+        const ts = appTree.exists(`${root}/app.ts`) ? `${root}/app.ts` : `${root}/app.component.ts`;
+        const html = appTree.exists(`${root}/app.html`) ? `${root}/app.html` : `${root}/app.component.html`;
+
+        return { ts, html };
+    }
+
+    async function run(fix: boolean = true): Promise<Tree> {
+        const [first] = projects.keys();
+
+        return runner.runSchematic(SCHEMATIC_NAME, { project: first, fix } satisfies Schema, appTree);
+    }
+
+    function firstTsPath(): string {
+        return paths(projects.get([...projects.keys()][0])!).ts;
+    }
+
+    function firstHtmlPath(): string {
+        return paths(projects.get([...projects.keys()][0])!).html;
+    }
+
+    it('rewrites reads on a receiver typed KbqCodeBlock', async () => {
+        const ts = firstTsPath();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    read(block: KbqCodeBlock) {\n' +
+                '        return block.softWrap && block.viewAll && block.files.length + block.activeFileIndex;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        const updated = (await run()).readText(ts);
+
+        expect(updated).toContain('block.softWrap() && block.viewAll()');
+        expect(updated).toContain('block.files().length + block.activeFileIndex()');
+    });
+
+    it('rewrites a plain write to a set call', async () => {
+        const ts = firstTsPath();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    write(block: KbqCodeBlock) {\n' +
+                '        block.activeFileIndex = 2;\n' +
+                '        block.softWrap = true;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        const updated = (await run()).readText(ts);
+
+        expect(updated).toContain('block.activeFileIndex.set(2);');
+        expect(updated).toContain('block.softWrap.set(true);');
+    });
+
+    it('reports a compound assignment instead of rewriting it', async () => {
+        const ts = firstTsPath();
+        const source =
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+            'class Demo {\n' +
+            '    wrap = false;\n' +
+            '    write(block: KbqCodeBlock) {\n' +
+            '        block.softWrap ||= this.wrap;\n' +
+            '    }\n' +
+            '}\n';
+
+        appTree.overwrite(ts, source);
+
+        // `block.softWrap.set(block.softWrap() || this.wrap)` would spell the receiver twice.
+        expect((await run()).readText(ts)).toBe(source);
+        expect(messages.join('\n')).toContain('left untouched');
+    });
+
+    it('rewrites a read under a negation rather than treating it as a write', async () => {
+        const ts = firstTsPath();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    read(block: KbqCodeBlock) {\n' +
+                '        return !block.softWrap;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        expect((await run()).readText(ts)).toContain('return !block.softWrap();');
+    });
+
+    it('rewrites a read through a template reference variable', async () => {
+        const html = firstHtmlPath();
+
+        appTree.overwrite(
+            html,
+            '<kbq-code-block #block="kbqCodeBlock" [files]="files" />\n' + '<div>{{ block.activeFileIndex }}</div>\n'
+        );
+
+        expect((await run()).readText(html)).toContain('{{ block.activeFileIndex() }}');
+    });
+
+    it('reports a read of a backing input', async () => {
+        const ts = firstTsPath();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    read(block: KbqCodeBlock) {\n' +
+                '        return block.softWrapInput;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        await run();
+
+        expect(messages.join('\n')).toContain('are backing inputs');
+    });
+
+    it('reports a maxHeight read, which changed type without changing name', async () => {
+        const ts = firstTsPath();
+        const source =
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+            'class Demo {\n' +
+            '    read(block: KbqCodeBlock) {\n' +
+            '        return block.maxHeight();\n' +
+            '    }\n' +
+            '}\n';
+
+        appTree.overwrite(ts, source);
+
+        expect((await run()).readText(ts)).toBe(source);
+
+        const fileReport = messages.find((message) => message.includes(ts))!;
+
+        expect(fileReport).toContain('maxHeight');
+    });
+
+    it('reports a write to the highlight file input', async () => {
+        const ts = firstTsPath();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlockHighlight } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    write(highlight: KbqCodeBlockHighlight, file: any) {\n' +
+                '        highlight.file = file;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        await run();
+
+        const fileReport = messages.find((message) => message.includes(ts))!;
+
+        expect(fileReport).toContain('write-only setter');
+    });
+
+    it('is idempotent - an already migrated read is left alone', async () => {
+        const ts = firstTsPath();
+        const source =
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+            'class Demo {\n' +
+            '    read(block: KbqCodeBlock) {\n' +
+            '        block.softWrap.set(true);\n' +
+            '        return block.softWrap();\n' +
+            '    }\n' +
+            '}\n';
+
+        appTree.overwrite(ts, source);
+
+        expect((await run()).readText(ts)).toBe(source);
+    });
+
+    it('leaves a shadowing binding of another type alone', async () => {
+        const ts = firstTsPath();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    blocks: { files: unknown[] }[] = [];\n' +
+                '    read(block: KbqCodeBlock) {\n' +
+                '        this.blocks.forEach((block: { files: unknown[] }) => console.log(block.files));\n' +
+                '        return block.files;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        const updated = (await run()).readText(ts);
+
+        expect(updated).toContain('console.log(block.files)');
+        expect(updated).toContain('return block.files();');
+    });
+
+    it('does not write when fix is false', async () => {
+        const ts = firstTsPath();
+        const source =
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+            'class Demo {\n' +
+            '    read(block: KbqCodeBlock) {\n' +
+            '        return block.softWrap;\n' +
+            '    }\n' +
+            '}\n';
+
+        appTree.overwrite(ts, source);
+
+        expect((await run(false)).readText(ts)).toBe(source);
+    });
+
+    it('applies the migration when `fix` is absent, as it is under `ng update`', async () => {
+        const ts = firstTsPath();
+        const [first] = projects.keys();
+
+        appTree.overwrite(
+            ts,
+            "import { KbqCodeBlock } from '@koobiq/components/code-block';\n" +
+                'class Demo {\n' +
+                '    read(block: KbqCodeBlock) {\n' +
+                '        return block.softWrap;\n' +
+                '    }\n' +
+                '}\n'
+        );
+
+        // Called through the rule rather than `runSchematic`: `ng update` runs the factory straight from
+        // migrations.json, which carries no schema, so the `fix` default in schema.json never applies.
+        const updated = await lastValueFrom(runner.callRule(codeBlockSignals({ project: first }), appTree));
+
+        expect(updated.readText(ts)).toContain('return block.softWrap();');
+    });
+
+    it('stays silent for a workspace that does not use the code block', async () => {
+        await run();
+
+        expect(messages.join('\n')).not.toContain(`[${SCHEMATIC_NAME}]`);
+    });
+});
diff --git a/packages/schematics/src/migrations/code-block-signals/index.ts b/packages/schematics/src/migrations/code-block-signals/index.ts
new file mode 100644
index 0000000000..acd33693d0
--- /dev/null
+++ b/packages/schematics/src/migrations/code-block-signals/index.ts
@@ -0,0 +1,965 @@
+import { Path } from '@angular-devkit/core';
+import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
+import ts from 'typescript';
+import { visitAll, Visitor } from '../../utils/ast';
+import { logMessage } from '../../utils/messages';
+import { setupOptions } from '../../utils/package-config';
+import { collectInlineTemplateRanges, parseTemplate } from '../../utils/typescript';
+import {
+    CODE_BLOCK_ELEMENT,
+    CODE_BLOCK_EXPORT_AS,
+    CODE_BLOCK_PACKAGE,
+    CODE_BLOCK_TYPE,
+    HIGHLIGHT_TYPE,
+    PLUMBING_MEMBERS,
+    plumbingMessage,
+    REPORTED_MEMBERS,
+    reportedMessage,
+    SIGNAL_API_METHODS,
+    SIGNAL_MEMBERS,
+    signalQueryMessage,
+    SUMMARY,
+    UNPARSEABLE_TEMPLATE_MESSAGE,
+    UNRESOLVED_RECEIVER_MESSAGE,
+    writeMessage
+} from './data';
+import { Schema } from './schema';
+
+const LABEL = '[code-block-signals]';
+const TS_EXT = '.ts';
+const HTML_EXT = '.html';
+
+/** Factories whose single argument gives the type of the declaration they set up. */
+const TYPING_FACTORIES: ReadonlySet<string> = new Set(['inject', 'viewChild', 'contentChild']);
+
+/** A half-open `[start, end)` span of the source being rewritten. */
+interface Range {
+    start: number;
+    end: number;
+}
+
+/** A text-span edit on the original file content. Applied right-to-left so offsets stay valid. */
+interface Edit extends Range {
+    text: string;
+}
+
+/** A receiver whose static type is a code block, valid within `scope`. */
+interface Receiver {
+    /** Source text of the receiver expression, e.g. `code block` or `this.code block`. */
+    text: string;
+    /** The node whose subtree the receiver name is visible in. */
+    scope: ts.Node;
+    /** The declaration `text` resolves to. A nested redeclaration of the same name resolves elsewhere. */
+    declaration: ts.Node;
+    /** Whether the receiver is a signal query, so reads through it need two calls rather than one. */
+    signalQuery: boolean;
+    /** Whether that query is `.required`, which decides whether the safe read needs a `?.`. */
+    required: boolean;
+}
+
+/** A name introduced by a declaration, together with the scope it is visible in. */
+interface Binding {
+    name: string;
+    declaration: ts.Node;
+    scope: ts.Node;
+}
+
+function escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Applies text-span edits to `content`, right-to-left, so earlier edits don't shift later offsets. */
+function applyEdits(content: string, edits: Edit[]): string {
+    const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+    let result = content;
+
+    for (const { start, end, text } of sorted) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+
+    return result;
+}
+
+/** Walks up from `node` to the nearest ancestor matching `predicate`. */
+function findAncestor(node: ts.Node, predicate: (node: ts.Node) => boolean): ts.Node | undefined {
+    let current = node.parent;
+
+    while (current) {
+        if (predicate(current)) return current;
+        current = current.parent;
+    }
+
+    return undefined;
+}
+
+/**
+ * Nodes that open a new binding scope. `ts.isFunctionLike` rather than a hand-rolled list of declarations,
+ * so a parameter of a `FunctionTypeNode` or a `MethodSignature` is bounded by its type instead of falling
+ * back to the whole file. Blocks and loops are included because `let`/`const` are block-scoped.
+ */
+const opensScope = (node: ts.Node): boolean =>
+    ts.isFunctionLike(node) ||
+    ts.isBlock(node) ||
+    ts.isCaseBlock(node) ||
+    ts.isModuleBlock(node) ||
+    ts.isForStatement(node) ||
+    ts.isForInStatement(node) ||
+    ts.isForOfStatement(node) ||
+    ts.isCatchClause(node) ||
+    ts.isClassLike(node) ||
+    ts.isSourceFile(node);
+
+/** Nodes that rebind `this`, so `this.code block` inside them is a different object. Arrows don't. */
+const rebindsThis = (node: ts.Node): boolean =>
+    ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isClassLike(node);
+
+/** Whether `node` sits inside `scope` without crossing a `barrier` node on the way up. */
+function reachesScope(node: ts.Node, scope: ts.Node, barrier: (node: ts.Node) => boolean): boolean {
+    let current: ts.Node | undefined = node.parent;
+
+    while (current && current !== scope) {
+        if (barrier(current)) return false;
+        current = current.parent;
+    }
+
+    return current === scope;
+}
+
+/** Whether a type annotation names one of `typeNames` directly (not through a union or type argument). */
+function isTypeReference(type: ts.TypeNode | undefined, typeNames: string[]): boolean {
+    return (
+        !!type &&
+        ts.isTypeReferenceNode(type) &&
+        ts.isIdentifier(type.typeName) &&
+        typeNames.includes(type.typeName.text)
+    );
+}
+
+const FIELD_MODIFIERS = new Set<ts.SyntaxKind>([
+    ts.SyntaxKind.PrivateKeyword,
+    ts.SyntaxKind.PublicKeyword,
+    ts.SyntaxKind.ProtectedKeyword,
+    ts.SyntaxKind.ReadonlyKeyword
+]);
+
+/** Every value declaration that introduces a plain identifier, with the scope it is visible in. */
+function collectBindings(sourceFile: ts.SourceFile): Binding[] {
+    const bindings: Binding[] = [];
+    const add = (name: string, declaration: ts.Node, scope: ts.Node | undefined) =>
+        bindings.push({ name, declaration, scope: scope ?? sourceFile });
+
+    const visit = (node: ts.Node): void => {
+        if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+            add(node.name.text, node, findAncestor(node, ts.isFunctionLike));
+        } else if ((ts.isVariableDeclaration(node) || ts.isBindingElement(node)) && ts.isIdentifier(node.name)) {
+            add(node.name.text, node, findAncestor(node, opensScope));
+        } else if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name) {
+            add(node.name.text, node, findAncestor(node, opensScope));
+        } else if ((ts.isImportSpecifier(node) || ts.isImportClause(node)) && node.name) {
+            add(node.name.text, node, sourceFile);
+        }
+
+        node.forEachChild(visit);
+    };
+
+    visit(sourceFile);
+
+    return bindings;
+}
+
+/** The declaration `name` binds to at `pos`: the innermost enclosing scope that declares it. */
+function resolveBinding(bindings: Binding[], name: string, pos: number): ts.Node | undefined {
+    let best: Binding | undefined;
+    let bestWidth = Number.POSITIVE_INFINITY;
+
+    for (const binding of bindings) {
+        if (binding.name !== name) continue;
+
+        const start = binding.scope.getStart();
+        const end = binding.scope.getEnd();
+
+        if (pos < start || pos > end) continue;
+
+        const width = end - start;
+
+        if (width < bestWidth) {
+            best = binding;
+            bestWidth = width;
+        }
+    }
+
+    return best?.declaration;
+}
+
+/** Local names `KbqCodeBlock` is bound to in this file, including aliased imports. */
+function localTypeNames(sourceFile: ts.SourceFile): string[] {
+    const names = new Set<string>([CODE_BLOCK_TYPE, HIGHLIGHT_TYPE]);
+
+    const visit = (node: ts.Node): void => {
+        if (ts.isImportSpecifier(node)) {
+            const imported = node.propertyName?.text ?? node.name.text;
+
+            if (imported === CODE_BLOCK_TYPE || imported === HIGHLIGHT_TYPE) names.add(node.name.text);
+        }
+
+        node.forEachChild(visit);
+    };
+
+    visit(sourceFile);
+
+    return [...names];
+}
+
+/**
+ * The code block-ness of an initializer, for the shapes a modern Angular consumer writes:
+ * `inject(KbqCodeBlock)`, `viewChild(KbqCodeBlock)`, `viewChild.required(…)`, `contentChild(…)`.
+ */
+function initializerTypeOf(
+    initializer: ts.Expression | undefined,
+    typeNames: string[]
+): { codeBlock: boolean; signalQuery: boolean; required: boolean } {
+    const none = { codeBlock: false, signalQuery: false, required: false };
+
+    if (!initializer || !ts.isCallExpression(initializer)) return none;
+
+    const callee = initializer.expression;
+    const qualified = ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression);
+    const name = ts.isIdentifier(callee) ? callee.text : qualified ? callee.expression.text : undefined;
+
+    if (!name || !TYPING_FACTORIES.has(name)) return none;
+
+    const [arg] = initializer.arguments;
+
+    if (!arg || !ts.isIdentifier(arg) || !typeNames.includes(arg.text)) return none;
+
+    // `viewChild.required(...)` is `Signal<KbqCodeBlock>`; the bare form adds `| undefined`.
+    const required = qualified && (callee as ts.PropertyAccessExpression).name.text === 'required';
+
+    return { codeBlock: true, signalQuery: name !== 'inject', required };
+}
+
+/**
+ * Collects the code block receivers: method/function params, class fields (incl.
+ * `@ViewChild(KbqCodeBlock) x: KbqCodeBlock`, constructor parameter-properties and the `inject()` /
+ * `viewChild()` initializer forms) and typed locals. Annotations that resolve are recorded in `resolved`,
+ * so the caller can report the mentions this pass could not turn into a receiver.
+ */
+function collectReceivers(sourceFile: ts.SourceFile, typeNames: string[], resolved?: Set<ts.Node>): Receiver[] {
+    const receivers: Receiver[] = [];
+    const add = (
+        text: string,
+        declaration: ts.Node,
+        scope: ts.Node | undefined,
+        signalQuery = false,
+        required = false
+    ) => receivers.push({ text, declaration, scope: scope ?? sourceFile, signalQuery, required });
+
+    const visit = (node: ts.Node): void => {
+        if (ts.isParameter(node) && ts.isIdentifier(node.name) && isTypeReference(node.type, typeNames)) {
+            resolved?.add(node.type!);
+            add(node.name.text, node, findAncestor(node, ts.isFunctionLike));
+
+            // A constructor parameter-property is also a class field, reachable as `this.<name>`.
+            if (node.modifiers?.some((modifier) => FIELD_MODIFIERS.has(modifier.kind))) {
+                const owner = findAncestor(node, ts.isClassDeclaration);
+
+                if (owner) add(`this.${node.name.text}`, node, owner);
+            }
+        } else if (ts.isPropertyDeclaration(node) && ts.isIdentifier(node.name)) {
+            const owner = findAncestor(node, ts.isClassDeclaration);
+            const annotated = isTypeReference(node.type, typeNames);
+            const { codeBlock, signalQuery, required } = initializerTypeOf(node.initializer, typeNames);
+
+            if (owner && (annotated || codeBlock)) {
+                if (annotated) resolved?.add(node.type!);
+                add(`this.${node.name.text}`, node, owner, signalQuery, required);
+            }
+        } else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            const annotated = isTypeReference(node.type, typeNames);
+            const { codeBlock, signalQuery, required } = initializerTypeOf(node.initializer, typeNames);
+
+            if (annotated || codeBlock) {
+                if (annotated) resolved?.add(node.type!);
+                add(node.name.text, node, findAncestor(node, opensScope), signalQuery, required);
+            }
+        }
+
+        node.forEachChild(visit);
+    };
+
+    visit(sourceFile);
+
+    return receivers;
+}
+
+/** Strips the wrappers that do not change which object an access reads from. */
+function unwrapReceiver(node: ts.Expression): ts.Expression {
+    let current = node;
+
+    while (ts.isNonNullExpression(current) || ts.isParenthesizedExpression(current)) {
+        current = current.expression;
+    }
+
+    return current;
+}
+
+/** The receiver a property access resolves to at this exact position, if any. */
+function resolveReceiver(
+    expression: ts.Expression,
+    at: ts.Node,
+    sourceFile: ts.SourceFile,
+    receivers: Receiver[],
+    bindings: Binding[]
+): Receiver | undefined {
+    const inner = unwrapReceiver(expression);
+    // `this . code block` and `this /* x */ . code block` spell the same receiver as `this.code block`.
+    const text = ts.isPropertyAccessExpression(inner)
+        ? `${inner.expression.getText(sourceFile).replace(/\s+/g, '')}.${inner.name.text}`
+        : inner.getText(sourceFile);
+
+    return receivers.find((receiver) => {
+        if (receiver.text !== text) return false;
+
+        // For `this.code block`, a nested `function` or class changes what `this` is; an arrow does not.
+        // For a bare `code block`, a nested redeclaration of the same name shadows the receiver.
+        if (receiver.text.startsWith('this.')) return reachesScope(at, receiver.scope, rebindsThis);
+
+        return (
+            reachesScope(at, receiver.scope, () => false) &&
+            resolveBinding(bindings, receiver.text, at.getStart(sourceFile)) === receiver.declaration
+        );
+    });
+}
+
+/** Binary operators that make their left operand a write target rather than a read. */
+const ASSIGNMENT_OPERATORS = new Set<ts.SyntaxKind>([
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken
+]);
+
+/** Whether `node` sits on the left of a destructuring assignment, where it is written rather than read. */
+function isDestructuringTarget(node: ts.Node): boolean {
+    let current: ts.Node = node;
+
+    while (
+        ts.isPropertyAssignment(current.parent) ||
+        ts.isShorthandPropertyAssignment(current.parent) ||
+        ts.isSpreadAssignment(current.parent) ||
+        ts.isSpreadElement(current.parent) ||
+        ts.isObjectLiteralExpression(current.parent) ||
+        ts.isArrayLiteralExpression(current.parent)
+    ) {
+        current = current.parent;
+    }
+
+    return (
+        ts.isBinaryExpression(current.parent) &&
+        current.parent.left === current &&
+        ASSIGNMENT_OPERATORS.has(current.parent.operatorToken.kind)
+    );
+}
+
+/** What a matched property access turned out to be. */
+type AccessKind = 'read' | 'write' | 'migrated';
+
+/** Unary operators that write their operand back. Every other prefix operator is a plain read. */
+const INCREMENT_OPERATORS = new Set<ts.SyntaxKind>([ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken]);
+
+/** Classifies a matched property access and appends the resulting edit, if any. */
+function classifyAccess(node: ts.PropertyAccessExpression, edits: Edit[]): AccessKind {
+    const parent = node.parent;
+
+    // Already migrated: `x.id()` (call) or the signal API on it.
+    if (ts.isCallExpression(parent) && parent.expression === node) return 'migrated';
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === node && SIGNAL_API_METHODS.has(parent.name.text))
+        return 'migrated';
+
+    // Write target. The plain form has a mechanical translation for a `WritableSignal`; a compound form
+    // (`||=`, `+=`) would need the receiver spelled twice, so it is reported rather than rewritten - and a
+    // member that stayed a read-only `input()` is reported whichever form it is written in.
+    if (ts.isBinaryExpression(parent) && parent.left === node && ASSIGNMENT_OPERATORS.has(parent.operatorToken.kind)) {
+        if (parent.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return 'write';
+
+        const rhs = parent.right;
+
+        edits.push({ start: node.getEnd(), end: rhs.getStart(), text: '.set(' });
+        edits.push({ start: rhs.getEnd(), end: rhs.getEnd(), text: ')' });
+
+        return 'migrated';
+    }
+
+    // `x.id++` / `--x.id` and `delete x.id` are writes too. Only the increment operators count: a
+    // `PrefixUnaryExpression` is also how `!x.id` is spelled, and that is a read.
+    if (ts.isPostfixUnaryExpression(parent) && parent.operand === node) return 'write';
+    if (ts.isPrefixUnaryExpression(parent) && parent.operand === node && INCREMENT_OPERATORS.has(parent.operator))
+        return 'write';
+    if (ts.isDeleteExpression(parent)) return 'write';
+    if (isDestructuringTarget(node)) return 'write';
+
+    // Read (incl. optional chain `x?.id`): append `()`.
+    edits.push({ start: node.getEnd(), end: node.getEnd(), text: '()' });
+
+    return 'read';
+}
+
+/** A read through a signal query, which the rewrite leaves alone and the caller reports instead. */
+interface SignalQueryRead {
+    member: string;
+    required: boolean;
+}
+
+/** What one TypeScript file needs rewritten and reported. */
+interface TsFindings {
+    edits: Edit[];
+    /** Members written programmatically, which have no mechanical translation. */
+    writes: Set<string>;
+    /** Members that left the public surface and the file still reads. */
+    hidden: Set<string>;
+    /** Members that kept their name but changed shape, so every call site has to be looked at. */
+    reported: Set<string>;
+    signalQueryReads: SignalQueryRead[];
+}
+
+/** Collects the edits and the findings for every access on a known code block receiver. */
+function collectAccesses(sourceFile: ts.SourceFile, receivers: Receiver[], bindings: Binding[]): TsFindings {
+    const edits: Edit[] = [];
+    const writes = new Set<string>();
+    const hidden = new Set<string>();
+    const reported = new Set<string>();
+    const signalQueryReads: SignalQueryRead[] = [];
+
+    const visit = (node: ts.Node): void => {
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+            const member = node.name.text;
+            const known =
+                SIGNAL_MEMBERS.includes(member) ||
+                PLUMBING_MEMBERS.includes(member) ||
+                REPORTED_MEMBERS.includes(member);
+            const receiver = known
+                ? resolveReceiver(node.expression, node, sourceFile, receivers, bindings)
+                : undefined;
+
+            if (receiver) {
+                if (PLUMBING_MEMBERS.includes(member)) {
+                    hidden.add(member);
+                } else if (REPORTED_MEMBERS.includes(member)) {
+                    reported.add(member);
+                } else if (receiver.signalQuery) {
+                    // A signal query holds the component behind a call of its own, so the read is
+                    // `query().id()`. Appending one `()` would be wrong in both halves.
+                    signalQueryReads.push({ member, required: receiver.required });
+                } else if (classifyAccess(node, edits) === 'write') {
+                    writes.add(member);
+                }
+            }
+        }
+
+        node.forEachChild(visit);
+    };
+
+    visit(sourceFile);
+
+    return { edits, writes, hidden, reported, signalQueryReads };
+}
+
+/**
+ * 1-based lines where `KbqCodeBlock` is named in a position `collectReceivers` cannot resolve, plus the
+ * reads the access pass structurally cannot reach: `code block['id']` and `const { id } = code block`.
+ */
+function collectUnresolvedMentions(
+    sourceFile: ts.SourceFile,
+    resolved: Set<ts.Node>,
+    typeNames: string[],
+    receivers: Receiver[],
+    bindings: Binding[]
+): number[] {
+    const lines = new Set<number>();
+    const members = [...SIGNAL_MEMBERS, ...PLUMBING_MEMBERS];
+    const report = (node: ts.Node) =>
+        lines.add(sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1);
+    const isReceiver = (expression: ts.Expression, at: ts.Node) =>
+        !!resolveReceiver(expression, at, sourceFile, receivers, bindings);
+
+    const visit = (node: ts.Node): void => {
+        if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && typeNames.includes(node.typeName.text)) {
+            if (!resolved.has(node)) report(node);
+        } else if (
+            ts.isElementAccessExpression(node) &&
+            ts.isStringLiteralLike(node.argumentExpression) &&
+            members.includes(node.argumentExpression.text) &&
+            isReceiver(node.expression, node)
+        ) {
+            report(node);
+        } else if (
+            ts.isVariableDeclaration(node) &&
+            ts.isObjectBindingPattern(node.name) &&
+            node.initializer &&
+            isReceiver(node.initializer, node) &&
+            node.name.elements.some((element) =>
+                members.includes((element.propertyName ?? element.name).getText(sourceFile))
+            )
+        ) {
+            report(node);
+        }
+
+        node.forEachChild(visit);
+    };
+
+    visit(sourceFile);
+
+    return [...lines].sort((a, b) => a - b);
+}
+
+/**
+ * Pass A — rewrite programmatic reads of code block signal members in TypeScript code. One `createSourceFile`
+ * and one `collectReceivers` walk per file: the rewrite and every report come out of the same traversal.
+ */
+function migrateTsExpressions(
+    content: string,
+    fileName: string
+): TsFindings & { content: string; unresolved: number[] } {
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const typeNames = localTypeNames(sourceFile);
+    const resolved = new Set<ts.Node>();
+    const receivers = collectReceivers(sourceFile, typeNames, resolved);
+    const bindings = collectBindings(sourceFile);
+    const unresolved = collectUnresolvedMentions(sourceFile, resolved, typeNames, receivers, bindings);
+    const empty: TsFindings = {
+        edits: [],
+        writes: new Set(),
+        hidden: new Set(),
+        reported: new Set(),
+        signalQueryReads: []
+    };
+
+    if (receivers.length === 0) return { ...empty, content, unresolved };
+
+    const findings = collectAccesses(sourceFile, receivers, bindings);
+
+    return {
+        ...findings,
+        content: findings.edits.length > 0 ? applyEdits(content, findings.edits) : content,
+        unresolved
+    };
+}
+
+/** Attribute-name prefixes that mark the value as an Angular expression rather than a literal. */
+const BINDING_PREFIX = /^(?:\[|\(|\*|bind-|bind(?:on)?-|on-)/;
+
+/** A code block reference variable, valid only within the embedded view that declares it. */
+interface TemplateRef extends Range {
+    name: string;
+}
+
+/**
+ * Walks a template's HTML AST, collecting what the rewrite needs: the reference variables bound to a
+ * `<kbq-code-block>`, the source ranges that actually hold Angular expressions, and every other name the
+ * template introduces.
+ */
+class TemplateScanner implements Visitor {
+    readonly codeBlockRefs: TemplateRef[] = [];
+    readonly otherNames = new Set<string>();
+    readonly expressions: Range[] = [];
+
+    /** The embedded view currently being walked; a ref declared in it is invisible outside. */
+    private view: Range;
+
+    constructor(private readonly template: string) {
+        this.view = { start: 0, end: template.length };
+    }
+
+    visitElement(element: any): void {
+        const isCodeBlock = element.name === CODE_BLOCK_ELEMENT;
+
+        for (const attr of element.attrs ?? []) {
+            if (typeof attr.name !== 'string') continue;
+
+            const reference = this.referenceName(attr.name);
+
+            if (reference !== undefined) {
+                // `#ctrl="ngModel"` names a directive on the element, not the code block: `NgModel` really
+                // has `name` and `value`, so treating it as the component corrupts a standard idiom.
+                const exportsCodeBlock = !attr.value || attr.value === CODE_BLOCK_EXPORT_AS;
+
+                if (isCodeBlock && exportsCodeBlock) this.codeBlockRefs.push({ name: reference, ...this.view });
+                else this.otherNames.add(reference);
+
+                continue;
+            }
+
+            // `let-item` on an <ng-template> introduces a name the refs must not collide with.
+            if (attr.name.startsWith('let-')) {
+                this.otherNames.add(attr.name.slice(4));
+                continue;
+            }
+
+            this.collectAttributeExpression(attr);
+        }
+
+        this.inView(element.name === 'ng-template' ? element.sourceSpan : undefined, () => this.visitChildren(element));
+    }
+
+    visitBlock(block: any): void {
+        for (const parameter of block.parameters ?? []) {
+            const span = parameter.sourceSpan;
+
+            if (!span) continue;
+
+            this.expressions.push({ start: span.start.offset, end: span.end.offset });
+
+            // `@for (code block of boxes; track code block)` and `@if (x; as y)` introduce names of their own.
+            for (const match of String(parameter.expression ?? '').matchAll(
+                /(?:^\s*|\b(?:as|let)\s+)([A-Za-z_$][\w$]*)\s*(?:\bof\b|\bin\b|=|$)/g
+            )) {
+                this.otherNames.add(match[1]);
+            }
+        }
+
+        this.inView(block.sourceSpan, () => this.visitChildren(block));
+    }
+
+    visitText(text: any): void {
+        const span = text.sourceSpan;
+
+        if (span) this.collectInterpolations(span.start.offset, span.end.offset);
+    }
+
+    visitLetDeclaration(decl: any): void {
+        if (decl.name) this.otherNames.add(decl.name);
+
+        const span = decl.valueSpan ?? decl.sourceSpan;
+
+        if (span) this.expressions.push({ start: span.start.offset, end: span.end.offset });
+    }
+
+    /** Runs `walk` with the embedded view narrowed to `span`, if the node opens one. */
+    private inView(span: any, walk: () => void): void {
+        if (!span) {
+            walk();
+
+            return;
+        }
+
+        const outer = this.view;
+
+        this.view = { start: span.start.offset, end: span.end.offset };
+        walk();
+        this.view = outer;
+    }
+
+    /** `#ref` / `ref-ref`, or `undefined` when the attribute is not a reference variable. */
+    private referenceName(name: string): string | undefined {
+        if (name.startsWith('#')) return name.slice(1);
+        if (name.startsWith('ref-')) return name.slice(4);
+
+        return undefined;
+    }
+
+    private collectAttributeExpression(attr: any): void {
+        const span = attr.valueSpan;
+
+        if (!span) return;
+
+        const start = span.start.offset;
+        const end = span.end.offset;
+
+        // A binding's whole value is an expression; a plain attribute only holds interpolations.
+        if (BINDING_PREFIX.test(attr.name)) this.expressions.push({ start, end });
+        else this.collectInterpolations(start, end);
+    }
+
+    private collectInterpolations(start: number, end: number): void {
+        for (const match of this.template.slice(start, end).matchAll(/\{\{([\s\S]*?)\}\}/g)) {
+            const from = start + match.index + 2;
+
+            this.expressions.push({ start: from, end: from + match[1].length });
+        }
+    }
+
+    private visitChildren(node: any): void {
+        for (const child of node.children ?? []) {
+            child.visit(this);
+        }
+    }
+
+    visitAttribute(): void {}
+    visitComment(): void {}
+    visitExpansion(): void {}
+    visitExpansionCase(): void {}
+    visitBlockParameter(): void {}
+}
+
+/**
+ * Matches `<ref>.<member>` inside a template expression. The lookbehind rejects `form.code block.value`,
+ * where `\b` alone matches after the dot, and admits a `$`-prefixed ref that `\b` never could. `\??\.`
+ * accepts the optional chain, and Angular's grammar allows whitespace around the dot. The three groups skip
+ * an already-migrated read, a signal-API call, and an assignment target.
+ */
+function memberAccessPattern(ref: string, members: readonly string[]): RegExp {
+    const methods = [...SIGNAL_API_METHODS].join('|');
+    const names = members.map(escapeRegExp).join('|');
+
+    return new RegExp(
+        `(?<![\\w$.])(${escapeRegExp(ref)})\\s*\\??\\.\\s*(${names})\\b` +
+            `(?!\\s*\\()(?!\\s*\\.\\s*(?:${methods})\\b)(?!\\s*=(?!=))`,
+        'g'
+    );
+}
+
+/**
+ * Rewrites `ref.id` reads to calls, only inside the given expression ranges. Restricting the rewrite to
+ * expressions is what keeps prose, comments and static attribute values out of it - `id`, `name` and
+ * `value` are common enough words that a raw-text pass would hit all of them.
+ */
+function rewriteRefReads(
+    template: string,
+    refs: TemplateRef[],
+    expressions: Range[]
+): { content: string; changed: boolean } {
+    const edits: Edit[] = [];
+
+    for (const { start, end } of expressions) {
+        const source = template.slice(start, end);
+
+        for (const ref of refs) {
+            if (start < ref.start || end > ref.end) continue;
+
+            for (const match of source.matchAll(memberAccessPattern(ref.name, SIGNAL_MEMBERS))) {
+                const at = start + match.index + match[0].length;
+
+                edits.push({ start: at, end: at, text: '()' });
+            }
+        }
+    }
+
+    return edits.length > 0
+        ? { content: applyEdits(template, edits), changed: true }
+        : { content: template, changed: false };
+}
+
+/** Protected members read through a code block reference variable, which no template can keep reading. */
+function collectRefHiddenMembers(template: string, refs: TemplateRef[], expressions: Range[]): Set<string> {
+    const found = new Set<string>();
+
+    for (const { start, end } of expressions) {
+        const source = template.slice(start, end);
+
+        for (const ref of refs) {
+            if (start < ref.start || end > ref.end) continue;
+
+            const pattern = new RegExp(
+                `(?<![\\w$.])${escapeRegExp(ref.name)}\\s*\\??\\.\\s*(${PLUMBING_MEMBERS.map(escapeRegExp).join('|')})\\b`,
+                'g'
+            );
+
+            for (const match of source.matchAll(pattern)) {
+                found.add(match[1]);
+            }
+        }
+    }
+
+    return found;
+}
+
+interface TemplateResult {
+    content: string;
+    changed: boolean;
+    /** Protected members read through a ref that need a hand migration. */
+    hidden: Set<string>;
+    /** The template renders the code block but could not be parsed, so nothing in it was inspected. */
+    unparseable: boolean;
+}
+
+const untouched = (template: string): TemplateResult => ({
+    content: template,
+    changed: false,
+    hidden: new Set(),
+    unparseable: false
+});
+
+/** Pass B (core) — parse a template, discover code block refs, rewrite their signal reads. */
+async function migrateTemplate(template: string): Promise<TemplateResult> {
+    if (!template.includes(CODE_BLOCK_ELEMENT)) return untouched(template);
+
+    const parsed = await parseTemplate(template);
+
+    if (!parsed.tree) return { ...untouched(template), unparseable: true };
+
+    const scanner = new TemplateScanner(template);
+
+    visitAll(scanner, (parsed.tree as { rootNodes: unknown[] }).rootNodes);
+
+    // A ref whose name is also introduced by a `@for`, an `@let` or a foreign `#ref` is ambiguous: the
+    // reads could belong to either, so neither is rewritten.
+    const refs = scanner.codeBlockRefs.filter((ref) => !scanner.otherNames.has(ref.name));
+
+    if (refs.length === 0) return untouched(template);
+
+    return {
+        ...rewriteRefReads(template, refs, scanner.expressions),
+        hidden: collectRefHiddenMembers(template, refs, scanner.expressions),
+        unparseable: false
+    };
+}
+
+/** Pass B (inline) — rewrite code block ref reads inside inline component templates. */
+async function migrateInlineTemplates(
+    content: string,
+    fileName: string
+): Promise<{ content: string; hidden: Set<string>; unparseable: boolean }> {
+    const hidden = new Set<string>();
+
+    // Parsing the file to find inline templates is the expensive half, and most consumers have none.
+    if (!content.includes(CODE_BLOCK_ELEMENT)) return { content, hidden, unparseable: false };
+
+    const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const ranges = collectInlineTemplateRanges(sourceFile).sort((a, b) => b.start - a.start);
+    let result = content;
+    let unparseable = false;
+
+    for (const { start, end } of ranges) {
+        const outcome = await migrateTemplate(result.slice(start, end));
+
+        for (const member of outcome.hidden) hidden.add(member);
+
+        unparseable ||= outcome.unparseable;
+
+        if (outcome.changed) {
+            result = result.slice(0, start) + outcome.content + result.slice(end);
+        }
+    }
+
+    return { content: result, hidden, unparseable };
+}
+
+/** One report per distinct member and query kind, however many reads a file holds. */
+function dedupe(reads: SignalQueryRead[]): SignalQueryRead[] {
+    const seen = new Map<string, SignalQueryRead>();
+
+    for (const read of reads) {
+        seen.set(`${read.member}:${read.required}`, read);
+    }
+
+    return [...seen.values()];
+}
+
+/**
+ * A `.ts` file is a code block consumer if it names the exported symbol, imports the package, or renders the
+ * element in an inline template — a component that only imports `KbqCodeBlockModule` names no type.
+ */
+function referencesCodeBlock(content: string): boolean {
+    return (
+        /\bKbqCodeBlock\w*\b/.test(content) ||
+        content.includes(CODE_BLOCK_PACKAGE) ||
+        content.includes(`<${CODE_BLOCK_ELEMENT}`)
+    );
+}
+
+export default function codeBlockSignals(options: Schema): Rule {
+    return async (tree: Tree, context: SchematicContext) => {
+        const { project } = options;
+        // `ng update` invokes migrations with no options at all, and migrations.json declares no schema, so
+        // the schema default never reaches us — applying the fix is the intended behaviour there.
+        const fix = options.fix ?? true;
+        const projectDefinition = await setupOptions(project, tree);
+        const root = projectDefinition?.root ?? '';
+        const rootDir = root ? tree.getDir(root as Path) : tree.root;
+
+        const tsPaths: string[] = [];
+        const htmlPaths: string[] = [];
+
+        rootDir.visit((filePath) => {
+            if (filePath.includes('node_modules') || filePath.includes('/dist/')) return;
+
+            if (filePath.endsWith(TS_EXT)) tsPaths.push(filePath);
+            else if (filePath.endsWith(HTML_EXT)) htmlPaths.push(filePath);
+        });
+
+        let touched = 0;
+        let consumers = 0;
+
+        const commit = (filePath: string, original: string, updated: string) => {
+            if (updated === original) return;
+
+            touched++;
+
+            if (fix) {
+                tree.overwrite(filePath, updated);
+            } else {
+                logMessage(context.logger, [`${LABEL} would update ${filePath} (run with --fix to apply)`]);
+            }
+        };
+
+        const report = (filePath: string, message: string) =>
+            logMessage(context.logger, [`${LABEL} ${filePath}`, `  ${message}`]);
+
+        for (const filePath of tsPaths) {
+            const original = tree.read(filePath)?.toString();
+
+            if (!original || !referencesCodeBlock(original)) continue;
+
+            consumers++;
+
+            const pass = migrateTsExpressions(original, filePath);
+
+            if (pass.hidden.size > 0) report(filePath, plumbingMessage(pass.hidden));
+            if (pass.reported.size > 0) report(filePath, reportedMessage(pass.reported));
+            if (pass.writes.size > 0) report(filePath, writeMessage(pass.writes));
+
+            for (const { member, required } of dedupe(pass.signalQueryReads)) {
+                report(filePath, signalQueryMessage(member, required));
+            }
+
+            if (pass.unresolved.length > 0) {
+                report(filePath, `${UNRESOLVED_RECEIVER_MESSAGE} ${pass.unresolved.join(', ')}.`);
+            }
+
+            const inline = await migrateInlineTemplates(pass.content, filePath);
+
+            if (inline.hidden.size > 0) report(filePath, plumbingMessage(inline.hidden));
+            if (inline.unparseable) report(filePath, UNPARSEABLE_TEMPLATE_MESSAGE);
+
+            commit(filePath, original, inline.content);
+        }
+
+        for (const filePath of htmlPaths) {
+            const original = tree.read(filePath)?.toString();
+
+            // Counted on "renders the code block", matching the `.ts` loop: a project whose only usage is a
+            // valueless attribute in an external template still needs the summary.
+            if (!original || !original.includes(`<${CODE_BLOCK_ELEMENT}`)) continue;
+
+            consumers++;
+
+            const outcome = await migrateTemplate(original);
+
+            if (outcome.hidden.size > 0) report(filePath, plumbingMessage(outcome.hidden));
+            if (outcome.unparseable) report(filePath, UNPARSEABLE_TEMPLATE_MESSAGE);
+
+            commit(filePath, original, outcome.content);
+        }
+
+        // Nothing here uses the code block, so the summary would only be noise.
+        if (consumers === 0) return;
+
+        logMessage(context.logger, [
+            `${LABEL} processed tree under "${root || '<workspace root>'}", ` +
+                `${fix ? 'updated' : 'would update'} ${touched} file(s).`,
+            ...SUMMARY
+        ]);
+    };
+}
diff --git a/packages/schematics/src/migrations/code-block-signals/schema.json b/packages/schematics/src/migrations/code-block-signals/schema.json
new file mode 100644
index 0000000000..376a58ac96
--- /dev/null
+++ b/packages/schematics/src/migrations/code-block-signals/schema.json
@@ -0,0 +1,20 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "koobiq-components-code-block-signals",
+    "title": "Koobiq components code block signals migration",
+    "type": "object",
+    "properties": {
+        "project": {
+            "type": "string",
+            "description": "Name of the project to migrate. If omitted, the migration runs over the whole tree.",
+            "$default": {
+                "$source": "projectName"
+            }
+        },
+        "fix": {
+            "type": "boolean",
+            "default": true,
+            "description": "When true, applies all auto-fix replacements. When false, prints what would change without writing."
+        }
+    }
+}
diff --git a/packages/schematics/src/migrations/code-block-signals/schema.ts b/packages/schematics/src/migrations/code-block-signals/schema.ts
new file mode 100644
index 0000000000..fefc5cd6b3
--- /dev/null
+++ b/packages/schematics/src/migrations/code-block-signals/schema.ts
@@ -0,0 +1,6 @@
+export interface Schema {
+    /** Name of the project to migrate. */
+    project?: string;
+    /** When true, applies replacements; when false, only logs what would change. Defaults to true. */
+    fix?: boolean;
+}
diff --git a/tools/check-public-api-any/baseline.json b/tools/check-public-api-any/baseline.json
index 2b93f9e666..56a3b2241e 100644
--- a/tools/check-public-api-any/baseline.json
+++ b/tools/check-public-api-any/baseline.json
@@ -9,7 +9,7 @@
     "button-toggle": 12,
     "checkbox": 7,
     "clamped-text": 3,
-    "code-block": 9,
+    "code-block": 15,
     "content-panel": 7,
     "core": 62,
     "datepicker": 12,
diff --git a/tools/public_api_guard/components/code-block.api.md b/tools/public_api_guard/components/code-block.api.md
index f738c08798..e006a89d46 100644
--- a/tools/public_api_guard/components/code-block.api.md
+++ b/tools/public_api_guard/components/code-block.api.md
@@ -46,63 +46,58 @@ export const KBQ_CODE_BLOCK_LOCALE_CONFIGURATION: InjectionToken<KbqCodeBlockLoc
 export class KbqCodeBlock implements AfterViewInit {
     constructor();
     protected readonly actionbarVisible: _angular_core.Signal<boolean>;
-    activeFileIndex: number;
+    protected readonly activeFile: _angular_core.Signal<KbqCodeBlockFile | undefined>;
+    readonly activeFileIndex: _angular_core.WritableSignal<number>;
     readonly activeFileIndexChange: _angular_core.OutputEmitterRef<number>;
+    readonly activeFileIndexInput: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly alwaysShowActionbar: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected readonly buttonStyle: typeof KbqButtonStyles;
-    protected get calculatedMaxHeight(): number | null;
+    protected readonly calculatedMaxHeight: _angular_core.Signal<number | null>;
     readonly canCopy: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    canDownload: boolean;
-    // @deprecated (undocumented)
-    set canLoad(value: boolean);
+    readonly canDownload: _angular_core.WritableSignal<boolean>;
+    readonly canDownloadInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    // @deprecated
+    readonly canLoadInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly canToggleSoftWrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected get codeContentTabIndex(): number;
-    // @deprecated (undocumented)
-    set codeFiles(files: KbqCodeBlockFile[]);
+    // @deprecated
+    readonly codeFilesInput: _angular_core.InputSignal<KbqCodeBlockFile[]>;
     protected readonly componentColor: typeof KbqComponentColors;
     protected readonly contentExceedsMaxHeight: _angular_core.WritableSignal<boolean>;
     protected copyCode(): void;
     protected downloadCode(): void;
     protected readonly fallbackFileName: string;
-    get files(): KbqCodeBlockFile[];
-    set files(files: KbqCodeBlockFile[]);
+    readonly files: _angular_core.WritableSignal<KbqCodeBlockFile[]>;
+    readonly filesInput: _angular_core.InputSignal<KbqCodeBlockFile[]>;
     readonly filled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    get hideTabs(): boolean;
-    set hideTabs(value: boolean);
+    readonly hideTabs: _angular_core.WritableSignal<boolean>;
     readonly hideTabsChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly hideTabsInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly lineNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected get localeConfiguration(): KbqCodeBlockLocaleConfiguration;
-    readonly maxHeight: _angular_core.InputSignalWithTransform<number, unknown>;
-    // (undocumented)
-    static ngAcceptInputType_activeFileIndex: unknown;
-    // (undocumented)
-    static ngAcceptInputType_canDownload: unknown;
-    // (undocumented)
-    static ngAcceptInputType_canLoad: unknown;
-    // (undocumented)
-    static ngAcceptInputType_hideTabs: unknown;
-    // (undocumented)
-    static ngAcceptInputType_softWrap: unknown;
-    // (undocumented)
-    static ngAcceptInputType_viewAll: unknown;
+    readonly maxHeight: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
     // (undocumented)
     ngAfterViewInit(): void;
     readonly noBorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected onSelectedTabChange(index: number): void;
     protected onViewAllEnterKeydown(event: Event): void;
     protected openLink(): void;
+    protected readonly renderedFileIndex: _angular_core.Signal<number>;
     // @deprecated
     readonly scrollableCodeContent: _angular_core.Signal<CdkScrollable>;
     scrollTo(options: ExtendedScrollToOptions): void;
-    softWrap: boolean;
+    readonly softWrap: _angular_core.WritableSignal<boolean>;
     readonly softWrapChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly softWrapInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected readonly tabLinkTemplate: TemplateRef<KbqTabLinkTemplateContext>;
+    readonly tabsHidden: _angular_core.Signal<boolean>;
     toggleSoftWrap(): void;
     toggleViewAll(): void;
-    viewAll: boolean;
+    readonly viewAll: _angular_core.WritableSignal<boolean>;
     readonly viewAllChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly viewAllInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     // (undocumented)
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqCodeBlock, "kbq-code-block", ["kbqCodeBlock"], { "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; "canToggleSoftWrap": { "alias": "canToggleSoftWrap"; "required": false; "isSignal": true; }; "softWrap": { "alias": "softWrap"; "required": false; }; "viewAll": { "alias": "viewAll"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "canLoad": { "alias": "canLoad"; "required": false; }; "canDownload": { "alias": "canDownload"; "required": false; }; "canCopy": { "alias": "canCopy"; "required": false; "isSignal": true; }; "alwaysShowActionbar": { "alias": "alwaysShowActionbar"; "required": false; "isSignal": true; }; "codeFiles": { "alias": "codeFiles"; "required": false; }; "files": { "alias": "files"; "required": false; }; "activeFileIndex": { "alias": "activeFileIndex"; "required": false; }; "noBorder": { "alias": "noBorder"; "required": false; "isSignal": true; }; "hideTabs": { "alias": "hideTabs"; "required": false; }; }, { "softWrapChange": "softWrapChange"; "viewAllChange": "viewAllChange"; "activeFileIndexChange": "activeFileIndexChange"; "hideTabsChange": "hideTabsChange"; }, ["tabLinkTemplate"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqCodeBlock, "kbq-code-block", ["kbqCodeBlock"], { "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; "canToggleSoftWrap": { "alias": "canToggleSoftWrap"; "required": false; "isSignal": true; }; "softWrapInput": { "alias": "softWrap"; "required": false; "isSignal": true; }; "viewAllInput": { "alias": "viewAll"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "canLoadInput": { "alias": "canLoad"; "required": false; "isSignal": true; }; "canDownloadInput": { "alias": "canDownload"; "required": false; "isSignal": true; }; "canCopy": { "alias": "canCopy"; "required": false; "isSignal": true; }; "alwaysShowActionbar": { "alias": "alwaysShowActionbar"; "required": false; "isSignal": true; }; "codeFilesInput": { "alias": "codeFiles"; "required": false; "isSignal": true; }; "filesInput": { "alias": "files"; "required": false; "isSignal": true; }; "activeFileIndexInput": { "alias": "activeFileIndex"; "required": false; "isSignal": true; }; "noBorder": { "alias": "noBorder"; "required": false; "isSignal": true; }; "hideTabsInput": { "alias": "hideTabs"; "required": false; "isSignal": true; }; }, { "softWrapChange": "softWrapChange"; "viewAllChange": "viewAllChange"; "activeFileIndexChange": "activeFileIndexChange"; "hideTabsChange": "hideTabsChange"; }, ["tabLinkTemplate"], never, true, never>;
     // (undocumented)
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqCodeBlock, never>;
 }
@@ -131,12 +126,13 @@ export type KbqCodeBlockFile = {
 
 // @public
 export class KbqCodeBlockHighlight {
-    set file(file: KbqCodeBlockFile);
+    constructor();
+    readonly file: _angular_core.InputSignal<KbqCodeBlockFile>;
     readonly pending: _angular_core.Signal<boolean>;
     readonly singleLine: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly startFrom: _angular_core.InputSignalWithTransform<number, unknown>;
     // (undocumented)
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqCodeBlockHighlight, "code[kbqCodeBlockHighlight]", ["kbqCodeBlockHighlight"], { "file": { "alias": "file"; "required": true; }; "startFrom": { "alias": "startFrom"; "required": false; "isSignal": true; }; "singleLine": { "alias": "singleLine"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqCodeBlockHighlight, "code[kbqCodeBlockHighlight]", ["kbqCodeBlockHighlight"], { "file": { "alias": "file"; "required": true; "isSignal": true; }; "startFrom": { "alias": "startFrom"; "required": false; "isSignal": true; }; "singleLine": { "alias": "singleLine"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
     // (undocumented)
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqCodeBlockHighlight, never>;
 }