@ziex/cli 0.1.0-dev.865 → 0.1.0-test.1

package/kv.d.ts

@@ -1,27 +0,0 @@
-export interface KVNamespace {
-    get(key: string): Promise<string | null>;
-    put(key: string, value: string, options?: {
-        expiration?: number;
-        expirationTtl?: number;
-    }): Promise<void>;
-    delete(key: string): Promise<void>;
-    list(options?: {
-        prefix?: string;
-    }): Promise<{
-        keys: {
-            name: string;
-        }[];
-    }>;
-}
-/**
- * In-memory KV namespace. Used as the default shim on platforms that don't
- * provide a real KV binding (e.g. Vercel). Data lives only for the lifetime
- * of the isolate instance.
- */
-export declare function createMemoryKV(): KVNamespace;
-/**
- * Create a `__zx_kv` import object for use with `run({ kv: ... })`.
- * Always returns a valid import object. When JSPI is unavailable all KV
- * operations are stubbed (get → not-found, put/delete → success, list → []).
- */
-export declare function createKVImports(bindings: Record<string, KVNamespace>, getMemory: () => WebAssembly.Memory): Record<string, unknown>;

package/react/dom.d.ts

@@ -1,21 +0,0 @@
-import type { ComponentMetadata } from "./types";
-export type PreparedComponent = {
-    domNode: HTMLElement;
-    props: Record<string, any> & {
-        dangerouslySetInnerHTML?: {
-            __html: string;
-        };
-    };
-    Component: (props: any) => React.ReactElement;
-};
-export declare function prepareComponent(component: ComponentMetadata): Promise<PreparedComponent>;
-export declare function filterComponents(components: ComponentMetadata[]): ComponentMetadata[];
-export type DiscoveredComponent = {
-    id: string;
-    name: string;
-    props: Record<string, any>;
-    container: HTMLElement;
-};
-export declare function discoverComponents(): DiscoveredComponent[];
-export type ComponentRegistry = Record<string, () => Promise<(props: any) => React.ReactElement>>;
-export declare function hydrateAll(registry: ComponentRegistry, render: (container: HTMLElement, Component: (props: any) => React.ReactElement, props: Record<string, any>) => void): Promise<void>;

package/react/index.d.ts

@@ -1,2 +0,0 @@
-export { prepareComponent, filterComponents, discoverComponents, hydrateAll, type PreparedComponent, type DiscoveredComponent, type ComponentRegistry, } from "./dom";
-export type { ComponentMetadata } from "./types";

package/react/index.js

