@vibecook/ice 0.10.0 → 0.14.0

package/dist/types/packages/objects/src/board/stroke.d.ts

@@ -0,0 +1,99 @@
+import type { RGB } from "../../../desk/src/index";
+import { BOARD } from "./theme";
+/** A stamp's floats: x, y (world units from the melamine's top-left) · dir x, y · s (arc length) · flow · size · seed. */
+export declare const STAMP_FLOATS = 8;
+/** A felt tip, world units: half extents (along the tip's long axis, across it), corner radius, edge softness, the angle it is held at (radians, screen space, y down). */
+export interface Tip {
+    readonly half: readonly [number, number];
+    readonly radius: number;
+    readonly softness: number;
+    readonly angle: number;
+}
+export type TipName = keyof typeof BOARD.tips;
+export declare const TIP_NAMES: readonly TipName[];
+/** A tip from the theme's numbers (degrees → radians). */
+export declare const tipOf: (t: {
+    readonly half: readonly [number, number];
+    readonly radius: number;
+    readonly softness: number;
+    readonly angle: number;
+}) => Tip;
+export declare const TIPS: Record<TipName, Tip>;
+export declare const ERASER_TIP: Tip;
+/** What lays the stamps down: a marker (its ink in LINEAR rgb, the coverage one pass lays) or the eraser. */
+export interface Tool {
+    readonly mode: "ink" | "erase";
+    readonly color: RGB;
+    readonly opacity: number;
+    readonly tip: Tip;
+    /** The felt's streaks, 0..1 — none for the eraser's own pattern. */
+    readonly streak: number;
+}
+export interface FeltLaw {
+    readonly streak: number;
+    readonly lanes: number;
+    readonly along: readonly [number, number];
+    readonly dry: readonly [number, number];
+    readonly dryLoss: number;
+    readonly bleed: {
+        readonly after: number;
+        readonly grow: number;
+        readonly tau: number;
+    };
+    readonly pitch: {
+        readonly k: number;
+        readonly min: number;
+        readonly max: number;
+    };
+}
+export declare const DEFAULT_FELT: FeltLaw;
+export declare function markerTool(color: RGB, opacity: number, tip: Tip, felt?: FeltLaw): Tool;
+export declare const ERASER_TOOL: Tool;
+/** The distance between stamps for a tip: a fraction of its narrow half, clamped (world units). */
+export declare const pitchOf: (tip: Tip, felt?: FeltLaw) => number;
+/**
+ * One stroke being drawn. `begin` at the press, `move` per pointer sample (coalesced events
+ * in order), `hold` once a frame while the pen rests (its bleed), `end` at the lift. Times are
+ * milliseconds (the events' own clock), positions the melamine's world units. `pending()`
+ * hands the stamps made since the last call — what the pass uploads this frame — and
+ * `stamps()` all of them, for the history.
+ */
+export declare class StrokeBuilder {
+    readonly tool: Tool;
+    readonly seed: number;
+    readonly spacing: number;
+    private readonly felt;
+    private buf;
+    private n;
+    private sent;
+    private x;
+    private y;
+    private t;
+    private dirX;
+    private dirY;
+    private s;
+    private carry;
+    private speed;
+    private flow;
+    private size;
+    private lastMove;
+    private active;
+    constructor(tool: Tool, seed: number, felt?: FeltLaw);
+    get count(): number;
+    get live(): boolean;
+    private push;
+    /** The press: the first footprint, where the tip lands. */
+    begin(x: number, y: number, t: number, size?: number): void;
+    /** A pointer sample: footprints every `spacing` along the segment since the last, the flow and size interpolated. */
+    move(x: number, y: number, t: number, size?: number): void;
+    /** The pen held still: past `bleed.after` ms the ink spreads into the melamine, growing toward `1 + grow`. */
+    hold(now: number): void;
+    /** The lift: the last sample's footprints; the stroke is complete. */
+    end(x?: number, y?: number, t?: number, size?: number): void;
+    /** The stamps made since the last call (a view — copy it before the next push). */
+    pending(): Float32Array;
+    /** Every stamp of the stroke, as its own array. */
+    stamps(): Float32Array;
+}
+/** A stroke's path for a reader — an agent, an export: one point per `every` stamps, world units from the melamine's top-left. */
+export declare function pathOf(stamps: Float32Array, every?: number): Array<readonly [number, number]>;

