@oh-my-pi/pi-utils 17.2.8 → 17.2.10

package/dist/types/marked/core.d.ts

@@ -0,0 +1,445 @@
+/** Token shapes emitted by the Markdown lexer. */
+export declare namespace Tokens {
+    /** A block quote. */
+    interface Blockquote {
+        type: "blockquote";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    }
+    /** A hard line break. */
+    interface Br {
+        type: "br";
+        raw: string;
+    }
+    /** A task-list checkbox. */
+    interface Checkbox {
+        type: "checkbox";
+        raw: string;
+        checked: boolean;
+    }
+    /** A code block. */
+    interface Code {
+        type: "code";
+        raw: string;
+        codeBlockStyle?: "indented";
+        lang?: string;
+        text: string;
+        escaped?: boolean;
+    }
+    /** An inline code span. */
+    interface Codespan {
+        type: "codespan";
+        raw: string;
+        text: string;
+    }
+    /** A reference-link definition. */
+    interface Def {
+        type: "def";
+        raw: string;
+        tag: string;
+        href: string;
+        title?: string;
+    }
+    /** Deleted text. */
+    interface Del {
+        type: "del";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    }
+    /** Emphasized text. */
+    interface Em {
+        type: "em";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    }
+    /** An escaped punctuation character. */
+    interface Escape {
+        type: "escape";
+        raw: string;
+        text: string;
+    }
+    /** A custom extension token. */
+    interface Generic {
+        [key: string]: any;
+        type: string;
+        raw: string;
+        tokens?: Token[];
+    }
+    /** A heading. */
+    interface Heading {
+        type: "heading";
+        raw: string;
+        depth: number;
+        text: string;
+        tokens: Token[];
+    }
+    /** A horizontal rule. */
+    interface Hr {
+        type: "hr";
+        raw: string;
+    }
+    /** Raw block or inline HTML. */
+    interface HTML {
+        type: "html";
+        raw: string;
+        pre?: boolean;
+        text: string;
+        block: boolean;
+        inLink?: boolean;
+        inRawBlock?: boolean;
+    }
+    /** An image. */
+    interface Image {
+        type: "image";
+        raw: string;
+        href: string;
+        title: string | null;
+        text: string;
+        tokens: Token[];
+    }
+    /** A hyperlink. */
+    interface Link {
+        type: "link";
+        raw: string;
+        href: string;
+        title?: string | null;
+        text: string;
+        tokens: Token[];
+    }
+    /** A list. */
+    interface List {
+        type: "list";
+        raw: string;
+        ordered: boolean;
+        start: number | "";
+        loose: boolean;
+        items: ListItem[];
+    }
+    /** A list item. */
+    interface ListItem {
+        type: "list_item";
+        raw: string;
+        task: boolean;
+        checked?: boolean;
+        loose: boolean;
+        text: string;
+        tokens: Token[];
+    }
+    /** A paragraph. */
+    interface Paragraph {
+        type: "paragraph";
+        raw: string;
+        pre?: boolean;
+        text: string;
+        tokens: Token[];
+    }
+    /** Blank block space. */
+    interface Space {
+        type: "space";
+        raw: string;
+    }
+    /** Strongly emphasized text. */
+    interface Strong {
+        type: "strong";
+        raw: string;
+        text: string;
+        tokens: Token[];
+    }
+    /** A GFM table cell. */
+    interface TableCell {
+        text: string;
+        tokens: Token[];
+        header: boolean;
+        align: "center" | "left" | "right" | null;
+    }
+    /** A GFM table. */
+    interface Table {
+        type: "table";
+        raw: string;
+        align: Array<"center" | "left" | "right" | null>;
+        header: TableCell[];
+        rows: TableCell[][];
+    }
+    /** Plain text. */
+    interface Text {
+        type: "text";
+        raw: string;
+        text: string;
+        tokens?: Token[];
+        escaped?: boolean;
+    }
+}
+type KnownToken = Tokens.Blockquote | Tokens.Br | Tokens.Checkbox | Tokens.Code | Tokens.Codespan | Tokens.Def | Tokens.Del | Tokens.Em | Tokens.Escape | Tokens.Heading | Tokens.Hr | Tokens.HTML | Tokens.Image | Tokens.Link | Tokens.List | Tokens.ListItem | Tokens.Paragraph | Tokens.Space | Tokens.Strong | Tokens.Table | Tokens.Text;
+/** A built-in or extension Markdown token. */
+export type Token = KnownToken | Tokens.Generic;
+/** Reference definitions collected while lexing. */
+export type Links = Record<string, Pick<Tokens.Link | Tokens.Image, "href" | "title">>;
+/** A token array carrying its reference-definition map. */
+export type TokensList = Token[] & {
+    links: Links;
+};
+/** Context supplied to extension tokenizers. */
+export interface TokenizerThis {
+    lexer: Lexer;
+}
+/** A tokenizer extension callback. */
+export type TokenizerExtensionFunction = (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | undefined;
+/** A tokenizer extension start hint. */
+export type TokenizerStartFunction = (this: TokenizerThis, src: string) => number | void;
+/** An inline or block tokenizer extension. */
+export interface TokenizerExtension {
+    name: string;
+    level: "block" | "inline";
+    start?: TokenizerStartFunction;
+    tokenizer: TokenizerExtensionFunction;
+    childTokens?: string[];
+}
+/** Context supplied to extension renderers. */
+export interface RendererThis {
+    parser: Parser;
+}
+/** A custom renderer extension callback. */
+export type RendererExtensionFunction = (this: RendererThis, token: Tokens.Generic) => string | false | undefined;
+/** A named renderer extension. */
+export interface RendererExtension {
+    name: string;
+    renderer: RendererExtensionFunction;
+}
+/** A combined tokenizer/renderer extension. */
+export type TokenizerAndRendererExtension = TokenizerExtension | RendererExtension | (TokenizerExtension & RendererExtension);
+/** Overrides for built-in tokenizer methods. */
+export interface TokenizerObject {
+    url?(this: Tokenizer, src: string): Tokens.Link | undefined | false;
+    lheading?(this: Tokenizer, src: string): Tokens.Heading | undefined | false;
+    del?(this: Tokenizer, src: string, maskedSrc?: string, prevChar?: string): Tokens.Del | undefined | false;
+}
+interface RendererTokenMap {
+    space: Tokens.Space;
+    html: Tokens.HTML;
+    link: Tokens.Link;
+    image: Tokens.Image;
+    text: Tokens.Text | Tokens.Escape;
+    code: Tokens.Code;
+    blockquote: Tokens.Blockquote;
+    heading: Tokens.Heading;
+    hr: Tokens.Hr;
+    list: Tokens.List;
+    listitem: Tokens.ListItem;
+    paragraph: Tokens.Paragraph;
+    strong: Tokens.Strong;
+    em: Tokens.Em;
+    codespan: Tokens.Codespan;
+    br: Tokens.Br;
+    del: Tokens.Del;
+}
+/** Overrides for built-in HTML renderer methods. */
+export type RendererObject = {
+    [K in keyof RendererTokenMap]?: (this: Renderer, token: RendererTokenMap[K]) => string | false;
+};
+/** Options supported by the in-house Markdown implementation. */
+export interface MarkedOptions {
+    async?: boolean;
+    breaks?: boolean;
+    gfm?: boolean;
+    pedantic?: boolean;
+    silent?: boolean;
+    tokenizer?: Tokenizer | TokenizerObject | null;
+    /** Built-in tokenizer overrides composed by Marked.use(). */
+    tokenizerOverrides?: TokenizerObject;
+    renderer?: Renderer | RendererObject | null;
+    walkTokens?: ((token: Token) => void | Promise<void>) | null;
+    extensions?: ExtensionRegistry | null;
+}
+interface ExtensionRegistry {
+    block: TokenizerExtension[];
+    inline: TokenizerExtension[];
+    renderers: Record<string, RendererExtensionFunction>;
+    childTokens: Record<string, string[]>;
+}
+/** Options accepted by Marked.use(). */
+export interface MarkedExtension extends Omit<MarkedOptions, "extensions"> {
+    extensions?: TokenizerAndRendererExtension[] | null;
+}
+/** Tokenizes the built-in inline Markdown surface. */
+export declare class Tokenizer {
+    options: MarkedOptions;
+    lexer: Lexer;
+    /** Creates a tokenizer with the supplied options. */
+    constructor(options?: MarkedOptions);
+    /** Tokenizes GFM deletion. */
+    del(src: string): Tokens.Del | undefined;
+}
+/** Stateful block and inline Markdown lexer. */
+export declare class Lexer {
+    tokens: TokensList;
+    options: MarkedOptions;
+    state: {
+        inLink: boolean;
+        inRawBlock: boolean;
+        top: boolean;
+    };
+    inlineQueue: Array<{
+        src: string;
+        tokens: Token[];
+    }>;
+    tokenizer: Tokenizer;
+    tokenizerOverrides: TokenizerObject;
+    extensions: ExtensionRegistry;
+    /** Creates a lexer. */
+    constructor(options?: MarkedOptions);
+    /** Exposes rule objects for callers that optimize regular expressions. */
+    static get rules(): {
+        block: {
+            normal: {
+                blockquote: RegExp;
+                code: RegExp;
+                def: RegExp;
+                fences: RegExp;
+                heading: RegExp;
+                hr: RegExp;
+                html: RegExp;
+                lheading: RegExp;
+                list: RegExp;
+                newline: RegExp;
+                paragraph: RegExp;
+                table: RegExp;
+                text: RegExp;
+            };
+            gfm: Record<string, RegExp>;
+            pedantic: Record<string, RegExp>;
+        };
+        inline: {
+            normal: {
+                _backpedal: RegExp;
+                anyPunctuation: RegExp;
+                autolink: RegExp;
+                blockSkip: RegExp;
+                br: RegExp;
+                code: RegExp;
+                del: RegExp;
+                delLDelim: RegExp;
+                delRDelim: RegExp;
+                emStrongLDelim: RegExp;
+                emStrongRDelimAst: RegExp;
+                emStrongRDelimUnd: RegExp;
+                escape: RegExp;
+                link: RegExp;
+                nolink: RegExp;
+                punctuation: RegExp;
+                reflink: RegExp;
+                reflinkSearch: RegExp;
+                tag: RegExp;
+                text: RegExp;
+                url: RegExp;
+            };
+            gfm: Record<string, RegExp>;
+            breaks: Record<string, RegExp>;
+            pedantic: Record<string, RegExp>;
+        };
+    };
+    /** Lexes a complete document. */
+    static lex(src: string, options?: MarkedOptions): TokensList;
+    /** Lexes inline Markdown. */
+    static lexInline(src: string, options?: MarkedOptions): Token[];
+    /** Lexes and resolves a complete document. */
+    lex(src: string): TokensList;
+    /** Appends block tokens to an output array. */
+    blockTokens(src: string, tokens?: Token[] | TokensList): Token[] | TokensList;
+    /** Queues inline tokenization compatibly with marked. */
+    inline(src: string, tokens?: Token[]): Token[];
+    /** Tokenizes inline Markdown immediately. */
+    inlineTokens(src: string, tokens?: Token[]): Token[];
+}
+/** Default HTML renderer. */
+export declare class Renderer {
+    options: MarkedOptions;
+    parser: Parser;
+    overrides: RendererObject;
+    /** Creates an HTML renderer. */
+    constructor(options?: MarkedOptions, overrides?: RendererObject);
+    /** Renders blank space. */ space(_token: Tokens.Space): string;
+    /** Renders a code block. */ code({ text, lang, escaped }: Tokens.Code): string;
+    /** Renders a block quote. */ blockquote({ tokens }: Tokens.Blockquote): string;
+    /** Passes raw HTML through. */ html({ text }: Tokens.HTML): string;
+    /** Renders a definition as no output. */ def(_token: Tokens.Def): string;
+    /** Renders a heading. */ heading({ tokens, depth }: Tokens.Heading): string;
+    /** Renders a horizontal rule. */ hr(_token: Tokens.Hr): string;
+    /** Renders a list. */ list(token: Tokens.List): string;
+    /** Renders a list item. */ listitem(item: Tokens.ListItem): string;
+    /** Renders a checkbox. */ checkbox({ checked }: Tokens.Checkbox): string;
+    /** Renders a paragraph. */ paragraph({ tokens }: Tokens.Paragraph): string;
+    /** Renders a table. */ table(token: Tokens.Table): string;
+    /** Renders a table row. */ tablerow(text: string): string;
+    /** Renders a table cell. */ tablecell(token: Tokens.TableCell): string;
+    /** Renders strong text. */ strong({ tokens }: Tokens.Strong): string;
+    /** Renders emphasized text. */ em({ tokens }: Tokens.Em): string;
+    /** Renders inline code. */ codespan({ text }: Tokens.Codespan): string;
+    /** Renders a line break. */ br(_token: Tokens.Br): string;
+    /** Renders deleted text. */ del({ tokens }: Tokens.Del): string;
+    /** Renders a link. */ link({ href, title, tokens }: Tokens.Link): string;
+    /** Renders an image. */ image({ href, title, text }: Tokens.Image): string;
+    /** Renders plain text. */ text({ text }: Tokens.Text | Tokens.Escape): string;
+}
+/** Converts token streams into HTML. */
+export declare class Parser {
+    options: MarkedOptions;
+    renderer: Renderer;
+    extensions: ExtensionRegistry;
+    /** Creates a parser. */
+    constructor(options?: MarkedOptions);
+    /** Parses block tokens. */ static parse(tokens: Token[], options?: MarkedOptions): string;
+    /** Parses inline tokens. */ static parseInline(tokens: Token[], options?: MarkedOptions): string;
+    /** Parses block tokens with the configured renderer. */
+    parse(tokens: Token[]): string;
+    /** Parses inline tokens with the configured renderer. */
+    parseInline(tokens: Token[]): string;
+    /** Renders a list item, including custom renderer overrides. */
+    renderListItem(item: Tokens.ListItem): string;
+    call<K extends keyof RendererTokenMap>(name: K, token: RendererTokenMap[K], fallback: () => string): string;
+}
+/** Configurable Markdown lexer and HTML parser. */
+export declare class Marked {
+    defaults: MarkedOptions;
+    /** Creates an isolated Marked instance. */
+    constructor(...extensions: MarkedExtension[]);
+    /** Merges default options. */ options(options: MarkedOptions): this;
+    /** Merges default options. */ setOptions(options: MarkedOptions): this;
+    /** Adds tokenizer, renderer, and walk-token extensions. */
+    use(...extensions: MarkedExtension[]): this;
+    /** Lexes Markdown into tokens. */ lexer(src: string, options?: MarkedOptions): TokensList;
+    /** Parses a token stream to HTML. */ parser(tokens: Token[], options?: MarkedOptions): string;
+    /** Walks a token tree depth first. */ walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => void | Promise<void>): Array<void | Promise<void>>;
+    /** Parses Markdown to HTML, synchronously unless async mode is requested. */
+    parse(src: string, options: MarkedOptions & {
+        async: true;
+    }): Promise<string>;
+    parse(src: string, options: MarkedOptions & {
+        async: false;
+    }): string;
+    parse(src: string, options?: MarkedOptions | null): string | Promise<string>;
+    /** Parses inline Markdown to HTML. */ parseInline(src: string, options?: MarkedOptions): string;
+}
+/** Parses Markdown with a shared default instance. */
+export declare function marked(src: string, options: MarkedOptions & {
+    async: true;
+}): Promise<string>;
+export declare function marked(src: string, options: MarkedOptions & {
+    async: false;
+}): string;
+export declare function marked(src: string, options?: MarkedOptions | null): string | Promise<string>;
+/** Parses Markdown with a shared default instance. */
+export declare const parse: typeof marked;
+/** Lexes Markdown with default options. */
+export declare const lexer: typeof Lexer.lex;
+/** Parses inline Markdown with default options. */
+export declare const parseInline: (src: string, options?: MarkedOptions) => string;
+/** Parses a token stream with default options. */
+export declare const parser: typeof Parser.parse;
+/** The default option object. */
+export declare const defaults: MarkedOptions;
+/** Returns a fresh copy of the default options. */
+export declare function getDefaults(): MarkedOptions;
+export {};

