@small-web/kitten-types 1.1.5 → 2.0.0

package/kitten/src/lib/KittenPage.d.ts

@@ -0,0 +1,202 @@
+/**
+  Represents a currently active live page. Live pages are open in the client
+  and either in the process of being served for the first time, connecting via
+  WebSocket, or connected via WebSocket.
+
+  All live pages belong to a session.
+
+  Usage:
+
+  When authoring, you can export your page route as a subclass of KittenPage using the global reference to it at `kitten.Page`.
+
+  Helpers:
+
+  page.send(): Sends message to connected page (calls page.socket.send()).
+  page.everyoneElse.send(): Sends message to everyone connected to this page but the current person.
+  page.everyone.send(): Send message to everyone connected to this page, including the current person.
+
+  @example
+
+  See the KittenComponent class for an example of usage.
+*/
+import type { JavaScriptFunction } from './KittenComponent.ts';
+export type KittenPageEvent = {
+    page: KittenPage;
+    name: string;
+    handler: string;
+    id: string;
+    target: string;
+    data: {
+        [s: string]: any;
+    };
+    headers: any;
+    event: any;
+};
+type WebSocketWithIsAlive = import('ws').WebSocket & {
+    isAlive: boolean;
+    id?: string;
+};
+type KittenRequest = import('../types/index.ts').KittenRequest & {
+    ws?: Function;
+};
+type KittenResponse = import('../types/index.ts').KittenResponse;
+type SwapTarget = {
+    before?: string;
+} | {
+    after?: string;
+} | {
+    asFirstChildOf?: string;
+} | {
+    asLastChildOf?: string;
+};
+type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | ReadonlyArray<any> | ReadonlyArray<number> | {
+    valueOf(): ArrayBuffer;
+} | {
+    valueOf(): SharedArrayBuffer;
+} | {
+    valueOf(): Uint8Array;
+} | {
+    valueOf(): ReadonlyArray<number>;
+} | {
+    valueOf(): string;
+} | {
+    [Symbol.toPrimitive](hint: string): string;
+};
+import KittenComponent from './KittenComponent.ts';
+import { type Session } from '../Sessions.ts';
+/**
+  Transform event name into event handler name.
+*/
+export declare function eventNameToEventHandlerName(eventName: string): string;
+/**
+  Converts any key paths found in the keys of
+  passed data into an actual object structure.
+
+  This enables you to specify object structure in
+  the names of your connected elements and makes it
+  easier to persist them on the server.
+*/
+export declare function convertKeypathsToObjects(data: {
+    [s: string]: any;
+}): {
+    [s: string]: any;
+};
+/**
+  Add message envelope used when inserting elements into the
+  DOM relative to another element using htmx’s out-of-band swaps
+  (oob-swaps).
+
+  If a swap target is not provided, the message is returned unchanged.
+*/
+export declare function addMessageEnvelopeIfNecessary(message: any, swapTarget: SwapTarget): any;
+export default class KittenPage extends KittenComponent {
+    _isPage: boolean;
+    session: Session | undefined;
+    _request: KittenRequest | undefined;
+    _response: KittenResponse | undefined;
+    _isAuthoredPage: boolean;
+    _socket: WebSocketWithIsAlive | undefined;
+    _sockets: Array<WebSocketWithIsAlive> | undefined;
+    timeout: ReturnType<typeof setTimeout> | undefined;
+    socketMessageHandler: ((event: any) => void) | undefined;
+    everyone: MessageSender;
+    everyoneElse: MessageSender;
+    /**
+      Every page has a unique ID (inherited from KittenComponent) and can hold
+      ephemeral page-level data. e.g., the states of components when
+      using the Streaming HTML workfow. (Page storage is ephemeral is that
+      it only lasts for the lifetime of a page in the browser and is destroyed
+      when the page is closed or reloaded.)
+  
+      If you need greater persistence, use session storage (request.session) or
+      the built-in JSDB database (kitten.db).
+  
+      A page is an authored page if the author of the Kitten app/site wrote
+      and exported a KittenPage subclass in the route (as opposed to exporting a
+      simple function and function-based event handlers that then resulted
+      in a generic page being created by Kitten’s PageRoute class). Keeping
+      track of this is an optimisation that enabled the PageSocketRoute to
+      not have to import the source file again if the page was authored
+      as a page instance and thus already contains its event handlers (as
+      opposed to the event handlers being exported as separate functions that
+      have be read in and mixed into the generic KittenPage instance by the PageSocketRoute).
+    */
+    constructor();
+    get request(): KittenRequest | undefined;
+    set request(request: KittenRequest | undefined);
+    get response(): import("../types/types.js").KittenResponse | undefined;
+    set response(response: import("../types/types.js").KittenResponse | undefined);
+    /**
+      The page has connected to its WebSocket. The list of sockets and the
+      specific socket for this page are passed for storage on the page and the
+      list of event handlers imported from the page (when using function-based
+      page routes), if any, to be mixed into this instance as methods.
+  
+    */
+    connect(socket: WebSocketWithIsAlive, sockets: WebSocketWithIsAlive[], eventHandlers?: {
+        [s: string]: JavaScriptFunction;
+    }): void;
+    /**
+      Remove the socket event listener on disconnect.
+    */
+    _onDisconnect(): void;
+    /**
+      Dynamically add specified event handler for specified event name.
+  
+      TODO: Is this still required with the new component model?
+      If we find that it doesn’t fit any use cases, we should remove this.
+  
+      @deprecated Instead of `on(eventName, handler)`, export `onEventName()` from your page (or add `onEventName()` method to your `kitten.Page` subclass if using class-based page routes.)
+    */
+    on(eventName: string, eventHandler: JavaScriptFunction): this;
+    /**
+      Send specified message to just this page’s socket,
+      awaiting promise if message is a promise (which can happen if
+      this.component is accessed in a kitten.html tagged template string).
+  
+      You can specify an optional swap target that intelligently
+      wraps what you’re sending with the necessary envelope tag.
+      This is normally rather confusing with htmx’s oob swaps,
+      especially when inserting table rows. See:
+      https://htmx.org/attributes/hx-swap-oob/#using-alternate-swap-strategies
+    */
+    send(message: BufferLike | Promise<BufferLike>, swapTarget?: SwapTarget): void;
+    /**
+      Sends message. Expects it not to be a promise.
+    */
+    sendImmediately(message: BufferLike, swapTarget: SwapTarget): void;
+    /**
+      The convention for page sockets is to map the name of the DOM element
+      that triggered the HTMX request to the name of the event handler so
+      that <element connect name='eventName' /> maps to onEventName() on
+      the page.
+    */
+    _messageHandler(event: {
+        data: any;
+    }): Promise<void>;
+}
+/**
+  Provides a namespaced send() method for use in Page instances.
+*/
+export declare class MessageSender {
+    socket: WebSocketWithIsAlive;
+    sockets: WebSocketWithIsAlive[];
+    includeSelf: boolean;
+    constructor({ socket, sockets, includeSelf }: {
+        socket: WebSocketWithIsAlive;
+        sockets: WebSocketWithIsAlive[];
+        includeSelf: boolean;
+    });
+    /**
+      Sends message either to all connections or to all connections
+      excluding the current one.
+  
+      You can specify an optional swap target that intelligently
+      wraps what you’re sending with the necessary envelope tag.
+      This is normally rather confusing with htmx’s oob swaps,
+      especially when inserting table rows. See:
+      https://htmx.org/attributes/hx-swap-oob/#using-alternate-swap-strategies
+    */
+    send(message: BufferLike, swapTarget?: SwapTarget): number;
+}
+export {};

