creo 0.1.0 → 0.2.0

package/dist/internal/internal_view.d.ts

@@ -1,38 +1,29 @@
 import type { Key } from "../functional/key";
-import type { Children, Slot, ViewBody, ViewFn } from "../public/view";
-import type { Engine } from "./engine";
-import { IndexedList } from "../structures/indexed_list";
+import type { Slot, ViewBody, ViewFn } from "../public/view";
 import type { Maybe } from "../functional/maybe";
 import type { Wildcard } from "./wildcard";
-export type PendingView<Props = Wildcard, Api = Wildcard> = {
+export type BitFlags = number;
+export declare const F_PENDING = 1;
+export declare const F_DIRTY: number;
+export declare const F_MOVED: number;
+export declare const F_QUICK_RERENDER: number;
+export declare const F_PRIMITIVE: number;
+export declare const F_TEXT_CONTENT: number;
+export type ViewRecord<Props = Wildcard, Api = Wildcard, RenderRef = Wildcard> = {
     viewFn: ViewFn<Props, Api>;
+    userKey: Maybe<Key>;
     props: Props;
     slot: Maybe<Slot>;
-    userKey: Maybe<Key>;
+    body: Maybe<ViewBody<Props, Api>>;
+    sc: Maybe<ViewRecord[]>;
+    renderRef: Maybe<RenderRef>;
+    flags: BitFlags;
+    children: Maybe<ViewRecord[]>;
+    keyToView: Maybe<Map<Key, ViewRecord>>;
+    unsubscribe: Maybe<(() => void)[]>;
+    parent: Maybe<ViewRecord>;
+    /** The primitive whose .children contains the live sc items after reconcile. */
+    scHost: Maybe<ViewRecord>;
 };
-export declare class View<Props = Wildcard, Api = Wildcard> implements Disposable {
-    #private;
-    viewFn: ViewFn<Props, Api>;
-    engine: Engine;
-    parent: Maybe<View>;
-    userKey: Maybe<Key>;
-    renderRef: unknown;
-    props: Props;
-    slotChildren: Children;
-    body: ViewBody<Props, Api>;
-    virtualDom: Maybe<IndexedList<View>>;
-    keyToIndex: Maybe<Map<Key, number>>;
-    dirty: boolean;
-    moved: boolean;
-    quickRerender: boolean;
-    constructor(viewFn: ViewFn<Props, Api>, initialProps: Props, slot: Maybe<Slot>, engine: Engine, parent: Maybe<View>, userKey: Maybe<Key>);
-    markDirty: () => void;
-    markMove(): void;
-    shouldUpdate(nextProps: Props): boolean;
-    onMount: () => void;
-    onUpdateBefore(): void;
-    onUpdateAfter: () => void;
-    nextProps(nextProps: Props, nextSlot: Maybe<Slot>): void;
-    reconsile(): void;
-    [Symbol.dispose](): void;
-}
+/** Structural change: viewFn, key, or count differs. Does NOT check props. */
+export declare function hasScStructuralChange(prev: Maybe<ViewRecord[]>, next: Maybe<ViewRecord[]>): boolean;

package/dist/internal/orchestrator.d.ts

@@ -9,7 +9,7 @@ import type { Engine } from "../internal/engine";
  */
 declare class Orchestrator {
     #private;
-    setCurrentEngine(engine: Engine): void;
+    setCurrentEngine(engine: Maybe<Engine>): void;
     currentEngine(): Maybe<Engine>;
 }
 export declare const orchestrator: Orchestrator;

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

@@ -45,7 +45,7 @@ export type HtmlAttrs = {
     [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 function text(content: string | number): 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>;

package/dist/public/view.d.ts

@@ -1,26 +1,22 @@
 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;
+    onUpdateAfter?: () => void;
 } : {
     render: () => void;
     onMount?: () => void;
     shouldUpdate?: (nextProps: Props) => boolean;
     onUpdateBefore?: () => void;
-    onUpdateafter?: () => 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;

package/dist/render/html_render.d.ts

@@ -1,35 +1,22 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
 import type { IRender } from "./render_interface";
+import type { Engine } from "../internal/engine";
 export declare class HtmlRender implements IRender<HTMLElement | Text> {
+    #private;
     private container;
+    engine: Engine;
     constructor(container: HTMLElement);
-    render(view: View): void;
-    unmount(view: View): void;
-    private buildDom;
-    private isEventProp;
-    private eventPropToCreoName;
+    render(view: ViewRecord): void;
+    unmount(view: ViewRecord): void;
+    private findParentDom;
+    private findInsertionPoint;
     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 moveDomNodes;
     private removeDomNodes;
 }

package/dist/render/json_render.d.ts

@@ -1,6 +1,7 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
 import type { IRender } from "./render_interface";
 import type { Maybe } from "../functional/maybe";
+import type { Engine } from "../internal/engine";
 export type JsonNode = {
     type: string;
     props: Record<string, unknown>;
@@ -10,8 +11,9 @@ export type JsonNode = {
 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;
+    engine: Engine;
+    constructor();
+    render(view: ViewRecord): void;
+    unmount(view: ViewRecord): void;
     private buildNode;
 }

package/dist/render/render_interface.d.ts

@@ -1,7 +1,9 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
+import type { Engine } from "../internal/engine";
 export interface IRender<Output> {
+    engine: Engine;
     /** 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;
+    render(view: ViewRecord): void;
+    /** Remove a view's output artifacts. */
+    unmount(view: ViewRecord): void;
 }

package/dist/render/string_render.d.ts

@@ -1,17 +1,22 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
 import type { IRender } from "./render_interface";
+import type { Engine } from "../internal/engine";
 /**
- * Stateless string renderer — pull-based.
- * mount/unmount/update are no-ops. Call renderToString() to
+ * HtmlStringRender — pull-based string renderer.
+ * render/unmount are no-ops. Call renderToString() to
  * get the current HTML string from the VDOM.
+ *
+ * Output matches HtmlRender's DOM serialization (innerHTML).
  */
-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. */
+export declare class HtmlStringRender implements IRender<string> {
+    private root;
+    engine: Engine;
+    render(view: ViewRecord): void;
+    unmount(_view: ViewRecord): void;
     renderToString(): string;
     private buildString;
-    private buildVoidTag;
+    private buildAttrs;
     private buildChildren;
 }
+/** @deprecated Use HtmlStringRender instead */
+export declare const StringRender: typeof HtmlStringRender;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "creo",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",