@selimssevgi/cube-design-angular 0.7.0 → 0.8.0

package/types/selimssevgi-cube-design-angular.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
-import { ErrorHandler, InjectionToken, Provider, TemplateRef } from "@angular/core";
+import { ErrorHandler, InjectionToken, OnDestroy, Provider, TemplateRef } from "@angular/core";
+import { Observable } from "rxjs";
 import { HttpInterceptorFn } from "@angular/common/http";
 import { ActivatedRouteSnapshot } from "@angular/router";
-import { Observable } from "rxjs";
 /**
  * drawing a cube of small cubes in isometric view: the left, right and top faces, each split into
  * n × n stickers. a sticker is coloured by a piece, or pale while nothing is known for it.
@@ -268,7 +268,7 @@ export interface CubePinched {
    * firefox send a trackpad's pinch; `gesture`: safari's own gesture events for a trackpad's pinch.
    */
   via: 'touch' | 'wheel' | 'gesture';
-  /** the event that decided it: the `pointerup`, the first `wheel` of the stream, the `gestureend`. */
+  /** the event that decided it: the `pointerup`, the stream's first real `wheel` step, the `gestureend`. */
   event: Event;
 }
 /** two fingers this much further apart than they started is a pinch in (cubes', mosaic's, anlat's). */
@@ -286,6 +286,19 @@ export declare const CUBE_WHEEL_QUIET_MS = 250;
  * the same rule.
  */
 export declare function startsWheelGesture(lastAt: number, now: number, quietMs?: number): boolean;