package/kitten/src/lib/Version.d.ts

@@ -0,0 +1,49 @@
+/**
+  Deserialises version information from the version.json
+  file created by the Kitten build process.
+
+  Singleton.
+*/
+export default class Version {
+    static instance: Version;
+    versionStamp: number;
+    gitHash: string;
+    apiVersion: number;
+    nodeVersion: string;
+    exactVersion: string;
+    _date: Date | undefined;
+    year: number | undefined;
+    month: number | undefined;
+    day: number | undefined;
+    paddedMonth: string | undefined;
+    paddedDay: string | undefined;
+    hour: number | undefined;
+    minute: number | undefined;
+    second: number | undefined;
+    paddedHour: string | undefined;
+    paddedMinute: string | undefined;
+    paddedSecond: string | undefined;
+    formattedDate: string | undefined;
+    formattedTime: string | undefined;
+    static getInstance(): Version;
+    constructor();
+    set date(date: Date);
+    get date(): Date;
+    birthday(): string;
+    /**
+      Get star sign based on passed month and day.
+  
+      Based on https://gist.github.com/vyach-vasiliev/175758c7633fda9587f9dabf850507c0
+      @returns {string} Star sign.
+    */
+    get starSign(): string;
+    get Component(): () => string | string[] | Promise<string | string[]>;
+    /**
+      HTML component to display version information.
+    */
+    html(): string | string[] | Promise<string | string[]>;
+    /**
+      Output version information to the console.
+    */
+    printToConsole(): void;
+}