package/dist/types/packages/objects/src/board/theme.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The WHITEBOARD (BOARD.md) — a desk dry-erase board under the mat's one lamp, ONE PHYSICS with
+ * the note and the notebook: it lifts as they lift (`PAPER.lift`), its slab casts the note's
+ * penumbra swept down its height with the notebook's contact term at its base (`BOOK.shadow`),
+ * and a face reads by the notebook's light (`BOOK.light`). What a board has of its own is the
+ * research whiteboard (research/whiteboard): melamine with an orange-peel grain and a sheen that
+ * slides with the eye, felt-tip ink laid by max-blended stamps — streaky when fast, bleeding when
+ * held, glossy while wet — and an eraser that leaves a ghost. The board is 3:2 like every
+ * whiteboard, on the tree-shadow design's 80-unit module, at the notebook's scale: 480 × 320
+ * beside the A6 notebook's 176 × 248 is a ~29 × 19 cm desk board. World units throughout; the
+ * research's tip and stroke numbers were CSS px on a full-screen board and are scaled into them.
+ * The colours are the product's (lab/theme.ts `BOARD_LOOK`, `MARKERS`).
+ */
+export declare const BOARD: {
+    /** A board as a host spawns one: its outer size, the aluminium frame's width, the frame's outer radius, the slab's height, the melamine's recess below the frame's top. */
+    readonly spec: {
+        readonly width: 480;
+        readonly height: 320;
+        readonly frame: 9;
+        readonly radius: 7;
+        readonly thick: 8;
+        readonly recess: 1.2;
+    };
+    readonly lift: {
+        readonly height: 12;
+        readonly scale: 1.03;
+    };
+    readonly shadow: {
+        readonly penumbra: {
+            readonly sigma0: 2.2;
+            readonly sigmaPerHeight: 0.9;
+            readonly alpha: 0.36;
+        };
+        readonly contact: {
+            readonly sigma: 1.1;
+            readonly alpha: 0.3;
+            readonly reach: 2.5;
+        };
+        readonly slopeMax: 2.2;
+    };
+    readonly light: {
+        readonly ambient: 0.5;
+        readonly cap: 1.35;
+    };
+    /**
+     * The melamine: its tone's drift (±), its orange-peel grain (±/255), the ghost old erasures
+     * leave; the SHEEN — the window's reflection — its strength, its spread, the eye's height over
+     * the board (× the board's height) and how far it slides with the pointer; the frame's lip on
+     * the surface: its shadow's alpha and σ.
+     */
+    readonly surface: {
+        readonly tone: 0.012;
+        readonly grain: number;
+        readonly ghost: 0.012;
+        readonly sheen: 0.16;
+        readonly spread: 0.35;
+        readonly eye: 1.6;
+        readonly parallax: 0.12;
+        readonly lip: {
+            readonly alpha: 0.2;
+            readonly sigma: 0.9;
+        };
+    };
+    /** The frame: brushed along its length (±/255), its profile's roll at the rims (rad), the metal's glint. */
+    readonly frame: {
+        readonly brushed: number;
+        readonly roll: 0.85;
+        readonly glint: 0.35;
+    };
+    /** The ink raster (texels per world unit — the open board fills the view at ~1.8× on a 2× display), how long fresh ink stays wet (s) and how dark it lays wet, the film's edge relief. */
+    readonly ink: {
+        readonly density: 4;
+        readonly wetSeconds: 1.2;
+        readonly wetDarken: 0.8;
+        readonly film: 0.04;
+    };
+    /** The tips, world units: half extents (along, across the tip), corner radius, edge softness, the angle it is held at (deg). The research's, scaled to the desk board. */
+    readonly tips: {
+        readonly fine: {
+            readonly half: readonly [0.75, 0.75];
+            readonly radius: 0.75;
+            readonly softness: 0.3;
+            readonly angle: 0;
+        };
+        readonly bullet: {
+            readonly half: readonly [1.35, 1.35];
+            readonly radius: 1.35;
+            readonly softness: 0.35;
+            readonly angle: 0;
+        };
+        readonly chisel: {
+            readonly half: readonly [2.4, 0.9];
+            readonly radius: 0.5;
+            readonly softness: 0.35;
+            readonly angle: -50;
+        };
+    };
+    readonly eraser: {
+        readonly half: readonly [16, 7];
+        readonly radius: 2.5;
+        readonly softness: 1.6;
+        readonly angle: 8;
+    };
+    /**
+     * The felt: its streaks (strength, lanes per world unit across, drift along ×2), how fast a
+     * stroke runs dry (world units/s: from, full) and how much flow it loses, a held pen's bleed
+     * (after ms, growth, its time constant ms), and the stamps' pitch (× the tip's narrow half, clamped).
+     */
+    readonly felt: {
+        readonly streak: 0.45;
+        readonly lanes: 0.75;
+        readonly along: readonly [0.058, 0.145];
+        readonly dry: readonly [200, 1450];
+        readonly dryLoss: 0.16;
+        readonly bleed: {
+            readonly after: 150;
+            readonly grow: 0.35;
+            readonly tau: 700;
+        };
+        readonly pitch: {
+            readonly k: 0.3;
+            readonly min: 0.12;
+            readonly max: 0.5;
+        };
+    };
+    /** The pen in the hand and on the board: its length, barrel radius, the cap's length, how steeply it rises from the tip (height per unit of length), how high it hovers unpressed, its lean with speed (rad). */
+    readonly pen: {
+        readonly length: 150;
+        readonly radius: 6.5;
+        readonly cap: 42;
+        readonly rise: 0.18;
+        readonly hover: 6;
+        readonly lean: 0.16;
+    };
+    /** The eraser in the hand: the felt block's half extents, the felt's and the wooden back's heights. */
+    readonly block: {
+        readonly half: readonly [18, 8];
+        readonly felt: 4;
+        readonly wood: 10;
+    };
+    readonly ring: 1.5;
+    /** The open board: CSS px kept clear round it and for the tray under it, the zoom band, and the pinch-out that closes it (× the framing's zoom). */
+    readonly focus: {
+        readonly pad: 48;
+        readonly tray: 92;
+        readonly minZoom: 0.5;
+        readonly maxZoom: 3;
+        readonly close: 0.72;
+    };
+};

