@structured-world/structured-public-domains 0.0.6 → 0.0.8

package/dist/tiny.d.cts

@@ -0,0 +1,45 @@
+import { D as DomainInfo } from './trie-jGeN4GI6.cjs';
+
+/** Default data source: the prebuilt trie served from this package via jsDelivr's CDN. */
+declare const DEFAULT_PSL_URL: string;
+/** Options for {@link load}. */
+interface LoadOptions {
+    /** Where to fetch `psl.bin` from. Defaults to {@link DEFAULT_PSL_URL}. */
+    url?: string;
+    /** Custom fetch implementation (e.g. for proxies/tests). Defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Enable the persistent local cache (Node file / browser CacheStorage). Default `true`. */
+    cache?: boolean;
+    /** Cache freshness window in milliseconds. Default 24h. */
+    cacheTtlMs?: number;
+    /** Node only: directory for the cache file. Defaults to an OS temp subdir. */
+    cacheDir?: string;
+    /** Re-fetch even if already loaded / cached. Default `false`. */
+    force?: boolean;
+}
+/**
+ * Fetch, cache, and parse the PSL trie. Idempotent: a second call is a no-op
+ * unless `force` is set. Must be awaited before {@link lookup} and friends.
+ *
+ * @throws if the data cannot be fetched or is implausibly small / corrupt.
+ *
+ * @example
+ * ```ts
+ * import { load, registrableDomain } from '@structured-world/structured-public-domains/tiny';
+ * await load();
+ * registrableDomain('sub.example.co.uk'); // "example.co.uk"
+ * ```
+ */
+declare function load(opts?: LoadOptions): Promise<void>;
+/** Whether {@link load} has completed and the lookup API is ready. */
+declare function isLoaded(): boolean;
+/** Look up a domain. Requires a prior `await load()`. See the main entry's `lookup`. */
+declare function lookup(domain: string): DomainInfo | undefined;
+/** Extract the registrable domain (eTLD+1). Requires a prior `await load()`. */
+declare function registrableDomain(domain: string): string | undefined;
+/** Whether a domain's suffix is a known PSL entry. Requires a prior `await load()`. */
+declare function isKnownSuffix(domain: string): boolean;
+/** The raw binary trie blob that was loaded (defensive copy). Requires a prior `await load()`. */
+declare function pslData(): Uint8Array;
+
+export { DEFAULT_PSL_URL, DomainInfo, type LoadOptions, isKnownSuffix, isLoaded, load, lookup, pslData, registrableDomain };

package/dist/tiny.d.ts

@@ -0,0 +1,45 @@
+import { D as DomainInfo } from './trie-jGeN4GI6.js';
+
+/** Default data source: the prebuilt trie served from this package via jsDelivr's CDN. */
+declare const DEFAULT_PSL_URL: string;
+/** Options for {@link load}. */
+interface LoadOptions {
+    /** Where to fetch `psl.bin` from. Defaults to {@link DEFAULT_PSL_URL}. */
+    url?: string;
+    /** Custom fetch implementation (e.g. for proxies/tests). Defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Enable the persistent local cache (Node file / browser CacheStorage). Default `true`. */
+    cache?: boolean;
+    /** Cache freshness window in milliseconds. Default 24h. */
+    cacheTtlMs?: number;
+    /** Node only: directory for the cache file. Defaults to an OS temp subdir. */
+    cacheDir?: string;
+    /** Re-fetch even if already loaded / cached. Default `false`. */
+    force?: boolean;
+}
+/**
+ * Fetch, cache, and parse the PSL trie. Idempotent: a second call is a no-op
+ * unless `force` is set. Must be awaited before {@link lookup} and friends.
+ *
+ * @throws if the data cannot be fetched or is implausibly small / corrupt.
+ *
+ * @example
+ * ```ts
+ * import { load, registrableDomain } from '@structured-world/structured-public-domains/tiny';
+ * await load();
+ * registrableDomain('sub.example.co.uk'); // "example.co.uk"
+ * ```
+ */
+declare function load(opts?: LoadOptions): Promise<void>;
+/** Whether {@link load} has completed and the lookup API is ready. */
+declare function isLoaded(): boolean;
+/** Look up a domain. Requires a prior `await load()`. See the main entry's `lookup`. */
+declare function lookup(domain: string): DomainInfo | undefined;
+/** Extract the registrable domain (eTLD+1). Requires a prior `await load()`. */
+declare function registrableDomain(domain: string): string | undefined;
+/** Whether a domain's suffix is a known PSL entry. Requires a prior `await load()`. */
+declare function isKnownSuffix(domain: string): boolean;
+/** The raw binary trie blob that was loaded (defensive copy). Requires a prior `await load()`. */
+declare function pslData(): Uint8Array;
+
+export { DEFAULT_PSL_URL, DomainInfo, type LoadOptions, isKnownSuffix, isLoaded, load, lookup, pslData, registrableDomain };

