@vmz/core 0.1.32 → 0.2.1

package/dist/shared/dom-attr-normalize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared class/style normalization for Direct SSR + client (0.1.33).
+ * Vue-compatible: string | string[] | object map | falsy parts.
+ */
+/** Normalize one or more class fragments into a deduped class string. */
+export declare function mergeClassParts(...parts: unknown[]): string;
+/** Merge static + dynamic style fragments; later parts override same keys. */
+export declare function mergeStyleParts(...parts: unknown[]): string;

package/dist/shared/dom-attr-normalize.js

@@ -0,0 +1,71 @@
+/**
+ * Shared class/style normalization for Direct SSR + client (0.1.33).
+ * Vue-compatible: string | string[] | object map | falsy parts.
+ */
+function pushClassTokens(out, value) {
+    if (value == null || value === false)
+        return;
+    if (typeof value === 'string') {
+        for (const token of value.split(/\s+/)) {
+            if (token)
+                out.push(token);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            pushClassTokens(out, item);
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const [key, enabled] of Object.entries(value)) {
+            if (enabled)
+                out.push(key);
+        }
+        return;
+    }
+    const s = String(value).trim();
+    if (s)
+        out.push(s);
+}
+/** Normalize one or more class fragments into a deduped class string. */
+export function mergeClassParts(...parts) {
+    const tokens = [];
+    for (const part of parts)
+        pushClassTokens(tokens, part);
+    return [...new Set(tokens)].join(' ');
+}
+function parseStyleObject(value) {
+    const out = {};
+    if (value == null || value === false)
+        return out;
+    if (typeof value === 'string') {
+        for (const chunk of value.split(';')) {
+            const idx = chunk.indexOf(':');
+            if (idx < 0)
+                continue;
+            const key = chunk.slice(0, idx).trim();
+            const val = chunk.slice(idx + 1).trim();
+            if (key)
+                out[key] = val;
+        }
+        return out;
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        for (const [key, raw] of Object.entries(value)) {
+            if (raw == null || raw === false)
+                continue;
+            out[key] = String(raw);
+        }
+    }
+    return out;
+}
+/** Merge static + dynamic style fragments; later parts override same keys. */
+export function mergeStyleParts(...parts) {
+    const merged = {};
+    for (const part of parts)
+        Object.assign(merged, parseStyleObject(part));
+    return Object.entries(merged)
+        .map(([key, val]) => `${key}: ${val}`)
+        .join('; ');
+}

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

@@ -0,0 +1,113 @@
+/**
+ * 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'>;
+/** Deployment graph document (`vmz.deployment.v0`). */
+export type DeploymentUnit = {
+    chunkId?: string;
+    name?: string;
+    entry?: string;
+    source?: string;
+    dependsOn?: string[];
+    [key: string]: unknown;
+};
+export type DeploymentLayoutChain = {
+    routeId?: string;
+    layouts?: string[];
+    page?: string;
+    [key: string]: unknown;
+};
+export type DeploymentDocument = {
+    schema?: string;
+    units?: DeploymentUnit[];
+    layoutChain?: DeploymentLayoutChain[] | Record<string, unknown>;
+    dependsOn?: Record<string, string[]>;
+    [key: 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>;
+export type ServeHostOpts = {
+    distDir?: string;
+    port?: number;
+    host?: string;
+    signal?: AbortSignal;
+    [key: string]: unknown;
+};
+export type SoftReloadOpts = {
+    reason?: string;
+    signal?: AbortSignal;
+    [key: string]: unknown;
+};
+export type RenderPageStreamOpts = HostRequestOpts & {
+    localeId?: string;
+    [key: string]: unknown;
+};
+export type RenderHostOpts = {
+    strict?: boolean;
+    closureRoots?: string[];
+    explicit?: Record<string, string>;
+    preload?: 'all' | 'closure' | 'none';
+    cacheBust?: string | number;
+    rootChunkIds?: string[] | null;
+    [key: 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,67 @@
+/**
+ * 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;
+/** Subset of `node:path` used by static resolve helpers. */
+export type NodePathModule = {
+    resolve(...paths: string[]): string;
+    join(...paths: string[]): string;
+    extname(path: string): string;
+    readonly sep: string;
+};
+/** Minimal `fs.Stats`-like surface for static file probes. */
+export type StatResult = {
+    isFile(): boolean;
+    isDirectory(): boolean;
+};
+export type StatFn = (path: string) => Promise<StatResult>;
+export type DistStaticResolveOpts = {
+    cookieHeader?: string;
+};
+/** Multipart form fields: text, File, or repeated same-name values. */
+export type MultipartFieldValue = string | File | Array<string | File>;
+export type MultipartFields = Record<string, MultipartFieldValue>;
+export type OctetStreamBody = {
+    bytes: Buffer;
+    size: number;
+    key: string;
+    uploadId: string;
+    chunkIndex?: number;
+    chunkTotal?: number;
+    contentType: string;
+};

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;