@noverax/courier-build 0.0.0-stage → 0.4.0

package/lib/config/index.d.ts

@@ -0,0 +1,420 @@
+import { CourierError } from "@noverax/courier";
+import { Jiti, TransformOptions, TransformResult } from "jiti";
+import { CourierConfig } from "@noverax/courier/config";
+/** The file names a Courier config may have, in the order they are looked for */
+export declare const CONFIG_BASENAMES: ReadonlyArray<string>;
+/**
+ * Every path a config is looked for at from a folder, in the order it is
+ * looked for: each of {@link CONFIG_BASENAMES} in the folder, then in each
+ * folder above it, up to the top of the project — the first folder that
+ * holds its repository (`.git`, `.hg`, `.jj`) or is the root of its
+ * workspace (`pnpm-workspace.yaml`, or a `package.json` that declares
+ * `workspaces`) — or, with no such folder, the root of the file system.
+ *
+ * @param startDir - The folder to look in first
+ * @returns The paths, absolute, whether there or not
+ * @example
+ * ```ts
+ * configCandidates("/repo/apps/web"); // → ["/repo/apps/web/courier.config.ts", …, "/repo/courier.config.cjs"]
+ * ```
+ */
+export declare function configCandidates(startDir: string): string[];
+/**
+ * A store of jiti transforms: TypeScript and ESM sources compiled to the
+ * CommonJS jiti evaluates, reused while the bytes and options that produced
+ * them are unchanged.
+ */
+interface TransformCache {
+  /**
+   * What jiti's transform yields for `options`: the kept code when the store
+   * holds a successful transform of the same file from the same bytes and
+   * options, and otherwise whatever `compute` returns.
+   *
+   * @param options - What jiti hands its transform
+   * @param compute - jiti's own transform, run on a miss
+   * @returns The result of `compute`, or its kept code, byte for byte
+   */
+  transform(options: TransformOptions, compute: (options: TransformOptions) => TransformResult): TransformResult;
+}
+/** Where a {@link TransformCache} keeps transforms, and how much in memory. */
+interface TransformCacheOptions {
+  /**
+   * A directory to keep transforms in across processes, as
+   * `findTransformCacheDirectory` finds it. Without one, or with `null`,
+   * transforms are kept in memory only.
+   */
+  directory?: string | null | undefined;
+  /**
+   * Characters of transformed code kept in memory across all files; the file
+   * used least recently is dropped first once they are exceeded. `0` keeps
+   * none, for a process that loads each module once. Defaults to 128 Mi
+   * characters.
+   */
+  maxMemoryChars?: number | undefined;
+  /**
+   * Whether the `directory` is only read: nothing in it is created, written,
+   * pruned or marked as used, so a transform computed on a miss stays in
+   * this process. For a process that loads, once, what another process has
+   * just kept there, as a mock worker loads the modules Studio loaded: its
+   * own entries would only duplicate that process's. Defaults to `false`.
+   */
+  readOnly?: boolean | undefined;
+}
+/**
+ * Create a {@link TransformCache} that keeps transforms in memory for the
+ * life of the process and, given a `directory`, on disk for the next one.
+ *
+ * Each file holds one entry per module system — required and imported are
+ * transformed differently, and a module reached both ways keeps both. An
+ * entry is reused only when the digest of jiti's version, the options and
+ * the source matches, so an edited file is transformed again the first time
+ * it is loaded.
+ *
+ * A transform is looked for in memory, then in the directory, where a hit
+ * is also kept in memory; only when both miss is it computed, and a success
+ * is then kept in both. The directory is shared with every process that
+ * names it, and a directory that cannot be read or written only costs
+ * transforms; see `createTransformCacheDisk` for what an entry must be to be
+ * used. A mock worker, which loads once the modules Studio has just loaded,
+ * opens Studio's directory `readOnly` with `maxMemoryChars: 0`: it reads
+ * what Studio kept, adds nothing to the directory, and holds nothing in
+ * memory past its one load.
+ *
+ * A failed transform, one whose result carries an `error`, is never kept:
+ * babel can fail on bytes it transforms without complaint a moment later,
+ * such as a deeply nested module that overflows the stack while babel is
+ * still cold. Such a file is transformed again on every load, and every
+ * failure reaches jiti with its error, as it does without a cache. A file
+ * named by a relative path, or not named, is transformed every time.
+ *
+ * @param options - The directory (default: none, memory only), the memory
+ *   bound (default: 128 Mi characters), and whether the directory is only
+ *   read (default: no)
+ * @returns A cache to pass to `createConfigJiti` or `loadCourierConfig`
+ * @example
+ * ```ts
+ * const transformCache = createTransformCache({
+ *   directory: findTransformCacheDirectory(projectRoot),
+ * });
+ * const first = await loadCourierConfig({ cwd: projectRoot, transformCache });
+ * // Unchanged modules are not transformed again, here or in the next process:
+ * const second = await loadCourierConfig({ cwd: projectRoot, transformCache });
+ *
+ * // A process that loads once what another has just kept:
+ * const reader = createTransformCache({ directory, readOnly: true, maxMemoryChars: 0 });
+ * ```
+ */
+export declare function createTransformCache({ directory, maxMemoryChars, readOnly }?: TransformCacheOptions): TransformCache;
+/** How a project-file loader resolves imports and transforms modules. */
+interface ConfigJitiOptions {
+  /**
+   * Whether imports resolve through the project's tsconfig path aliases, as
+   * the project's own files expect. Off to load an installed package as it is:
+   * an alias of its scope would send its imports to project sources.
+   */
+  aliases?: boolean | undefined;
+  /**
+   * Where to reuse each module's transform while its bytes are unchanged.
+   * Without one, every module is transformed on every load. Aliases take no
+   * part in it: they change where an import resolves, never the code a
+   * module's own bytes transform to.
+   */
+  transformCache?: TransformCache | undefined;
+  /**
+   * Told the file of each module the load transforms — the config and every
+   * TypeScript or ES module of the project it reaches — so whoever follows
+   * the project knows which files its config depends on.
+   */
+  onModule?: ((filename: string) => void) | undefined;
+  /**
+   * Runs each transform the load makes, the first of which loads the
+   * transformer itself. A caller noting what the config's code reads runs it
+   * unnoted: what the transformer reads is its own, not the config's.
+   */
+  runTransform?: (<TResult>(transform: () => TResult) => TResult) | undefined;
+}
+/**
+ * The module loader for Courier's project files — `courier.config.*` and
+ * `courier.mocks.*` — with the options both need: the project's tsconfig path
+ * aliases, default-export interop, no module cache, and no native import
+ * tried before the loader's own.
+ *
+ * The module cache is off because this is also the reload path: the dev
+ * server loads the files again on every edit, and a cached module would hand
+ * back the file as it was before the user changed it. Every load therefore
+ * reads and evaluates every file again; a `transformCache` only spares the
+ * transform of a file whose bytes are unchanged.
+ *
+ * jiti's native attempt, which imports every module natively before falling
+ * back to its own loader, stays off too, whatever `JITI_TRY_NATIVE` says and
+ * under Bun, where it defaults to on: a module imported natively is the
+ * runtime's first evaluation of it for the life of the process, so an edit to
+ * it would never be seen, and the attempt comes before the module cache
+ * `evalModule` is handed, so two files evaluated over one cache would each
+ * evaluate a module they both import.
+ *
+ * jiti's own file cache stays off, with or without a `transformCache`:
+ * - it writes each entry in place, so concurrent writers can leave an entry
+ *   torn between two transforms that its check still accepts;
+ * - an entry it cannot write makes the whole load throw `EACCES`;
+ * - unless the file's own directory has a `node_modules`, it falls back to
+ *   `os.tmpdir()/jiti`, where another user of the machine can place an entry
+ *   that is then run;
+ * - its key ignores `interopDefault` and the babel options, so a transform
+ *   made under other options can be handed back;
+ * - nothing ever prunes it.
+ *
+ * jiti is loaded here rather than at the top of a module so a bundler that
+ * merely reaches this code does not pull a TypeScript transpiler into its
+ * graph; only a process that actually reads such a file pays for it.
+ *
+ * @param file - Absolute, symlink-resolved path of the file to load; modules
+ *   and aliases resolve from its directory
+ * @param options - Whether to resolve through the project's path aliases
+ *   (default: yes), and where to reuse transforms (default: nowhere)
+ * @returns A jiti instance for that file
+ * @example
+ * ```ts
+ * const transformCache = createTransformCache();
+ * const jiti = await createConfigJiti(configFile, { transformCache });
+ * const config = await jiti.import(configFile, { default: true });
+ * ```
+ */
+export declare function createConfigJiti(file: string, { aliases, transformCache, onModule, runTransform }?: ConfigJitiOptions): Promise<Jiti>;
+/**
+ * Result of a successful `loadCourierConfig` call.
+ *
+ * `configFile` is the absolute, symlink-resolved path of the file that
+ * was loaded — the dev-server side uses it for the `fs.watch` dep tracker;
+ * the runtime side uses it only for log/debug output.
+ */
+interface LoadedCourierConfig {
+  config: CourierConfig;
+  configFile: string;
+}
+/**
+ * Options for `loadCourierConfig`.
+ */
+interface LoadCourierConfigOptions {
+  /**
+   * Starting directory for the config search. Defaults to `process.cwd()`.
+   * The dev-server passes the explicit project root; the runtime path
+   * passes `process.cwd()` so the walk-up finds configs located at the
+   * workspace root from a nested package cwd (common in monorepos).
+   */
+  cwd?: string | undefined;
+  /**
+   * When true, skip the walk-up and require the config file to exist at
+   * exactly `cwd`. The dev-server uses this because it was told the
+   * project root explicitly and wants to distinguish "no config in root"
+   * from "config found higher up" (which would usually mean the user
+   * pointed at the wrong directory). The runtime path leaves this false
+   * so a nested `cwd` still discovers a root-level config.
+   *
+   * Defaults to false (walk up).
+   */
+  requireAtCwd?: boolean | undefined;
+  /**
+   * Where to reuse each module's transform while its bytes are unchanged. A
+   * caller that keeps one across loads transforms only the modules whose
+   * bytes changed; without one, every module is transformed on every load.
+   */
+  transformCache?: TransformCache | undefined;
+  /** Told the file of each module the load transforms; see `createConfigJiti`. */
+  onModule?: ((filename: string) => void) | undefined;
+  /**
+   * Reuse the transforms kept in the project's `node_modules/.cache`, the
+   * ones Studio keeps, and keep there the ones this load makes: a process
+   * that loads the config beside Studio — an app that attaches, the MCP
+   * server, `courier-server` — transforms only the modules no process has
+   * transformed yet. On a project of a thousand endpoints that is hundreds
+   * of modules, most of a second. Passed over when `transformCache` is given.
+   */
+  projectTransforms?: boolean | undefined;
+}
+/**
+ * Walk up from `startDir` looking for a `courier.config.*` file, up to the
+ * top of the project: the folder that holds its repository or is the root
+ * of its workspace (see {@link configCandidates}). A config found in a folder
+ * above `startDir` is taken only when it belongs to this user or to the
+ * owner of `startDir`, and no user outside its group may write it: a folder
+ * many users share, such as `/tmp`, would otherwise run anyone's config.
+ *
+ * @param startDir - The directory to look in first
+ * @returns The absolute path of the first match, or `null` when no directory
+ *   up to the top of the project holds one
+ * @throws UntrustedConfigError when the nearest config lies above `startDir`
+ *   and someone else could have put it there
+ * @example
+ * ```ts
+ * findConfigFile("/app/src"); // → "/app/courier.config.ts", or null
+ * ```
+ */
+export declare function findConfigFile(startDir: string): string | null;
+/**
+ * Find a config file in `cwd` itself, without walking up.
+ *
+ * @param cwd - The directory to look in
+ * @returns The first of {@link CONFIG_BASENAMES} present there, or `null`
+ * @example
+ * ```ts
+ * findConfigFileAt(process.cwd()); // → "/app/courier.config.ts", or null
+ * ```
+ */
+export declare function findConfigFileAt(cwd: string): string | null;
+/**
+ * Find and load a `courier.config.*` file.
+ *
+ * Returns `null` when no config file exists, so a caller can fall back.
+ * Throws when a file was found and loading it failed, reporting what the
+ * loader reported — for a TypeScript config, usually an unresolvable import.
+ *
+ * @param options - Where to look, and where to reuse transforms
+ * @returns The config and its canonical path, or `null` when there is no config
+ * @example
+ * ```ts
+ * const loaded = await loadCourierConfig({ cwd: projectRoot, requireAtCwd: true });
+ * ```
+ */
+export declare function loadCourierConfig(options?: LoadCourierConfigOptions): Promise<LoadedCourierConfig | null>;
+/**
+ * The transforms kept in a project's `node_modules/.cache` — the ones Studio
+ * keeps — for a process that loads the project's modules once: it reuses
+ * them, keeps there the ones it makes, and holds none in memory.
+ *
+ * @param projectRoot - The project's root
+ * @returns The cache, or `undefined` when the project has no directory to keep them in
+ * @example
+ * ```ts
+ * await loadCourierConfigFile(file, { transformCache: projectTransformCache(dirname(file)) });
+ * ```
+ */
+export declare function projectTransformCache(projectRoot: string): TransformCache | undefined;
+/** How one config file is loaded: the loader's options, and when its code is about to run. */
+interface LoadConfigFileOptions extends ConfigJitiOptions {
+  /**
+   * Called once the loader is made, just before the config's code runs. A
+   * caller noting what that code reads starts here, so the loader's own
+   * start-up is not taken for the config's.
+   */
+  beforeRun?: (() => void) | undefined;
+}
+/**
+ * Load one config file, found by whatever means the caller chose — the
+ * standalone server takes it from `--config`.
+ *
+ * @param file - Absolute path of an existing config file
+ * @param options - How the loader resolves imports and where it reuses
+ *   transforms, see {@link ConfigJitiOptions}, and what runs before the config
+ * @returns The config and the canonical path it was loaded from
+ * @throws What the loader reported when the file will not load — for a
+ *   TypeScript config, usually an unresolvable import
+ * @example
+ * ```ts
+ * const { config } = await loadCourierConfigFile("/app/courier.config.ts", {
+ *   transformCache: createTransformCache(),
+ * });
+ * ```
+ */
+export declare function loadCourierConfigFile(file: string, { beforeRun, ...options }?: LoadConfigFileOptions): Promise<LoadedCourierConfig>;
+/** Path aliases a project declares, ready for both consumers. */
+interface PathAliases {
+  /**
+   * Prefix → absolute target, in the shape jiti's `alias` option takes.
+   * Only the first target of a mapping appears: jiti resolves one path per
+   * alias, while `candidatesFor` offers every declared target.
+   */
+  readonly loader: Readonly<Record<string, string>>;
+  /** Absolute paths `specifier` may denote, in declaration order. */
+  candidatesFor(specifier: string): string[];
+}
+/**
+ * Read the path aliases that apply to `projectRoot`.
+ *
+ * @param projectRoot - Directory holding the project's `tsconfig.json`
+ * @returns The aliases, empty when the project declares none
+ *
+ * @example
+ * ```ts
+ * const aliases = readPathAliases("/app");
+ * aliases.candidatesFor("@/lib/sources"); // → ["/app/src/lib/sources"]
+ * ```
+ */
+export declare function readPathAliases(projectRoot: string): PathAliases;
+/**
+ * Where a project's transforms are kept across processes:
+ * `.cache/courier/transform` in the nearest `node_modules` directory at or
+ * above the project root.
+ *
+ * The nearest one is taken, not the one module resolution would reach: under
+ * pnpm that lies inside `.pnpm`, and what keeps the directory safe is the
+ * rule below, not where it is. Every file in it holds code that Studio, mock
+ * workers and build plugins run, so on POSIX the directory is refused when
+ * `node_modules`, `.cache`, `courier` or `transform` — those that exist — is
+ * a symbolic link or belongs to another user, and when `courier` or
+ * `transform`, which only Studio creates, is writable by its group or
+ * others; any of these lets someone else replace or remove entries, or put
+ * the directory somewhere they control. `node_modules` and `.cache` may be
+ * group-writable, as package managers leave them under a umask of 002:
+ * whoever can write `node_modules` can replace any package in it already. On
+ * Windows only links and other kinds of file are refused.
+ *
+ * There is none when no `node_modules` exists, as with Yarn Plug'n'Play, or
+ * when `COURIER_TRANSFORM_CACHE` is `0`, `false` or `off` in any case. The
+ * system temporary directory, which every user of the machine may write, is
+ * never used instead. Why there is none is logged at debug level, once for
+ * each root until the reason changes, however often the root is looked up.
+ *
+ * @param projectRoot - The directory holding `courier.config.*`
+ * @param env - The environment to read `COURIER_TRANSFORM_CACHE` from
+ *   (default: `process.env`)
+ * @returns The directory, which may not exist yet, or `null` for none
+ * @example
+ * ```ts
+ * const transformCache = createTransformCache({
+ *   directory: findTransformCacheDirectory(projectRoot),
+ * });
+ * ```
+ */
+export declare function findTransformCacheDirectory(projectRoot: string, env?: Readonly<Record<string, string | undefined>>): string | null;
+/**
+ * The keys of a courier.config that Courier does not read, at the top and
+ * in its `studio`, `server`, `runtime` and `agents` blocks — a misspelt `studo:` say
+ * — so a load can name them rather than ignore them in silence.
+ *
+ * @param config - The config, as its module exported it
+ * @returns Each such key, dotted under its block
+ * @example
+ * ```ts
+ * unknownConfigKeys({ sources: {}, studo: {}, server: { prot: 3001 } }); // → ["studo", "server.prot"]
+ * ```
+ */
+export declare function unknownConfigKeys(config: unknown): string[];
+/** Where a config that was not run lies, and the folder it was looked for from. */
+interface UntrustedConfigContext extends Record<string, unknown> {
+  /** The config, absolute. */
+  configFile: string;
+  /** The folder the config was looked for from, below it. */
+  folder: string;
+}
+/**
+ * The config nearest a folder lies in a folder above it, and someone else
+ * could have put it there: it belongs to another user, or any user may
+ * write it. It was not run, as it would run with the rights of whoever
+ * builds or serves the project.
+ *
+ * @example
+ * ```ts
+ * throw new UntrustedConfigError("/tmp/courier.config.ts", "/tmp/app", "it belongs to uid 1001");
+ * ```
+ */
+export declare class UntrustedConfigError extends CourierError<"CONFIG_NOT_TRUSTED"> {
+  readonly context: UntrustedConfigContext;
+  /**
+   * @param configFile - The config that was not run, absolute
+   * @param folder - The folder it was looked for from
+   * @param reason - Why it is not trusted, worded to follow "and"
+   */
+  constructor(configFile: string, folder: string, reason: string);
+}
+export type { ConfigJitiOptions, LoadConfigFileOptions, LoadCourierConfigOptions, LoadedCourierConfig, PathAliases, TransformCache, TransformCacheOptions, UntrustedConfigContext };

