creo 0.0.3-dev → 0.1.0

package/dist/public/primitives/primitives.d.ts

@@ -0,0 +1,318 @@
+import { type EventHandlerProps } from "../primitive";
+import { type PublicView } from "../view";
+export type BaseEventData = {
+    stopPropagation: () => void;
+    preventDefault: () => void;
+};
+export type PointerEventData = BaseEventData & {
+    x: number;
+    y: number;
+};
+export type KeyEventData = BaseEventData & {
+    key: string;
+    code: string;
+};
+export type InputEventData = BaseEventData & {
+    value: string;
+};
+export type FocusEventData = BaseEventData;
+export type ContainerEvents = {
+    click: (e: PointerEventData) => void;
+    dblclick: (e: PointerEventData) => void;
+    pointerDown: (e: PointerEventData) => void;
+    pointerUp: (e: PointerEventData) => void;
+    pointerMove: (e: PointerEventData) => void;
+    keyDown: (e: KeyEventData) => void;
+    keyUp: (e: KeyEventData) => void;
+    focus: (e: FocusEventData) => void;
+    blur: (e: FocusEventData) => void;
+};
+export type FormEvents = ContainerEvents & {
+    input: (e: InputEventData) => void;
+    change: (e: InputEventData) => void;
+    keyDown: (e: KeyEventData) => void;
+    keyUp: (e: KeyEventData) => void;
+};
+export type HtmlAttrs = {
+    class?: string;
+    id?: string;
+    style?: string;
+    title?: string;
+    tabindex?: number;
+    hidden?: boolean;
+    role?: string;
+    draggable?: boolean;
+    [attr: string]: unknown;
+};
+export declare function html<Attrs extends HtmlAttrs = HtmlAttrs, Events = ContainerEvents>(tag: string): PublicView<Attrs & EventHandlerProps<Events>, void>;
+export declare const text: PublicView<any, void>;
+export declare const div: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const span: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const section: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const article: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const aside: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const nav: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const header: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const footer: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const main: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const p: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const h1: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const h2: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const h3: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const h4: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const h5: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const h6: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const pre: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const code: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const em: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const strong: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const small: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const br: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const hr: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const a: PublicView<HtmlAttrs & {
+    href?: string;
+    target?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const blockquote: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const label: PublicView<HtmlAttrs & {
+    for?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const ul: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const ol: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const li: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const table: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const thead: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const tbody: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const tfoot: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const tr: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const th: PublicView<HtmlAttrs & {
+    colspan?: number;
+    rowspan?: number;
+    scope?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const td: PublicView<HtmlAttrs & {
+    colspan?: number;
+    rowspan?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const form: PublicView<HtmlAttrs & {
+    action?: string;
+    method?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const button: PublicView<HtmlAttrs & {
+    disabled?: boolean;
+    type?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const input: PublicView<HtmlAttrs & {
+    type?: string;
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    checked?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    min?: string;
+    max?: string;
+    step?: string;
+    pattern?: string;
+    required?: boolean;
+    autofocus?: boolean;
+} & EventHandlerProps<FormEvents>, void>;
+export declare const textarea: PublicView<HtmlAttrs & {
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    rows?: number;
+    cols?: number;
+    name?: string;
+    required?: boolean;
+} & EventHandlerProps<FormEvents>, void>;
+export declare const select: PublicView<HtmlAttrs & {
+    value?: string;
+    disabled?: boolean;
+    name?: string;
+    multiple?: boolean;
+    required?: boolean;
+} & EventHandlerProps<FormEvents>, void>;
+export declare const option: PublicView<HtmlAttrs & {
+    value?: string;
+    selected?: boolean;
+    disabled?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const fieldset: PublicView<HtmlAttrs & {
+    disabled?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const legend: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const img: PublicView<HtmlAttrs & {
+    src: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const video: PublicView<HtmlAttrs & {
+    src?: string;
+    controls?: boolean;
+    autoplay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    width?: number;
+    height?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const audio: PublicView<HtmlAttrs & {
+    src?: string;
+    controls?: boolean;
+    autoplay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const canvas: PublicView<HtmlAttrs & {
+    width?: number;
+    height?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const source: PublicView<HtmlAttrs & {
+    src?: string;
+    type?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const details: PublicView<HtmlAttrs & {
+    open?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const summary: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const dialog: PublicView<HtmlAttrs & {
+    open?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const menu: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const iframe: PublicView<HtmlAttrs & {
+    src?: string;
+    width?: number;
+    height?: number;
+    sandbox?: string;
+    allow?: string;
+    loading?: string;
+    referrerpolicy?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const embed: PublicView<HtmlAttrs & {
+    src?: string;
+    type?: string;
+    width?: number;
+    height?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const object: PublicView<HtmlAttrs & {
+    data?: string;
+    type?: string;
+    width?: number;
+    height?: number;
+    name?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const picture: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const portal: PublicView<HtmlAttrs & {
+    src?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const svg: PublicView<HtmlAttrs & {
+    viewBox?: string;
+    xmlns?: string;
+    width?: number | string;
+    height?: number | string;
+    fill?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const script: PublicView<HtmlAttrs & {
+    src?: string;
+    type?: string;
+    async?: boolean;
+    defer?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const noscript: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const template: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const slot: PublicView<HtmlAttrs & {
+    name?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const address: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const hgroup: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const search: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const abbr: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const b: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const bdi: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const bdo: PublicView<HtmlAttrs & {
+    dir?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const cite: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const data: PublicView<HtmlAttrs & {
+    value?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const dfn: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const i: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const kbd: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const mark: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const q: PublicView<HtmlAttrs & {
+    cite?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const rp: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const rt: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const ruby: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const s: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const samp: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const sub: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const sup: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const time: PublicView<HtmlAttrs & {
+    datetime?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const u: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const varEl: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const wbr: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const del: PublicView<HtmlAttrs & {
+    cite?: string;
+    datetime?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const ins: PublicView<HtmlAttrs & {
+    cite?: string;
+    datetime?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const caption: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const colgroup: PublicView<HtmlAttrs & {
+    span?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const col: PublicView<HtmlAttrs & {
+    span?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const datalist: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const optgroup: PublicView<HtmlAttrs & {
+    label?: string;
+    disabled?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const output: PublicView<HtmlAttrs & {
+    for?: string;
+    name?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const progress: PublicView<HtmlAttrs & {
+    value?: number;
+    max?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const meter: PublicView<HtmlAttrs & {
+    value?: number;
+    min?: number;
+    max?: number;
+    low?: number;
+    high?: number;
+    optimum?: number;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const figure: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const figcaption: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const dd: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const dl: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const dt: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
+export declare const track: PublicView<HtmlAttrs & {
+    src?: string;
+    kind?: string;
+    srclang?: string;
+    label?: string;
+    default?: boolean;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const map: PublicView<HtmlAttrs & {
+    name?: string;
+} & EventHandlerProps<ContainerEvents>, void>;
+export declare const area: PublicView<HtmlAttrs & {
+    alt?: string;
+    coords?: string;
+    href?: string;
+    shape?: string;
+    target?: string;
+} & EventHandlerProps<ContainerEvents>, void>;

package/dist/public/state.d.ts

@@ -0,0 +1,37 @@
+import type { MaybePromise } from "../functional/maybe_promise";
+/**
+ * Reactive value — the shared interface returned by `use()`.
+ * Both local state and store bindings implement this.
+ */
+export interface Reactive<T> {
+    get(): T;
+    set(value: T): void;
+    update(fn: (current: T) => MaybePromise<T>): void;
+}
+/**
+ * A single reactive state slot.
+ * Returned by calling use(initial) during view init.
+ *
+ *   const count = use(0);
+ *   count.get()              // read current value
+ *   count.set(5)             // set immediately, schedule render
+ *   count.update(n => n + 1) // update via fn, schedule render
+ */
+export declare class State<T> implements Reactive<T> {
+    #private;
+    constructor(initial: T, schedule: () => void);
+    get(): T;
+    set(value: T): void;
+    update(fn: (current: T) => MaybePromise<T>): void;
+}
+/**
+ * Use factory bound to a view.
+ * Tracks instances by call order (like React hooks).
+ *
+ * use(store)    — subscribe to a Store, returns Store<T> (Reactive<T>)
+ * use(initial)  — create local State<T> (Reactive<T>)
+ */
+export type Use = {
+    <T>(storeOrInitial: import("../public/store").Store<T>): Reactive<T>;
+    <T>(initial: T): Reactive<T>;
+};

package/dist/public/store.d.ts

@@ -0,0 +1,35 @@
+import type { MaybePromise } from "../functional/maybe_promise";
+declare const $store: unique symbol;
+/**
+ * Store — globally visible reactive data.
+ *
+ * Create a store:
+ *   const ThemeStore = store.new("light");
+ *
+ * Set from anywhere:
+ *   ThemeStore.set("dark"); // updates all subscribers
+ *
+ * Read from a view:
+ *   const myView = view(({ use }) => {
+ *     const theme = use(ThemeStore); // re-renders on change
+ *     return {
+ *       render() {
+ *         div(() => text(`Current theme: ${theme.get()}`));
+ *       }
+ *     };
+ *   });
+ */
+export declare class Store<T> {
+    #private;
+    readonly [$store] = true;
+    constructor(initial: T);
+    get(): T;
+    set(value: T): void;
+    update(fn: (current: T) => MaybePromise<T>): void;
+    subscribe(cb: () => void): () => void;
+}
+export declare function isStore(value: unknown): value is Store<unknown>;
+export declare const store: {
+    "new"<T>(initial: T): Store<T>;
+};
+export {};

package/dist/public/view.d.ts

@@ -0,0 +1,37 @@
+import type { Key } from "../functional/key";
+import type { Maybe } from "../functional/maybe";
+import type { Use } from "./state";
+import type { PendingView } from "../internal/internal_view";
+import type { $primitive } from "./primitive";
+export type ViewBody<Props, Api> = Api extends void ? {
+    render: () => void;
+    onMount?: () => void;
+    shouldUpdate?: (nextProps: Props) => boolean;
+    onUpdateBefore?: () => void;
+    onUpdateafter?: () => void;
+} : {
+    render: () => void;
+    onMount?: () => void;
+    shouldUpdate?: (nextProps: Props) => boolean;
+    onUpdateBefore?: () => void;
+    onUpdateafter?: () => void;
+    api: Api;
+};
+/** Slot callback — passed by the caller at the call site. */
+export type Slot = () => void;
+/** Children — pre-collected PendingViews available inside the view. */
+export type Children = Maybe<PendingView[]>;
+export type ViewFn<Props, Api> = {
+    (ctx: {
+        props: () => Props;
+        use: Use;
+        slot: Slot;
+    }): ViewBody<Props, Api>;
+    [$primitive]?: string;
+};
+export declare function view<Props = void, Api = void>(body: ViewFn<Props, Api>): (props: Props extends void ? {
+    key?: Key;
+} | void : Props & {
+    key?: Key;
+}, slot?: Slot) => void;
+export type PublicView<Props, Api> = ReturnType<typeof view<Props, Api>>;

package/dist/render/canvas_render.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/render/html_render.d.ts

@@ -0,0 +1,35 @@
+import type { View } from "../internal/internal_view";
+import type { IRender } from "./render_interface";
+export declare class HtmlRender implements IRender<HTMLElement | Text> {
+    private container;
+    constructor(container: HTMLElement);
+    render(view: View): void;
+    unmount(view: View): void;
+    private buildDom;
+    private isEventProp;
+    private eventPropToCreoName;
+    private setAttributes;
+    private diffAttributes;
+    private bindEvent;
+    private unbindEvent;
+    private mapEventData;
+    private setAttribute;
+    private removeAttribute;
+    /**
+     * Compute where a view's DOM node should be placed in its parent.
+     *
+     * Fast paths (O(1)):
+     *  - Last child → endComment (composite) or null/appendChild (primitive)
+     *  - Previous sibling rendered → nextSibling of prev's last DOM node
+     *
+     * Slow path (O(k)): walk backward through unrendered siblings.
+     *
+     * Composite parents always return endComment as fallback (never null),
+     * so insertBefore(node, result) is safe for all parent types.
+     */
+    private fastInsertionPoint;
+    private getParentDomNode;
+    private moveDomNodes;
+    private getFirstDomNode;
+    private removeDomNodes;
+}

package/dist/render/json_render.d.ts

@@ -0,0 +1,17 @@
+import type { View } from "../internal/internal_view";
+import type { IRender } from "./render_interface";
+import type { Maybe } from "../functional/maybe";
+export type JsonNode = {
+    type: string;
+    props: Record<string, unknown>;
+    children: JsonNode[];
+    key?: string | number;
+};
+export declare class JsonRender implements IRender<JsonNode> {
+    /** The root JSON node after mount. */
+    root: Maybe<JsonNode>;
+    render(view: View): void;
+    unmount(view: View): void;
+    private getNextSibling;
+    private buildNode;
+}

package/dist/render/render_interface.d.ts

@@ -0,0 +1,7 @@
+import type { View } from "../internal/internal_view";
+export interface IRender<Output> {
+    /** Create output if view is new (no renderRef), or update if existing. */
+    render(view: View): void;
+    /** Remove a view's output artifacts. Called from View[Symbol.dispose]. */
+    unmount(view: View): void;
+}

package/dist/render/stream_render.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/render/string_render.d.ts

@@ -0,0 +1,17 @@
+import type { View } from "../internal/internal_view";
+import type { IRender } from "./render_interface";
+/**
+ * Stateless string renderer — pull-based.
+ * mount/unmount/update are no-ops. Call renderToString() to
+ * get the current HTML string from the VDOM.
+ */
+export declare class StringRender implements IRender<string> {
+    private rootView;
+    render(view: View): void;
+    unmount(_view: View): void;
+    /** Build and return the current HTML string from the VDOM. */
+    renderToString(): string;
+    private buildString;
+    private buildVoidTag;
+    private buildChildren;
+}

package/dist/structures/indexed_list.d.ts

@@ -0,0 +1,46 @@
+/**
+ * IndexedList — linked list with O(1) identity-based lookup.
+ *
+ * Combines a doubly-linked list (O(1) insert/delete given a node)
+ * with a Map<T, INode<T>> for O(1) lookup by value identity.
+ *
+ * All mutating operations are O(1):
+ *   push, delete, has, first, last, clear
+ */
+import { type INode } from "./list";
+import type { Maybe } from "../functional/maybe";
+export declare class IndexedList<T> {
+    #private;
+    /** Append item to the end. No-op if already present. Returns the node. */
+    push(item: T): INode<T>;
+    /** Insert item at the front. No-op if already present. */
+    unshift(item: T): void;
+    /** Insert item after ref. No-op if item already present. */
+    insertAfter(ref: T, item: T): void;
+    /** Remove item. O(1). */
+    delete(item: T): void;
+    /** Check membership. O(1). */
+    has(item: T): boolean;
+    /** Number of items. */
+    get length(): number;
+    /** Get the first item (head). O(1). */
+    first(): Maybe<T>;
+    /** Get the last item (tail). O(1). */
+    last(): Maybe<T>;
+    /** Get the linked-list node for an item. O(1). */
+    getNode(item: T): Maybe<INode<T>>;
+    /** Positional access. O(n) — prefer getNode + getNext for traversal. */
+    at(index: number): Maybe<T>;
+    /**
+     * Replace item at `pos`, or insert if nothing is there.
+     * If `pos >= length`, appends to the end.
+     * Returns the node.
+     */
+    upsert(pos: number, item: T): INode<T>;
+    /** Swap two items in the list. O(1). No-op if either item is missing. */
+    swap(a: T, b: T): void;
+    /** Reset to empty. O(1). */
+    clear(): void;
+    /** Iterate values in insertion order. */
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/dist/structures/list.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Linked list implementation
+ */
+import type { Maybe } from "../functional/maybe";
+declare const $next: unique symbol;
+declare const $prev: unique symbol;
+declare const $owner: unique symbol;
+export interface INode<T> {
+    insertNext(value: T): INode<T>;
+    insertPrev(value: T): INode<T>;
+    v: T;
+    delete(): void;
+    getNext(): Maybe<INode<T>>;
+    getPrev(): Maybe<INode<T>>;
+    isFirst(): boolean;
+    isLast(): boolean;
+}
+export declare class ListNode<T> implements INode<T> {
+    [$owner]: Maybe<IBaseContainer<T>>;
+    [$next]: Maybe<ListNode<T>>;
+    [$prev]: Maybe<ListNode<T>>;
+    v: T;
+    constructor(node: T, prev: Maybe<ListNode<T>>, next: Maybe<ListNode<T>>, list: IBaseContainer<T>);
+    isFirst(): boolean;
+    isLast(): boolean;
+    delete(): void;
+    clearFields(): void;
+    insertNext(value: T): INode<T>;
+    insertPrev(value: T): INode<T>;
+    getNext(): Maybe<ListNode<T>>;
+    getPrev(): Maybe<ListNode<T>>;
+    getList(): Maybe<IBaseContainer<T>>;
+}
+interface IBaseContainer<T> {
+    delete(node: INode<T>): void;
+    insertNext(ref: INode<T>, value: T): INode<T>;
+    insertPrev(ref: INode<T>, value: T): INode<T>;
+}
+export interface IList<T> extends Iterable<INode<T>>, IBaseContainer<T> {
+    insertStart(value: T): INode<T>;
+    insertEnd(value: T): INode<T>;
+    at(n: number): Maybe<INode<T>>;
+    first(): Maybe<INode<T>>;
+    last(): Maybe<INode<T>>;
+    readonly size: number;
+    [Symbol.iterator](): IterableIterator<INode<T>>;
+}
+export declare class InternalList<T> implements IList<T> {
+    #private;
+    insertStart(value: T): ListNode<T>;
+    delete(node: INode<T>): void;
+    at(n: number): Maybe<ListNode<T>>;
+    get size(): number;
+    /** Reset the list to empty. O(1). */
+    clear(): void;
+    /** O(1) head access. */
+    first(): Maybe<ListNode<T>>;
+    /** O(1) tail access. */
+    last(): Maybe<ListNode<T>>;
+    insertEnd(value: T): ListNode<T>;
+    insertNext(ref: INode<T>, value: T): ListNode<T>;
+    insertPrev(ref: INode<T>, value: T): ListNode<T>;
+    [Symbol.iterator](): Generator<ListNode<T>, void, unknown>;
+}
+export declare class List<T> extends InternalList<T> implements IList<T> {
+    static from<T>(arrayLike: Iterable<T>): List<T>;
+}
+export {};

package/package.json

@@ -1,15 +1,32 @@
 {
   "name": "creo",
-  "version": "0.0.3-dev",
+  "version": "0.1.0",
   "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "dev": "vite",
-    "build": "tsc && vite build",
-    "preview": "vite preview"
+    "build": "bun run build.ts",
+    "build-only": "rm -rf ./dist/*; bun run build.ts",
+    "test": "bun test src/",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "typescript": "^5.2.2",
-    "vite": "^5.2.0",
-    "bun-types": "latest"
+    "@types/bun": "latest",
+    "happy-dom": "^20.8.4",
+    "tsc-alias": "^1.8.16"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
   }
 }