@vmz/core 0.1.32 → 0.2.0

package/dist/browser/dom-core.types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Internal types for `@vmz/core` browser DOM runtime (`dom-core.ts`).
+ */
+import type { DirectApi, DirectInstance, PatchFn, BindingId } from './direct-api.types.js';
+export type { DirectApi, DirectInstance, PatchFn, BindingId };
+export type ComponentCtor = (new (props?: object) => DirectInstance) & {
+    __vmzDirect?: boolean;
+    __vmzCreate?: (this: DirectInstance, api: DirectApi) => Node;
+    __vmzSerialize?: (this: DirectInstance, api: DirectApi) => unknown;
+    __vmzPlan?: unknown;
+    __vmzHostBox?: string;
+    __vmzTag?: string;
+    __vmzState?: string[];
+    __vmzProps?: string[];
+    __vmzWBInstalled?: boolean;
+    __vmzCtorAppliesProps?: boolean;
+    name?: string;
+    [key: string]: unknown;
+};
+export type VmzDomElement = Element & {
+    __vmzEvt?: Record<string, EventListener>;
+    __vmzInst?: DirectInstance;
+    __vmzPropBindSeq?: number;
+    __vmzDispose?: (() => void) | null;
+    value?: string;
+    options?: HTMLOptionsCollection;
+};
+export type VmzDomNode = Node & {
+    __vmzDispose?: (() => void) | null;
+    __vmzInst?: DirectInstance;
+};
+export type VmzContainer = Element & {
+    __vmzInst?: DirectInstance | null;
+};
+export type ReactiveOwner = {
+    report: (segs: string[] | null) => void;
+    baseSegs: string[];
+    inst?: DirectInstance | null;
+};
+export type ReactiveEntry = {
+    proxy: object;
+    owners: ReactiveOwner[];
+    kind: 'barrier' | 'proxy';
+};
+export type DirtyNotice = {
+    type: 'replace';
+    root: string;
+} | {
+    type: 'path';
+    root: string;
+    segs: string[];
+};
+export type TraceEvent = {
+    kind: string;
+    stableId: {
+        kind: string;
+        id: string;
+    };
+    dep?: string;
+    t?: number;
+    chunkId?: string | null;
+};
+export type PrecisionState = {
+    enabled: boolean;
+    writes: number;
+    bindingEvals: number;
+    patchExecs: number;
+    domCreates: number;
+    domMoves: number;
+    domRemoves: number;
+    componentExecs: number;
+    writesByRoot: Record<string, number>;
+    bindingEvalsByDep: Record<string, number>;
+    patchesByDep: Record<string, number>;
+    bindingEvalsByBinding: Record<string, number>;
+    patchesByBinding: Record<string, number>;
+};
+export type TraceBuffer = {
+    enabled: boolean;
+    events: TraceEvent[];
+};
+export type ResumeAdoptCtx = {
+    el: (tag: string) => Element;
+    text: (value?: unknown) => Text;
+    componentHost?: (name: string) => HTMLElement | null;
+    enter?: (node: Element) => boolean;
+    leave?: () => void;
+    scopeDepth?: () => number;
+    rewindScope?: (depth: number) => void;
+    beginBranchScope?: () => () => void;
+    _enterBalance?: number;
+    inst?: DirectInstance;
+};
+export type EachCtx = {
+    noteItemBind: (bindingId: BindingId, deps: string[], fn: PatchFn) => void;
+    needDelegate: (type: string) => void;
+    inst?: DirectInstance;
+};
+export type TaskStatus = 'pending' | 'success' | 'error' | 'cancelled';
+export type TaskEntry = {
+    generation: number;
+    controller: AbortController | {
+        signal: {
+            aborted: boolean;
+        };
+        abort: () => void;
+    };
+    status: TaskStatus;
+    result?: unknown;
+    error?: unknown;
+    promise?: Promise<unknown>;
+};
+export type WbSharedEntry = {
+    owners: ReactiveOwner[];
+};
+export type WbDiagnostic = {
+    kind: string;
+    message: string;
+};
+export type LogicalAssignKind = '||' | '&&' | '??';
+export type LeafDirty = {
+    root: string;
+    field: string;
+    idxs: number[];
+};
+export type UnknownComponentErrorDetail = {
+    kind: string;
+    component: string;
+    via: string;
+};
+export type SerializeTreeNode = {
+    __kind: 'el' | 'text';
+    tag?: string;
+    attrs?: Record<string, string>;
+    children?: SerializeTreeNode[];
+    value?: string;
+    appendChild?: (c: SerializeTreeNode | null | undefined) => void;
+};

package/dist/browser/dom-core.types.js

@@ -0,0 +1,4 @@
+/**
+ * Internal types for `@vmz/core` browser DOM runtime (`dom-core.ts`).
+ */
+export {};

package/dist/{position-context.js → browser/position-context.js}

@@ -2,7 +2,7 @@
  * PositionContext backed by compiler OffsetIndex via N-API (`offsetIndexLineCol`).
  * `@vmz/diagnostic` stays free of a native dependency — hosts wire this helper.
  */
