@vmz/core 0.1.32 → 0.2.0

package/dist/shared/host.types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared host / Node runtime types for `@vmz/core`.
+ */
+import type { ServerResponse } from 'node:http';
+export type ComponentEntry = {
+    chunkId: string;
+    name: string;
+    entry: string;
+    source?: string;
+};
+export type HostRequestOpts = {
+    signal?: AbortSignal;
+    searchParams?: URLSearchParams;
+    cookieHeader?: string;
+    method?: string;
+    body?: unknown;
+};
+export type LocaleHostCtx = {
+    localeId?: string;
+    dir?: string;
+    alternates?: unknown;
+};
+export type ClosedAccessResult = {
+    kind: 'allow';
+    props?: Record<string, unknown>;
+} | {
+    kind: 'redirect';
+    location: string;
+} | {
+    kind: 'deny';
+} | {
+    kind: 'not-found';
+};
+export type SseClient = Pick<ServerResponse, 'write' | 'end'>;
+export type DeploymentDocument = Record<string, unknown>;
+export type ComponentRegistryMap = Record<string, unknown>;
+export type LoadComponentEntriesOpts = {
+    strict?: boolean;
+    closureRoots?: string[];
+    explicit?: Record<string, string>;
+};
+export type DedupeComponentEntriesOpts = {
+    strict?: boolean;
+};
+export type ImportComponentEntriesOpts = {
+    cacheBust?: string | number;
+    loaded?: Set<string>;
+};
+export type BootstrapComponentRegistryOpts = LoadComponentEntriesOpts & ImportComponentEntriesOpts & {
+    preload?: 'all' | 'closure' | 'none';
+};
+export type ClientComponentListEntry = {
+    name: string;
+    entry: string;
+    chunkId?: string;
+};
+export type ListClientComponentsOpts = {
+    strict?: boolean;
+};
+export type PreloadComponentRegistryOpts = ListClientComponentsOpts & {
+    cacheBust?: string | number;
+    include?: (entry: ClientComponentListEntry) => boolean;
+    explicit?: Record<string, string>;
+    closureRoots?: string[];
+    preload?: 'all' | 'closure' | 'none';
+};
+export type NativeAddon = Record<string, unknown>;

package/dist/shared/host.types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared host / Node runtime types for `@vmz/core`.
+ */
+export {};

package/dist/shared/server.types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Types for `@vmz/core` server / RPC runtime (`faces/server.ts`).
+ */
+import type { IncomingMessage } from 'node:http';
+export type RpcRequest = {
+    moduleId: string;
+    method: string;
+    args?: unknown[];
+};
+export type Route = {
+    verb: string;
+    path: string;
+    moduleId: string;
+    method: string;
+    className?: string;
+};
+export type PageStreamResult = AsyncIterable<string> | {
+    status?: number;
+    stream?: AsyncIterable<string>;
+    redirect?: string;
+    headers?: Record<string, string>;
+} | null;
+export type NodeRequestOptions = {
+    distDir?: string;
+    renderIndex?: () => Promise<string> | string;
+    renderIndexStream?: (opts?: {
+        signal?: AbortSignal;
+    }) => AsyncIterable<string>;
+    renderPage?: (pathname: string) => Promise<string | null> | string | null;
+    renderPageStream?: (pathname: string, opts?: {
+        signal?: AbortSignal;
+        searchParams?: URLSearchParams;
+        cookieHeader?: string;
+        method?: string;
+        body?: unknown;
+    }) => Promise<PageStreamResult> | PageStreamResult;
+    req?: IncomingMessage;
+};
+export type ServerModuleResolver = (id: string) => string | URL;

package/dist/shared/server.types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for `@vmz/core` server / RPC runtime (`faces/server.ts`).
+ */
+export {};

package/dist/{dom-ssr.d.ts → ssr/dom-ssr.d.ts}

@@ -1,76 +1,47 @@
 /**
- * VMZ DOM SSR / hydrate / resume — precise patches, no VDOM diff.
+ * VMZ DOM SSR / hydrate / resume ??precise patches, no VDOM diff.
  * Imports client DOM primitives from ./dom-core.js for tree-shakeable browser entry.
  */
