poe-code 12.0.1 → 12.0.3

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

@@ -0,0 +1,98 @@
+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>;
+export interface WebDavAtomicEmptyDirectoryRequest {
+    readonly operation: "atomic-empty-rmdir/v1";
+    readonly namespaceUrl: string;
+    readonly path: string;
+    readonly signal?: AbortSignal;
+}
+export interface WebDavAtomicEmptyDirectoryResult {
+    readonly operation: "atomic-empty-rmdir/v1";
+    readonly namespaceUrl: string;
+    readonly path: string;
+    readonly outcome: "removed";
+}
+export interface WebDavAtomicEmptyDirectoryBinding {
+    readonly namespaceUrl: string;
+    readonly removeEmptyDirectory: (request: WebDavAtomicEmptyDirectoryRequest) => Promise<WebDavAtomicEmptyDirectoryResult>;
+}
+export interface WebDavFileSystemOptions {
+    readonly baseUrl: string;
+    readonly fetch: WebDavFetch;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly maxResponseBytes?: number;
+    readonly maxXmlBytes?: number;
+    readonly maxEntries?: number;
+    readonly timeoutMs?: number;
+    readonly overwritePolicy?: "lock" | "etag";
+    readonly atomicEmptyDirectory?: WebDavAtomicEmptyDirectoryBinding;
+    readonly compareEntry?: (this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>;
+}
+export declare class WebDavFileSystem implements FileSystem {
+    readonly capabilities: Readonly<{
+        symlinks: false;
+        hardlinks: false;
+        permissions: false;
+        timestamps: true;
+        atomicRename: false;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly base;
+    private readonly baseSegments;
+    private readonly transport;
+    private readonly headers;
+    private readonly maxResponseBytes;
+    private readonly maxXmlBytes;
+    private readonly maxEntries;
+    private readonly timeoutMs;
+    private readonly overwritePolicy;
+    private readonly configuredComparison;
+    private readonly atomicEmptyDirectory;
+    private readonly etags;
+    constructor(options: WebDavFileSystemOptions);
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    private resourceId;
+    private url;
+    private hrefPath;
+    private httpError;
+    private request;
+    private requestStream;
+    private bytes;
+    private bodyChunks;
+    private xml;
+    private multistatus;
+    private lockFailure;
+    private entryStat;
+    private entries;
+    private mutation;
+    private unsupported;
+    private maybeStat;
+    stat(path: string, options?: FsOptions): Promise<FileStat>;
+    lstat(path: string, options?: FsOptions): Promise<FileStat>;
+    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+    readStream(path: string, options?: ReadStreamOptions): AsyncGenerator<Uint8Array>;
+    private prepareWrite;
+    writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+    writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
+    appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    private atomicRmdir;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    private guardTransferIdentity;
+    private transfer;
+    private withDestinationLock;
+    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    realpath(path: string, options?: FsOptions): Promise<string>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    readlink(path: string, _options?: FsOptions): Promise<string>;
+    symlink(_target: string, path: string, _options?: FsOptions): Promise<void>;
+    link(_source: string, path: string, _options?: FsOptions): Promise<void>;
+    chmod(path: string, _mode: number, _options?: FsOptions): Promise<void>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, _length?: number, _options?: FsOptions): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+export interface XmlElement {
+    readonly namespace: string;
+    readonly localName: string;
+    readonly children: XmlElement[];
+    text: string;
+}
+export interface XmlLimits {
+    readonly maxDepth?: number;
+    readonly maxNodes?: number;
+    readonly maxAttributes?: number;
+}
+export declare function parseXml(input: string, limits?: XmlLimits): XmlElement;
+export declare function davChildren(element: XmlElement, localName: string): XmlElement[];
+export declare function davChild(element: XmlElement, localName: string): XmlElement | undefined;
+export declare function scalar(element: XmlElement): string;

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

@@ -0,0 +1,11 @@
+export * from "./contracts/index.js";
+export * from "./fs/memory/index.js";
+export * from "./fs/real/index.js";
+export * from "./fs/s3/index.js";
+export type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./fs/s3/transport.js";
+export * from "./fs/s3/http/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./node/index.js";

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

@@ -0,0 +1,11 @@
+import type * as FsPromises from "node:fs/promises";
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
+export interface NodeFsBridgeOptions {
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+export interface NodeFsBridgeFileSystem extends FileSystem {
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+}
+export declare function createNodeFsBridge(fs: FileSystem, options?: NodeFsBridgeOptions): NodeFsImplementation;

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

@@ -0,0 +1,2 @@
+export { createNodeFsBridge } from "./filesystem.js";
+export type { NodeFsBridgeOptions, NodeFsBridgeFileSystem, NodeFsImplementation } from "./filesystem.js";

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

@@ -0,0 +1,4 @@
+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>;

package/packages/safe-fs/dist/node/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/safejs/dist/chunks/{chunk-73RTIWRH.js → chunk-T55OILHA.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-HD7TQKZ7.js";
+} from "./chunk-Z3ZMLYCK.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8055,4 +8055,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-73RTIWRH.js.map
+//# sourceMappingURL=chunk-T55OILHA.js.map

package/packages/safejs/dist/chunks/{chunk-HD7TQKZ7.js → chunk-Z3ZMLYCK.js}

@@ -25224,6 +25224,7 @@ var stringMethodNames = /* @__PURE__ */ new Set([
   "includes",
   "indexOf",
   "lastIndexOf",
+  "localeCompare",
   "match",
   "matchAll",
   "normalize",
@@ -25258,6 +25259,7 @@ function getStringMember(value, property, budget) {
   return createSandboxClosure({
     sandbox: true,
     name: `String#${property}`,
+    ...property === "localeCompare" ? { length: 1 } : {},
     call: (args) => callStringMethod(value, property, args, budget)
   });
 }
@@ -25283,6 +25285,42 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   if (methodName === "match" || methodName === "matchAll" || methodName === "search") {
     return callMatchLikeMethod(value, methodName, args);
   }
+  if (methodName === "localeCompare") {
+    if (isSandboxClosure(args[0])) {
+      throw new TypeError("String#localeCompare does not support function comparison values.");
+    }
+    const comparison = budget.allocateString(String(deepCopyFromSandbox(args[0])));
+    const locales = Reflect.apply(Intl.getCanonicalLocales, Intl, [
+      deepCopyFromSandbox(args[1])
+    ]);
+    const options = args[2];
+    const nativeOptions = options === void 0 || options === null ? options : Object.fromEntries(
+      [
+        "usage",
+        "localeMatcher",
+        "collation",
+        "numeric",
+        "caseFirst",
+        "sensitivity",
+        "ignorePunctuation"
+      ].map((property) => {
+        const descriptor = Object.getOwnPropertyDescriptor(options, property);
+        if (descriptor !== void 0 && !("value" in descriptor)) {
+          throw new TypeError("String#localeCompare only supports data option properties.");
+        }
+        const option = descriptor?.value;
+        return [
+          property,
+          option === void 0 ? void 0 : property === "numeric" || property === "ignorePunctuation" ? Boolean(option) : deepCopyFromSandbox(option)
+        ];
+      })
+    );
+    return Reflect.apply(String.prototype.localeCompare, value, [
+      comparison,
+      locales,
+      nativeOptions
+    ]);
+  }
   if (args.some(isSandboxClosure)) {
     throw new TypeError(`String#${methodName} does not support function arguments.`);
   }
@@ -29256,4 +29294,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-HD7TQKZ7.js.map
+//# sourceMappingURL=chunk-Z3ZMLYCK.js.map