-import { requireNativeFn } from './native-addon.js';
+import { requireNativeFn } from '../host/native-addon.js';
 /**
  * Build a diagnostic PositionContext for `sourceText` using the native OffsetIndex.
  */

package/dist/browser/unknown-component.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Unknown Direct component resilience (`ssr-unknown-component-error-node`).
+ * Leaf failure → subtree error node; do not throw out of document SSR.
+ */
+import type { SerializeTreeNode } from './dom-core.types.js';
+export declare const UNKNOWN_COMPONENT_ERROR = "unknown-component";
+/** Append a leaf diagnostic for tooling (does not replace the error node). */
+export declare function noteUnknownComponent(name: string, via?: string): void;
+/** SSR serialize-tree error node (keeps document HTTP 200). */
+export declare function serializeUnknownComponentNode(name: string): SerializeTreeNode;
+/** Live DOM error host (client create / schedule). */
+export declare function createUnknownComponentElement(name: string, via?: string): HTMLElement;
+/** Mark an existing island host as unknown (resume / EventEntry). */
+export declare function markUnknownComponentHost(el: HTMLElement, name: string, via?: string): void;

package/dist/{unknown-component.js → browser/unknown-component.js}

@@ -2,11 +2,7 @@
  * Unknown Direct component resilience (`ssr-unknown-component-error-node`).
  * Leaf failure → subtree error node; do not throw out of document SSR.
  */
-/** @type {string} */
 export const UNKNOWN_COMPONENT_ERROR = 'unknown-component';