-import { findOwnedDefaultSlot } from './dom-core.js';
-export declare function renderToString(Component: any, props?: {}, opts?: {}): Promise<any>;
+import { findOwnedDefaultSlot } from '../browser/dom-core.js';
+export declare function renderToString(Component: any, props?: any, opts?: any): Promise<any>;
 /**
  * Stream SSR via the same Direct serialize schedule as `renderToString`.
- * Yields HTML chunks (open tag → children → close). Joining chunks equals `renderToString`.
+ * Yields HTML chunks (open tag ??children ??close). Joining chunks equals `renderToString`.
  * Supports AbortSignal for cancel; consumers should respect backpressure (await between chunks).
- * @param {new (props?: object) => any} Component
- * @param {object} [props]
- * @param {{ signal?: AbortSignal, slotHtml?: string }} [opts]
- * @returns {AsyncGenerator<string, void, void>}
  */
-export declare function renderToStream(Component: any, props?: {}, opts?: {}): AsyncGenerator<any, void, unknown>;
+export declare function renderToStream(Component: any, props?: any, opts?: any): AsyncGenerator<any, void, unknown>;
 /**
  * Live-DOM counterpart: first default `<slot>` owned by this tree, not by a nested
  * `[data-vmz]` component (Button/Link labels, etc.).
  * Re-exported from dom-core (single implementation).
- * @param {Element | null | undefined} root
- * @returns {Element | null}
  */
 export { findOwnedDefaultSlot };
 /**
- * Hydrate/mount a file-route page inside an optional layout chain (outer → inner).
+ * Hydrate/mount a file-route page inside an optional layout chain (outer ??inner).
  * Mirrors SSR `slotHtml` wrapping: each layout's owned default slot becomes the
  * outlet for the next layout or the page. Retains layout instances on `container`
  * so SPA transitions can dispose only the page host.
- * @param {new (props?: object) => any} Page
- * @param {Element} container
- * @param {object} [props]
- * @param {Array<new (props?: object) => any>} [layoutCtors] outer → inner
- * @param {{ preserveState?: boolean | Record<string, unknown>, skipOnMount?: boolean }} [opts]
  */
 export declare function hydrateRoute(Page: any, container: any, props?: {}, layoutCtors?: any[], opts?: {}): Promise<any>;
 /**
  * SPA same-layout transition: dispose only the page host, keep layout instances.
  * Callers must verify `data-vmz-layout` is unchanged before using this.
- * @param {new (props?: object) => any} Page
- * @param {Element} container `#app` that already has `__vmzPageHost` / `__vmzLayoutInsts`
- * @param {object} [props]
- * @param {{ preserveState?: boolean | Record<string, unknown>, skipOnMount?: boolean }} [opts]
  */
-export declare function hydrateRoutePage(Page: any, container: any, props?: {}, opts?: {}): Promise<any>;
+export declare function hydrateRoutePage(Page: any, container: any, props?: any, opts?: any): Promise<any>;
 /**
  * resume: attach to existing Island DOM without re-running construct structure or onMount.
  * Consumes ResumeEntry product (`data-vmz-resume`) derived from the same Execution Plan.
- * @param {new (props?: object) => any} Component
- * @param {HTMLElement} container
- * @param {{ props?: object, state?: Record<string, unknown>, strategy?: string } | null} [slice]
  */
 export declare function resume(Component: any, container: any, slice?: any): Promise<any>;
 /**
  * Resume all `[data-vmz-island]` hosts (prefer ResumeEntry / EventEntry over mount).
  * Event strategy islands wait for the DOM event before attach (lazy EventEntry).
- * @param {ParentNode} [root]
  */
 export declare function resumeIslands(root?: Document): void;
 /**
  * EventEntry attach: only wire `client:event` / `client:event:*` islands.
  * Idle/load/visible ResumeEntries are left alone (static shell can defer framework work).
- * @param {ParentNode} [root]
  */
 export declare function attachEventEntries(root?: Document): void;
-/**
- * @param {new (props?: object) => any} Component
- * @param {HTMLElement} container
- * @param {object} [props]
- * @param {{ preserveState?: boolean | Record<string, unknown>, skipOnMount?: boolean }} [opts]
- */
-export declare function hydrate(Component: any, container: any, props?: {}, opts?: {}): Promise<any>;
-/**
- * @param {ParentNode} [root]
- */
+export declare function hydrate(Component: any, container: any, props?: any, opts?: any): Promise<any>;
 export declare function hydrateIslands(root?: Document): void;