package/dist/tiny.js

@@ -0,0 +1,167 @@
+import { parseTrie, lookupTrie } from './chunk-EON4VJGA.js';
+
+// src/tiny.ts
+var PSL_RANGE = "0.0" ;
+var DEFAULT_PSL_URL = `https://cdn.jsdelivr.net/npm/@structured-world/structured-public-domains@${PSL_RANGE}/dist/psl.bin`;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var cachedBytes;
+var cachedTrie;
+var inFlight;
+var latestGen = 0;
+var latestSettled;
+function load(opts = {}) {
+  if (cachedTrie !== void 0 && opts.force !== true) return Promise.resolve();
+  if (inFlight !== void 0 && opts.force !== true) return inFlight;
+  const gen = ++latestGen;
+  const pending = doLoad(opts, gen);
+  latestSettled = pending;
+  inFlight = pending;
+  pending.finally(() => {
+    if (inFlight === pending) inFlight = void 0;
+  }).catch(() => void 0);
+  return pending;
+}
+function mirrorLatest() {
+  return latestSettled ?? Promise.resolve();
+}
+async function doLoad(opts, gen) {
+  let data;
+  let trie;
+  try {
+    [data, trie] = await fetchAndParse(opts);
+  } catch (err) {
+    if (gen !== latestGen) return mirrorLatest();
+    throw err;
+  }
+  if (gen !== latestGen) return mirrorLatest();
+  cachedBytes = data;
+  cachedTrie = trie;
+}
+async function fetchAndParse(opts) {
+  const url = opts.url ?? DEFAULT_PSL_URL;
+  const ttlMs = opts.cacheTtlMs ?? DEFAULT_TTL_MS;
+  const useCache = opts.cache ?? true;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  if (useCache && opts.force !== true) {
+    const cached = await readCache(url, ttlMs, opts.cacheDir);
+    if (cached !== void 0) {
+      try {
+        return [cached, parseTrie(cached)];
+      } catch {
+        await deleteCache(url, opts.cacheDir).catch(() => void 0);
+      }
+    }
+  }
+  if (typeof doFetch !== "function") {
+    throw new Error("no fetch implementation available; pass `fetch` in LoadOptions");
+  }
+  const data = await fetchBytes(doFetch, url);
+  const trie = parseTrie(data);
+  if (useCache) await writeCache(url, data, opts.cacheDir).catch(() => void 0);
+  return [data, trie];
+}
+function isLoaded() {
+  return cachedTrie !== void 0;
+}
+function requireTrie() {
+  if (cachedTrie === void 0) {
+    throw new Error("PSL data not loaded \u2014 call `await load()` before lookups");
+  }
+  return cachedTrie;
+}
+function lookup(domain) {
+  return lookupTrie(requireTrie(), domain);
+}
+function registrableDomain(domain) {
+  return lookup(domain)?.registrableDomain;
+}
+function isKnownSuffix(domain) {
+  return lookup(domain)?.known ?? false;
+}
+function pslData() {
+  if (cachedBytes === void 0) {
+    throw new Error("PSL data not loaded \u2014 call `await load()` before pslData()");
+  }
+  return cachedBytes.slice();
+}
+async function fetchBytes(doFetch, url) {
+  const res = await doFetch(url);
+  if (!res.ok) {
+    throw new Error(`failed to fetch PSL data from ${url}: ${res.status} ${res.statusText}`);
+  }
+  const data = new Uint8Array(await res.arrayBuffer());
+  if (data.length < 1024) {
+    throw new Error(`PSL data from ${url} is implausibly small (${data.length} bytes)`);
+  }
+  return data;
+}
+function cacheKey(url) {
+  let h = 2166136261;
+  for (let i = 0; i < url.length; i++) {
+    h ^= url.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+async function readCache(url, ttlMs, cacheDir) {
+  try {
+    return isNode ? await readNodeCache(url, ttlMs, cacheDir) : await readBrowserCache(url, ttlMs);
+  } catch {
+    return void 0;
+  }
+}
+async function writeCache(url, data, cacheDir) {
+  if (isNode) await writeNodeCache(url, data, cacheDir);
+  else await writeBrowserCache(url, data);
+}
+async function deleteCache(url, cacheDir) {
+  if (isNode) {
+    const { fs, file } = await nodeCache(url, cacheDir);
+    fs.rmSync(file, { force: true });
+  } else if (typeof caches !== "undefined") {
+    const cache = await caches.open("structured-public-domains");
+    await cache.delete(url);
+  }
+}
+var nodeRequire = (m) => import(
+  /* @vite-ignore */
+  m
+);
+async function nodeCache(url, cacheDir) {
+  const fs = await nodeRequire("node:fs");
+  const os = await nodeRequire("node:os");
+  const path = await nodeRequire("node:path");
+  const dir = cacheDir ?? path.join(os.tmpdir(), "structured-public-domains-cache");
+  return { fs, dir, file: path.join(dir, `psl-${cacheKey(url)}.bin`) };
+}
+async function readNodeCache(url, ttlMs, cacheDir) {
+  const { fs, file } = await nodeCache(url, cacheDir);
+  const stat = fs.statSync(file);
+  if (Date.now() - stat.mtimeMs >= ttlMs) return void 0;
+  return new Uint8Array(fs.readFileSync(file));
+}
+async function writeNodeCache(url, data, cacheDir) {
+  const { fs, dir, file } = await nodeCache(url, cacheDir);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, data);
+  fs.renameSync(tmp, file);
+}
+async function readBrowserCache(url, ttlMs) {
+  if (typeof caches === "undefined") return void 0;
+  const cache = await caches.open("structured-public-domains");
+  const res = await cache.match(url);
+  if (res == null) return void 0;
+  const cachedAt = Number(res.headers.get("x-cached-at") ?? "0");
+  if (!Number.isFinite(cachedAt) || Date.now() - cachedAt >= ttlMs) return void 0;
+  return new Uint8Array(await res.arrayBuffer());
+}
+async function writeBrowserCache(url, data) {
+  if (typeof caches === "undefined") return;
+  const cache = await caches.open("structured-public-domains");
+  const body = data.slice();
+  await cache.put(url, new Response(body, { headers: { "x-cached-at": String(Date.now()) } }));
+}
+
+export { DEFAULT_PSL_URL, isKnownSuffix, isLoaded, load, lookup, pslData, registrableDomain };

package/dist/trie-jGeN4GI6.d.cts

@@ -0,0 +1,11 @@
+/** Result of a PSL lookup. */
+interface DomainInfo {
+    /** The public suffix (e.g. `"co.uk"`, `"com"`, `"github.io"`). */
+    readonly suffix: string;
+    /** The registrable domain (eTLD+1), or `undefined` if the input is itself a suffix. */
+    readonly registrableDomain: string | undefined;
+    /** Whether the suffix matched an explicit PSL rule (vs the `*` fallback). */
+    readonly known: boolean;
+}
+
+export type { DomainInfo as D };

package/dist/trie-jGeN4GI6.d.ts

@@ -0,0 +1,11 @@
+/** Result of a PSL lookup. */
+interface DomainInfo {
+    /** The public suffix (e.g. `"co.uk"`, `"com"`, `"github.io"`). */
+    readonly suffix: string;
+    /** The registrable domain (eTLD+1), or `undefined` if the input is itself a suffix. */
+    readonly registrableDomain: string | undefined;
+    /** Whether the suffix matched an explicit PSL rule (vs the `*` fallback). */
+    readonly known: boolean;
+}
+
+export type { DomainInfo as D };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@structured-world/structured-public-domains",
-  "version": "0.0.6",
-  "description": "Compact Public Suffix List (PSL). ~108KB binary trie, ~2.4M lookups/sec, checked daily against publicsuffix.org.",
+  "version": "0.0.8",
+  "description": "Compact Public Suffix List (PSL) as a native TypeScript package: embedded ~108KB binary trie, synchronous zero-dependency lookups, ESM + CommonJS. Checked daily against publicsuffix.org.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -12,46 +12,60 @@
     "public-suffix",
     "domain",
     "tld",
-    "validation",
-    "wasm",
-    "webassembly"
+    "etld",
+    "registrable-domain",
+    "trie",
+    "validation"
   ],
   "type": "module",