package/dist/types/packages/objects/src/calendar/data.d.ts

@@ -0,0 +1,97 @@
+import { type Entity, type GuardedTx, type World } from "../../../core/src/index";
+import type { CalEvent } from "./events";
+import { type CalendarLaw } from "./law";
+/** A pad's event: a line on a day or a band across days (`start` … `end`, inclusive ISO day keys). */
+export declare const CalendarEvent: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly start: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly end: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly text: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly seeds: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly ink: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly start: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly end: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly text: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly seeds: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly ink: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+export declare const EVENT_TYPE = "desk.event";
+export declare const EventPrefab: import("../../../core/src/index").Prefab;
+/** A note stuck to a day of a pad: the pin's day (ISO key); its note by the `PinsNote` edge. */
+export declare const NotePin: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly day: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly day: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+/**
+ * pin → the note it holds (a reified edge: the day is the pin's cell). DEPENDENT (D3t-c — core's `defineRelation({ dependent })`):
+ * the pin dies with its note in the same transaction (a stuck note deleted leaves no pin behind; one ⌘Z brings both back).
+ */
+export declare const PinsNote: import("@vibecook/strata-ecs").Relation;
+/** The notes stuck to a pad, with their days (its pins' edges) — what rides with it, what goes with its months. */
+export declare function pinnedNotes(world: World, pad: Entity): {
+    readonly pin: Entity;
+    readonly note: Entity;
+    readonly day: string;
+}[];
+export declare const PIN_TYPE = "desk.pin";
+export declare const PinPrefab: import("../../../core/src/index").Prefab;
+/**
+ * Runtime, on a pad: the USER's selection on it (D3t-c) — a run of days (`anchor` … `focus`, day keys; "" none) or one entry
+ * (`entry`, an event child; 0 none) — and `home`, bumped by the held bar's today (the hand then rolls home and selects today).
+ * The user's fact, as `Selected` is: never in the document, a peer's selection its own. Its writers: the calendar's hand
+ * (objects/calendar-hand.ts, host/calendar-input.ts) and the today tool's bump.
+ */
+export declare const PadSelection: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly anchor: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly focus: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly entry: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly home: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly anchor: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly focus: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly entry: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly home: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/** An event as an author states one. */
+export interface EventSpec {
+    readonly start: string;
+    readonly end?: string;
+    readonly text?: string;
+    readonly seeds?: string;
+    readonly ink?: string;
+}
+/** Write an event on a pad — one entity, the pad's newest child — inside the caller's transaction. */
+export declare function addEvent(tx: GuardedTx, pad: Entity, s: EventSpec): Entity;
+/** Stick a note to a day of a pad — the pin a child of the pad, its edge to the note — inside the caller's transaction. */
+export declare function pinNote(tx: GuardedTx, pad: Entity, note: Entity, day: string): Entity;
+/** A month index as its key ("2026-09"). */
+export declare function monthKeyOf(m: number): string;
+/** A month key (YYYY-MM) as the law's month index; undefined when it is not one. */
+export declare function monthOfKey(key: string): number | undefined;
+/**
+ * Where a note stuck to `day` lies on a pad centred at (cx, cy) — its day's slot on the month that day is in (the
+ * lab's `slotOf`; the oracle's `pinnedAt`), world units. Throws for a day off its month's sheet.
+ */
+export declare function daySlot(cx: number, cy: number, day: string, weekStart?: 0 | 1, law?: CalendarLaw): {
+    readonly x: number;
+    readonly y: number;
+};
+/** An event's cell as a reader takes it (a tolerant reader: a string field strata hands back as null reads as its default). */
+export interface EventRow {
+    readonly start: string | null;
+    readonly end: string | null;
+    readonly text: string | null;
+    readonly seeds: string | null;
+    readonly ink: string | null;
+}
+/** A day key's day number, or undefined when it is not one (YYYY-MM-DD, a real day). */
+export declare function dayOr(key: string): number | undefined;
+/**
+ * An event entity as the PRINT takes it (calendar/events.ts `CalEvent`, the prototype's): its days as day numbers, its text and
+ * its hand's seeds decoded, and two numbers the prototype kept on the event and the world does not (D-D3t-c.2): its own `seed`
+ * — the band's wobble, the hand of a glyph with no stored seed — made from what the entry IS (its days and its ink, so it holds
+ * still while the entry is written), identical on every peer; and its `rev`, a hash of its whole cell (a cell edited redraws
+ * the tiles over it). Null for a cell whose days are not days.
+ */
+export declare function calEventOf(entity: Entity, row: EventRow): CalEvent | null;