package/kitten/src/lib/ansi-highlight-html.d.ts

@@ -0,0 +1,5 @@
+/**
+  Highlight a string of HTML. Pair with an indenter (e.g. htmlfy)
+  upstream; this only colours, it doesn't reformat.
+*/
+export declare function ansiHighlightHtml(html: string): string;

package/kitten/src/lib/components/stateful/CopyButton.component.d.ts

@@ -0,0 +1,14 @@
+/**
+  CopyButton: stateful
+*/
+import KittenComponent from '../../KittenComponent.ts';
+import { type CopyButtonProps } from '../stateless/copyButton.component.ts';
+export default class CopyButton extends KittenComponent {
+    html(props: CopyButtonProps): string | string[] | Promise<string | string[]>;
+    onCopy(data: {
+        value: unknown;
+    }): void;
+    onCopyFail(data: {
+        value: unknown;
+    }): void;
+}

package/kitten/src/lib/components/stateless/copyButton.component.d.ts

@@ -0,0 +1,21 @@
+/**
+  Copy button component: stateless.
+
+  The stateful component wraps this.
+*/
+export type CopyButtonProps = {
+    value: unknown;
+    SLOT?: unknown;
+    success?: string;
+    failure?: string;
+};
+/**
+  Button that copies the passed data to the clipboard on the client when clicked.
+
+  @param value - The value to copy.
+  @param SLOT - The contents of the button.
+  @param success - Name of event to be raised on successful copy. (default='copy'; maps to `onCopy()` method on nearest KittenComponent or KittenPage).
+  @param failure - Name of event to be raised on failed copy. (default='copyFail'; maps to `onCopyFail()` method on nearest KittenComponent or KittenPage).
+
+*/
+export default function copyButton({ value, SLOT, success, failure, ...props }: CopyButtonProps): string | string[] | Promise<string | string[]>;

package/kitten/src/lib/crypto.d.ts