-  "main": "./node.cjs",
-  "types": "./index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "node": {
-        "import": {
-          "types": "./index.d.ts",
-          "default": "./node.js"
-        },
-        "require": {
-          "types": "./index.d.cts",
-          "default": "./node.cjs"
-        }
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       },
-      "default": {
-        "types": "./browser.d.ts",
-        "default": "./browser.js"
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
-    "./browser": {
-      "types": "./browser.d.ts",
-      "default": "./browser.js"
-    }
+    "./tiny": {
+      "import": {
+        "types": "./dist/tiny.d.ts",
+        "default": "./dist/tiny.js"
+      },
+      "require": {
+        "types": "./dist/tiny.d.cts",
+        "default": "./dist/tiny.cjs"
+      }
+    },
+    "./psl.bin": "./dist/psl.bin"
   },
+  "sideEffects": false,
   "files": [
-    "*.js",
-    "*.cjs",
-    "*.d.ts",
-    "*.d.cts",
-    "*.wasm"
+    "dist",
+    "README.md"
   ],
   "publishConfig": {
     "access": "public"
   },
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "gen:data": "node scripts/gen-data.mjs",
+    "build": "npm run gen:data && tsup && node -e \"const fs=require('fs');fs.copyFileSync('src/psl-data.cjs','dist/psl-data.cjs');fs.copyFileSync('../src/psl.bin','dist/psl.bin');fs.copyFileSync('../README.md','README.md')\"",
+    "test": "npm run gen:data && vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "tsup": "^8",
+    "typescript": "^5.6",
+    "vitest": "^2"
   }
 }