package/dist/types/packages/objects/src/calendar/events.d.ts

@@ -0,0 +1,58 @@
+/** One entry on the calendar. */
+export interface CalEvent {
+    readonly id: number;
+    /** First and last day (day numbers, inclusive); equal for a one-day line. */
+    start: number;
+    end: number;
+    text: string;
+    /** Each glyph's seed — its hand (paper/text.ts `carrySeeds`). */
+    seeds: number[];
+    seed: number;
+    /** The pen (a line) or the highlighter (a band) — the host's names; the law never reads them. */
+    ink: string;
+    /** Bumped on every edit: part of the raster's key. */
+    rev: number;
+}
+export declare const isSpan: (e: CalEvent) => boolean;
+/**
+ * A time at the head of an entry: `9:30`, `14:00`, `9am`, `9.30pm`, `3 pm`, `12a` — hours and minutes,
+ * or an hour with am/pm. A bare number is not a time ("3 apples"). Returns minutes after midnight
+ * and how many characters it took (with the space after it), or null.
+ */
+export declare function parseTime(text: string): {
+    readonly minutes: number;
+    readonly len: number;
+} | null;
+/** An event's time, or null (an all-day line). */
+export declare const timeOf: (e: CalEvent) => number | null;
+/** The order of a day's one-day lines: untimed first (as written, by id), then timed by the clock. */
+export declare function compareLines(a: CalEvent, b: CalEvent): number;
+/** One week's piece of a band: the columns it covers in that row, its lane, whether the event starts or ends in it. */
+export interface SpanSeg {
+    readonly event: CalEvent;
+    readonly row: number;
+    readonly col0: number;
+    readonly col1: number;
+    readonly lane: number;
+    readonly head: boolean;
+    readonly tail: boolean;
+}
+/** A day's lines as its cell writes them (an entry may take two lines: `layoutMonth`'s `size`). */
+export interface CellLines {
+    readonly day: number;
+    /** Lines the week's bands take at the top of this cell (their lanes through it). */
+    readonly lanes: number;
+    /** The one-day lines, sorted; those that fit and those that do not. */
+    readonly shown: readonly CalEvent[];
+    readonly hidden: number;
+}
+/**
+ * Lay a grid's weeks out: every band cut into its week rows and given a lane that holds across the row
+ * (sorted by start, the longer first; the first lane free for all its columns), and every day's one-day
+ * lines. `capacity(day, lanes)` says how many lines a cell has in all (the host knows the cell's height
+ * and whether a note hangs in it); `size(e)` how many a one-day entry takes (its writing wraps).
+ */
+export declare function layoutMonth(events: readonly CalEvent[], first: number, rows: number, capacity: (day: number, lanes: number) => number, size?: (e: CalEvent) => number): {
+    readonly spans: readonly SpanSeg[];
+    readonly cells: readonly CellLines[];
+};