@@ -0,0 +1,95 @@
+/**
+  Kitten Crypto API
+
+  Runs in browsers (packaged via esbuild) and in Node.
+
+  Exposes high-level cryptographic functions to enable generation
+  of secret key material as well as Diffie-Hellman key exchange (shared secrets)
+  and signing and encryption for the Small Web Protocol.
+
+  When used in browsers, does so in the person’s own browser without ever
+  hitting the server and, from there, generates the ed25519, ssh, and pgp
+  public keys that are sent to the server for storage and discovery.
+
+  ⚠️ Node-native subgraph: this module is loaded natively by Node.js via
+  type stripping. Only use erasable TypeScript syntax here. Additionally,
+  this module is bundled for the browser (see ./build), so it must remain
+  platform-neutral: no Node-only imports or types in its surface.
+
+  Copyright © 2022-present, Aral Balkan
+  Small Technology Foundation.
+  Released under GNU AGPLv3.
+*/
+import { secretToEmojiString, emojiStringToSecret } from './KittenMoji.ts';
+import { getSharedSecret, sign, verify } from '@noble/ed25519';
+import { encrypt, decrypt } from 'micro-aes-gcm';
+import { randomBytes } from 'ed25519-keygen/utils';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+export { secretToEmojiString, emojiStringToSecret, getSharedSecret, encrypt, decrypt, sign, verify, randomBytes, bytesToHex, hexToBytes };
+/**
+  Generates cryptographically random 32-byte token and coverts it to hexadecimal representation.
+
+  Use anywhere you need a secret token (domain token, webhook secret, etc.)
+*/
+export declare function random32ByteTokenInHex(): string;
+/**
+  Calculates the shared secret for a domain using the
+  domain’s public key and our private key.
+
+  @param domain
+  @param ourPrivateKey The emoji-encoded private key.
+*/
+export declare function sharedSecretForDomain(domain: string, ourPrivateKey: string): Promise<Uint8Array<ArrayBufferLike>>;
+/**
+  Encrypts a message for a domain.
+
+  @param message
+  @param ourPrivateKey The emoji-encoded private key.
+  @param domain
+
+  @returns Hex-encoded encrypted message.
+*/
+export declare function encryptMessageForDomain(message: string, ourPrivateKey: string, domain: string): Promise<string>;
+/**
+  Decrypts message from domain.
+
+  @param encryptedMessage Hex-encoded encrypted message.
+  @param ourPrivateKey Emoji-encoded private key string.
+  @param domain
+
+  @returns Unencrypted message as UTF8 string.
+*/
+export declare function decryptMessageFromDomain(encryptedMessage: string, ourPrivateKey: string, domain: string): Promise<string>;
+/**
+  The public and private key material for a domain.
+*/
+export type DomainKeys = {
+    private: {
+        ssh: {
+            asString: string;
+        };
+        ed25519?: {
+            asBytes: Uint8Array;
+            asString: string;
+        };
+    };
+    public: {
+        ed25519: {
+            asString: string;
+            asBytes: Uint8Array;
+        };
+        ssh: {
+            asString: string;
+            asBytes: Uint8Array;
+            fingerprint: string;
+        };
+    };
+};
+/**
+  Creates keys for domain.
+*/
+export declare function createKeys(domain: string): Promise<DomainKeys>;
+/**
+  Derive keys from secret key for domain.
+*/
+export declare function deriveKeysFromSecretKeyForDomain(secretKey: Uint8Array, domain: string): Promise<DomainKeys>;

package/kitten/src/lib/deploy.d.ts

@@ -0,0 +1,20 @@
+/**
+  Deploys an app from a Git repository as a
+  systemd --user service.
+
+  Copyright ⓒ 2021-present, Aral Balkan
+  Small Technology Foundation
+
+  License: AGPL version 3.0.
+*/
+import type { DeploymentOptions } from '../cli/index.ts';
+type DeployOptions = DeploymentOptions & {
+    progress?: (message: string) => void;
+    context?: 'cli' | 'web';
+    'is-being-deployed-by-domain'?: boolean;
+};
+/**
+  @param gitHttpsCloneUrl git clone url (HTTPS)
+*/
+export default function deploy(gitHttpsCloneUrl: string, options: DeployOptions): Promise<void>;
+export {};

package/kitten/src/lib/ensure.d.ts

@@ -0,0 +1,28 @@
+/**
+  Kitten critical assertions.
+
+  Copyright ⓒ 2022-present, Aral Balkan (https://ar.al)
+  Small Technology Foundation (https://small-tech.org).
+
+  License: AGPL version 3.0.
+*/
+declare const functions: {
+    commandExists: typeof commandExists;
+    systemctl: typeof systemctl;
+    journalctl: typeof journalctl;
+    serviceNotActive: typeof serviceNotActive;
+    portsAreFree: typeof portsAreFree;
+    canEnableService: typeof canEnableService;
+};
+export default functions;
+/**
+  Does the command with the passed name exist?
+
+  @param {string} command
+*/
+export declare function commandExists(command: string): boolean;
+export declare function systemctl(): void;
+export declare function journalctl(): void;
+export declare function portsAreFree(): Promise<void>;
+export declare function canEnableService(): Promise<void>;
+export declare function serviceNotActive(): void;