package/browser.d.ts

@@ -1,17 +0,0 @@
-// The ".js" specifier is the ESM convention for type re-exports: under
-// node16/nodenext resolution it resolves to the sibling index.d.ts. Writing
-// "./index.d.ts" here would be a TypeScript error (TS2846 / TS5097 — importing
-// a declaration-file extension is not allowed without allowImportingTsExtensions).
-export { DomainInfo, lookup, registrableDomain, isKnownSuffix } from "./index.js";
-
-/**
- * Initialise the wasm module.  Must be awaited before calling any other
- * function from this package.
- *
- * Without arguments the `.wasm` binary is fetched from a sibling URL
- * (works with most bundlers).  You may also pass a `URL`, `Response`,
- * `BufferSource`, or `WebAssembly.Module`.
- */
-export function init(
-  input?: BufferSource | WebAssembly.Module | URL | Response | Promise<Response>,
-): Promise<void>;

package/browser.js

@@ -1,44 +0,0 @@
-// Browser entry — async init() must be called before other functions.
-import _init, {
-  lookup as _lookup,
-  registrableDomain,
-  isKnownSuffix,
-} from "./structured_public_domains.js";
-
-/**
- * Initialise the wasm module.  Must be called (and awaited) before
- * `lookup`, `registrableDomain`, or `isKnownSuffix`.
- *
- * Without arguments the wasm binary is fetched from a sibling URL
- * (works with most bundlers).  You may also pass a `URL`, `Response`,
- * `BufferSource`, or `WebAssembly.Module`.
- */
-export async function init(input) {
-  // Forward as the current single-object form; `undefined` keeps the default
-  // (fetch the sibling .wasm). Passing raw bytes/URL positionally is deprecated
-  // by wasm-bindgen, so wrap any caller-provided input.
-  await _init(input === undefined ? undefined : { module_or_path: input });
-}
-
-/**
- * Look up a domain in the Public Suffix List.
- *
- * Returns a plain object with `suffix`, `registrableDomain`, and `known`
- * properties, or `undefined` for invalid input.
- *
- * @param {string} domain
- * @returns {{ suffix: string, registrableDomain: string | undefined, known: boolean } | undefined}
- */
-export function lookup(domain) {
-  const info = _lookup(domain);
-  if (info == null) return undefined;
-  const result = {
-    suffix: info.suffix,
-    registrableDomain: info.registrableDomain,
-    known: info.known,
-  };
-  info.free();
-  return result;
-}
-
-export { registrableDomain, isKnownSuffix };