@@ -1,144 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/react/dom.ts
-function findCommentMarker(id) {
-  const startPrefix = `$${id} `;
-  const endMarker = `/$${id}`;
-  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT, null);
-  let startComment = null;
-  let endComment = null;
-  let name = "";
-  let props = {};
-  let node;
-  while (node = walker.nextNode()) {
-    const text = node.textContent?.trim() || "";
-    if (text.startsWith(startPrefix)) {
-      startComment = node;
-      const content = text.slice(startPrefix.length);
-      const jsonStart = content.indexOf("{");
-      if (jsonStart !== -1) {
-        name = content.slice(0, jsonStart).trim();
-        const jsonStr = content.slice(jsonStart);
-        try {
-          props = JSON.parse(jsonStr);
-        } catch {}
-      } else {
-        name = content.trim();
-      }
-    }
-    if (text === endMarker) {
-      endComment = node;
-      break;
-    }
-  }
-  if (startComment && endComment) {
-    return { startComment, endComment, name, props };
-  }
-  return null;
-}
-function createContainerBetweenMarkers(startComment, endComment) {
-  const container = document.createElement("div");
-  container.style.display = "contents";
-  let current = startComment.nextSibling;
-  while (current && current !== endComment) {
-    const next = current.nextSibling;
-    container.appendChild(current);
-    current = next;
-  }
-  endComment.parentNode?.insertBefore(container, endComment);
-  return container;
-}
-async function prepareComponent(component) {
-  const marker = findCommentMarker(component.id);
-  if (!marker) {
-    throw new Error(`Comment marker for ${component.id} not found`, { cause: component });
-  }
-  const props = marker.props;
-  const domNode = createContainerBetweenMarkers(marker.startComment, marker.endComment);
-  const Component = await component.import();
-  return { domNode, props, Component };
-}
-function filterComponents(components) {
-  const currentPath = window.location.pathname;
-  return components.filter((component) => component.route === currentPath || !component.route);
-}
-function discoverComponents() {
-  const components = [];
-  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT, null);
-  const markers = [];
-  let node;
-  while (node = walker.nextNode()) {
-    const text = node.textContent?.trim() || "";
-    if (text.startsWith("$") && !text.startsWith("/$")) {
-      const spaceIdx = text.indexOf(" ");
-      if (spaceIdx !== -1) {
-        const id = text.slice(1, spaceIdx);
-        const content = text.slice(spaceIdx + 1);
-        if (content.startsWith("[")) {
-          continue;
-        }
-        const jsonStart = content.indexOf("{");
-        let name = "";
-        let props = {};
-        if (jsonStart !== -1) {
-          name = content.slice(0, jsonStart).trim();
-          try {
-            props = JSON.parse(content.slice(jsonStart));
-          } catch {}
-        } else {
-          name = content.trim();
-        }
-        markers.push({ id, name, props, startComment: node, endComment: null });
-      }
-    } else if (text.startsWith("/$")) {
-      const id = text.slice(2);
-      const marker = markers.find((m) => m.id === id && !m.endComment);
-      if (marker) {
-        marker.endComment = node;
-      }
-    }
-  }
-  for (const marker of markers) {
-    if (!marker.endComment)
-      continue;
-    const container = createContainerBetweenMarkers(marker.startComment, marker.endComment);
-    components.push({
-      id: marker.id,
-      name: marker.name,
-      props: marker.props,
-      container
-    });
-  }
-  return components;
-}
-async function hydrateAll(registry, render) {
-  const components = discoverComponents();
-  await Promise.all(components.map(async ({ name, props, container }) => {
-    const importer = registry[name];
-    if (!importer) {
-      console.warn(`Component "${name}" not found in registry`);
-      return;
-    }
-    try {
-      const Component = await importer();
-      render(container, Component, props);
-    } catch (error) {
-      console.error(`Failed to hydrate "${name}":`, error);
-    }
-  }));
-}
-export {
-  prepareComponent,
-  hydrateAll,
-  filterComponents,
-  discoverComponents
-};

package/react/types.d.ts

