[Canonical page](<https://docs.dhtmlx.com/planning-engine/wasm/api/init/>)
[Full documentation index](<https://docs.dhtmlx.com/planning-engine/llms.txt>)


# init

The default export of the browser build (`pkg/plen_wasm.js`). It fetches and instantiates the WebAssembly module. Await it once before the first `new` [`JsonProject`](<https://docs.dhtmlx.com/planning-engine/wasm/api/json-project.md>) or [`schedule`](<https://docs.dhtmlx.com/planning-engine/wasm/api/schedule.md>) call. The Node build (`pkg-node/`) has no `init`: `require` loads and instantiates the module synchronously.

## Signature

```ts
init(module_or_path?: { module_or_path: InitInput | Promise<InitInput> }): Promise<InitOutput>

type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
```

Asynchronous. It's the only async step of the raw surface; every other export is synchronous.

## Parameters

| Name | Type | Description |
|---|---|---|
| `module_or_path` | `{ module_or_path: InitInput \| Promise<InitInput> }` | Optional. Where to load the module from. Omitted: `plen_wasm_bg.wasm` in the same folder as `plen_wasm.js`. |

Accepted values for `module_or_path.module_or_path`:

| Value | What `init` does |
|---|---|
| URL string, `URL`, `Request` | Fetches it, then instantiates the response. |
| `Response` | Instantiates the response body. Streams it when the server sends `Content-Type: application/wasm`; otherwise logs a warning and falls back to reading the whole body. |
| `BufferSource` (bytes) | Instantiates the bytes. |
| `WebAssembly.Module` | Instantiates the compiled module. |
| A promise of any of these | Awaits it, then handles the value as above. |

Passing the value directly, without the `{ module_or_path }` wrapper, still works. wasm-bindgen marks that form as deprecated and logs a warning.

## Behavior

- Runs once per page or worker. When the module is already instantiated, a later `init` or `initSync` call returns the existing instance and ignores its argument.
- The exports read the module that `init` installs. Calling `new JsonProject(...)` or `schedule(...)` before the promise resolves throws a `TypeError`.

## Returns

A promise of the instantiated module's raw exports (`InitOutput`). These are binding-generator internals. Call the named exports (`JsonProject`, `schedule`) instead, and treat the resolved value only as a "ready" signal.

## Errors

| Error | When |
|---|---|
| Rejects with `Error` (`failed to fetch Wasm: ...`) | The fetched `Response` has a non-2xx status. |
| Rejects (fetch error) | The URL can't be fetched. |
| Rejects (`WebAssembly.CompileError` / `LinkError`) | The bytes aren't a valid module for this build. |

See [Error handling](<https://docs.dhtmlx.com/planning-engine/wasm/error-handling.md#host-level-throws>) for the other host-level failures.

## initSync

```ts
initSync(module: { module: SyncInitInput }): InitOutput

type SyncInitInput = BufferSource | WebAssembly.Module;
```

Instantiates the module synchronously from bytes or a compiled `WebAssembly.Module`. Bytes are compiled on the calling thread. It fetches nothing, so it fits hosts that already hold the module, such as a worker that receives a `WebAssembly.Module` from the main thread. Like `init`, it returns the existing instance when the module is already instantiated. Passing the value without the `{ module }` wrapper is deprecated and logs a warning. Invalid bytes throw synchronously.

## Example

```js
import init, { schedule } from "./pkg/plen_wasm.js";

await init({ module_or_path: new URL("/static/plen_wasm_bg.wasm", location.origin) });

const data = { tasks: [{ id: 1, start_date: "2026-01-05", duration: 2 }] };
const envelope = JSON.parse(schedule(JSON.stringify(data), "{}"));
```

Synchronous loading in a worker:

```js
import { initSync, JsonProject } from "./pkg/plen_wasm.js";

self.onmessage = ({ data }) => {
  initSync({ module: data.wasmModule }); // WebAssembly.Module sent by the main thread
  const project = new JsonProject("{}");
  // ...
  project.free();
};
```

Build targets and the Node loading path are in [Module and handles](<https://docs.dhtmlx.com/planning-engine/wasm/module-and-handles.md>).

:::note
The package entry (`plen-wasm`) also has a default export `init`, used with the `Project` class. In the browser build, `await init()` before creating a `Project`; it loads the WebAssembly module and resolves to the module's exports. See [JavaScript usage](<https://docs.dhtmlx.com/planning-engine/wasm/javascript.md>).
:::

## Related

- [`JsonProject`](<https://docs.dhtmlx.com/planning-engine/wasm/api/json-project.md>) - the project handle to create once the module is loaded
- [`schedule`](<https://docs.dhtmlx.com/planning-engine/wasm/api/schedule.md>) - one-shot scheduling without a handle
- [Module and Handles](<https://docs.dhtmlx.com/planning-engine/wasm/module-and-handles.md>) - build targets, loading and handle lifetime
- [Run in a worker](<https://docs.dhtmlx.com/planning-engine/wasm/how-to/run-in-a-worker.md>) - loading the module off the main thread
- [Error handling](<https://docs.dhtmlx.com/planning-engine/wasm/error-handling.md>) - host-level failures such as calling an export before `init` resolves