poe-code 12.0.6 → 12.0.7

package/packages/package-lint/dist/model.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { collectCanonicalDeclarations } from "./bundle-policy.js";
 import { parse as parseYaml } from "yaml";
 import { createNpmPacklistProvider, loadPackageFileView } from "./packlist.js";
 import { scanRuntimeFileAssets } from "./runtime-files.js";
@@ -107,6 +108,7 @@ async function loadPackage(fs, rootDir, relDir, isRoot) {
         ecosystem,
         main: typeof pkg.main === "string" ? pkg.main : undefined,
         exports: pkg.exports,
+        imports: pkg.imports,
         bin: toBinRecord(pkg.bin, typeof pkg.name === "string" ? pkg.name : relDir),
         files: Array.isArray(pkg.files)
             ? pkg.files.filter((f) => typeof f === "string")
@@ -448,12 +450,17 @@ export async function loadBuildView(fs, rootDir) {
     catch {
         return undefined;
     }
+    let metafile;
     try {
-        return parseMetafile(JSON.parse(raw));
+        metafile = JSON.parse(raw);
     }
     catch {
         return undefined;
     }
+    if (metafile.canonicalBundle || metafile.browserCanonicalBundle) {
+        Object.assign(metafile, await collectCanonicalDeclarations(rootDir, fs));
+    }
+    return parseMetafile(metafile);
 }
 /** All workspace packages plus the root package. */
 export function allPackages(model) {

package/packages/safe-fs/dist/bridge/filesystem.d.ts

@@ -0,0 +1,88 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import type { BridgePrimitives, BufferEncodingOption, FsBridgeDirent, FsBridgeEncoding, FsBridgeStats, MakeDirectoryOptions, Mode, ObjectEncodingOptions, StatOptions } from "./types.js";
+type Encoding = FsBridgeEncoding | "buffer";
+type ReadOptions = ObjectEncodingOptions & {
+    flag?: string | number | undefined;
+    signal?: AbortSignal | undefined;
+};
+type DirectoryOptions = {
+    encoding?: Encoding | null | undefined;
+    recursive?: boolean | undefined;
+    withFileTypes?: boolean | undefined;
+};
+export declare class FileSystemBridge<Binary extends Uint8Array> {
+    #private;
+    constructor(fs: FileSystem, options: {
+        readonly cwd?: string;
+        readonly signal?: AbortSignal;
+    }, primitives: BridgePrimitives<Binary>);
+    readFile(path: unknown, options?: {
+        encoding?: null | undefined;
+        flag?: string | number | undefined;
+        signal?: AbortSignal | undefined;
+    } | null): Promise<Binary>;
+    readFile(path: unknown, options: FsBridgeEncoding | (ReadOptions & {
+        encoding: FsBridgeEncoding;
+    })): Promise<string>;
+    readFile(path: unknown, options?: ReadOptions | FsBridgeEncoding | null): Promise<string | Binary>;
+    writeFile(path: unknown, data: unknown, options?: unknown): Promise<void>;
+    appendFile(path: unknown, data: unknown, options?: unknown): Promise<void>;
+    stat(path: unknown, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<FsBridgeStats>;
+    stat(path: unknown, options: StatOptions & {
+        bigint: true;
+    }): Promise<never>;
+    stat(path: unknown, options?: StatOptions): Promise<FsBridgeStats>;
+    lstat(path: unknown, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<FsBridgeStats>;
+    lstat(path: unknown, options: StatOptions & {
+        bigint: true;
+    }): Promise<never>;
+    lstat(path: unknown, options?: StatOptions): Promise<FsBridgeStats>;
+    readdir(path: unknown, options?: FsBridgeEncoding | (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | null): Promise<string[]>;
+    readdir(path: unknown, options: "buffer" | (DirectoryOptions & {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+    })): Promise<Binary[]>;
+    readdir(path: unknown, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Promise<FsBridgeDirent[]>;
+    readdir(path: unknown, options: DirectoryOptions & {
+        encoding: "buffer";
+        withFileTypes: true;
+    }): Promise<FsBridgeDirent<Binary>[]>;
+    mkdir(path: unknown, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): Promise<string | undefined>;
+    mkdir(path: unknown, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null): Promise<void>;
+    mkdir(path: unknown, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
+    access(path: unknown, mode?: number): Promise<void>;
+    rm(path: unknown, value?: unknown): Promise<void>;
+    rmdir(path: unknown, value?: unknown): Promise<void>;
+    rename(source: unknown, destination: unknown): Promise<void>;
+    copyFile(source: unknown, destination: unknown, mode?: number): Promise<void>;
+    cp(source: unknown, destination: unknown, value?: unknown): Promise<void>;
+    readlink(path: unknown, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    readlink(path: unknown, options: BufferEncodingOption): Promise<Binary>;
+    readlink(path: unknown, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    realpath(path: unknown, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    realpath(path: unknown, options: BufferEncodingOption): Promise<Binary>;
+    realpath(path: unknown, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    mkdtemp(prefix: string, options?: ObjectEncodingOptions | FsBridgeEncoding | null): Promise<string>;
+    mkdtemp(prefix: string, options: BufferEncodingOption): Promise<Binary>;
+    mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncodingOption | string | null): Promise<string | Binary>;
+    symlink(target: unknown, path: unknown, type?: unknown): Promise<void>;
+    link(existing: unknown, path: unknown): Promise<void>;
+    chmod(path: unknown, value: unknown): Promise<void>;
+    utimes(path: unknown, atime: unknown, mtime: unknown): Promise<void>;
+    truncate(path: unknown, length?: number): Promise<void>;
+}
+export {};

package/packages/safe-fs/dist/bridge/index.d.ts

@@ -0,0 +1,6 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+import { FileSystemBridge } from "./filesystem.js";
+import type { FsBridgeOptions } from "./types.js";
+export type { FsBridgeCodec, FsBridgeDirent, FsBridgeEncoding, FsBridgeFileSystem, FsBridgeOptions, FsBridgeStats } from "./types.js";
+export type FsBridge = FileSystemBridge<Uint8Array<ArrayBuffer>>;
+export declare function createFsBridge(fs: FileSystem, options: FsBridgeOptions): FsBridge;

package/packages/safe-fs/dist/bridge/stats.d.ts

@@ -0,0 +1,4 @@
+import type { FsBridgeDirent, FsBridgeStats } from "./types.js";
+import type { FileStat, FileType } from "../contracts/filesystem.js";
+export declare function bridgeStats(stat: FileStat): FsBridgeStats;
+export declare function bridgeDirent<Name extends string | Uint8Array>(name: Name, parentPath: string, type: FileType): FsBridgeDirent<Name>;

package/packages/safe-fs/dist/bridge/types.d.ts

@@ -0,0 +1,75 @@
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export interface FsBridgeCodec {
+    isEncoding(encoding: string): boolean;
+    encode(text: string, encoding: string): Uint8Array;
+    decode(bytes: Uint8Array, encoding: string): string;
+}
+export interface FsBridgeOptions {
+    readonly codec: FsBridgeCodec;
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+export interface FsBridgeFileSystem extends FileSystem {
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+}
+export type FsBridgeEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+export interface ObjectEncodingOptions {
+    encoding?: FsBridgeEncoding | null | undefined;
+}
+export type BufferEncodingOption = "buffer" | {
+    encoding: "buffer";
+};
+export type Mode = number | string;
+export interface MakeDirectoryOptions {
+    recursive?: boolean | undefined;
+    mode?: Mode | undefined;
+}
+export interface StatOptions {
+    bigint?: boolean | undefined;
+}
+export interface FsBridgePredicates {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface FsBridgeStats extends FsBridgePredicates {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+export interface FsBridgeDirent<Name extends string | Uint8Array = string> extends FsBridgePredicates {
+    name: Name;
+    parentPath: string;
+    path: string;
+}
+export interface BridgePrimitives<Binary extends Uint8Array> {
+    readonly codec: FsBridgeCodec;
+    copyBytes(bytes: Uint8Array): Binary;
+    pathValue?(value: unknown): unknown;
+    randomSuffix(): string;
+    readonly paths: {
+        isAbsolute(path: string): boolean;
+        dirname(path: string): string;
+        relative(from: string, to: string): string;
+        resolve(cwd: string, ...paths: string[]): string;
+    };
+}

package/packages/safe-fs/dist/bridge/values.d.ts

@@ -0,0 +1,6 @@
+export declare function record(value: unknown, name: string): Record<string, unknown>;
+export declare function onlyKeys(value: Record<string, unknown>, allowed: readonly string[]): void;
+export declare function booleanValue(value: unknown, fallback?: boolean): boolean;
+export declare function abortError(): Error;
+export declare function checkSignal(signal: AbortSignal | undefined): void;
+export declare function withSignal<Value>(signal: AbortSignal | undefined, operation: () => Promise<Value>): Promise<Value>;

package/packages/safe-fs/dist/contracts/errors.d.ts

@@ -1,3 +1,5 @@
+import type { PlatformErrno } from "#safe-fs-platform";
+export type { PlatformErrno } from "#safe-fs-platform";
 declare const descriptions: {
     readonly EACCES: "permission denied";
     readonly EAGAIN: "resource temporarily unavailable";
@@ -37,7 +39,7 @@ export interface FsErrorOptions extends ErrorOptions {
 }
 export declare class FsError extends Error {
     readonly code: ErrnoCode;
-    readonly errno: number;
+    readonly errno: PlatformErrno;
     readonly syscall?: string;
     readonly path?: string;
     readonly dest?: string;
@@ -46,4 +48,3 @@ export declare class FsError extends Error {
 export declare function isErrnoCode(code: unknown): code is ErrnoCode;
 export declare function isFsError(error: unknown, code?: ErrnoCode): error is FsError;
 export declare function toFsError(error: unknown, options?: FsErrorOptions): FsError;
-export {};

package/packages/safe-fs/dist/contracts/path.d.ts

@@ -1,13 +1,8 @@
 import { posix } from "node:path";
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./virtual-path.js";
 export declare const posixPath: typeof posix;
 export declare const basename: typeof posix.basename;
 export declare const dirname: typeof posix.dirname;
 export declare const extname: typeof posix.extname;
 export declare const joinPath: typeof posix.join;
 export declare const isAbsolutePath: typeof posix.isAbsolute;
-export declare function validatePath(path: string): void;
-export declare function resolvePath(cwd: string, ...paths: string[]): string;
-export declare function normalizePath(path: string, cwd?: string): string;
-export declare function relativePath(from: string, to: string): string;
-export declare function isPathWithin(root: string, path: string): boolean;
-export declare function assertPathWithin(root: string, path: string): string;

package/packages/safe-fs/dist/contracts/virtual-path.d.ts

@@ -0,0 +1,7 @@
+export declare function validatePath(path: string): void;
+export declare function resolvePath(cwd: string, ...paths: string[]): string;
+export declare function normalizePath(path: string, cwd?: string): string;
+export declare function dirname(path: string): string;
+export declare function relativePath(from: string, to: string): string;
+export declare function isPathWithin(root: string, path: string): boolean;
+export declare function assertPathWithin(root: string, path: string): string;

package/packages/safe-fs/dist/core.d.ts

@@ -0,0 +1,11 @@
+export * from "./contracts/errors.js";
+export * from "./contracts/filesystem.js";
+export * from "./contracts/io.js";
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./contracts/virtual-path.js";
+export * from "./fs/memory/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./bridge/index.js";
+export { compareEntries } from "./fs/mount/comparison.js";

package/packages/safe-fs/dist/fs/mount/comparison.d.ts

@@ -11,6 +11,7 @@ export interface EntryView extends EntryLocation {
 }
 export type EntryViewResolver = (path: string, options: FsOptions) => Promise<EntryLocation>;
 export type EntryAuthority = (own: EntryView, peer: EntryView, options: FsOptions) => Promise<EntryComparison>;
+export declare function assertCallbackAuthorityAllowed(): void;
 export declare function registerEntryView(filesystem: FileSystem, resolver: EntryViewResolver): void;
 export declare function registerEntryAuthority(filesystem: FileSystem, authority: EntryAuthority): void;
 export declare function resolveEntryView(filesystem: FileSystem, path: string, options?: FsOptions): Promise<EntryView>;

package/packages/safe-fs/dist/fs/overlay/index.d.ts

@@ -1,4 +1,5 @@
-import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+import type { ByteSource } from "../../contracts/io.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export interface OverlayFileSystemOptions {
     readonly upper: FileSystem;
     readonly lower: FileSystem;

package/packages/safe-fs/dist/fs/readonly/index.d.ts

@@ -1,4 +1,5 @@
-import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+import type { ByteSource } from "../../contracts/io.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export declare class ReadOnlyFileSystem implements FileSystem {
     #private;
     constructor(filesystem: FileSystem);

package/packages/safe-fs/dist/fs/s3/authority.d.ts

@@ -1,13 +1,7 @@
-import type { EntryComparison, FileStat, FileSystem, FsOptions } from "../../contracts/filesystem.js";
-import type { EntryView } from "../mount/comparison.js";
+import type { FileStat, FileSystem } from "../../contracts/filesystem.js";
 import type { S3HeadOutput, S3ObjectInput } from "./transport.js";
-export interface OwnedS3Entry {
-    readonly storage: object;
-    readonly key: string;
-}
+export { registerS3EntryOwner, getOwnedS3Entry, compareOwnedS3Entries } from "./registry.js";
+export type { OwnedS3Entry } from "./registry.js";
 export declare function recordMockS3Head(output: S3HeadOutput, input: S3ObjectInput, storage: object): void;
 export declare function queryS3Head(input: S3ObjectInput, action: () => Promise<S3HeadOutput>): Promise<S3HeadOutput>;
 export declare function recordS3Stat(filesystem: FileSystem, path: string, stat: FileStat, metadata: S3HeadOutput | undefined): void;
-export declare function registerS3EntryOwner(filesystem: FileSystem, normalize: (path: string) => string, intact: () => boolean, baseComparison: NonNullable<FileSystem["compareEntry"]>, comparison?: NonNullable<FileSystem["compareEntry"]>): void;
-export declare function getOwnedS3Entry(view: EntryView): OwnedS3Entry | undefined;
-export declare function compareOwnedS3Entries(own: EntryView, peer: EntryView, options: FsOptions): Promise<EntryComparison>;

package/packages/safe-fs/dist/fs/s3/registry.d.ts

@@ -0,0 +1,10 @@
+import type { FileStat, FileSystem, FsOptions, EntryComparison } from "../../contracts/filesystem.js";
+import type { EntryView } from "../mount/comparison.js";
+export interface OwnedS3Entry {
+    readonly storage: object;
+    readonly key: string;
+}
+export declare function recordS3Observation(filesystem: FileSystem, path: string, stat: FileStat, entry: OwnedS3Entry): void;
+export declare function registerS3EntryOwner(filesystem: FileSystem, normalize: (path: string) => string, intact: () => boolean, baseComparison: NonNullable<FileSystem["compareEntry"]>, comparison?: NonNullable<FileSystem["compareEntry"]>): void;
+export declare function getOwnedS3Entry(view: EntryView): OwnedS3Entry | undefined;
+export declare function compareOwnedS3Entries(own: EntryView, peer: EntryView, options: FsOptions): Promise<EntryComparison>;

package/packages/safe-fs/dist/fs/webdav/webdav.d.ts

@@ -1,3 +1,4 @@
+import type { PlatformComparisonCallback } from "#safe-fs-platform";
 import type { ByteSource } from "../../contracts/io.js";
 import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
@@ -27,7 +28,7 @@ export interface WebDavFileSystemOptions {
     readonly timeoutMs?: number;
     readonly overwritePolicy?: "lock" | "etag";
     readonly atomicEmptyDirectory?: WebDavAtomicEmptyDirectoryBinding;
-    readonly compareEntry?: (this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>;
+    readonly compareEntry?: PlatformComparisonCallback<(this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>>;
 }
 export declare class WebDavFileSystem implements FileSystem {
     readonly capabilities: Readonly<{

package/packages/safe-fs/dist/node/stats.d.ts

@@ -1,4 +1 @@
-import type { Dirent, Stats } from "node:fs";
-import type { FileStat, FileType } from "../contracts/filesystem.js";
-export declare function nodeStats(stat: FileStat): Stats;
-export declare function nodeDirent<Name extends string | Buffer>(name: Name, parentPath: string, type: FileType): Dirent<Name>;
+export { bridgeDirent as nodeDirent, bridgeStats as nodeStats } from "../bridge/stats.js";

package/packages/safe-fs/dist/node/values.d.ts

@@ -1,6 +1 @@
-export declare function record(value: unknown, name: string): Record<string, unknown>;
-export declare function onlyKeys(value: Record<string, unknown>, allowed: readonly string[]): void;
-export declare function booleanValue(value: unknown, fallback?: boolean): boolean;
-export declare function abortError(): Error;
-export declare function checkSignal(signal: AbortSignal | undefined): void;
-export declare function withSignal<Value>(signal: AbortSignal | undefined, operation: () => Promise<Value>): Promise<Value>;
+export { abortError, booleanValue, checkSignal, onlyKeys, record, withSignal } from "../bridge/values.js";

package/packages/safe-fs/dist/node-host.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/packages/safe-fs/dist/node-unavailable.d.ts

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

package/packages/safe-fs/dist/platform/browser.d.ts

@@ -0,0 +1,12 @@
+import type { FsOptions } from "../contracts/filesystem.js";
+export type PlatformErrno = number | undefined;
+export type PlatformComparisonCallback<Callback> = Callback & never;
+export declare const platform: Readonly<{
+    errno(_code: string): PlatformErrno;
+    callbackAuthorities: false;
+    randomUUID(): string;
+}>;
+export declare const comparisonContext: Readonly<{
+    active(options: FsOptions): boolean;
+    run<Result>(options: FsOptions, action: (nested: FsOptions) => Promise<Result>): Promise<Result>;
+}>;

package/packages/safe-fs/dist/platform/node.d.ts

@@ -0,0 +1,13 @@
+import { randomUUID } from "node:crypto";
+import type { FsOptions } from "../contracts/filesystem.js";
+export type PlatformErrno = number;
+export type PlatformComparisonCallback<Callback> = Callback;
+export declare const platform: Readonly<{
+    errno(code: string): PlatformErrno;
+    callbackAuthorities: true;
+    randomUUID: typeof randomUUID;
+}>;
+export declare const comparisonContext: Readonly<{
+    active(_options: FsOptions): boolean;
+    run<Result>(options: FsOptions, action: (nested: FsOptions) => Promise<Result>): Promise<Result>;
+}>;