@@ -1,190 +0,0 @@
-/**
- * Metadata for a client-side component used within a ZX file.
- *
- * This type represents the metadata for components that are marked with the `@rendering` attribute
- * in ZX files. When a component is declared with `@rendering={.react}` or `@rendering={.client}` in a
- * `.zx` file, the ZX transpiler generates a `ComponentMetadata` entry that is included in the
- * generated `components` array.
- *
- * @example
- * ```tsx
- * // In a ZX file (page.zx):
- * <CounterComponent @rendering={.react} max_count={10} />
- *
- * // Generated components array (components.ts):
- * export const components: ComponentMetadata[] = [
- *   {
- *     name: "CounterComponent",
- *     path: "./components/CounterComponent.tsx",
- *     id: "zx-dcde04c415da9d1b15ca2690d8b497ae",
- *     type: "react",
- *     import: () => import('./components/CounterComponent.tsx')
- *   }
- * ];
- * ```
- *
- * @example
- * ```tsx
- * // Using ComponentMetadata with prepareComponent:
- * import { prepareComponent, type ComponentMetadata } from "ziex";
- *
- * for (const component of components) {
- *   const { domNode, props, Component } = await prepareComponent(component);
- *   // Render component to DOM node
- * }
- * ```
- */
-export type ComponentMetadata = {
-    /**
-     * The name of the component as declared in the ZX file.
-     *
-     * This is the tag name used in JSX syntax within `.zx` files. It corresponds to the component
-     * identifier used in the component declaration (e.g., `<CounterComponent />`).
-     *
-     * @example
-     * ```tsx
-     * // In ZX file:
-     * <CounterComponent @rendering={.react} />
-     *
-     * // name will be: "CounterComponent"
-     * ```
-     */
-    name: string;
-    /**
-     * The file path to the component module.
-     *
-     * This is the relative or absolute path to the component file that will be dynamically imported
-     * at runtime. For CSR components, this typically points to a `.tsx` or `.jsx` file. For Client
-     * components, this points to a Zig component file.
-     *
-     * The path is determined from the `@jsImport` directive in the ZX file, or defaults to
-     * `./{componentName}.tsx` if not explicitly specified.
-     *
-     * @example
-     * ```tsx
-     * // In ZX file:
-     * const CounterComponent = @jsImport("components/Counter.tsx");
-     * <CounterComponent @rendering={.react} />
-     *
-     * // path will be: "components/Counter.tsx"
-     * ```
-     *
-     * @example
-     * ```tsx
-     * // Without explicit @jsImport:
-     * <MyComponent @rendering={.react} />
-     *
-     * // path will default to: "./MyComponent.tsx"
-     * ```
-     */
-    path: string;
-    /**
-     * The route of of the component in which page the component was used,
-     * null in case the component was used in other non-page/layout context.
-     * ```
-     */
-    route: string | null;
-    /**
-     * A unique identifier for the component's hydration boundary.
-     *
-     * This ID is generated by hashing the component's path and name using MD5, then formatting it
-     * as a hex string with the "zx-" prefix and a counter suffix. The ID is used to locate the
-     * component's comment markers in the DOM during client-side hydration.
-     *
-     * The ID format is: `zx-{32 hex characters}-{counter}` (e.g., `zx-dcde04c415da9d1b15ca2690d8b497ae-0`)
-     *
-     * The ZX runtime renders components with comment markers in the format:
-     * `<!--$id name props-->...<!--/$id-->`
-     *
-     * @example
-     * ```tsx
-     * // Component metadata:
-     * {
-     *   name: "CounterComponent",
-     *   path: "./components/Counter.tsx",
-     *   id: "zx-dcde04c415da9d1b15ca2690d8b497ae-0"
-     * }
-     *
-     * // Generated HTML with comment markers:
-     * <!--$zx-dcde04c415da9d1b15ca2690d8b497ae-0 CounterComponent {"max_count":10}-->
-     * <button>0</button>
-     * <!--/$zx-dcde04c415da9d1b15ca2690d8b497ae-0-->
-     * ```
-     */
-    id: string;
-    /**
-     * The rendering type of the component, determining how it will be rendered on the client.
-     *
-     * - **"react"** (Client Side React): The component is a React component that will be rendered
-     *   using React's client-side rendering. The component file should export a default React
-     *   component function. This is the most common type for interactive UI components.
-     *
-     * - **"client"** (Client Side Zig): The component is a Zig component that will be compiled to
-     *   WebAssembly and rendered on the client side. This allows you to use Zig's performance
-     *   and type safety for client-side components.
-     *
-     * The type is determined by the `@rendering` attribute value in the ZX file (`.react` or `.client`).
-     *
-     * @example
-     * ```tsx
-     * // CSR component (React):
-     * <CounterComponent @rendering={.react} max_count={10} />
-     * // type: "react"
-     *
-     * // Component file (CounterComponent.tsx):
-     * export default function CounterComponent({ max_count }: { max_count: number }) {
-     *   return <div>Count: {max_count}</div>;
-     * }
-     * ```
-     *
-     * @example
-     * ```tsx
-     * // Client component (Zig/WASM):
-     * <CounterComponent @rendering={.client} />
-     * // type: "client"
-     *
-     * // Component file (CounterComponent.zig):
-     * pub fn CounterComponent(allocator: zx.Allocator) zx.Component {
-     *   return (<div @allocator={allocator}>Counter</div>);
-     * }
-     * ```
-     */
-    type: "react" | "client";
-    /**
-     * A lazy-loading function that dynamically imports the component module.
-     *
-     * This function returns a Promise that resolves to the component function. It enables
-     * code-splitting and lazy loading of components, improving initial page load performance
-     * by only loading components when they are needed.
-     *
-     * For CSR components, the imported module should export a default React component.
-     * For Client components, the import mechanism depends on the WASM module structure.
-     *
-     * The function is called during client-side hydration to load and render the component
-     * into its corresponding DOM container element.
-     *
-     * @returns A Promise that resolves to a component function that accepts props and returns a React element.
-     *
-     * @example
-     * ```tsx
-     * // Component metadata:
-     * {
-     *   import: () => import('./components/CounterComponent.tsx')
-     * }
-     *
-     * // Usage:
-     * const Component = await component.import();
-     * // Component is now the default export from CounterComponent.tsx
-     * ```
-     *
-     * @example
-     * ```tsx
-     * // With prepareComponent helper:
-     * import { prepareComponent } from "ziex";
-     *
-     * const { Component, props, domNode } = await prepareComponent(component);
-     * // Component is loaded and ready to render with props
-     * ```
-     */
-    import: () => Promise<(props: any) => React.ReactElement>;
-};

