@typecad/cuttlefish 1.0.0-alpha.14 → 1.0.0-alpha.15

package/dist/create/board-spec.d.ts

@@ -1,181 +0,0 @@
-import { z } from 'zod';
-export declare function stripJsonc(text: string): string;
-export declare const BoardSpecSchema: z.ZodObject<{
-    architecture: z.ZodString;
-    mcuId: z.ZodString;
-    mcuName: z.ZodString;
-    boardId: z.ZodString;
-    boardName: z.ZodString;
-    vendor: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    clockSpeed: z.ZodNumber;
-    fqbn: z.ZodString;
-    arduinoDefine: z.ZodString;
-    moduleFlash: z.ZodNullable<z.ZodNumber>;
-    externalRam: z.ZodNullable<z.ZodNumber>;
-    gpioRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
-    excludedGpio: z.ZodArray<z.ZodNumber>;
-    pins: z.ZodArray<z.ZodObject<{
-        gpio: z.ZodNumber;
-        capabilities: z.ZodEnum<{
-            FULL_GPIO: "FULL_GPIO";
-            FULL_GPIO_ANALOG: "FULL_GPIO_ANALOG";
-            FULL_GPIO_TOUCH: "FULL_GPIO_TOUCH";
-            FULL_GPIO_ANALOG_TOUCH: "FULL_GPIO_ANALOG_TOUCH";
-            FULL_GPIO_DAC: "FULL_GPIO_DAC";
-            INPUT_ONLY: "INPUT_ONLY";
-        }>;
-        functions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<{
-                i2c: "i2c";
-                spi: "spi";
-                uart: "uart";
-                adc: "adc";
-                dac: "dac";
-                pwm: "pwm";
-                touch: "touch";
-                usb: "usb";
-            }>;
-            instance: z.ZodNumber;
-            role: z.ZodString;
-        }, z.core.$strict>>>;
-        alt: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        unsafe: z.ZodOptional<z.ZodBoolean>;
-        notes: z.ZodOptional<z.ZodString>;
-        onboardLed: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    unsafe: z.ZodArray<z.ZodString>;
-    analog: z.ZodArray<z.ZodString>;
-    i2c: z.ZodRecord<z.ZodString, z.ZodObject<{
-        sda: z.ZodOptional<z.ZodString>;
-        scl: z.ZodOptional<z.ZodString>;
-        mosi: z.ZodOptional<z.ZodString>;
-        miso: z.ZodOptional<z.ZodString>;
-        sck: z.ZodOptional<z.ZodString>;
-        cs: z.ZodOptional<z.ZodString>;
-        tx: z.ZodOptional<z.ZodString>;
-        rx: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    spi: z.ZodRecord<z.ZodString, z.ZodObject<{
-        sda: z.ZodOptional<z.ZodString>;
-        scl: z.ZodOptional<z.ZodString>;
-        mosi: z.ZodOptional<z.ZodString>;
-        miso: z.ZodOptional<z.ZodString>;
-        sck: z.ZodOptional<z.ZodString>;
-        cs: z.ZodOptional<z.ZodString>;
-        tx: z.ZodOptional<z.ZodString>;
-        rx: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    uart: z.ZodRecord<z.ZodString, z.ZodObject<{
-        sda: z.ZodOptional<z.ZodString>;
-        scl: z.ZodOptional<z.ZodString>;
-        mosi: z.ZodOptional<z.ZodString>;
-        miso: z.ZodOptional<z.ZodString>;
-        sck: z.ZodOptional<z.ZodString>;
-        cs: z.ZodOptional<z.ZodString>;
-        tx: z.ZodOptional<z.ZodString>;
-        rx: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    peripheralInstances: z.ZodObject<{
-        i2c: z.ZodArray<z.ZodObject<{
-            instance: z.ZodNumber;
-            defaultPins: z.ZodRecord<z.ZodString, z.ZodString>;
-            alternatePins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-        }, z.core.$strict>>;
-        spi: z.ZodArray<z.ZodObject<{
-            instance: z.ZodNumber;
-            defaultPins: z.ZodRecord<z.ZodString, z.ZodString>;
-            alternatePins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-        }, z.core.$strict>>;
-        uart: z.ZodArray<z.ZodObject<{
-            instance: z.ZodNumber;
-            defaultPins: z.ZodRecord<z.ZodString, z.ZodString>;
-            alternatePins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    adc: z.ZodArray<z.ZodObject<{
-        instance: z.ZodNumber;
-        channels: z.ZodNumber;
-        resolution: z.ZodNumber;
-        referenceVoltage: z.ZodNumber;
-        maxValue: z.ZodNumber;
-        referenceVoltages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    }, z.core.$strict>>;
-    pwm: z.ZodObject<{
-        channels: z.ZodNumber;
-        resolution: z.ZodNumber;
-        maxFrequency: z.ZodNumber;
-    }, z.core.$strict>;
-    touch: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        channels: z.ZodNumber;
-        pins: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>>;
-    timers: z.ZodArray<z.ZodObject<{
-        instance: z.ZodNumber;
-        type: z.ZodEnum<{
-            general: "general";
-            high_speed: "high_speed";
-            rtc: "rtc";
-            sys: "sys";
-        }>;
-        bits: z.ZodUnion<readonly [z.ZodLiteral<8>, z.ZodLiteral<16>, z.ZodLiteral<32>, z.ZodLiteral<64>]>;
-        features: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            pwm: "pwm";
-            capture: "capture";
-            compare: "compare";
-            interrupt: "interrupt";
-            dma: "dma";
-        }>>>;
-    }, z.core.$strict>>;
-    wifi: z.ZodObject<{
-        type: z.ZodEnum<{
-            wifi: "wifi";
-            wifi6: "wifi6";
-        }>;
-        supportsStation: z.ZodBoolean;
-        supportsAp: z.ZodBoolean;
-    }, z.core.$strict>;
-    bluetooth: z.ZodObject<{
-        type: z.ZodEnum<{
-            classic: "classic";
-            ble: "ble";
-            dual: "dual";
-        }>;
-        version: z.ZodString;
-    }, z.core.$strict>;
-    usb: z.ZodObject<{
-        type: z.ZodEnum<{
-            device: "device";
-            host: "host";
-            otg: "otg";
-        }>;
-        vid: z.ZodString;
-        pid: z.ZodString;
-    }, z.core.$strict>;
-    features: z.ZodObject<{
-        multicore: z.ZodBoolean;
-        coreCount: z.ZodNumber;
-        deepSleep: z.ZodBoolean;
-        watchdog: z.ZodBoolean;
-        externalInterrupts: z.ZodBoolean;
-        hardwareRng: z.ZodBoolean;
-        fpu: z.ZodBoolean;
-    }, z.core.$strict>;
-    memory: z.ZodObject<{
-        flash: z.ZodNumber;
-        sram: z.ZodNumber;
-        eeprom: z.ZodNumber;
-        externalRam: z.ZodOptional<z.ZodNumber>;
-        rtcMemory: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type BoardSpec = z.infer<typeof BoardSpecSchema>;
-export declare function parseBoardSpec(jsoncText: string): BoardSpec;
-export declare function safeParseBoardSpec(jsoncText: string): {
-    success: true;
-    spec: BoardSpec;
-} | {
-    success: false;
-    errors: string[];
-};

package/dist/create/board-spec.js

@@ -1,214 +0,0 @@
-// ---------------------------------------------------------------------------
-// board-spec.ts — Zod schema + types for the .jsonc chip spec consumed by
-// `cuttlefish board add`. The spec is a human-authored description of the
-// silicon + board; the codegen transforms it into package source files.
-// ---------------------------------------------------------------------------
-import { z } from 'zod';
-// ---------------------------------------------------------------------------
-// Comment stripper — .jsonc → JSON. Strips // line comments and /* */ blocks
-// while respecting string literals (a // inside a string is not a comment).
-// ---------------------------------------------------------------------------
-export function stripJsonc(text) {
-    let result = '';
-    let i = 0;
-    while (i < text.length) {
-        const ch = text[i];
-        const next = text[i + 1];
-        // String literal — copy verbatim until closing quote
-        if (ch === '"') {
-            result += ch;
-            i++;
-            while (i < text.length) {
-                result += text[i];
-                if (text[i] === '\\' && i + 1 < text.length) {
-                    result += text[i + 1];
-                    i += 2;
-                    continue;
-                }
-                if (text[i] === '"') {
-                    i++;
-                    break;
-                }
-                i++;
-            }
-            continue;
-        }
-        // Line comment // ... \n
-        if (ch === '/' && next === '/') {
-            while (i < text.length && text[i] !== '\n')
-                i++;
-            continue;
-        }
-        // Block comment /* ... */
-        if (ch === '/' && next === '*') {
-            i += 2;
-            while (i < text.length && !(text[i] === '*' && text[i + 1] === '/'))
-                i++;
-            i += 2;
-            continue;
-        }
-        result += ch;
-        i++;
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Sub-schemas
-// ---------------------------------------------------------------------------
-const PinFunctionSchema = z.object({
-    type: z.enum(['i2c', 'spi', 'uart', 'adc', 'dac', 'pwm', 'touch', 'usb']),
-    instance: z.number().int(),
-    role: z.string(),
-}).strict();
-const PinSpecSchema = z.object({
-    gpio: z.number().int(),
-    capabilities: z.enum([
-        'FULL_GPIO', 'FULL_GPIO_ANALOG', 'FULL_GPIO_TOUCH',
-        'FULL_GPIO_ANALOG_TOUCH', 'FULL_GPIO_DAC', 'INPUT_ONLY',
-    ]),
-    functions: z.array(PinFunctionSchema).optional(),
-    alt: z.array(z.string()).optional(),
-    warnings: z.array(z.string()).optional(),
-    unsafe: z.boolean().optional(),
-    notes: z.string().optional(),
-    onboardLed: z.boolean().optional(),
-}).strict();
-const PeripheralInstanceSchema = z.object({
-    instance: z.number().int(),
-    defaultPins: z.record(z.string(), z.string()),
-    alternatePins: z.record(z.string(), z.array(z.string())).optional(),
-}).strict();
-const AdcSchema = z.object({
-    instance: z.number().int(),
-    channels: z.number().int(),
-    resolution: z.number().int(),
-    referenceVoltage: z.number(),
-    maxValue: z.number().int(),
-    referenceVoltages: z.record(z.string(), z.number()).optional(),
-}).strict();
-const BusPinMapSchema = z.record(z.string(), z.object({
-    sda: z.string().optional(),
-    scl: z.string().optional(),
-    mosi: z.string().optional(),
-    miso: z.string().optional(),
-    sck: z.string().optional(),
-    cs: z.string().optional(),
-    tx: z.string().optional(),
-    rx: z.string().optional(),
-}).strict());
-// ---------------------------------------------------------------------------
-// Top-level spec schema
-// ---------------------------------------------------------------------------
-export const BoardSpecSchema = z.object({
-    // Identity
-    architecture: z.string().min(1),
-    mcuId: z.string().min(1),
-    mcuName: z.string().min(1),
-    boardId: z.string().min(1),
-    boardName: z.string().min(1),
-    vendor: z.string().min(1),
-    description: z.string().optional(),
-    // Build
-    clockSpeed: z.number().int(),
-    fqbn: z.string().min(1),
-    arduinoDefine: z.string().min(1),
-    // Memory (module-level; silicon memory is derived)
-    moduleFlash: z.number().int().nullable(),
-    externalRam: z.number().int().nullable(),
-    // GPIO range
-    gpioRange: z.tuple([z.number().int(), z.number().int()]),
-    excludedGpio: z.array(z.number().int()),
-    // Pin data
-    pins: z.array(PinSpecSchema),
-    unsafe: z.array(z.string()),
-    analog: z.array(z.string()),
-    // Bus maps
-    i2c: BusPinMapSchema,
-    spi: BusPinMapSchema,
-    uart: BusPinMapSchema,
-    // Peripherals
-    peripheralInstances: z.object({
-        i2c: z.array(PeripheralInstanceSchema),
-        spi: z.array(PeripheralInstanceSchema),
-        uart: z.array(PeripheralInstanceSchema),
-    }).strict(),
-    adc: z.array(AdcSchema),
-    pwm: z.object({
-        channels: z.number().int(),
-        resolution: z.number().int(),
-        maxFrequency: z.number().int(),
-    }).strict(),
-    touch: z.object({
-        channels: z.number().int(),
-        pins: z.array(z.string()),
-    }).nullable().optional(),
-    timers: z.array(z.object({
-        instance: z.number().int(),
-        type: z.enum(['general', 'high_speed', 'rtc', 'sys']),
-        bits: z.union([z.literal(8), z.literal(16), z.literal(32), z.literal(64)]),
-        features: z.array(z.enum(['pwm', 'capture', 'compare', 'interrupt', 'dma'])).optional(),
-    }).strict()),
-    // Connectivity
-    wifi: z.object({
-        type: z.enum(['wifi', 'wifi6']),
-        supportsStation: z.boolean(),
-        supportsAp: z.boolean(),
-    }).strict(),
-    bluetooth: z.object({
-        type: z.enum(['classic', 'ble', 'dual']),
-        version: z.string(),
-    }).strict(),
-    usb: z.object({
-        type: z.enum(['device', 'host', 'otg']),
-        vid: z.string(),
-        pid: z.string(),
-    }).strict(),
-    // Features
-    features: z.object({
-        multicore: z.boolean(),
-        coreCount: z.number().int(),
-        deepSleep: z.boolean(),
-        watchdog: z.boolean(),
-        externalInterrupts: z.boolean(),
-        hardwareRng: z.boolean(),
-        fpu: z.boolean(),
-    }).strict(),
-    // Silicon memory
-    memory: z.object({
-        flash: z.number().int(),
-        sram: z.number().int(),
-        eeprom: z.number().int(),
-        externalRam: z.number().int().optional(),
-        rtcMemory: z.number().int().optional(),
-    }).strict(),
-}).strict();
-// ---------------------------------------------------------------------------
-// Parse + validate a .jsonc string
-// ---------------------------------------------------------------------------
-export function parseBoardSpec(jsoncText) {
-    const jsonText = stripJsonc(jsoncText);
-    let parsed;
-    try {
-        parsed = JSON.parse(jsonText);
-    }
-    catch (e) {
-        throw new Error(`Invalid JSON in spec file: ${e.message}`);
-    }
-    return BoardSpecSchema.parse(parsed);
-}
-export function safeParseBoardSpec(jsoncText) {
-    try {
-        const spec = parseBoardSpec(jsoncText);
-        return { success: true, spec };
-    }
-    catch (e) {
-        if (e instanceof z.ZodError) {
-            const errors = e.issues.map(issue => {
-                const path = issue.path.join('.');
-                return path ? `${path}: ${issue.message}` : issue.message;
-            });
-            return { success: false, errors };
-        }
-        return { success: false, errors: [e.message] };
-    }
-}

package/dist/install/framework-catalog.d.ts

@@ -1,53 +0,0 @@
-/** A framework family that ships as an installable @typecad/framework-* package. */
-export interface FrameworkCatalogEntry {
-    /** Short id, e.g. "arduino". Matches the suffix of @typecad/framework-<id>. */
-    id: string;
-    /** Full npm package name, e.g. "@typecad/framework-arduino". */
-    packageName: string;
-    /** Human-readable label shown in the install prompt. */
-    label: string;
-    /**
-     * Whether a real package exists on the registry. Used to filter the prompt:
-     * "esp-idf" is a known family with no published package yet, so it must not
-     * be offered for install (it would fail at the package-manager step).
-     */
-    installable: boolean;
-}
-/**
- * The installable frameworks. Kept aligned with the packages/ directory:
- * framework-arduino, framework-native, framework-zephyr all ship real packages.
- * esp-idf is intentionally absent (no published package in this repo).
- */
-export declare const FRAMEWORK_CATALOG: readonly FrameworkCatalogEntry[];
-/** Structural shape we need from a board/target. Keeps this module decoupled
- *  from the create/ module's KnownTarget (and trivially testable with literals). */
-export interface BoardLike {
-    isNative?: boolean;
-    architecture?: string;
-}
-/** Look up a catalog entry by framework id (e.g. "arduino"). */
-export declare function frameworkCatalogEntry(id: string): FrameworkCatalogEntry | undefined;
-/**
- * The framework ids compatible with a board. Native boards map to ["native"];
- * embedded boards map via ARCHITECTURE_FRAMEWORKS (falling back to arduino for
- * unknown architectures). Order is preserved as the catalog order so the most
- * common framework is offered first in the prompt.
- */
-export declare function frameworksForTarget(target: BoardLike): FrameworkCatalogEntry[];
-export type PackageManager = "npm" | "pnpm" | "yarn";
-/**
- * Detect the package manager for a directory. Priority:
- *   1. package.json#packageManager field (the strongest signal, Corepack-style)
- *   2. lockfile presence (pnpm-lock.yaml / yarn.lock → otherwise npm)
- *   3. default "npm"
- * Never throws — unreadable/missing files fall through to the next signal.
- */
-export declare function detectPackageManager(cwd: string): PackageManager;
-/**
- * Build the package-manager invocation that installs `packageName` into the
- * current project (project-local, never global — per the install command spec).
- */
-export declare function buildInstallCommand(pm: PackageManager, packageName: string): {
-    bin: string;
-    args: string[];
-};

package/dist/install/framework-catalog.js

@@ -1,107 +0,0 @@
-// Framework catalog + board→framework compatibility for `cuttlefish install`.
-//
-// A "framework" is a `@typecad/framework-<id>` npm package. This module is the
-// single source of truth for which frameworks exist as installable packages and
-// which are compatible with a given board architecture. It is deliberately
-// free of side effects (no fs/process beyond lockfile/package.json reads in
-// detectPackageManager) so it unit-tests cleanly.
-import path from "node:path";
-import fs from "node:fs";
-/**
- * The installable frameworks. Kept aligned with the packages/ directory:
- * framework-arduino, framework-native, framework-zephyr all ship real packages.
- * esp-idf is intentionally absent (no published package in this repo).
- */
-export const FRAMEWORK_CATALOG = [
-    { id: "arduino", packageName: "@typecad/framework-arduino", label: "Arduino (digitalWrite, Wire, SPI)", installable: true },
-    { id: "zephyr", packageName: "@typecad/framework-zephyr", label: "Zephyr RTOS", installable: true },
-    { id: "native", packageName: "@typecad/framework-native", label: "Native (Windows/Linux executable)", installable: true },
-];
-/**
- * Architecture → compatible framework ids. Derived from each framework
- * package's framework.manifest.ts `profile.targets`:
- *   - arduino: avr, esp32 family, rp2040/rp2350, samd, stm32
- *   - zephyr:  nrf52 (xiao_ble), esp32, esp32s3
- *   - native:  desktop only
- * Unknown embedded architectures fall back to [arduino] (the broadest core).
- */
-const ARCHITECTURE_FRAMEWORKS = {
-    avr: ["arduino"],
-    esp32: ["arduino", "zephyr"],
-    esp32s2: ["arduino"],
-    esp32s3: ["arduino", "zephyr"],
-    esp32c3: ["arduino"],
-    esp32c6: ["arduino"],
-    rp2040: ["arduino"],
-    rp2350: ["arduino"],
-    samd: ["arduino"],
-    stm32: ["arduino"],
-    nrf52: ["zephyr"],
-};
-const FALLBACK_FRAMEWORKS = ["arduino"];
-/** Look up a catalog entry by framework id (e.g. "arduino"). */
-export function frameworkCatalogEntry(id) {
-    return FRAMEWORK_CATALOG.find((f) => f.id === id);
-}
-/**
- * The framework ids compatible with a board. Native boards map to ["native"];
- * embedded boards map via ARCHITECTURE_FRAMEWORKS (falling back to arduino for
- * unknown architectures). Order is preserved as the catalog order so the most
- * common framework is offered first in the prompt.
- */
-export function frameworksForTarget(target) {
-    let ids;
-    if (target.isNative) {
-        ids = ["native"];
-    }
-    else {
-        ids = ARCHITECTURE_FRAMEWORKS[target.architecture ?? ""] ?? FALLBACK_FRAMEWORKS;
-    }
-    // Re-map ids → catalog entries in catalog order (stable ordering), dropping
-    // any id that has no catalog entry (defensive — keeps the prompt clean).
-    return FRAMEWORK_CATALOG.filter((entry) => ids.includes(entry.id));
-}
-/**
- * Detect the package manager for a directory. Priority:
- *   1. package.json#packageManager field (the strongest signal, Corepack-style)
- *   2. lockfile presence (pnpm-lock.yaml / yarn.lock → otherwise npm)
- *   3. default "npm"
- * Never throws — unreadable/missing files fall through to the next signal.
- */
-export function detectPackageManager(cwd) {
-    try {
-        const pkgPath = path.join(cwd, "package.json");
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-        const pm = typeof pkg.packageManager === "string" ? pkg.packageManager : "";
-        if (pm.startsWith("pnpm"))
-            return "pnpm";
-        if (pm.startsWith("yarn"))
-            return "yarn";
-        if (pm.startsWith("npm"))
-            return "npm";
-    }
-    catch {
-        // no package.json or unparseable JSON — fall through to lockfile detection
-    }
-    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml")))
-        return "pnpm";
-    if (fs.existsSync(path.join(cwd, "yarn.lock")))
-        return "yarn";
-    // package-lock.json implies npm; absence also defaults to npm.
-    return "npm";
-}
-/**
- * Build the package-manager invocation that installs `packageName` into the
- * current project (project-local, never global — per the install command spec).
- */
-export function buildInstallCommand(pm, packageName) {
-    switch (pm) {
-        case "pnpm":
-            return { bin: "pnpm", args: ["add", packageName] };
-        case "yarn":
-            return { bin: "yarn", args: ["add", packageName] };
-        case "npm":
-        default:
-            return { bin: "npm", args: ["install", packageName] };
-    }
-}

package/dist/install/handle-install.d.ts

@@ -1,35 +0,0 @@
-import type { InstallCommandOptions } from "../types.js";
-import { type FrameworkCatalogEntry, type PackageManager } from "./framework-catalog.js";
-interface InstallCommand {
-    bin: string;
-    args: string[];
-    cwd: string;
-}
-interface InstallRunResult {
-    /** Exit status; null when the process could not be launched (ENOENT, etc.). */
-    status: number | null;
-    /** Populated only when the binary could not be launched. */
-    launchError?: string;
-}
-type InstallRunner = (cmd: InstallCommand) => InstallRunResult;
-/**
- * FOR TESTS ONLY. Replaces the real spawn-based installer with `runner`.
- * Pass `undefined` to restore the real executor.
- */
-export declare function __setInstallRunnerForTest(runner: InstallRunner | undefined): void;
-export interface InstallResult {
-    pm: PackageManager;
-    bin: string;
-    args: string[];
-}
-/**
- * Resolve the package manager and run the install for `entry`'s package. In
- * dry-run mode the command is printed but not executed. Throws on launch
- * failure or non-zero exit so the CLI surfaces a clear error.
- */
-export declare function installFrameworkPackage(entry: FrameworkCatalogEntry, opts: {
-    cwd: string;
-    dryRun?: boolean;
-}): InstallResult;
-export declare function handleInstall(options: InstallCommandOptions): Promise<void>;
-export {};