package/index.d.cts

@@ -1,3 +0,0 @@
-// CommonJS type surface for the require() entry. The declarations are shared
-// with the ESM entry; this file re-exports them so the two never drift.
-export * from "./index.js";

package/index.d.ts

@@ -1,28 +0,0 @@
-/** Result of a PSL lookup. */
-export interface DomainInfo {
-  /** The public suffix (e.g. `"co.uk"`, `"com"`, `"github.io"`). */
-  readonly suffix: string;
-  /** The registrable domain (eTLD+1), or `undefined` if the input is itself a suffix. */
-  readonly registrableDomain: string | undefined;
-  /** Whether the suffix matched an explicit PSL rule (vs the `*` fallback). */
-  readonly known: boolean;
-}
-
-/**
- * Look up a domain in the Public Suffix List.
- *
- * Returns `undefined` for empty or invalid input.
- */
-export function lookup(domain: string): DomainInfo | undefined;
-
-/**
- * Extract the registrable domain (eTLD+1).
- *
- * Returns `undefined` if the domain is itself a public suffix.
- */
-export function registrableDomain(domain: string): string | undefined;
-
-/**
- * Check if a domain's suffix is a known entry in the PSL.
- */
-export function isKnownSuffix(domain: string): boolean;

package/node.cjs

@@ -1,30 +0,0 @@
-// CommonJS entry — the nodejs-target glue loads the wasm synchronously at
-// require() time, so every function is usable immediately with no init() call.
-const {
-  lookup: _lookup,
-  registrableDomain,
-  isKnownSuffix,
-} = require("./structured_public_domains_node.cjs");
-
-/**
- * Look up a domain in the Public Suffix List.
- *
- * Returns a plain object with `suffix`, `registrableDomain`, and `known`
- * properties, or `undefined` for invalid input.
- *
- * @param {string} domain
- * @returns {{ suffix: string, registrableDomain: string | undefined, known: boolean } | undefined}
- */
-function lookup(domain) {
-  const info = _lookup(domain);
-  if (info == null) return undefined;
-  const result = {
-    suffix: info.suffix,
-    registrableDomain: info.registrableDomain,
-    known: info.known,
-  };
-  info.free();
-  return result;
-}
-
-module.exports = { lookup, registrableDomain, isKnownSuffix };