+/**
+ * the least `deltaY` of one ctrl + wheel event that decides a pinch's way. a trackpad begins a pinch
+ * with a still event (0) or the fingers settling the other way (-1) before the real steps come, so a
+ * smaller step only moves the stream's end (the every-level prototype's rule, 6 nov 2026).
+ */
+export declare const CUBE_WHEEL_STEP = 2;
+/**
+ * which way a ctrl + wheel stream that has not decided yet goes, given its event's `deltaY` and the
+ * sum of the stream's deltas so far, this one counted: the first step of at least `least` decides
+ * by its own sign; a slow pinch of small steps decides once they add up to three times `least`;
+ * else not yet (null). pure, so an app with a wheel of its own reads a stream the same way.
+ */
+export declare function wheelWay(deltaY: number, sum: number, least?: number): 'in' | 'out' | null;
 /**
  * the pinch (principle 25, two fingers together is one level out): fingers apart on a piece raise
  * one `cubePinched` with `way: 'in'`, fingers together one with `way: 'out'`. on a computer a
@@ -1122,6 +1135,21 @@ export declare function squareLayout(view: ViewKey, count: number, room: SquareR
   listRow?: number;
   least?: number;
 }): SquareLayout;
+/**
+ * the one tile size on a screen (0.8.0): the cell of `across` tiles in `width` px, with the gap a
+ * square of that many across has. every square on the screen given this `cell` draws its tiles at
+ * it, whatever its count or view, the context cube's too (selim, 6 november 2026: the tiles got
+ * smaller between the lobby, all and a thing, "a problem also in current prod apps").
+ */
+export declare function squareCell(width: number, across: number): number;
+/**
+ * the side a square of `count` tiles in `view` (at least `least` across) takes to draw each at
+ * `cell` px: what `[cell]` gives `<cube-square>` as its `maxSide` (0.8.0; the every-level page's
+ * `sizes.ts`, moved in).
+ */
+export declare function squareSideAt(view: ViewKey, count: number, cell: number, opts?: {
+  least?: number;
+}): number;
 /** what a tile's template is given. */
 export interface CubeSquareTileContext<T> {
   /** the tile, as the app gave it. */
@@ -1176,6 +1204,13 @@ export declare class CubeSquare<T> {
   readonly view: import("@angular/core").InputSignal<ViewKey>;
   /** the largest side the square takes on a wide screen, in px. */
   readonly maxSide: import("@angular/core").InputSignal<number>;
+  /**
+   * one tile size on every screen (0.8.0): each tile drawn `cell` px wide, whatever the count or the
+   * view (`squareSideAt`), never wider than `maxSide` nor the room. null (the default) sizes the
+   * tiles from the room, as before. give every square on a screen the same cell (`squareCell`,
+   * `CubeRoom`).
+   */
+  readonly cell: import("@angular/core").InputSignal<number | null>;
   /**
    * where a square narrower than its place stands (0.6.2): `'center'` (the default) in the middle,
    * its spare width shared on both sides, `'start'` at the start, as before 0.6.2. a square is
@@ -1275,6 +1310,11 @@ export declare class CubeSquare<T> {
       "required": false;
       "isSignal": true;
     };
+    "cell": {
+      "alias": "cell";
+      "required": false;
+      "isSignal": true;
+    };
     "align": {
       "alias": "align";
       "required": false;
@@ -1381,6 +1421,11 @@ export declare class CubeContext {
   readonly words: import("@angular/core").InputSignal<ContextWords | null>;
   /** the largest side the square takes on a wide screen, in px. */
   readonly maxSide: import("@angular/core").InputSignal<number>;
+  /**
+   * one tile size on every screen (0.8.0): its tiles drawn `cell` px wide, as the level's square
+   * beside it (`<cube-square [cell]>`, `CubeRoom.cell()`); null sizes them from the room.
+   */
+  readonly cell: import("@angular/core").InputSignal<number | null>;
   /**
    * what keeps the held thing the same thing while a pick is answered (itself by default). an app
    * whose store gives a new object when the pick changes it (a rename, a hide) passes its id here, or
@@ -1446,6 +1491,11 @@ export declare class CubeContext {
       "required": false;
       "isSignal": true;
     };
+    "cell": {
+      "alias": "cell";
+      "required": false;
+      "isSignal": true;
+    };
     "heldKey": {
       "alias": "heldKey";
       "required": false;
@@ -1478,6 +1528,517 @@ export interface TurningRows<T> {
 /** the sides of one row: its front and the three behind it. */
 export declare const TURNING_SIDES = 4;
 export declare function turningRows<T>(pieces: readonly T[], own: T | null, cols?: number, rows?: number): TurningRows<T>;
+/** below this width a screen is a phone: three tiles across; from it, four (0.8.0). */
+export declare const CUBE_ROOM_NARROW = 640;
+/**
+ * the room a screen's squares share (0.8.0): the width the square has (the column beside or below
+ * the head, the same on every level), measured by `[cubeRoom]`, and from it the one tile size
+ * (`cell()`) every square on the screen is given, `<cube-square [cell]>` and `<cube-context [cell]>`
+ * alike. three across on a phone, four from 640 px. the every-level model page's `sizes.ts`, moved
+ * in; one per app (root).
+ */
+export declare class CubeRoom {
+  /** the width a square has on this screen, at most `SQUARE_MAX_SIDE`; 0 before the first measure. */
+  readonly width: import("@angular/core").WritableSignal<number>;
+  /** a phone: narrower than `CUBE_ROOM_NARROW`. */
+  readonly narrow: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  private static isNarrow;
+  /** tiles across on this screen. */
+  across(): number;
+  /** the one tile size on this screen, in px, or 0 before the first measure. */
+  cell(): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeRoom, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * `[cubeRoom]` on the element that holds a screen's square: its width is the room every square on
+ * the screen has (`CubeRoom.width`), measured when it is drawn and whenever it changes size.
+ */
+export declare class CubeRoomMeasure implements OnDestroy {
+  private readonly room;
+  private readonly el;
+  private readonly seen;
+  constructor();
+  private measure;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeRoomMeasure, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<CubeRoomMeasure, "[cubeRoom]", never, {}, {}, never, never, true, never>;
+}
+/** what the zoom does beyond the trail; `provideCubeZoom` sets it. */
+export interface CubeZoomOptions {
+  /**
+   * a step out puts the page back where the level was left, and holds it there while the level
+   * settles (mosaic's RC-2). true by default; false leaves the scroll to the app.
+   */
+  keepScroll: boolean;
+}
+export declare const CUBE_ZOOM_OPTIONS: InjectionToken<CubeZoomOptions>;
+/** `providers: [provideCubeZoom({ keepScroll: false })]` in an app's config. */
+export declare function provideCubeZoom(options: Partial<CubeZoomOptions>): {
+  provide: InjectionToken<CubeZoomOptions>;
+  useValue: {
+    keepScroll: boolean;
+  };
+};
+/**
+ * "i left this level": a step out through the cube (`stepBack`, `leaveAll`), said before the
+ * navigation. `from` is the address being left, `to` where the step goes (null when the app goes
+ * by place, not by the trail, and did not say where). an app reads what the person did inside a
+ * level here, when they leave it, never while they are in it (the every-level model's reading).
+ */
+export interface CubeLeft {
+  from: string;
+  to: string | null;
+  /** one step out (`stepBack`), or out of a whole stretch at once (`leaveAll`). */
+  via: 'step' | 'all';
+}
+/**
+ * Whether an event is the person moving the page, so the kept scroll lets go of it. The step out
+ * itself is not: a trackpad's pinch (ctrl and the wheel) goes on after the level it stepped out of
+ * is gone, and the escape that stepped out is still on its way up when the level is back (RC-5,
+ * RC-7: both landed at the top on a computer).
+ */
+export declare function cubeMovesThePage(e: Event, since: number): boolean;
+/**
+ * Whether the trail still says the way the person came, when they go from `from` to `to`: only when
+ * they step on from the last screen they left through the cube, or go back to one on the trail. A
+ * screen reached another way (a menu, a tab, the address bar) starts a new way, so ‹ never names a
+ * place left long ago (UAT mosaic-14: "‹ lately" after opening todarch from the menu).
+ */
+export declare function cubeTrailHolds(trail: readonly {
+  url: string;
+}[], from: string, to: string): boolean;
+export interface CubeEntrance {
+  kind: 'in' | 'out';
+  /** Where the screen grows from: the middle of the tile that was opened. */
+  origin: string | null;
+}
+/**
+ * Moving through the cube is a change of distance, never of place (Anlat's `zoom.ts`): the next
+ * screen grows out of the piece that was opened, or settles from closer when stepping out. It
+ * also keeps the way the person came, so back goes the way they came.
+ */
+export declare class CubeZoomService {
+  private next;
+  private readonly trail;
+  /** Where each screen left through the cube was scrolled to, so stepping out finds it there. */
+  private readonly scrolled;
+  /** The scroll to put back once the screen being stepped out to has been drawn (RC-2). */
+  private restore;
+  /**
+   * Where the last step out through the cube goes (`stepBack`, `leaveAll`), taken off the trail just
+   * before the navigation: going there is the way i came, so the trail is kept (RC-3).
+   */
+  private steppingOutTo;
+  private readonly options;
+  private readonly router;
+  private readonly leaving;
+  /** "i left this level", once a step out (see `CubeLeft`). */
+  readonly left: Observable<CubeLeft>;
+  constructor();
+  leave(url: string, label: string): void;
+  /**
+   * Puts the page back at `top` and holds it there while the level settles: the screen left is
+   * taken away, the level grows in from closer and may still be loading, and each of those moves
+   * the page. It lets go once the page has stood still at `top` for a moment, after a short while
+   * at most, or as soon as a finger, the wheel or a key moves it (never the pinch or the escape that
+   * stepped out, `cubeMovesThePage`), or the next navigation starts.
+   */
+  private scrollBack;
+  /** The screen back would go to, if the person came here from one. */
+  previous(url: string): {
+    url: string;
+    label: string;
+  } | null;
+  /**
+   * one step out, the way i came: the screen being stepped out to comes off the trail. `to` is
+   * where the app goes when the trail is empty (one level out by place), so `left` can say it.
+   */
+  stepBack(to?: string): void;
+  /**
+   * Out of a whole stretch at once (a context cube, after its journey ended): the screens on the
+   * trail that `inside` says are part of it are passed by, and the one before them is where it goes.
+   */
+  leaveAll(inside: (url: string) => boolean): {
+    url: string;
+    label: string;
+  } | null;
+  into(element: Element | null): void;
+  outOf(): void;
+  /** The way the screen opening now comes in, once. */
+  take(): CubeEntrance | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeZoomService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * `cubeZoomPinch`: a pinch on a screen of the cube goes where the cube goes. fingers apart on a
+ * piece goes into it (the nearest `[data-zoom]` under the fingers is tapped), fingers together says
+ * `cubeZoomOut`, where the app steps out the way i came. the gesture is `cubePinch` (one pinch is
+ * one level, however long a trackpad's stream), worn as a host directive.
+ */
+export declare class CubeZoomPinch {
+  private readonly host;
+  readonly cubeZoomOut: import("@angular/core").OutputEmitterRef<void>;
+  constructor();
+  private zoomInto;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeZoomPinch, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<CubeZoomPinch, "[cubeZoomPinch]", never, {}, {
+    "cubeZoomOut": "cubeZoomOut";
+  }, never, never, true, [{
+    directive: typeof CubePinch;
+    inputs: {
+      "cubePinchDisabled": "cubePinchDisabled";
+      "cubePinchQuietMs": "cubePinchQuietMs";
+    };
+    outputs: {};
+  }]>;
+}
+/** how far a finger goes sideways to turn the head's cube, in px. */
+export declare const CUBE_HEAD_SWIPE = 30;
+/**
+ * `<cube-head>`: the top of every level of a cube (0.8.0). one step out (‹ and where it goes back
+ * to), the level's cube in its circle, its name and its line, and a place under them for what the
+ * app says once (the quiet line, `<cube-quiet>`, or "this cube grew"), given as content. mosaic
+ * wrote it (lang-app-fe `shared/cube/cube-head` and `core/groups/level/groups-head`), todarch and
+ * the every-level model page copied it; this is the one they share.
+ *
+ * it says no words: the back label, its aria label, the name and the line are the app's. held,
+ * the cube says `held` (the app opens its context cube); with two pieces or more and `turns`, a
+ * sideways swipe or an arrow key turns it. a carried piece can be dropped on ‹ when the app gives
+ * `backDrop` (it is a `data-drop` place for `cubeCarry`). its look is css variables
+ * (`--cube-head-*`), set in both token files. on a phone it stands on top; the app's split puts it
+ * beside the square from 900 px: its host is `display: contents`, so its parts are the split's.
+ */
+export declare class CubeHead {
+  /** the level's cube: how many stickers, their colours (null is not known yet), its art. */
+  readonly count: import("@angular/core").InputSignal<number>;
+  readonly colours: import("@angular/core").InputSignal<(string | null)[]>;
+  readonly art: import("@angular/core").InputSignal<CubeArt>;
+  readonly whole: import("@angular/core").InputSignal<boolean>;
+  readonly hint: import("@angular/core").InputSignal<boolean>;
+  /** the cube's width in px; the circle around it is `--cube-head-circle-size`. */
+  readonly width: import("@angular/core").InputSignal<number>;
+  /**
+   * the level's name (an `h1`) and its line, the app's words. with a name, the line's place is kept
+   * on a phone even when it says nothing; with neither, neither is drawn.
+   */
+  readonly title: import("@angular/core").InputSignal<string | null>;
+  readonly line: import("@angular/core").InputSignal<string | null>;
+  /** where ‹ goes back to, in the app's words; null draws no ‹. */
+  readonly backLabel: import("@angular/core").InputSignal<string | null>;
+  /** what a screen reader hears for ‹ (the app's words: "back to moments"); the label by default. */
+  readonly backAria: import("@angular/core").InputSignal<string | null>;
+  /** ‹ is a place a carried piece can be dropped on: its `data-drop` key; null is not. */
+  readonly backDrop: import("@angular/core").InputSignal<string | null>;
+  /** something is being carried now: ‹ with a `backDrop` is marked as a place to drop. */
+  readonly carrying: import("@angular/core").InputSignal<boolean>;
+  /** a press and hold on the cube says `held`; off unless asked. */
+  readonly holds: import("@angular/core").InputSignal<boolean>;
+  /** how long a hold takes, in ms (`cubeHoldMs`). */
+  readonly holdMs: import("@angular/core").InputSignal<number>;
+  /** with two pieces or more, a sideways swipe or an arrow key turns the cube. */
+  readonly turns: import("@angular/core").InputSignal<boolean>;
+  /** the app changes the look itself on a turn (`turned`); otherwise the colours move one on. */
+  readonly regroups: import("@angular/core").InputSignal<boolean>;
+  /** the cube grows in, once (something was added to it). */
+  readonly grew: import("@angular/core").InputSignal<boolean>;
+  readonly back: import("@angular/core").OutputEmitterRef<void>;
+  readonly held: import("@angular/core").OutputEmitterRef<CubeHeld>;
+  /** a turn, at its middle when the side is edge on: 1 forward, -1 back. */
+  readonly turned: import("@angular/core").OutputEmitterRef<1 | -1>;
+  protected readonly rot: import("@angular/core").WritableSignal<number>;
+  protected readonly turning: import("@angular/core").WritableSignal<boolean>;
+  protected startX: number | null;
+  private readonly timers;
+  constructor();
+  protected start(event: PointerEvent): void;
+  protected end(event: PointerEvent): void;
+  protected key(event: KeyboardEvent): void;
+  private turn;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeHead, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CubeHead, "cube-head", never, {
+    "count": {
+      "alias": "count";
+      "required": false;
+      "isSignal": true;
+    };
+    "colours": {
+      "alias": "colours";
+      "required": false;
+      "isSignal": true;
+    };
+    "art": {
+      "alias": "art";
+      "required": false;
+      "isSignal": true;
+    };
+    "whole": {
+      "alias": "whole";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "width": {
+      "alias": "width";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "line": {
+      "alias": "line";
+      "required": false;
+      "isSignal": true;
+    };
+    "backLabel": {
+      "alias": "backLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "backAria": {
+      "alias": "backAria";
+      "required": false;
+      "isSignal": true;
+    };
+    "backDrop": {
+      "alias": "backDrop";
+      "required": false;
+      "isSignal": true;
+    };
+    "carrying": {
+      "alias": "carrying";
+      "required": false;
+      "isSignal": true;
+    };
+    "holds": {
+      "alias": "holds";
+      "required": false;
+      "isSignal": true;
+    };
+    "holdMs": {
+      "alias": "holdMs";
+      "required": false;
+      "isSignal": true;
+    };
+    "turns": {
+      "alias": "turns";
+      "required": false;
+      "isSignal": true;
+    };
+    "regroups": {
+      "alias": "regroups";
+      "required": false;
+      "isSignal": true;
+    };
+    "grew": {
+      "alias": "grew";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "back": "back";
+    "held": "held";
+    "turned": "turned";
+  }, never, ["*"], true, never>;
+}
+/**
+ * how a tile looks (0.8.0): a piece (`piece`, the default), my own box where something is added
+ * (`own`, a + before its name, dashed in the accent), a place that holds nothing yet (`dashed`), or
+ * something not known yet or set aside (`pale`).
+ */
+export type CubeTileLook = 'piece' | 'own' | 'dashed' | 'pale';
+/**
+ * the small cube's width on a tile, for its level and its cell's side (mosaic's grouped home): as
+ * a tile says less, the cube takes more of it.
+ */
+export declare function cubeTilePicture(level: SquareLevel, cell: number): number;
+/**
+ * `<cube-tile>`: one piece inside a `<cube-square>` (0.8.0): its small cube, its name and its line,
+ * ticked when it is in use, in one of four looks (`CubeTileLook`). mosaic drew it three times, todarch
+ * once, the every-level model page once more; this is the one they share. it fills the cell the
+ * square gives (`level`, `cell`, from `cubeSquareTile`'s context) and says only what the app gives
+ * it. the host is the tile: the app puts its own attributes, `role`, `tabindex`, `(click)` and the
+ * gestures (`cubeCarry`, `cubeHold`) on `<cube-tile>` itself. its look is css variables
+ * (`--cube-tile-*`), set in both token files.
+ *
+ * ```html
+ * <cube-square [tiles]="tiles" [cell]="room.cell()">
+ *   <ng-template [cubeSquareTile]="tiles" let-t let-level="level" let-cell="cell">
+ *     <cube-tile [name]="t.name" [line]="t.line" [level]="level" [cell]="cell" [count]="t.count"
+ *       [colours]="t.colours" role="button" tabindex="0" (click)="open(t)" />
+ *   </ng-template>
+ * </cube-square>
+ * ```
+ */
+export declare class CubeTile {
+  /** the piece's name, as the app says it. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** its line under the name; said on the face at the nearer levels when `says`, else only to a screen reader. */
+  readonly line: import("@angular/core").InputSignal<string | null | undefined>;
+  /** whether the line is said on the face (true), or kept for a screen reader only. */
+  readonly says: import("@angular/core").InputSignal<boolean>;
+  /** how much it says (the square's `level`) and its cell's side in px (the square's `cell`). */
+  readonly level: import("@angular/core").InputSignal<SquareLevel>;
+  readonly cell: import("@angular/core").InputSignal<number>;
+  /** its small cube: how many stickers, their colours (null is not known yet), its art, whole. */
+  readonly count: import("@angular/core").InputSignal<number>;
+  readonly colours: import("@angular/core").InputSignal<(string | null)[]>;
+  readonly art: import("@angular/core").InputSignal<CubeArt>;
+  /** one colour on every face; by default when it holds one. */
+  readonly whole: import("@angular/core").InputSignal<boolean | null>;
+  readonly look: import("@angular/core").InputSignal<CubeTileLook>;
+  /** in use (chosen, an answer it stands in): a ring and the tick. */
+  readonly ticked: import("@angular/core").InputSignal<boolean>;
+  /** the tick's mark (a sign, not a word) and what a screen reader hears for it (the app's word). */
+  readonly tick: import("@angular/core").InputSignal<string>;
+  readonly tickedWord: import("@angular/core").InputSignal<string | null>;
+  /** a faint edge in the accent: a piece with a way of its own, as the app decides. */
+  readonly marked: import("@angular/core").InputSignal<boolean>;
+  protected readonly picture: import("@angular/core").Signal<number>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeTile, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CubeTile, "cube-tile", never, {
+    "name": {
+      "alias": "name";
+      "required": true;
+      "isSignal": true;
+    };
+    "line": {
+      "alias": "line";
+      "required": false;
+      "isSignal": true;
+    };
+    "says": {
+      "alias": "says";
+      "required": false;
+      "isSignal": true;
+    };
+    "level": {
+      "alias": "level";
+      "required": false;
+      "isSignal": true;
+    };
+    "cell": {
+      "alias": "cell";
+      "required": false;
+      "isSignal": true;
+    };
+    "count": {
+      "alias": "count";
+      "required": false;
+      "isSignal": true;
+    };
+    "colours": {
+      "alias": "colours";
+      "required": false;
+      "isSignal": true;
+    };
+    "art": {
+      "alias": "art";
+      "required": false;
+      "isSignal": true;
+    };
+    "whole": {
+      "alias": "whole";
+      "required": false;
+      "isSignal": true;
+    };
+    "look": {
+      "alias": "look";
+      "required": false;
+      "isSignal": true;
+    };
+    "ticked": {
+      "alias": "ticked";
+      "required": false;
+      "isSignal": true;
+    };
+    "tick": {
+      "alias": "tick";
+      "required": false;
+      "isSignal": true;
+    };
+    "tickedWord": {
+      "alias": "tickedWord";
+      "required": false;
+      "isSignal": true;
+    };
+    "marked": {
+      "alias": "marked";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** what an app says once, quietly: its words and, when it can be undone, how (the app's own). */
+export interface CubeQuietNote<U = unknown> {
+  says: string;
+  /** what undoes it, the app's own; none when it cannot be undone. */
+  undo?: U | null;
+}
+/**
+ * the quiet line, headless (0.8.0): what the app read from what the person did, said once on the
+ * level it was said on, with one tap to undo, and gone after the next move (pin 4 of the every-level
+ * study). a step in and back out keeps it on its level; the app says what clears it (`say(null)` on
+ * its next move). it keeps no words: the app gives them, and draws the line with `<cube-quiet>`.
+ *
+ * ```ts
+ * readonly quiet = new CubeQuietLine<Note>();
+ * apply(r: { note?: Note }) { this.quiet.say(r.note ?? null, this.router.url); }
+ * // the head's content: <cube-quiet [note]="quiet.on(here())" undoWord="undo" (undo)="undo()" />
+ * ```
+ */
+export declare class CubeQuietLine<N extends CubeQuietNote = CubeQuietNote> {
+  private readonly said;
+  /** the note said last, wherever it was said. */
+  readonly note: import("@angular/core").Signal<N | null>;
+  /** the level (its address) it was said on. */
+  readonly at: import("@angular/core").Signal<string | null>;
+  /** say `note` on the level at `at` (an address); null clears the line. */
+  say(note: N | null, at: string): void;
+  /** the line goes with the person to `at` (a level a step out lands on in place of the one it was said on). */
+  move(at: string): void;
+  clear(): void;
+  /** the note on the level at `url`, or null when it was said elsewhere. */
+  on(url: string): N | null;
+}
+/**
+ * `<cube-quiet [note] undoWord (undo)>`: the quiet line drawn (0.8.0), a `role="status"` line with
+ * the app's words and, when the note can be undone, a button in the app's word. nothing is drawn
+ * without a note. put it in `<cube-head>`'s content so the head keeps its place; give the place a
+ * fixed height on a phone so the square below does not move when it is said. its look is css
+ * variables (`--cube-quiet-*`).
+ */
+export declare class CubeQuiet {
+  readonly note: import("@angular/core").InputSignal<CubeQuietNote<unknown> | null>;
+  /** the app's word for undo; without it no button is drawn. */
+  readonly undoWord: import("@angular/core").InputSignal<string | null>;
+  /** undo was tapped: the note it undoes. */
+  readonly undo: import("@angular/core").OutputEmitterRef<CubeQuietNote<unknown>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CubeQuiet, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CubeQuiet, "cube-quiet", never, {
+    "note": {
+      "alias": "note";
+      "required": false;
+      "isSignal": true;
+    };
+    "undoWord": {
+      "alias": "undoWord";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "undo": "undo";
+  }, never, never, true, never>;
+}
 /**
  * something on its way, the cube design way: the cube picture's pale stickers take colour (a page,
  * a cube) or its colours turn round the stickers (a piece: a tile, a button saving). picked by selim