package/kitten/src/lib/fragments.d.ts

@@ -0,0 +1 @@
+export declare const developmentTimeHotReloadScript = "\n    <script>\n      // Kitten development time hot reload script.\n      let __kittenDevelopmentSocket\n      let __kittenDevelopmentSocketReconnectionAttemptTimeoutId = null\n\n      // The server sends a boot id (unique per server process start) on connect.\n      // We remember the first one we see and reload only when a reconnect reports\n      // a different id (i.e. after the server process restarts).\n      let __kittenServerBootId = null\n\n      function __kittenConnectToDevelopmentSocket () {\n        console.info('Attempting to connect to Kitten development socket.')\n        __kittenDevelopmentSocket = new WebSocket(`wss://${location.host}/\uD83D\uDC31/development-socket/`)\n\n        const socketOpenHandler = () => {\n          clearTimeout(__kittenDevelopmentSocketReconnectionAttemptTimeoutId)\n          console.info('\uD83D\uDC31 Kitten: connected to development-time hot reload socket.')\n        }\n\n        const socketMessageHandler = (event) => {\n          let message\n          try {\n            message = JSON.parse(event.data)\n          } catch {\n            return\n          }\n          if (message && message.type === 'kitten-development-boot-id') {\n            if (__kittenServerBootId === null) {\n              // First connection: remember the server\u2019s boot id.\n              __kittenServerBootId = message.bootId\n            } else if (message.bootId !== __kittenServerBootId) {\n              // The server process has restarted (new boot id). Reload the page.\n              window.location.reload()\n            }\n          }\n        }\n\n        const socketCloseHandler = () => {\n          clearTimeout(__kittenDevelopmentSocketReconnectionAttemptTimeoutId)\n          __kittenDevelopmentSocketReconnectionAttemptTimeoutId = setTimeout(__kittenConnectToDevelopmentSocket, 50)\n        }\n\n        __kittenDevelopmentSocket.addEventListener('open', socketOpenHandler)\n        __kittenDevelopmentSocket.addEventListener('message', socketMessageHandler)\n        __kittenDevelopmentSocket.addEventListener('close', socketCloseHandler)\n\n        // This is mainly a fix for Firefox, which is the only browser that results in\n        // the closing of the WebSocket connection at the start of an HTTP load request\n        // (e.g., form POST) and subsequent reconnection, thereby firing of a premature\n        // GET request to the server.\n        // See: https://mastodon.ar.al/@aral/109104595295584049\n        window.addEventListener('beforeunload', () => {\n          clearTimeout(__kittenDevelopmentSocketReconnectionAttemptTimeoutId)\n          __kittenDevelopmentSocket.removeEventListener('open', socketOpenHandler)\n          __kittenDevelopmentSocket.removeEventListener('message', socketMessageHandler)\n          __kittenDevelopmentSocket.removeEventListener('close', socketCloseHandler)\n          __kittenDevelopmentSocket.close()\n        }) \n      }\n\n      // In case the developer is using htmx to update the body of the page,\n      // make sure the development script runs only once.\n      if (!globalThis.kittenDevelopmentTimeHotReloadScriptAlreadyInitialised) {\n        globalThis.kittenDevelopmentTimeHotReloadScriptAlreadyInitialised = true\n        __kittenConnectToDevelopmentSocket()\n      }\n    </script>\n  ";

package/kitten/src/lib/globals.d.ts

@@ -0,0 +1,10 @@
+/**
+  Creates and populates the Kitten global namespace (kitten).
+*/
+export default class Globals {
+    static initialised: boolean;
+    /**
+      Initialise Kitten globals (unique for each domain/port/project directory combination).
+    */
+    static initialise(domain: string, port: number): void;
+}

package/kitten/src/lib/html.d.ts