package/lib/config/index.js

@@ -0,0 +1,66 @@
+import { n as isRecord } from "../errno-code-CNx_E80R.js";
+import { a as projectTransformCache, c as UntrustedConfigError, d as CONFIG_BASENAMES, f as configCandidates, i as loadCourierConfigFile, l as createConfigJiti, n as findConfigFileAt, o as findTransformCacheDirectory, r as loadCourierConfig, s as createTransformCache, t as findConfigFile, u as readPathAliases } from "../load-config-BeedbpkN.js";
+// src/config/unknown-config-keys.ts
+const TOP_LEVEL = {
+	sources: true,
+	imports: true,
+	studio: true,
+	server: true,
+	runtime: true,
+	agents: true
+};
+const BLOCKS = /* @__PURE__ */ new Map([
+	["studio", {
+		port: true,
+		host: true,
+		mockBasePort: true,
+		open: true,
+		allowedSpecHosts: true,
+		routes: true
+	}],
+	["server", {
+		port: true,
+		host: true,
+		allowedOrigins: true,
+		allowedHosts: true,
+		maxBodyBytes: true,
+		maxUploadBytes: true,
+		rateLimit: true,
+		browsersOnly: true
+	}],
+	["runtime", { appOrigin: true }],
+	["agents", {
+		offer: true,
+		allow: true,
+		deny: true,
+		access: true,
+		confirm: true
+	}]
+]);
+/**
+* The keys of a courier.config that Courier does not read, at the top and
+* in its `studio`, `server`, `runtime` and `agents` blocks — a misspelt `studo:` say
+* — so a load can name them rather than ignore them in silence.
+*
+* @param config - The config, as its module exported it
+* @returns Each such key, dotted under its block
+* @example
+* ```ts
+* unknownConfigKeys({ sources: {}, studo: {}, server: { prot: 3001 } }); // → ["studo", "server.prot"]
+* ```
+*/
+function unknownConfigKeys(config) {
+	if (!isRecord(config)) return [];
+	const unknown = [];
+	for (const [key, value] of Object.entries(config)) {
+		if (!Object.hasOwn(TOP_LEVEL, key)) {
+			unknown.push(key);
+			continue;
+		}
+		const known = BLOCKS.get(key);
+		if (!known || !isRecord(value)) continue;
+		for (const inner of Object.keys(value)) if (!Object.hasOwn(known, inner)) unknown.push(`${key}.${inner}`);
+	}
+	return unknown;
+}
+export { CONFIG_BASENAMES, UntrustedConfigError, configCandidates, createConfigJiti, createTransformCache, findConfigFile, findConfigFileAt, findTransformCacheDirectory, loadCourierConfig, loadCourierConfigFile, projectTransformCache, readPathAliases, unknownConfigKeys };