-/**
- * @returns {boolean}
- */
 function isDevSurface() {
     try {
         if (typeof process !== 'undefined' && process.env) {
@@ -21,11 +17,7 @@ function isDevSurface() {
     }
     return false;
 }
-/**
- * Append a leaf diagnostic for tooling (does not replace the error node).
- * @param {string} name
- * @param {string} [via]
- */
+/** Append a leaf diagnostic for tooling (does not replace the error node). */
 export function noteUnknownComponent(name, via = 'ssr') {
     const detail = { kind: UNKNOWN_COMPONENT_ERROR, component: String(name || ''), via };
     try {
@@ -43,7 +35,6 @@ export function noteUnknownComponent(name, via = 'ssr') {
         if (!Array.isArray(g.__VMZ_COMPONENT_ERRORS__)) {
             g.__VMZ_COMPONENT_ERRORS__ = [];
         }
-        /** @type {unknown[]} */
         const bag = g.__VMZ_COMPONENT_ERRORS__;
         bag.push(detail);
     }
@@ -51,18 +42,13 @@ export function noteUnknownComponent(name, via = 'ssr') {
         /* ignore */
     }
 }
-/**
- * SSR serialize-tree error node (keeps document HTTP 200).
- * @param {string} name
- */
+/** SSR serialize-tree error node (keeps document HTTP 200). */
 export function serializeUnknownComponentNode(name) {
     noteUnknownComponent(name, 'ssr');
-    /** @type {Record<string, string>} */
     const attrs = {
         'data-vmz-error': UNKNOWN_COMPONENT_ERROR,
         'data-vmz-component': String(name || ''),
     };
-    /** @type {any[]} */
     const children = [];
     if (isDevSurface()) {
         children.push({
@@ -81,12 +67,7 @@ export function serializeUnknownComponentNode(name) {
         },
     };
 }
-/**
- * Live DOM error host (client create / schedule).
- * @param {string} name
- * @param {string} [via]
- * @returns {HTMLElement}
- */
+/** Live DOM error host (client create / schedule). */
 export function createUnknownComponentElement(name, via = 'client') {
     noteUnknownComponent(name, via);
     const host = document.createElement('div');
@@ -97,12 +78,7 @@ export function createUnknownComponentElement(name, via = 'client') {
     }
     return host;
 }
-/**
- * Mark an existing island host as unknown (resume / EventEntry).
- * @param {HTMLElement} el
- * @param {string} name
- * @param {string} [via]
- */
+/** Mark an existing island host as unknown (resume / EventEntry). */
 export function markUnknownComponentHost(el, name, via = 'resume') {
     if (!el)
         return;

package/dist/{dom.browser.d.ts → faces/dom.browser.d.ts}

@@ -3,5 +3,5 @@
  * Does NOT re-export Node SSR `renderToString` / `renderToStream`.
  * Full barrel remains `@vmz/core/dom` (`dom.js` / dist `vmz-dom.js`) for Node host.
  */
-export * from './dom-core.js';
-export { attachEventEntries, hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage, resume, resumeIslands, } from './dom-ssr.js';
+export * from '../browser/dom-core.js';
+export { attachEventEntries, hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage, resume, resumeIslands, } from '../ssr/dom-ssr.js';

package/dist/{dom.browser.js → faces/dom.browser.js}

@@ -1,8 +1,7 @@
-// @ts-nocheck
 /**
  * Browser delivery face (0.1.31): DOM core + hydrate/resume/route attach.
  * Does NOT re-export Node SSR `renderToString` / `renderToStream`.
  * Full barrel remains `@vmz/core/dom` (`dom.js` / dist `vmz-dom.js`) for Node host.
  */
-export * from './dom-core.js';
-export { attachEventEntries, hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage, resume, resumeIslands, } from './dom-ssr.js';
+export * from '../browser/dom-core.js';
+export { attachEventEntries, hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage, resume, resumeIslands, } from '../ssr/dom-ssr.js';

package/dist/faces/dom.client.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Browser / client-only DOM entry �?tree-shakeable (no SSR serialize/hydrate).
+ */
+export * from '../browser/dom-core.js';

package/dist/faces/dom.client.js

@@ -0,0 +1,4 @@
+/**
+ * Browser / client-only DOM entry �?tree-shakeable (no SSR serialize/hydrate).
+ */
+export * from '../browser/dom-core.js';

package/dist/faces/dom.d.ts

@@ -0,0 +1,6 @@
+/**
+ * VMZ DOM / SSR runtime �?precise patches, no VDOM diff.
+ * Compat barrel for `@vmz/core/dom` (full client + SSR).
+ */
+export * from '../browser/dom-core.js';
+export * from '../ssr/dom-ssr.js';

package/dist/faces/dom.js

@@ -0,0 +1,6 @@
+/**
+ * VMZ DOM / SSR runtime �?precise patches, no VDOM diff.
+ * Compat barrel for `@vmz/core/dom` (full client + SSR).
+ */
+export * from '../browser/dom-core.js';
+export * from '../ssr/dom-ssr.js';

package/dist/{http.d.ts → faces/http.d.ts}

@@ -1,4 +1,4 @@
-/** Compile-time HTTP decorators — erased from server JS emit; kept for authoring. */
+/** Compile-time HTTP decorators �?erased from server JS emit; kept for authoring. */
 export declare function Get(path: any): (_target: any, _key: any, descriptor: any) => any;
 export declare function Post(path: any): (_target: any, _key: any, descriptor: any) => any;
 export declare function Put(path: any): (_target: any, _key: any, descriptor: any) => any;

package/dist/{http.js → faces/http.js}

@@ -1,5 +1,4 @@
-// @ts-nocheck
-/** Compile-time HTTP decorators — erased from server JS emit; kept for authoring. */
+/** Compile-time HTTP decorators �?erased from server JS emit; kept for authoring. */
 export function Get(path) {
     return function GetDecorator(_target, _key, descriptor) {
         return descriptor;

package/dist/{server.d.ts → faces/server.d.ts}

@@ -1,46 +1,29 @@
 /**
  * Minimal VMZ runtime — `#server` invoke + RPC/REST HTTP + optional static/SSR.
  *
- *
  * Browser-safe: no static `node:*` imports. Node builtins are loaded only inside
  * Node/SSR request handlers so client bundles can `import { callServer }`.
  */
+import type { Route, ServerModuleResolver } from '../shared/server.types.js';
 /**
- * Map `#server/foo` → filesystem / URL the host can `import`.
- * Only set this in Node/SSR hosts — browser bundles must omit it so RPC goes HTTP.
- */
-export declare function setServerModuleResolver(fn: any): void;
-/** @param {Route[]} next */
-export declare function setRoutes(next: any): void;
-/**
- * @param {string} moduleId
- * @param {string} method
- * @param {unknown[]} args
- */
-export declare function callServer(moduleId: any, method: any, args?: any[]): Promise<any>;
-/**
- * @param {RpcRequest} body
+ * Map `#server/foo` �?filesystem / URL the host can `import`.
+ * Only set this in Node/SSR hosts �?browser bundles must omit it so RPC goes HTTP.
  */
+export declare function setServerModuleResolver(fn: ServerModuleResolver): void;
+export declare function setRoutes(next: Route[]): void;
+export declare function callServer(moduleId: string, method: string, args?: unknown[]): Promise<unknown>;
 export declare function handleRpc(body: any): Promise<any>;
 /**
  * Match REST route from `vmz-routes.json`.
- * @param {string} verb
- * @param {string} pathname
- * @returns {Route | null}
  */
-export declare function matchRoute(verb: any, pathname: any): any;
+export declare function matchRoute(verb: any, pathname: any): Route;
 /**
  * Web Standards Fetch entry for ServerArtifact hosts (Node adapter, worker/edge parity).
  * Handles RPC + public ServerRoute only; static/SSR stay on Node host options.
- * @param {Request} request
- * @returns {Promise<Response>}
  */
 export declare function handleFetchRequest(request: any): Promise<Response>;
 /**
  * Node `http.createServer` listener: RPC + REST + optional static / SSR index.
  * RPC/REST go through {@link handleFetchRequest} so Node and Fetch hosts share one core.
- * @param {import('node:http').IncomingMessage} req
- * @param {import('node:http').ServerResponse} res
- * @param {NodeRequestOptions} [opts]
  */
-export declare function handleNodeRequest(req: any, res: any, opts?: {}): Promise<void>;
+export declare function handleNodeRequest(req: any, res: any, opts?: any): Promise<void>;