package/runtime.d.ts

@@ -1,70 +0,0 @@
-import type { WASI } from "./wasi";
-import type { KVNamespace } from "./kv";
-/** Minimal Durable Object namespace shape needed for WebSocket routing. */
-export type DurableObjectNamespace = {
-    idFromName(name: string): unknown;
-    get(id: unknown): {
-        fetch(req: Request): Promise<Response>;
-    };
-};
-export type WsState = {
-    upgraded: boolean;
-    server: WebSocket | null;
-    pendingWrites: Uint8Array[];
-    messageQueue: Uint8Array[];
-    recvResolve: ((bytes: Uint8Array | null) => void) | null;
-    /** Resolved when ws_recv is called for the first time (WASM has entered the message loop). */
-    _resolveFirstSuspend?: () => void;
-    subscribe?: (topic: string) => void;
-    unsubscribe?: (topic: string) => void;
-    publish?: (topic: string, data: Uint8Array) => number;
-    isSubscribed?: (topic: string) => boolean;
-};
-/** Build the __zx_ws import object for a given connection state. */
-export declare function buildWsImports(Suspending: any, mem: () => WebAssembly.Memory, decoder: TextDecoder, ws: WsState): {
-    ws_upgrade: () => void;
-    ws_write: (ptr: number, len: number) => void;
-    ws_close: (code: number, reason_ptr: number, reason_len: number) => void;
-    ws_recv: any;
-    ws_subscribe: (ptr: number, len: number) => void;
-    ws_unsubscribe: (ptr: number, len: number) => void;
-    ws_publish: (topic_ptr: number, topic_len: number, data_ptr: number, data_len: number) => number;
-    ws_is_subscribed: (ptr: number, len: number) => number;
-};
-/** Create WebSocketPair, wire message/close listeners, flush pending writes. */
-export declare function attachWebSocket(ws: WsState): {
-    client: WebSocket;
-};
-/**
- * Run a WASM module for a single request using JSPI.
- *
- * Pass `kv` as a map of binding names → KV namespaces. The Zig side selects
- * a binding via `zx.kv.scope("name")`; the top-level `zx.kv.*` functions use
- * `"default"`.
- *
- * @example
- * ```ts
- * return run({
- *   request, env, ctx, module,
- *   kv: { default: env.KV, users: env.USERS_KV },
- * });
- * ```
- */
-export declare function run({ request, env, ctx, module, kv: kvBindings, imports, wasi, websocket: doNamespace, }: {
-    request: Request;
-    env?: unknown;
-    ctx?: {
-        waitUntil(promise: Promise<unknown>): void;
-    };
-    module: WebAssembly.Module;
-    /** KV namespace bindings — `{ default: env.KV, otherName: env.OTHER_KV }` */
-    kv?: Record<string, KVNamespace>;
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
-    wasi?: WASI;
-    /**
-     * Durable Object namespace to use for WebSocket connections.
-     * When provided, WebSocket upgrade requests are automatically forwarded to
-     * the DO so that pub/sub works across multiple connected clients.
-     */
-    websocket?: DurableObjectNamespace;
-}): Promise<Response>;

package/vercel/index.d.ts

@@ -1,26 +0,0 @@
-/**
- * Ziex adapter for Vercel Edge Functions.
- *
- * @example
- * ```ts
- * import { Ziex } from "ziex/cloudflare";
- * import { handle } from "ziex/vercel";
- * import module from "./app.wasm"; // or fetch at runtime
- *
- * const app = new Ziex({ module });
- *
- * export const config = { runtime: "edge" };
- * export default handle(app);
- * ```
- */
-type FetchApp = {
-    fetch(req: Request, env?: unknown, ctx?: unknown): Promise<Response>;
-};
-/**
- * Wrap a Ziex app as a Vercel Edge Function handler.
- *
- * Returns a standard `(req: Request) => Promise<Response>` function.
- * Vercel's edge runtime calls it directly — just export it as default.
- */
-export declare function handle(app: FetchApp): (req: Request) => Promise<Response>;
-export {};