package/lib/config-file-of-Zkwyi9zf.js

@@ -0,0 +1,28 @@
+import { t as errnoCode } from "./errno-code-CNx_E80R.js";
+import { c as UntrustedConfigError, t as findConfigFile } from "./load-config-BeedbpkN.js";
+import { resolve } from "node:path";
+import { realpathSync } from "node:fs";
+// src/util/config-file-of.ts
+/**
+* The config file the routes are read from, as a bundler names a module:
+* its real path. One that is not there yet, or that is not run, gives none
+* here; the engine reports why when the routes are read.
+*
+* @param root - The project's root, where the config is looked for and above
+* @param named - The config, from the root or absolute, when it is not the one found
+* @returns The config file, absolute and real; none when there is no config to read
+* @example
+* ```ts
+* configFileOf("/app"); // "/app/courier.config.ts"
+* ```
+*/
+function configFileOf(root, named) {
+	try {
+		const file = named === void 0 ? findConfigFile(root) : resolve(root, named);
+		return file === null ? void 0 : realpathSync(file);
+	} catch (error) {
+		if (error instanceof UntrustedConfigError || errnoCode(error) === "ENOENT") return void 0;
+		throw error;
+	}
+}
+export { configFileOf as t };

package/lib/config-in-page-message-DLd3f0Jd.js