@@ -0,0 +1,61 @@
+/**
+  Tagged template HTML rendering.
+
+  This is a combination of xhtm (https://github.com/dy/xhtm) by Dmitry Ivanov
+  and vhtml (https://github.com/developit/vhtml) by Jason Miller.
+
+  I (Aral) was initially mantaining separate forks of them but parsing
+  tagged templates into hyperscript and rendering them into HTML is fiddly
+  enough to get your head around without having two modules interacting with
+  each other in the way these two did.
+
+  Given how fundamental rendering templates to HTML is to Kitten, I’m
+  inlining them here with an eye towards removing redudancy and hopefully
+  simplifying the interaction between the two in the future (as I don’t need
+  the flexibility of having them work independently) and being able to
+  iterate faster on authoring features that are impacted by the renderer.
+
+  Original vhtml code is Copyright © 2015-present Jason Miller (MIT license).
+  Original xhtm code is Copyright © 2019-present Dmitry Ivanov (MIT license).
+
+  Any modifications are Copyright © 2023-present Aral Balkan
+  and released under AGPL version 3.0 as is the rest of Kitten.
+
+  ⚠️ Node-native subgraph: this module (and everything it imports) is loaded
+  natively by Node.js via type stripping (imported by the loader). Only use
+  erasable TypeScript syntax here.
+*/
+export { h as hyperscriptToHtmlString };
+/**
+   Render any Markdown areas there might be and
+   return an updated list of values (as their order
+   might have changed during rendering).
+
+*/
+export declare function renderMarkdown(strings: TemplateStringsArray | string[], values: any[]): {
+    finalStrings: string[] | TemplateStringsArray;
+    finalValues: any[];
+};
+/**
+  Kitten HTML tagged template.
+
+  Supports both synchronous and asynchronous use.
+
+*/
+export declare function html(strings: TemplateStringsArray, ...values: any[]): string | string[] | Promise<string | string[]>;
+/**
+  HyperScript (HyperText with JavaScript)
+  reviver that constructs sanitised HTML string.
+  (Generator; so we can use it with both synchronous
+  and asynchronous components.)
+
+  The original approach dates back to the HyperScript
+  project by Dominic Tarr:
+
+  https://github.com/hyperhype/hyperscript
+
+*/
+declare function h(name: any, attrs: any, ...children: any[]): Generator<any, any, any>;
+declare namespace h {
+    var token: string;
+}

package/kitten/src/lib/markdown.d.ts

@@ -0,0 +1,16 @@
+/**
+  Kitten’s Markdown support, based on MarkdownIt and its plugins.
+
+  This library is used by both the ES Module Loader and main process.
+
+  ⚠️ Node-native subgraph: this module is loaded natively by Node.js via
+  type stripping. Only use erasable TypeScript syntax here.
+
+  Copyright ⓒ 2024-present, Aral Balkan, Small Technology Foundation.
+  Released under the AGPL 3.0 license.
+*/
+import MarkdownIt from 'markdown-it';
+import slugify from '@sindresorhus/slugify';
+declare const markdownIt: MarkdownIt;
+export default markdownIt;
+export { slugify };

package/kitten/src/lib/paths.d.ts

@@ -0,0 +1,25 @@
+declare const paths: {
+    BINARY_HOME: string;
+    KITTEN_BINARY_PATH: string;
+    DATA_HOME: string;
+    SMALL_TECH_DATA_HOME: string;
+    KITTEN_DATA_HOME: string;
+    KITTEN_APP_DIRECTORY_PATH: string;
+    KITTEN_WEB_APP_DIRECTORY_PATH: string;
+    KITTEN_TLS_DIRECTORY: string;
+    KITTEN_TLS_LOCAL_CERTIFICATE_DIRECTORY: string;
+    KITTEN_TLS_GLOBAL_CERTIFICATE_DIRECTORY: string;
+    KITTEN_TEMP_DIRECTORY: string;
+    KITTEN_TEMP_RUNTIME_ARCHIVE_PATH: string;
+    KITTEN_SAME_DEVICE_TEMP_DIRECTORY: string;
+    KITTEN_RUNTIME_DIRECTORY: string;
+    KITTEN_RUNTIME_BIN_DIRECTORY: string;
+    KITTEN_DATA_DIRECTORY: string;
+    KITTEN_GLOBAL_INTERNAL_DATABASE_DIRECTORY: string;
+    KITTEN_DEPLOYMENTS_DIRECTORY: string;
+    KITTEN_CLONES_DIRECTORY: string;
+    CONFIG_HOME: string;
+    SYSTEMD_USER_DIRECTORY: string;
+    KITTEN_SYSTEMD_UNIT_PATH: string;
+};
+export default paths;