package/vercel/index.js

@@ -1,18 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/vercel/index.ts
-function handle(app) {
-  return (req) => app.fetch(req);
-}
-export {
-  handle
-};

package/wasi.d.ts

@@ -1,61 +0,0 @@
-export declare class ProcExit extends Error {
-    readonly code: number;
-    constructor(code: number);
-}
-export type WASI = {
-    wasiImport: Record<string, (...args: any[]) => unknown>;
-    start(instance: {
-        exports: {
-            memory: WebAssembly.Memory;
-            _start: () => unknown;
-        };
-    }): number;
-    initialize?(instance: {
-        exports: {
-            memory: WebAssembly.Memory;
-            _initialize?: () => unknown;
-        };
-    }): void;
-};
-export declare function createWasiImports({ request, stdinData, onStdout, }: {
-    request: Request;
-    stdinData?: Uint8Array;
-    /** Called for each stdout chunk. When provided, chunks are NOT buffered internally. */
-    onStdout?: (chunk: Uint8Array) => void;
-}): {
-    wasiImport: {
-        args_sizes_get(argc_ptr: number, argv_buf_size_ptr: number): number;
-        args_get(argv_ptr: number, argv_buf_ptr: number): number;
-        environ_sizes_get(count_ptr: number, buf_size_ptr: number): number;
-        environ_get(_environ_ptr: number, _environ_buf_ptr: number): number;
-        fd_write(fd: number, iovs_ptr: number, iovs_len: number, nwritten_ptr: number): number;
-        fd_read(fd: number, iovs_ptr: number, iovs_len: number, nread_ptr: number): number;
-        fd_fdstat_get(_fd: number, fdstat_ptr: number): number;
-        fd_prestat_get(_fd: number, _bufptr: number): number;
-        fd_prestat_dir_name(_fd: number, _path: number, _path_len: number): number;
-        fd_close(_fd: number): number;
-        fd_pread(_fd: number, _iovs: number, _iovs_len: number, _offset: bigint, nread_ptr: number): number;
-        fd_pwrite(_fd: number, _iovs: number, _iovs_len: number, _offset: bigint, nwritten_ptr: number): number;
-        fd_filestat_get(_fd: number, filestat_ptr: number): number;
-        fd_seek(_fd: number, _offset: bigint, _whence: number, newoffset_ptr: number): number;
-        proc_exit(code: number): never;
-        sched_yield(): number;
-        clock_time_get(_id: number, _precision: bigint, time_ptr: number): number;
-        random_get(buf_ptr: number, buf_len: number): number;
-        path_open(_fd: number, _dirflags: number, _path: number, _path_len: number, _oflags: number, _rights_base: bigint, _rights_inheriting: bigint, _fdflags: number, opened_fd_ptr: number): number;
-        path_create_directory(_fd: number, _path: number, _path_len: number): number;
-        path_unlink_file(_fd: number, _path: number, _path_len: number): number;
-        path_remove_directory(_fd: number, _path: number, _path_len: number): number;
-        path_rename(_fd: number, _old_path: number, _old_path_len: number, _new_fd: number, _new_path: number, _new_path_len: number): number;
-        path_filestat_get(_fd: number, _flags: number, _path: number, _path_len: number, filestat_ptr: number): number;
-        path_readlink(_fd: number, _path: number, _path_len: number, _buf: number, _buf_len: number, nread_ptr: number): number;
-        fd_readdir(_fd: number, _buf: number, _buf_len: number, _cookie: bigint, bufused_ptr: number): number;
-        poll_oneoff(_in: number, _out: number, _nsubscriptions: number, nevents_ptr: number): number;
-    };
-    setMemory: (m: WebAssembly.Memory) => void;
-    collectOutput: () => {
-        stdout: Uint8Array;
-        stderrText: string;
-    };
-};
-export declare function mergeUint8Arrays(arrays: Uint8Array[]): Uint8Array;

package/wasm/core.d.ts