@@ -0,0 +1,20 @@
+import { basename } from "node:path";
+// src/util/config-in-page-message.ts
+/**
+* Why the project's config cannot be a module of a page, and what to write
+* instead. It holds the server's settings and the definition of every API —
+* their addresses, their middleware, what reads their secrets — and imported
+* as a value it ships all of them to the browser. A page needs its type
+* alone, which an `import type` gives without a byte of it.
+*
+* @param configFile - The project's config
+* @returns The message a build fails with
+* @example
+* ```ts
+* configInPageMessage("/app/courier.config.ts"); // "[courier] courier.config.ts is imported into a page as a value, …"
+* ```
+*/
+function configInPageMessage(configFile) {
+	return `[courier] ${basename(configFile)} is imported into a page as a value, which would ship the server's settings and every API's definition to the browser. Import its type alone: write \`import type config from\` where the page writes \`import config from\`.`;
+}
+export { configInPageMessage as t };

package/lib/courier-routes-options-BYF7Sfdf.d.cts

@@ -0,0 +1,13 @@
+/**
+ * Options of the routes plugins that need to know only where the config is:
+ * those of webpack, Rspack, Rsbuild, esbuild, Rollup and Jest, and of the
+ * frameworks built on them.
+ */
+interface CourierRoutesOptions {
+  /**
+   * The config file, from the project's root or absolute, when it is not
+   * the `courier.config.*` in the root or the nearest folder above it.
+   */
+  config?: string | undefined;
+}
+export { CourierRoutesOptions as t };

package/lib/courier-routes-options-BYF7Sfdf.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Options of the routes plugins that need to know only where the config is:
+ * those of webpack, Rspack, Rsbuild, esbuild, Rollup and Jest, and of the
+ * frameworks built on them.
+ */
+interface CourierRoutesOptions {
+  /**
+   * The config file, from the project's root or absolute, when it is not
+   * the `courier.config.*` in the root or the nearest folder above it.
+   */
+  config?: string | undefined;
+}
+export { CourierRoutesOptions as t };

package/lib/engine/worker.d.ts

@@ -0,0 +1 @@
+export {}