package/dist/types/marked.d.ts

@@ -0,0 +1,2 @@
+/** Behavior-compatible reimplementation of marked's used surface. */
+export * from "./marked/core.js";

package/dist/types/postmortem.d.ts

@@ -27,6 +27,14 @@ export declare enum Reason {
  * instances across bundles/realms.
  */
 export declare const NATIVE_PROCESS_EXIT: unique symbol;
+/** User-facing command printed before fatal cleanup so interrupted work can be resumed. */
+export interface FatalRecoveryHint {
+    /** Stable label identifying the recoverable session or process. */
+    label: string;
+    /** Complete shell command the user can execute to resume the interrupted work. */
+    command: string;
+}
+type FatalRecoveryHintProvider = () => FatalRecoveryHint | undefined;
 /** Origin of an EPIPE raised by a process communication channel. */
 export type BrokenPipeSource = "ipc-send" | "stdio-write";
 /**
@@ -64,6 +72,11 @@ export declare function isExpectedCleanupError(reason: unknown): boolean;
  * process down. A consuming interceptor owns reporting and keeps the process alive.
  */
 export declare function interceptUnhandledRejections(interceptor: (reason: unknown) => boolean): () => void;
+/**
+ * Register a synchronous recovery command to print when the process exits
+ * through an uncaught exception or unhandled rejection.
+ */
+export declare function registerFatalRecoveryHint(provider: FatalRecoveryHintProvider): () => void;
 /**
  * Register a process cleanup callback, to be run on shutdown, signal, or fatal error.
  *
@@ -88,3 +101,4 @@ export interface QuitOptions {
  * In workers: runs cleanup only (process.exit would kill entire process).
  */
 export declare function quit(code?: number, options?: QuitOptions): Promise<void>;
+export {};

package/dist/types/procmgr.d.ts

@@ -14,8 +14,24 @@ export interface ShellConfigOptions {
  * Check if a shell binary is executable.
  */
 export declare function isExecutable(path: string): boolean;
+/**
+ * Get shell args for the resolved shell.
+ * cmd.exe takes `/c`; PowerShell (powershell.exe / pwsh) takes
+ * `-NoLogo -Command`, with `-NoProfile` when PI_BASH_NO_LOGIN /
+ * CLAUDE_BASH_NO_LOGIN is set (profile scripts are PowerShell's login-shell
+ * analog); POSIX shells take `-c`, with `-l` unless the same env is set.
+ *
+ * Exported for tests; `env` overrides the process env gate.
+ */
+export declare function getShellArgs(shell: string, env?: Record<string, string | undefined>): string[];
 /** Whether the shell is Windows cmd.exe (spawn paths must use `/c`, not `-c`). */
 export declare function isCmdShell(shell: string): boolean;
+/**
+ * Whether the shell is Windows PowerShell or PowerShell Core (pwsh). Spawn
+ * paths must use `-Command`: passing the POSIX `-l -c` pair makes PowerShell
+ * parse `-l` as the command and fail with `The term '-l' is not recognized`.
+ */
+export declare function isPowerShell(shell: string): boolean;
 /**
  * Resolve a basic shell (bash or sh) as fallback.
  */

package/dist/types/prompt.d.ts

@@ -1,5 +1,5 @@
-import type { HelperDelegate, HelperOptions, Template, TemplateDelegate } from "handlebars";
-export type { HelperDelegate, HelperOptions, Template, TemplateDelegate };
+import type { HelperDelegate, Template } from "./template.js";
+export type { HelperDelegate, HelperOptions, Template, TemplateDelegate } from "./template.js";
 export type PromptRenderPhase = "pre-render" | "post-render";
 export interface PromptFormatOptions {
     renderPhase?: PromptRenderPhase;

package/dist/types/readability/readability.d.ts

@@ -0,0 +1,9 @@
+/** Behavior-compatible reimplementation of @mozilla/readability's used surface. */
+import type { ReadabilityArticle, ReadabilityDocument, ReadabilityOptions } from "./types.js";
+/** Extracts the article body and metadata from a standards-shaped document. */
+export declare class Readability<T = string> {
+    #private;
+    constructor(document: ReadabilityDocument, options?: ReadabilityOptions<T>);
+    /** Runs extraction once; the supplied document is consumed and should not be reused. */
+    parse(): ReadabilityArticle<T> | null;
+}

package/dist/types/readability/readerable.d.ts

@@ -0,0 +1,10 @@
+/** Behavior-compatible reimplementation of @mozilla/readability's used surface. */
+import type { ReadabilityDocument, ReadabilityNode } from "./types.js";
+/** Options for the inexpensive readerability estimate. */
+export interface ReaderableOptions {
+    minContentLength?: number;
+    minScore?: number;
+    visibilityChecker?: (node: ReadabilityNode) => boolean;
+}
+/** Estimates whether a document contains enough prose for article extraction. */
+export declare function isProbablyReaderable(document: ReadabilityDocument, options?: ReaderableOptions | ((node: ReadabilityNode) => boolean)): boolean;

package/dist/types/readability/types.d.ts

@@ -0,0 +1,70 @@
+/** Behavior-compatible reimplementation of @mozilla/readability's used surface. */
+/** Minimal standards-shaped DOM node accepted by the readability extractor. */
+export interface ReadabilityNode {
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly tagName?: string;
+    readonly ownerDocument?: ReadabilityDocument | null;
+    parentNode: ReadabilityNode | null;
+    readonly children?: ArrayLike<ReadabilityElement>;
+    readonly childNodes: ArrayLike<ReadabilityNode>;
+    readonly firstChild: ReadabilityNode | null;
+    readonly textContent: string | null;
+    appendChild(node: ReadabilityNode): ReadabilityNode;
+    cloneNode(deep?: boolean): ReadabilityNode;
+    remove(): void;
+}
+/** Minimal standards-shaped DOM element accepted by the readability extractor. */
+export interface ReadabilityElement extends ReadabilityNode {
+    readonly children: ArrayLike<ReadabilityElement>;
+    readonly tagName: string;
+    id: string;
+    className: string;
+    innerHTML: string;
+    readonly attributes: ArrayLike<{
+        readonly name: string;
+        readonly value: string;
+    }>;
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+    getElementsByTagName(name: string): ArrayLike<ReadabilityElement>;
+    querySelector(selector: string): ReadabilityElement | null;
+    querySelectorAll(selector: string): ArrayLike<ReadabilityElement>;
+}
+/** Minimal standards-shaped document accepted by the readability extractor. */
+export interface ReadabilityDocument extends ReadabilityNode {
+    title: string;
+    readonly body: ReadabilityElement | null;
+    readonly documentElement: ReadabilityElement | null;
+    createElement(name: string): ReadabilityElement;
+    getElementsByTagName(name: string): ArrayLike<ReadabilityElement>;
+    querySelector(selector: string): ReadabilityElement | null;
+    querySelectorAll(selector: string): ArrayLike<ReadabilityElement>;
+}
+/** Configuration for article extraction. */
+export interface ReadabilityOptions<T = string> {
+    debug?: boolean;
+    maxElemsToParse?: number;
+    nbTopCandidates?: number;
+    charThreshold?: number;
+    classesToPreserve?: string[];
+    keepClasses?: boolean;
+    serializer?: (node: ReadabilityNode) => T;
+    disableJSONLD?: boolean;
+    allowedVideoRegex?: RegExp;
+}
+/** Extracted article and metadata. */
+export interface ReadabilityArticle<T = string> {
+    title: string | null | undefined;
+    content: T | null | undefined;
+    textContent: string | null | undefined;
+    length: number | null | undefined;
+    excerpt: string | null | undefined;
+    byline: string | null | undefined;
+    dir: string | null | undefined;
+    siteName: string | null | undefined;
+    lang: string | null | undefined;
+    publishedTime: string | null | undefined;
+}

package/dist/types/readability.d.ts

@@ -0,0 +1,4 @@
+/** Behavior-compatible reimplementation of @mozilla/readability's used surface. */
+export { Readability } from "./readability/readability.js";
+export { isProbablyReaderable, type ReaderableOptions } from "./readability/readerable.js";
+export type { ReadabilityArticle, ReadabilityDocument, ReadabilityElement, ReadabilityNode, ReadabilityOptions, } from "./readability/types.js";

package/dist/types/template.d.ts

@@ -0,0 +1,62 @@
+/** Behavior-compatible reimplementation of handlebars' used surface. */
+/** Values accepted as registered partial templates. */
+export type Template = string | TemplateDelegate;
+/** A compiled template function. */
+export type TemplateDelegate<T = unknown> = (context?: T, options?: RuntimeOptions) => string;
+/** Runtime options accepted by compiled templates. */
+export interface RuntimeOptions {
+    data?: Record<string, unknown>;
+    helpers?: Record<string, HelperDelegate>;
+    partials?: Record<string, Template>;
+}
+/** Options passed as the final argument to helpers. */
+export interface HelperOptions {
+    name: string;
+    hash: Record<string, unknown>;
+    data: Record<string, unknown>;
+    fn: (context?: unknown, options?: {
+        data?: Record<string, unknown>;
+    }) => string;
+    inverse: (context?: unknown, options?: {
+        data?: Record<string, unknown>;
+    }) => string;
+    lookupProperty: (parent: unknown, propertyName: string) => unknown;
+}
+/** A template helper function. */
+export type HelperDelegate = {
+    bivarianceHack(this: unknown, ...args: unknown[]): unknown;
+}["bivarianceHack"];
+/** Template compilation behavior. */
+export interface CompileOptions {
+    noEscape?: boolean;
+    strict?: boolean;
+}
+/** A string that bypasses HTML escaping when interpolated. */
+export declare class SafeString {
+    #private;
+    constructor(value: unknown);
+    /** Return the unescaped string value. */
+    toString(): string;
+    /** Return the unescaped primitive value. */
+    toHTML(): string;
+}
+/** Escape a value with Handlebars' HTML entity set. */
+export declare function escapeExpression(value: unknown): string;
+/** Register a helper for subsequently compiled templates. */
+export declare function registerHelper(name: string, helper: HelperDelegate): void;
+/** Register a partial for subsequently rendered templates. */
+export declare function registerPartial(name: string, partial: Template): void;
+/** Compile a template into a reusable rendering function. */
+export declare function compile<T = unknown>(source: string, options?: CompileOptions): TemplateDelegate<T>;
+/** Create an isolated template engine with its own helper and partial registries. */
+export declare function create(): TemplateEngine;
+/** Isolated template compiler and registry. */
+export declare class TemplateEngine {
+    #private;
+    /** Register a helper in this engine. */
+    registerHelper(name: string, helper: HelperDelegate): void;
+    /** Register a partial in this engine. */
+    registerPartial(name: string, partial: Template): void;
+    /** Compile a template using this engine's registries. */
+    compile<T = unknown>(source: string, options?: CompileOptions): TemplateDelegate<T>;
+}