@@ -1,78 +0,0 @@
-import { ZigJS } from "../../../../vendor/jsz/js/src";
-/**
- * Core WASM bridge — environment-agnostic (browser + edge).
- * Contains no references to browser globals (document, window, WebSocket, HTMLFormElement).
- */
-export declare const CallbackType: {
-    readonly Event: 0;
-    readonly FetchSuccess: 1;
-    readonly FetchError: 2;
-    readonly Timeout: 3;
-    readonly Interval: 4;
-    readonly WebSocketOpen: 5;
-    readonly WebSocketMessage: 6;
-    readonly WebSocketError: 7;
-    readonly WebSocketClose: 8;
-};
-export type CallbackTypeValue = typeof CallbackType[keyof typeof CallbackType];
-export type CallbackHandler = (callbackType: number, id: bigint, dataRef: bigint) => void;
-export type FetchCompleteHandler = (fetchId: bigint, statusCode: number, bodyPtr: number, bodyLen: number, isError: number) => void;
-export type WsOnOpenHandler = (wsId: bigint, protocolPtr: number, protocolLen: number) => void;
-export type WsOnMessageHandler = (wsId: bigint, dataPtr: number, dataLen: number, isBinary: number) => void;
-export type WsOnErrorHandler = (wsId: bigint, msgPtr: number, msgLen: number) => void;
-export type WsOnCloseHandler = (wsId: bigint, code: number, reasonPtr: number, reasonLen: number, wasClean: number) => void;
-export declare const jsz: ZigJS;
-/** Store a value using jsz.storeValue and get the 64-bit reference. */
-export declare function storeValueGetRef(val: any): bigint;
-/** Shared encoder/decoder — avoids allocating new instances on every call. */
-export declare const textDecoder: TextDecoder;
-export declare const textEncoder: TextEncoder;
-export declare function getMemoryView(): Uint8Array;
-/** Read a string from WASM memory */
-export declare function readString(ptr: number, len: number): string;
-/** Write bytes to WASM memory at a specific location */
-export declare function writeBytes(ptr: number, data: Uint8Array): void;
-/**
- * Core ZX Bridge — works in both browser and edge runtimes.
- * Contains fetch, timers, and logging. No DOM or browser-WebSocket references.
- *
- * Extend this class in browser environments to add DOM and WebSocket support.
- */
-export declare class ZxBridgeCore {
-    #private;
-    protected readonly _alloc: (size: number) => number;
-    constructor(exports: WebAssembly.Exports);
-    /**
-     * Async fetch with full options support.
-     * Calls __zx_fetch_complete when done.
-     */
-    fetchAsync(urlPtr: number, urlLen: number, methodPtr: number, methodLen: number, headersPtr: number, headersLen: number, bodyPtr: number, bodyLen: number, timeoutMs: number, fetchId: bigint): void;
-    /** Notify WASM that a fetch completed */
-    protected _notifyFetchComplete(fetchId: bigint, statusCode: number, body: string, isError: boolean): void;
-    /** Set a timeout and callback when it fires */
-    setTimeout(callbackId: bigint, delayMs: number): void;
-    /** Set an interval and callback each time it fires */
-    setInterval(callbackId: bigint, intervalMs: number): void;
-    /** Clear an interval */
-    clearInterval(callbackId: bigint): void;
-    /** Write a string to WASM memory, returning pointer and length */
-    protected _writeStringToWasm(str: string): {
-        ptr: number;
-        len: number;
-    };
-    protected _writeBytesToWasm(data: Uint8Array): {
-        ptr: number;
-        len: number;
-    };
-    /** Log a message from WASM at the given level (0=error, 1=warn, 2=info, 3=debug) */
-    static log(level: number, ptr: number, len: number): void;
-    /**
-     * Create the core import object for WASM instantiation.
-     * Includes only environment-agnostic bindings: log, fetch, and timers.
-     * Use ZxBridge.createImportObject (from wasm/index.ts) in browser contexts
-     * to additionally include DOM and WebSocket bindings.
-     */
-    static createImportObject(bridgeRef: {
-        current: ZxBridgeCore | null;
-    }): WebAssembly.Imports;
-}

package/wasm/dom.d.ts

@@ -1,4 +0,0 @@
-import type { ComponentMetadata } from "./types";
-export type PreparedComponent = {};
-export declare function prepareComponent(component: ComponentMetadata): Promise<PreparedComponent>;
-export declare function filterComponents(components: ComponentMetadata[]): ComponentMetadata[];