package/node.js

@@ -1,35 +0,0 @@
-// ESM Node entry — reads the wasm file synchronously and initialises it during
-// module evaluation (top-level await), so no init() call is needed. CommonJS
-// consumers use ./node.cjs instead (see package.json "exports").
-import { readFileSync } from "node:fs";
-import init, {
-  lookup as _lookup,
-  registrableDomain,
-  isKnownSuffix,
-} from "./structured_public_domains.js";
-
-const wasmPath = new URL("./structured_public_domains_bg.wasm", import.meta.url);
-await init({ module_or_path: readFileSync(wasmPath) });
-
-/**
- * Look up a domain in the Public Suffix List.
- *
- * Returns a plain object with `suffix`, `registrableDomain`, and `known`
- * properties, or `undefined` for invalid input.
- *
- * @param {string} domain
- * @returns {{ suffix: string, registrableDomain: string | undefined, known: boolean } | undefined}
- */
-export function lookup(domain) {
-  const info = _lookup(domain);
-  if (info == null) return undefined;
-  const result = {
-    suffix: info.suffix,
-    registrableDomain: info.registrableDomain,
-    known: info.known,
-  };
-  info.free();
-  return result;
-}
-
-export { registrableDomain, isKnownSuffix };

package/structured_public_domains.d.ts

@@ -1,87 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/**
- * Result of a PSL lookup, returned as an opaque JS object.
- *
- * JavaScript consumers receive property accessors; the JS wrapper layer
- * copies these into a plain object and calls the generated JS `.free()`
- * method so callers never deal with manual memory management.
- */
-export class DomainInfo {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Whether the suffix matched an explicit PSL rule (vs the `*` fallback).
-     */
-    readonly known: boolean;
-    /**
-     * The registrable domain (eTLD+1), or `undefined` if the input is a
-     * bare suffix.
-     */
-    readonly registrableDomain: string | undefined;
-    /**
-     * The public suffix (e.g. `"co.uk"`).
-     */
-    readonly suffix: string;
-}
-
-/**
- * Check if a domain's suffix is a known entry in the PSL.
- */
-export function isKnownSuffix(domain: string): boolean;
-
-/**
- * Look up a domain in the Public Suffix List.
- *
- * Returns `undefined` for empty or invalid input.
- */
-export function lookup(domain: string): DomainInfo | undefined;
-
-/**
- * Extract the registrable domain (eTLD+1).
- *
- * Returns `undefined` if the domain is itself a public suffix.
- */
-export function registrableDomain(domain: string): string | undefined;
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-    readonly memory: WebAssembly.Memory;
-    readonly __wbg_domaininfo_free: (a: number, b: number) => void;
-    readonly domaininfo_known: (a: number) => number;
-    readonly domaininfo_registrableDomain: (a: number) => [number, number];
-    readonly domaininfo_suffix: (a: number) => [number, number];
-    readonly isKnownSuffix: (a: number, b: number) => number;
-    readonly lookup: (a: number, b: number) => number;
-    readonly registrableDomain: (a: number, b: number) => [number, number];
-    readonly __wbindgen_externrefs: WebAssembly.Table;
-    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-    readonly __wbindgen_malloc: (a: number, b: number) => number;
-    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-    readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-
-/**
- * Instantiates the given `module`, which can either be bytes or
- * a precompiled `WebAssembly.Module`.
- *
- * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
- *
- * @returns {InitOutput}
- */
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
-
-/**
- * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
- * for everything else, calls `WebAssembly.instantiate` directly.
- *
- * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
- *
- * @returns {Promise<InitOutput>}
- */
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;