package/dist/types/packages/objects/src/calendar/hand.d.ts

@@ -0,0 +1,53 @@
+import { type Entity, type World } from "../../../core/src/index";
+import { type CalendarLaw } from "./law";
+import { type Pads } from "./kind";
+import type { CalendarWriting } from "./writing";
+import { type TypingDocs } from "../../../desk/src/index";
+export interface CalendarHandOptions {
+    readonly world: World;
+    readonly docs: TypingDocs;
+    readonly pads: () => Pads | undefined;
+    readonly writing: CalendarWriting;
+    /** The editor's caret on the line being written — its index and when its blink restarted (the hand's clock) — and the newest glyph's wipe. */
+    readonly caret: () => {
+        readonly index: number;
+        readonly t0: number;
+        readonly wipe: {
+            readonly index: number;
+            readonly t0: number;
+        } | null;
+    } | null;
+    /** The caret's blink, ms (530). */
+    readonly blinkMs?: number;
+    /** The newest glyph's wipe, ms (the hand's 110). */
+    readonly wipeMs?: number;
+    /** Where a transaction runs: out of the frame (a microtask) unless a test says. */
+    readonly defer?: (fn: () => void) => void;
+    /** The builder's word on a pad — its geometry as drawn, the hand's frame, the held pose (the roll by hand reads them; absent: no hands). */
+    readonly geometryOf?: (e: Entity) => unknown;
+    readonly hand?: () => {
+        readonly entity: Entity;
+        readonly landing: boolean;
+        readonly frame: {
+            readonly cx: number;
+            readonly cy: number;
+            readonly s: number;
+        };
+    } | undefined;
+    readonly heldToWorld?: (e: Entity, x: number, y: number) => readonly [number, number] | undefined;
+    readonly isPad?: (e: Entity) => boolean;
+    /** Is this entity a sticky note (it may be stuck to a day)? Absent: nothing sticks. */
+    readonly isNote?: (e: Entity) => boolean;
+    /** The glide into a day's slot, ms (the prototype's 3.2 Hz spring, as a tween). */
+    readonly glideMs?: number;
+    readonly law?: CalendarLaw;
+}
+export interface CalendarHand {
+    /** Once a frame, before the kinds' clocks: the marks on every pad; the bar's today acted on. */
+    follow(now: number): void;
+    /** Nothing to follow (D7 #14): no pad on the desk, nothing in hand, no press, no selection, no note carried, no glide owed. */
+    idle(): boolean;
+    /** Leave the document's commit door (the landing's extender). */
+    dispose(): void;
+}
+export declare function createCalendarHand(opts: CalendarHandOptions): CalendarHand;

package/dist/types/packages/objects/src/calendar/host/input.d.ts

