ic-mops 2.14.1 → 2.15.1

package/dist/helpers/autofix-motoko.js

@@ -1,7 +1,8 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
+import chalk from "chalk";
 import { execa } from "execa";
-import { TextDocument, } from "vscode-languageserver-textdocument";
+import { TextDocument } from "vscode-languageserver-textdocument";
 export function parseDiagnostics(stdout) {
     if (!stdout) {
         return [];
@@ -24,25 +25,14 @@ function extractDiagnosticFixes(diagnostics) {
     for (const diag of diagnostics) {
         const editsByFile = new Map();
         for (const span of diag.spans) {
-            if (span.suggestion_applicability === "MachineApplicable" &&
-                span.suggested_replacement !== null) {
-                const file = resolve(span.file);
-                const edits = editsByFile.get(file) ?? [];
-                edits.push({
-                    range: {
-                        start: {
-                            line: span.line_start - 1,
-                            character: span.column_start - 1,
-                        },
-                        end: {
-                            line: span.line_end - 1,
-                            character: span.column_end - 1,
-                        },
-                    },
-                    newText: span.suggested_replacement,
-                });
-                editsByFile.set(file, edits);
+            if (span.suggestion_applicability !== "MachineApplicable" ||
+                span.suggested_replacement === null) {
+                continue;
             }
+            const file = resolve(span.file);
+            const edits = editsByFile.get(file) ?? [];
+            edits.push({ span, newText: span.suggested_replacement });
+            editsByFile.set(file, edits);
         }
         for (const [file, edits] of editsByFile) {
             const existing = result.get(file) ?? [];
@@ -52,32 +42,47 @@ function extractDiagnosticFixes(diagnostics) {
     }
     return result;
 }
-function normalizeRange(range) {
-    const { start, end } = range;
-    if (start.line > end.line ||
-        (start.line === end.line && start.character > end.character)) {
-        return { start: end, end: start };
-    }
-    return range;
-}
 /**
- * Applies diagnostic fixes to a document, processing each diagnostic as
+ * Applies diagnostic fixes to a file's contents, processing each diagnostic as
  * an atomic unit. If any edit from a diagnostic overlaps with an already-accepted
  * edit, the entire diagnostic is skipped (picked up in subsequent iterations).
  * Based on vscode-languageserver-textdocument's TextDocument.applyEdits.
+ *
+ * Edits prefer `byte_start`/`byte_end` (byte-accurate on any UTF-8 source);
+ * falls back to line+column for older moc, which mis-applies on non-ASCII
+ * lines since moc's `column_*` are bytes but LSP expects UTF-16 code units.
  */
-function applyDiagnosticFixes(doc, fixes) {
+function applyDiagnosticFixes(content, fixes) {
+    let buf = null;
+    const byteToOffset = (byteOffset) => {
+        buf ??= Buffer.from(content, "utf8");
+        return buf.subarray(0, byteOffset).toString("utf8").length;
+    };
+    let doc = null;
+    const toOffsetEdit = ({ span, newText }) => {
+        if (span.byte_start != null && span.byte_end != null) {
+            const [s, e] = span.byte_start <= span.byte_end
+                ? [span.byte_start, span.byte_end]
+                : [span.byte_end, span.byte_start];
+            return { start: byteToOffset(s), end: byteToOffset(e), newText };
+        }
+        doc ??= TextDocument.create("inmemory://autofix", "motoko", 0, content);
+        const start = doc.offsetAt({
+            line: span.line_start - 1,
+            character: span.column_start - 1,
+        });
+        const end = doc.offsetAt({
+            line: span.line_end - 1,
+            character: span.column_end - 1,
+        });
+        return start <= end
+            ? { start, end, newText }
+            : { start: end, end: start, newText };
+    };
     const acceptedEdits = [];
     const appliedCodes = [];
     for (const fix of fixes) {
-        const offsets = fix.edits.map((e) => {
-            const range = normalizeRange(e.range);
-            return {
-                start: doc.offsetAt(range.start),
-                end: doc.offsetAt(range.end),
-                newText: e.newText,
-            };
-        });
+        const offsets = fix.edits.map(toOffsetEdit);
         const overlaps = offsets.some((o) => acceptedEdits.some((a) => o.start < a.end && o.end > a.start));
         if (overlaps) {
             continue;
@@ -86,7 +91,6 @@ function applyDiagnosticFixes(doc, fixes) {
         appliedCodes.push(fix.code);
     }
     acceptedEdits.sort((a, b) => a.start - b.start);
-    const text = doc.getText();
     const spans = [];
     let lastOffset = 0;
     for (const edit of acceptedEdits) {
@@ -94,41 +98,57 @@ function applyDiagnosticFixes(doc, fixes) {
             continue;
         }
         if (edit.start > lastOffset) {
-            spans.push(text.substring(lastOffset, edit.start));
+            spans.push(content.substring(lastOffset, edit.start));
         }
         if (edit.newText.length) {
             spans.push(edit.newText);
         }
         lastOffset = edit.end;
     }
-    spans.push(text.substring(lastOffset));
+    spans.push(content.substring(lastOffset));
     return { text: spans.join(""), appliedCodes };
 }
 const MAX_FIX_ITERATIONS = 10;
 export async function autofixMotoko(mocPath, files, mocArgs) {
     const fixedFilesCodes = new Map();
+    // Frozen migration files are often chmod'd read-only; warn once and skip
+    // them rather than aborting the whole run on EACCES/EPERM.
+    const readOnlySkipped = new Set();
     for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
         const fixesByFile = new Map();
-        // Single invocation: moc dedups shared imports across all files.
-        const result = await execa(mocPath, [...files, ...mocArgs, "--error-format=json"], { stdio: "pipe", reject: false });
-        const diagnostics = parseDiagnostics(result.stdout);
-        for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
-            const existing = fixesByFile.get(targetFile) ?? [];
-            existing.push(...fixes);
-            fixesByFile.set(targetFile, existing);
+        for (const file of files) {
+            const result = await execa(mocPath, [file, ...mocArgs, "--error-format=json"], { stdio: "pipe", reject: false });
+            const diagnostics = parseDiagnostics(result.stdout);
+            for (const [targetFile, fixes] of extractDiagnosticFixes(diagnostics)) {
+                const existing = fixesByFile.get(targetFile) ?? [];
+                existing.push(...fixes);
+                fixesByFile.set(targetFile, existing);
+            }
         }
         if (fixesByFile.size === 0) {
             break;
         }
         let progress = false;
         for (const [file, fixes] of fixesByFile) {
+            if (readOnlySkipped.has(file)) {
+                continue;
+            }
             const original = await readFile(file, "utf-8");
-            const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
-            const { text: result, appliedCodes } = applyDiagnosticFixes(doc, fixes);
+            const { text: result, appliedCodes } = applyDiagnosticFixes(original, fixes);
             if (result === original) {
                 continue;
             }
-            await writeFile(file, result, "utf-8");
+            try {
+                await writeFile(file, result, "utf-8");
+            }
+            catch (err) {
+                if (err?.code === "EACCES" || err?.code === "EPERM") {
+                    readOnlySkipped.add(file);
+                    console.warn(chalk.yellow(`Skipped read-only file ${relative(process.cwd(), file)} (${appliedCodes.length} fix(es) not applied)`));
+                    continue;
+                }
+                throw err;
+            }
             progress = true;
             const existing = fixedFilesCodes.get(file) ?? [];
             existing.push(...appliedCodes);

package/dist/helpers/migrations.d.ts

@@ -7,7 +7,7 @@ export declare function getMigrationFiles(dir: string): string[];
 export declare function getNextMigrationFile(nextDir: string): string | null;
 export declare function validateNextMigrationOrder(chainDirOrFiles: string | string[], nextFile: string): void;
 export declare function validateMigrationsConfig(migrations: MigrationsConfig, canisterName: string): void;
-export declare function prepareMigrationArgs(migrations: MigrationsConfig | undefined, canisterName: string, mode: "check" | "build", verbose?: boolean): Promise<MigrationArgsResult>;
+export declare function prepareMigrationArgs(migrations: MigrationsConfig | undefined, canisterName: string, mode: "check" | "build", verbose?: boolean, ignoreLimit?: boolean): Promise<MigrationArgsResult>;
 /**
  * Absolute paths of chain migration files that `mops lint` should skip,
  * mirroring the `check-limit` trimming applied to `moc` during `mops check`.

package/dist/helpers/migrations.js

@@ -68,7 +68,7 @@ export function validateMigrationsConfig(migrations, canisterName) {
  * for moc) and `getTrimmedMigrationFiles` (which feeds `excludedChainFiles`
  * to lint).
  */
-function resolveMigrationChain(migrations, canisterName, mode) {
+function resolveMigrationChain(migrations, canisterName, mode, ignoreLimit = false) {
     validateMigrationsConfig(migrations, canisterName);
     const chainDir = resolveConfigPath(migrations.chain);
     const nextDir = migrations.next
@@ -91,7 +91,11 @@ function resolveMigrationChain(migrations, canisterName, mode) {
     if (nextFile && nextDir) {
         all.push({ file: nextFile, dir: nextDir });
     }
-    const limit = mode === "check" ? migrations["check-limit"] : migrations["build-limit"];
+    const limit = ignoreLimit
+        ? undefined
+        : mode === "check"
+            ? migrations["check-limit"]
+            : migrations["build-limit"];
     const isTrimming = limit !== undefined && limit < all.length;
     const included = isTrimming ? all.slice(-limit) : all;
     // Dropped entries are always a chain-only prefix (next sorts last).
@@ -100,11 +104,11 @@ function resolveMigrationChain(migrations, canisterName, mode) {
         .map((e) => resolve(e.dir, e.file));
     return { chainDir, nextDir, included, excludedChainFiles, isTrimming };
 }
-export async function prepareMigrationArgs(migrations, canisterName, mode, verbose) {
+export async function prepareMigrationArgs(migrations, canisterName, mode, verbose, ignoreLimit = false) {
     if (!migrations) {
         return { migrationArgs: [], cleanup: async () => { } };
     }
-    const { chainDir, nextDir, included, excludedChainFiles, isTrimming } = resolveMigrationChain(migrations, canisterName, mode);
+    const { chainDir, nextDir, included, excludedChainFiles, isTrimming } = resolveMigrationChain(migrations, canisterName, mode, ignoreLimit);
     const hasNext = included.some((e) => e.dir === nextDir);
     const needsTempDir = hasNext || isTrimming;
     if (!needsTempDir) {

package/dist/helpers/moc-args.d.ts

@@ -0,0 +1,25 @@
+import { CanisterConfig, Config } from "../types.js";
+/** Single source of truth for "how moc is invoked for canister X" — keeps
+ * `mops build` and `mops generate candid` in lockstep so the auto-generated
+ * `.did` they each produce stays subtype-compatible with the curated one
+ * embedded by `mops build`. */
+export interface PrepareMocArgsOptions {
+    /** Selects the migration trim limit (`build-limit` vs `check-limit`). */
+    mode: "check" | "build";
+    /** Per-flag hints used when warning about conflicting `args` entries. */
+    managedFlags: Record<string, string>;
+    /** Command label shown in the warning, e.g. "mops build". */
+    commandName: string;
+    verbose?: boolean;
+    extraArgs?: string[];
+}
+export interface PreparedMocArgs {
+    motokoPath: string;
+    /** sources + [moc].args + migration + [build].args + [canisters.x].args + CLI extras. */
+    args: string[];
+    /** Cleans up the migration staging dir; call from a `finally`. */
+    cleanup: () => Promise<void>;
+}
+export declare const BUILD_MANAGED_FLAGS: Record<string, string>;
+export declare const GENERATE_CANDID_MANAGED_FLAGS: Record<string, string>;
+export declare function prepareMocArgs(config: Config, canister: CanisterConfig, canisterName: string, options: PrepareMocArgsOptions): Promise<PreparedMocArgs>;

package/dist/helpers/moc-args.js

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { getGlobalMocArgs, resolveConfigPath } from "../mops.js";
+import { sourcesArgs } from "../commands/sources.js";
+import { prepareMigrationArgs } from "./migrations.js";
+import { validateCanisterArgs } from "./resolve-canisters.js";
+export const BUILD_MANAGED_FLAGS = {
+    "-o": "use [build].outputDir in mops.toml or --output flag instead",
+    "-c": "this flag is always set by mops build",
+    "--idl": "this flag is always set by mops build",
+    "--stable-types": "this flag is always set by mops build",
+    "--public-metadata": "this flag is managed by mops build",
+};
+export const GENERATE_CANDID_MANAGED_FLAGS = {
+    "-o": "use the --output flag on `mops generate candid` instead",
+    "-c": "this flag is incompatible with mops generate candid (would also emit .wasm)",
+    "--idl": "this flag is always set by mops generate candid",
+    "--stable-types": "this flag is incompatible with mops generate candid (would also emit .most)",
+};
+export async function prepareMocArgs(config, canister, canisterName, options) {
+    if (!canister.main) {
+        cliError(`No main file is specified for canister ${canisterName}`);
+    }
+    const motokoPath = resolveConfigPath(canister.main);
+    const migration = await prepareMigrationArgs(canister.migrations, canisterName, options.mode, options.verbose);
+    const args = [
+        ...(await sourcesArgs()).flat(),
+        ...getGlobalMocArgs(config),
+        ...migration.migrationArgs,
+        ...collectExtraArgs(config, canister, canisterName, options.managedFlags, options.commandName, options.extraArgs),
+    ];
+    return { motokoPath, args, cleanup: migration.cleanup };
+}
+function collectExtraArgs(config, canister, canisterName, managedFlags, commandName, extraArgs) {
+    const args = [];
+    if (config.build?.args) {
+        if (typeof config.build.args === "string") {
+            cliError(`[build] config 'args' should be an array of strings in mops.toml config file`);
+        }
+        args.push(...config.build.args);
+    }
+    if (canister.args) {
+        validateCanisterArgs(canister, canisterName, config);
+        args.push(...canister.args);
+    }
+    if (extraArgs) {
+        args.push(...extraArgs);
+    }
+    const warned = new Set();
+    for (const arg of args) {
+        const hint = managedFlags[arg];
+        if (hint && !warned.has(arg)) {
+            warned.add(arg);
+            console.warn(chalk.yellow(`Warning: '${arg}' in args for canister ${canisterName} may conflict with ${commandName} — ${hint}`));
+        }
+    }
+    return args;
+}

package/dist/helpers/pocket-ic-client.d.ts

@@ -1,5 +1,5 @@
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, type StartServerOptions } from "pic-js-mops";
+import type { PocketIc, PocketIcServer } from "pic-ic";
+import type { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, StartServerOptions } from "pic-js-mops";
 export type AnyPocketIcServer = PocketIcServer | PocketIcServerModern;
 export type AnyPocketIc = PocketIc | PocketIcModern;
 export type AnySetupCanister = PocketIc["setupCanister"] & PocketIcModern["setupCanister"];

package/dist/helpers/pocket-ic-client.js

@@ -1,18 +1,22 @@
 import semver from "semver";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, } from "pic-js-mops";
 import { readConfig } from "../mops.js";
 function isLegacy() {
     let version = readConfig().toolchain?.["pocket-ic"];
     return !!version && !!semver.valid(version) && semver.lt(version, "9.0.0");
 }
 export async function startPocketIc(options) {
+    // Imported lazily so commands that never start a replica don't load the
+    // PocketIC client. `pic-js-mops` ships ESM without `type: module`, which a
+    // static import fails to resolve under tsx (local dev); a dynamic import
+    // resolves it on every platform.
     if (isLegacy()) {
+        const { PocketIc, PocketIcServer } = await import("pic-ic");
         let server = await PocketIcServer.start(options);
         let client = await PocketIc.create(server.getUrl());
         return { server, client };
     }
-    let server = await PocketIcServerModern.start(options);
-    let client = await PocketIcModern.create(server.getUrl());
+    const { PocketIc, PocketIcServer } = await import("pic-js-mops");
+    let server = await PocketIcServer.start(options);
+    let client = await PocketIc.create(server.getUrl());
     return { server, client };
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.14.1",
+  "version": "2.15.1",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -55,7 +55,7 @@
     "markdown-table": "3.0.4",
     "mdast-util-from-markdown": "2.0.2",
     "mdast-util-to-markdown": "2.1.2",
-    "minimatch": "10.2.4",
+    "minimatch": "10.2.5",
     "ncp": "2.0.0",
     "octokit": "3.1.2",
     "pem-file": "1.0.1",
@@ -69,7 +69,7 @@
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
-    "tar": "7.5.11",
+    "tar": "7.5.16",
     "terminal-size": "4.0.0",
     "vscode-languageserver-textdocument": "1.0.12"
   },
@@ -85,13 +85,13 @@
     "@types/proper-lockfile": "4.1.4",
     "@types/semver": "7.5.8",
     "@types/stream-to-promise": "2.2.4",
-    "@types/tar": "6.1.13",
-    "esbuild": "0.23.1",
+    "@types/tar": "7.0.87",
+    "esbuild": "0.28.1",
     "eslint": "8.57.0",
     "npm-run-all": "4.1.5",
     "rexreplace": "7.1.13",
     "ts-jest": "29.4.5",
-    "tsx": "4.19.2",
+    "tsx": "4.22.4",
     "typescript": "5.9.2",
     "wasm-pack": "0.15.0"
   }

package/dist/tests/check-fix-utf8.test.d.ts

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

package/dist/tests/check-fix-utf8.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, test, beforeAll } from "@jest/globals";
+import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import path from "path";
+import { cli, normalizePaths } from "./helpers";
+// Regression: --fix must apply byte-accurately on UTF-8 source. The fixture
+// pins a moc version that emits `byte_start`/`byte_end` so the byte path is
+// exercised; without those fields the fixer over-deletes on multi-byte lines
+// (e.g. `Char.toNat32(c)` after a `"京"` on the same line losing its `)`).
+describe("check --fix (utf-8 source)", () => {
+    const fixDir = path.join(import.meta.dirname, "check/fix-utf8");
+    const runDir = path.join(fixDir, "run");
+    const warningFlags = "-W=M0236";
+    beforeAll(() => {
+        for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
+            unlinkSync(path.join(runDir, file));
+        }
+    });
+    test("multi-byte characters do not corrupt the fix", async () => {
+        const src = "multibyte.mo";
+        const runFilePath = path.join(runDir, src);
+        cpSync(path.join(fixDir, src), runFilePath);
+        const fixResult = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        const fixedContent = readFileSync(runFilePath, "utf-8");
+        expect(fixedContent).toMatchSnapshot("fixed file");
+        // Concrete byte-accuracy assertions: every Char.toNat32 call must be
+        // rewritten to dot notation, with the multi-byte literal before it intact
+        // and the trailing `)` preserved (the original regression: 京/💩 used to
+        // drop it).
+        expect(fixedContent).toContain('"A" # debug_show (c.toNat32());');
+        expect(fixedContent).toContain('"京" # debug_show (c.toNat32());');
+        expect(fixedContent).toContain('"💩" # debug_show (c.toNat32());');
+        expect(fixedContent).not.toMatch(/debug_show \(Char\.toNat32/);
+        // Verify no remaining M0236 warnings.
+        const afterResult = await cli(["check", runFilePath, "--", warningFlags, "--error-format=json"], { cwd: fixDir });
+        expect(afterResult.stdout).not.toContain('"code":"M0236"');
+    });
+});

package/dist/tests/check-fix.test.js

@@ -1,5 +1,5 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
-import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { chmodSync, cpSync, readdirSync, readFileSync, unlinkSync, } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -19,7 +19,9 @@ describe("check --fix", () => {
     const diagnosticFlags = [warningFlags, "--error-format=json"];
     beforeAll(() => {
         for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
-            unlinkSync(path.join(runDir, file));
+            const p = path.join(runDir, file);
+            chmodSync(p, 0o644);
+            unlinkSync(p);
         }
     });
     function copyFixture(file) {
@@ -86,6 +88,16 @@ describe("check --fix", () => {
         expect(fixResult.stdout).toContain("1 fix applied");
         expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
     });
+    test("read-only file is skipped, not crashed", async () => {
+        const runFilePath = copyFixture("M0223.mo");
+        const before = readFileSync(runFilePath, "utf-8");
+        chmodSync(runFilePath, 0o444);
+        const result = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(result.exitCode).toBe(0);
+        expect(result.stderr).toMatch(/Skipped read-only file/);
+        // File left untouched since the fix couldn't be written.
+        expect(readFileSync(runFilePath, "utf-8")).toBe(before);
+    });
     test("verbose", async () => {
         const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
             cwd: fixDir,

package/dist/tests/check.test.js

@@ -12,12 +12,6 @@ describe("check", () => {
         await cliSnapshot(["check", "Error.mo"], { cwd }, 1);
         await cliSnapshot(["check", "Ok.mo", "Error.mo"], { cwd }, 1);
     });
-    // The verbose snapshot shows a single "moc ... [both files]" line, proving the
-    // whole set is checked in one invocation rather than one moc call per file.
-    test("multiple files in a single invocation", async () => {
-        const cwd = path.join(import.meta.dirname, "check/success");
-        await cliSnapshot(["check", "Ok.mo", "Warning.mo", "--verbose"], { cwd }, 0);
-    });
     test("warning", async () => {
         const cwd = path.join(import.meta.dirname, "check/success");
         const result = await cliSnapshot(["check", "Warning.mo"], { cwd }, 0);
@@ -143,4 +137,25 @@ describe("check", () => {
         expect(result.exitCode).toBe(0);
         expect(result.stdout).toMatch(/✓ Lint fixes applied/);
     });
+    // The migrations-chain fixture has 4 migrations with check-limit=3, so the
+    // oldest is trimmed by default (staged dir + M0254 suppression). --no-check-limit
+    // must point moc at the real chain dir and drop the trimming side effects.
+    const migrationsChain = "check-stable/migrations-chain";
+    test("check-limit trims the migration chain by default", async () => {
+        const cwd = path.join(import.meta.dirname, migrationsChain);
+        const result = await cli(["check", "--verbose"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/--enhanced-migration=[^"]*\.migrations-/);
+        expect(result.stdout).toMatch(/-A=M0254/);
+    });
+    test("--no-check-limit uses the full migration chain", async () => {
+        const cwd = path.join(import.meta.dirname, migrationsChain);
+        const result = await cli(["check", "--verbose", "--no-check-limit"], {
+            cwd,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/--enhanced-migration=/);
+        expect(result.stdout).not.toMatch(/\.migrations-/);
+        expect(result.stdout).not.toMatch(/-A=M0254/);
+    });
 });

package/dist/tests/deployed.test.d.ts

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