package/kitten/src/lib/service-status.d.ts

@@ -0,0 +1,14 @@
+/**
+  Function: serviceStatus (synchronous)
+
+  Returns the Kitten server daemon status.
+
+  Proxies: systemctl status --user kitten
+
+  TODO: This module has not been updated for Kitten yet (copied over from Site.js).
+*/
+export default function serviceStatus(): {
+    isActive: boolean;
+    isEnabled: boolean;
+    daemonDetails: {} | null;
+};

package/kitten/src/lib/system-exit-codes.d.ts

@@ -0,0 +1,39 @@
+/**
+  Exit status codes for system programs that attempts to conform to the nearest
+  thing I could find to a standard which is used in C/C++, via sysexists.h.
+  (See: https:tldp.org/LDP/abs/html/exitcodes.html)
+
+  Any additions to this will be documented here:
+
+   - 99: Restart request.
+
+  Original sysexists.h, where some portions of the comments in this file are
+  from, is copyright © 1987, 1993 The Regents of the University of California.
+  All rights reserved. And released under the 3-Clause BSD License.
+
+  Copyright ⓒ 2022-present, Aral Balkan
+  Small Technology Foundation
+
+  License: AGPL version 3.0.
+*/
+declare const _default: {
+    ok: number;
+    generalError: number;
+    cliSyntaxError: number;
+    dataError: number;
+    fileNotFound: number;
+    accountNotFound: number;
+    hostNotFound: number;
+    unavailable: number;
+    internalSoftwareError: number;
+    systemError: number;
+    criticalSystemFileMissing: number;
+    cannotCreateOutputFile: number;
+    inputOutputError: number;
+    temporaryFailure: number;
+    protocolError: number;
+    permissionDenied: number;
+    configurationError: number;
+    restartRequest: number;
+};
+export default _default;

package/kitten/src/lib/terminal-link.d.ts

@@ -0,0 +1,24 @@
+/**
+  Uses OSC 8 (https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda)
+  to create clickable hyperlinks with custom text in terminal.
+
+  Additionally, styles them with a dotted underline manually as some terminals
+  don’t do this (yet, at least).
+
+  e.g., See https://github.com/wez/wezterm/issues/4077#issuecomment-2324401900
+
+  Terminal support for this feature appears to be good:
+  https://github.com/Alhadis/OSC8-Adoption
+
+  Based on:
+  https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda?permalink_comment_id=5098507#gistcomment-5098507
+
+  For sequence code documentation, please see
+  https://gist.github.com/ConnerWill/d4b6c776b509add763e17f9f113fd25b#sequences
+*/
+/**
+  @param {string} text
+  @param {string} url
+*/
+export declare const link: (text: string, url: string) => string;
+export default link;

package/kitten/src/middleware/authentication.d.ts

@@ -0,0 +1,8 @@
+/**
+  Authentication middleware.
+
+  Any route can require authentication if it contains the lock emoji in its name.
+*/
+import type { NextHandler } from 'polka';
+import type { KittenRequest, KittenResponse, KittenPolka } from '../types/index.ts';
+export default function (app: KittenPolka): (request: KittenRequest, response: KittenResponse, next: NextHandler) => Promise<void>;

package/kitten/src/middleware/index.d.ts

@@ -0,0 +1,5 @@
+import type { KittenPolka } from '../types/index.ts';
+/**
+  Adds all Kitten middleware to the Kitten Server’s Polka app.
+*/
+export default function addAllMiddlewareToApp(app: KittenPolka): void;

package/kitten/src/middleware/request-and-response-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { NextHandler } from 'polka';
+import type { KittenRequest, KittenResponse } from '../types/index.ts';
+/**
+  Adds helpers to request and response objects.
+*/
+export default function (): (request: KittenRequest, response: KittenResponse, next: NextHandler) => void;