@@ -0,0 +1,67 @@
+import { type Entity, type WidgetType, type World } from "../../../../core/src/index";
+import { type CalendarLaw } from "../law";
+import type { EventLine } from "../print";
+import { type CalendarPart } from "../kind";
+import type { CalendarDriver } from "../object";
+import { type TypingDocs } from "../../../../desk/src/index";
+import type { DeskEditor } from "../../../../desk/src/kit/index";
+/** The desk calendar's text part's name (K8a) — a day's line: what the editor's lease carries while the calendar holds it. */
+export declare const CALENDAR_LINE = "calendar.line";
+export interface CalendarInputOptions {
+    readonly container: HTMLElement;
+    readonly world: World;
+    /** The builder's word on a pad: its geometry as drawn, the hand's frame, the held pose (host/layer.ts hands the builder). */
+    readonly geometryOf: (e: Entity) => unknown;
+    readonly hand: () => {
+        readonly entity: Entity;
+        readonly landing: boolean;
+        readonly frame: {
+            readonly cx: number;
+            readonly cy: number;
+            readonly s: number;
+        };
+    } | undefined;
+    readonly heldToWorld: (e: Entity, x: number, y: number) => readonly [number, number] | undefined;
+    readonly editor: DeskEditor;
+    /** The calendar's driver (`CalendarDriver`, D-D7-A.3): this is the CALENDAR's DOM half, which the calendar declares (K4b) — the host hands it the calendar's own and it joins it; none, no input. */
+    readonly driver: CalendarDriver | undefined;
+    /** The calendar object (its compiled widget type — its first group is a pad's props: its month, its week start). */
+    readonly object: WidgetType;
+    readonly docs: TypingDocs;
+    /** The calendar's look as the desk composed it (the highlighters a band is drawn in). */
+    readonly look: () => unknown;
+    readonly law?: CalendarLaw;
+    /** The hand's clock (the caret's blink, the wipe): `performance.now` unless a test says. */
+    readonly now?: () => number;
+    readonly wake: () => void;
+}
+export interface CalendarInput {
+    /** The caret on the line being written — its index, its blink's restart, the newest glyph's wipe — for the hand's marks. */
+    caret(): {
+        readonly index: number;
+        readonly t0: number;
+        readonly wipe: {
+            readonly index: number;
+            readonly t0: number;
+        } | null;
+    } | null;
+    /** Select days on a pad (a rig's door, the keys' own path): a run from `anchor` to `focus`; lends the editor. */
+    selectDays(pad: Entity, anchor: number, focus: number): void;
+    /** Select an entry on a pad; lends the editor. */
+    selectEntry(pad: Entity, entry: Entity): void;
+    /** Let go of the selection (and the editor). */
+    clear(): void;
+    /** Begin writing a new line on the selected days (the ⏎'s path); true when it began. */
+    write(): boolean;
+    /** Write into an entry, the caret at `index` (the end by default). */
+    edit(pad: Entity, entry: Entity, index?: number): boolean;
+    /** What a client point lands on — the pad and its part — as a click would read it (a rig's door). */
+    partAtClient(clientX: number, clientY: number): {
+        readonly pad: Entity;
+        readonly part: CalendarPart;
+    } | null;
+    dispose(): void;
+}
+/** The caret index nearest a sheet point on a line — where a tap puts the pen (the prototype's `caretIndexAt`). */
+export declare function caretIndexAt(line: EventLine, sx: number, sy: number): number;
+export declare function createCalendarInput(opts: CalendarInputOptions): CalendarInput | undefined;

package/dist/types/packages/objects/src/calendar/host/print.d.ts

@@ -0,0 +1,9 @@
+import { type TextRaster, type PrintRaster } from "../../../../desk/src/kit/index";
+import { type SheetPrint } from "../print";
+export interface PrintRasterOptions {
+    /** The desk's text raster: the hand's face and its metrics (the note's). */
+    readonly text: TextRaster;
+    /** The hand's face by name (`PEN_FACES` — the note's Caveat unless a host says). */
+    readonly face?: string;
+}
+export declare function printRaster(opts: PrintRasterOptions): PrintRaster<SheetPrint>;