@duplojs/server 0.0.0-stage → 0.1.0-beta.2

package/dist/dataStructure/constraint/size.cjs

@@ -0,0 +1,29 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/constraint/size.ts
+const sizeConstraintKind = require_kind.createKind("size-constraint");
+const SizeConstraint = _duplojs_lang_dataStructure.createConstraint(sizeConstraintKind, ({ init }) => (params) => init({
+	max: params.max === void 0 ? void 0 : _duplojs_lang_common.stringToBytes(params.max),
+	min: params.min === void 0 ? void 0 : _duplojs_lang_common.stringToBytes(params.min)
+}, {
+	executeCheck: async (self, data) => {
+		const result = _duplojs_lang_either.rightPipe(await data.stat(), (stat) => {
+			if (!stat.isFile) return _duplojs_lang_either.fail();
+			if (self.definition.max !== void 0 && stat.sizeBytes > self.definition.max) return _duplojs_lang_either.fail();
+			if (self.definition.min !== void 0 && stat.sizeBytes < self.definition.min) return _duplojs_lang_either.fail();
+			return stat;
+		});
+		if (_duplojs_lang_either.isLeft(result)) return _duplojs_lang_dataStructure.ErrorSymbol;
+		return _duplojs_lang_dataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+exports.SizeConstraint = SizeConstraint;
+exports.sizeConstraintKind = sizeConstraintKind;

package/dist/dataStructure/constraint/size.d.ts

@@ -0,0 +1,16 @@
+import * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+export declare const sizeConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/size-constraint", unknown>>;
+export interface SizeConstraintDefinition extends DDataStructure.ConstraintDefinition {
+    min?: number;
+    max?: number;
+}
+export interface SizeConstraintParams {
+    min?: number | DCommon.BytesInString;
+    max?: number | DCommon.BytesInString;
+}
+export interface SizeConstraint extends DCommon.UnionToIntersection<DDataStructure.Constraint<DSFile.FileInterface, DSFile.FileInterface, SizeConstraintDefinition> & DKind.Kind<typeof sizeConstraintKind>> {
+}
+export declare const SizeConstraint: (params: SizeConstraintParams) => SizeConstraint;

package/dist/dataStructure/constraint/size.mjs

@@ -0,0 +1,24 @@
+import { createKind } from "../kind.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/constraint/size.ts
+const sizeConstraintKind = createKind("size-constraint");
+const SizeConstraint = DDataStructure.createConstraint(sizeConstraintKind, ({ init }) => (params) => init({
+	max: params.max === void 0 ? void 0 : DCommon.stringToBytes(params.max),
+	min: params.min === void 0 ? void 0 : DCommon.stringToBytes(params.min)
+}, {
+	executeCheck: async (self, data) => {
+		const result = DEither.rightPipe(await data.stat(), (stat) => {
+			if (!stat.isFile) return DEither.fail();
+			if (self.definition.max !== void 0 && stat.sizeBytes > self.definition.max) return DEither.fail();
+			if (self.definition.min !== void 0 && stat.sizeBytes < self.definition.min) return DEither.fail();
+			return stat;
+		});
+		if (DEither.isLeft(result)) return DDataStructure.ErrorSymbol;
+		return DDataStructure.SuccessSymbol;
+	},
+	isAsynchronous: () => true
+}));
+//#endregion
+export { SizeConstraint, sizeConstraintKind };

package/dist/dataStructure/constraint/types/constraints.d.ts

@@ -0,0 +1,10 @@
+import { ExistConstraint } from '../exist';
+import { MimeTypeConstraint } from '../mimeType';
+import { SizeConstraint } from '../size';
+declare module "@duplojs/lang/dataStructure" {
+    interface ConstraintsStore {
+        exist: ExistConstraint;
+        size: SizeConstraint;
+        mimeType: MimeTypeConstraint;
+    }
+}

package/dist/dataStructure/constraint/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './constraints';

package/dist/dataStructure/fundamentalType/file.cjs

@@ -0,0 +1,11 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_fileInterface = require("../../file/fileInterface.cjs");
+const require_kind = require("../kind.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/fundamentalType/file.ts
+const fileFundamentalTypeKind = require_kind.createKind("file-fundamental-type");
+const TheFile = _duplojs_lang_dataStructure.createFundamentalType(fileFundamentalTypeKind, (self, data) => require_fileInterface.isFileInterface(data) ? _duplojs_lang_dataStructure.SuccessSymbol : _duplojs_lang_dataStructure.ErrorSymbol);
+//#endregion
+exports.TheFile = TheFile;
+exports.fileFundamentalTypeKind = fileFundamentalTypeKind;

package/dist/dataStructure/fundamentalType/file.d.ts

@@ -0,0 +1,8 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DSFile from '../../file';
+export declare const fileFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/file-fundamental-type", unknown>>;
+export interface TheFile extends DCommon.UnionToIntersection<DDataStructure.FundamentalType<DSFile.FileInterface> & DKind.Kind<typeof fileFundamentalTypeKind>> {
+}
+export declare const TheFile: TheFile;

package/dist/dataStructure/fundamentalType/file.mjs

@@ -0,0 +1,8 @@
+import { isFileInterface } from "../../file/fileInterface.mjs";
+import { createKind } from "../kind.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/fundamentalType/file.ts
+const fileFundamentalTypeKind = createKind("file-fundamental-type");
+const TheFile = DDataStructure.createFundamentalType(fileFundamentalTypeKind, (self, data) => isFileInterface(data) ? DDataStructure.SuccessSymbol : DDataStructure.ErrorSymbol);
+//#endregion
+export { TheFile, fileFundamentalTypeKind };

package/dist/dataStructure/fundamentalType/index.d.ts

@@ -0,0 +1,2 @@
+export * from './file';
+export type * from './types';

package/dist/dataStructure/fundamentalType/types/fundamentalTypes.d.ts

@@ -0,0 +1,6 @@
+import { TheFile } from '../file';
+declare module "@duplojs/lang/dataStructure" {
+    interface FundamentalTypesStore {
+        serverFile: TheFile;
+    }
+}

package/dist/dataStructure/fundamentalType/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './fundamentalTypes';

package/dist/dataStructure/helper/exist.cjs

@@ -0,0 +1,7 @@
+const require_exist = require("../constraint/exist.cjs");
+//#region scripts/dataStructure/helper/exist.ts
+function exist() {
+	return require_exist.ExistConstraint();
+}
+//#endregion
+exports.exist = exist;

package/dist/dataStructure/helper/exist.d.ts

@@ -0,0 +1,2 @@
+import { ExistConstraint } from '../constraint';
+export declare function exist(): ExistConstraint;

package/dist/dataStructure/helper/exist.mjs

@@ -0,0 +1,7 @@
+import { ExistConstraint } from "../constraint/exist.mjs";
+//#region scripts/dataStructure/helper/exist.ts
+function exist() {
+	return ExistConstraint();
+}
+//#endregion
+export { exist };

package/dist/dataStructure/helper/file.cjs

@@ -0,0 +1,10 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_file = require("../type/file.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/helper/file.ts
+function file(constraints = []) {
+	return _duplojs_lang_dataStructure.TypeStructure(require_file.FileType(), constraints);
+}
+//#endregion
+exports.file = file;

package/dist/dataStructure/helper/file.d.ts

@@ -0,0 +1,3 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+export declare function file<const GenericConstraints extends readonly DDataStructure.Constraint<DSFile.FileInterface>[] = readonly []>(constraints?: GenericConstraints): NoInfer<DDataStructure.TypeStructure<DSFile.FileInterface, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helper/file.mjs

@@ -0,0 +1,8 @@
+import { FileType } from "../type/file.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/helper/file.ts
+function file(constraints = []) {
+	return DDataStructure.TypeStructure(FileType(), constraints);
+}
+//#endregion
+export { file };

package/dist/dataStructure/helper/index.d.ts

@@ -0,0 +1,4 @@
+export * from './exist';
+export * from './file';
+export * from './mimeType';
+export * from './size';

package/dist/dataStructure/helper/mimeType.cjs

@@ -0,0 +1,7 @@
+const require_mimeType = require("../constraint/mimeType.cjs");
+//#region scripts/dataStructure/helper/mimeType.ts
+function mimeType(mimeType) {
+	return require_mimeType.MimeTypeConstraint(mimeType);
+}
+//#endregion
+exports.mimeType = mimeType;

package/dist/dataStructure/helper/mimeType.d.ts

@@ -0,0 +1,2 @@
+import { MimeTypeConstraint } from '../constraint';
+export declare function mimeType(mimeType: Parameters<typeof MimeTypeConstraint>[0]): MimeTypeConstraint;

package/dist/dataStructure/helper/mimeType.mjs

@@ -0,0 +1,7 @@
+import { MimeTypeConstraint } from "../constraint/mimeType.mjs";
+//#region scripts/dataStructure/helper/mimeType.ts
+function mimeType(mimeType) {
+	return MimeTypeConstraint(mimeType);
+}
+//#endregion
+export { mimeType };

package/dist/dataStructure/helper/size.cjs

@@ -0,0 +1,7 @@
+const require_size = require("../constraint/size.cjs");
+//#region scripts/dataStructure/helper/size.ts
+function size(params) {
+	return require_size.SizeConstraint(params);
+}
+//#endregion
+exports.size = size;

package/dist/dataStructure/helper/size.d.ts

@@ -0,0 +1,2 @@
+import { SizeConstraint, SizeConstraintParams } from '../constraint';
+export declare function size(params: SizeConstraintParams): SizeConstraint;

package/dist/dataStructure/helper/size.mjs

@@ -0,0 +1,7 @@
+import { SizeConstraint } from "../constraint/size.mjs";
+//#region scripts/dataStructure/helper/size.ts
+function size(params) {
+	return SizeConstraint(params);
+}
+//#endregion
+export { size };

package/dist/dataStructure/index.cjs

@@ -0,0 +1,62 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("./kind.cjs");
+const require_file = require("./fundamentalType/file.cjs");
+const require_json = require("./common/codec/defaults/json.cjs");
+const require_string = require("./common/codec/defaults/string.cjs");
+const require_defaultInterpreter = require("./common/error/defaultInterpreter.cjs");
+const require_exist = require("./constraint/exist.cjs");
+const require_mimeType = require("./constraint/mimeType.cjs");
+const require_size = require("./constraint/size.cjs");
+const require_exist$1 = require("./helper/exist.cjs");
+const require_file$1 = require("./type/file.cjs");
+const require_file$2 = require("./helper/file.cjs");
+const require_mimeType$1 = require("./helper/mimeType.cjs");
+const require_size$1 = require("./helper/size.cjs");
+//#region scripts/dataStructure/index.ts
+var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	ExistConstraint: () => require_exist.ExistConstraint,
+	FileType: () => require_file$1.FileType,
+	MimeTypeConstraint: () => require_mimeType.MimeTypeConstraint,
+	SizeConstraint: () => require_size.SizeConstraint,
+	TheFile: () => require_file.TheFile,
+	codecsJson: () => require_json.codecsJson,
+	codecsString: () => require_string.codecsString,
+	createKind: () => require_kind.createKind,
+	defaultErrorInterpreterCodecDictionary: () => require_defaultInterpreter.defaultErrorInterpreterCodecDictionary,
+	defaultErrorInterpreterDataStructureDictionary: () => require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary,
+	exist: () => require_exist$1.exist,
+	existConstraintKind: () => require_exist.existConstraintKind,
+	file: () => require_file$2.file,
+	fileFundamentalTypeKind: () => require_file.fileFundamentalTypeKind,
+	fileTypeKind: () => require_file$1.fileTypeKind,
+	mimeType: () => require_mimeType$1.mimeType,
+	mimeTypeConstraintKind: () => require_mimeType.mimeTypeConstraintKind,
+	size: () => require_size$1.size,
+	sizeConstraintKind: () => require_size.sizeConstraintKind
+});
+//#endregion
+exports.ExistConstraint = require_exist.ExistConstraint;
+exports.FileType = require_file$1.FileType;
+exports.MimeTypeConstraint = require_mimeType.MimeTypeConstraint;
+exports.SizeConstraint = require_size.SizeConstraint;
+exports.TheFile = require_file.TheFile;
+exports.codecsJson = require_json.codecsJson;
+exports.codecsString = require_string.codecsString;
+exports.createKind = require_kind.createKind;
+Object.defineProperty(exports, "dataStructure_exports", {
+	enumerable: true,
+	get: function() {
+		return dataStructure_exports;
+	}
+});
+exports.defaultErrorInterpreterCodecDictionary = require_defaultInterpreter.defaultErrorInterpreterCodecDictionary;
+exports.defaultErrorInterpreterDataStructureDictionary = require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary;
+exports.exist = require_exist$1.exist;
+exports.existConstraintKind = require_exist.existConstraintKind;
+exports.file = require_file$2.file;
+exports.fileFundamentalTypeKind = require_file.fileFundamentalTypeKind;
+exports.fileTypeKind = require_file$1.fileTypeKind;
+exports.mimeType = require_mimeType$1.mimeType;
+exports.mimeTypeConstraintKind = require_mimeType.mimeTypeConstraintKind;
+exports.size = require_size$1.size;
+exports.sizeConstraintKind = require_size.sizeConstraintKind;

package/dist/dataStructure/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './constraint';
+export * from './fundamentalType';
+export * from './helper';
+export * from './kind';
+export * from './type';

package/dist/dataStructure/index.mjs

@@ -0,0 +1,38 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { createKind } from "./kind.mjs";
+import { TheFile, fileFundamentalTypeKind } from "./fundamentalType/file.mjs";
+import { codecsJson } from "./common/codec/defaults/json.mjs";
+import { codecsString } from "./common/codec/defaults/string.mjs";
+import { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary } from "./common/error/defaultInterpreter.mjs";
+import { ExistConstraint, existConstraintKind } from "./constraint/exist.mjs";
+import { MimeTypeConstraint, mimeTypeConstraintKind } from "./constraint/mimeType.mjs";
+import { SizeConstraint, sizeConstraintKind } from "./constraint/size.mjs";
+import { exist } from "./helper/exist.mjs";
+import { FileType, fileTypeKind } from "./type/file.mjs";
+import { file } from "./helper/file.mjs";
+import { mimeType } from "./helper/mimeType.mjs";
+import { size } from "./helper/size.mjs";
+//#region scripts/dataStructure/index.ts
+var dataStructure_exports = /* @__PURE__ */ __exportAll({
+	ExistConstraint: () => ExistConstraint,
+	FileType: () => FileType,
+	MimeTypeConstraint: () => MimeTypeConstraint,
+	SizeConstraint: () => SizeConstraint,
+	TheFile: () => TheFile,
+	codecsJson: () => codecsJson,
+	codecsString: () => codecsString,
+	createKind: () => createKind,
+	defaultErrorInterpreterCodecDictionary: () => defaultErrorInterpreterCodecDictionary,
+	defaultErrorInterpreterDataStructureDictionary: () => defaultErrorInterpreterDataStructureDictionary,
+	exist: () => exist,
+	existConstraintKind: () => existConstraintKind,
+	file: () => file,
+	fileFundamentalTypeKind: () => fileFundamentalTypeKind,
+	fileTypeKind: () => fileTypeKind,
+	mimeType: () => mimeType,
+	mimeTypeConstraintKind: () => mimeTypeConstraintKind,
+	size: () => size,
+	sizeConstraintKind: () => sizeConstraintKind
+});
+//#endregion
+export { ExistConstraint, FileType, MimeTypeConstraint, SizeConstraint, TheFile, codecsJson, codecsString, createKind, dataStructure_exports, defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary, exist, existConstraintKind, file, fileFundamentalTypeKind, fileTypeKind, mimeType, mimeTypeConstraintKind, size, sizeConstraintKind };

package/dist/dataStructure/kind.cjs

@@ -0,0 +1,7 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/dataStructure/kind.ts
+const createKind = _duplojs_lang_kind.createNamespace("DuplojsServerDataStructure");
+//#endregion
+exports.createKind = createKind;

package/dist/dataStructure/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from "@duplojs/lang/kind";
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('@duplojs/lang/string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsServerDataStructure/${GenericName}`, GenericKindValue>>;

package/dist/dataStructure/kind.mjs

@@ -0,0 +1,5 @@
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/dataStructure/kind.ts
+const createKind = DKind.createNamespace("DuplojsServerDataStructure");
+//#endregion
+export { createKind };

package/dist/dataStructure/type/file.cjs

@@ -0,0 +1,14 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_file = require("../fundamentalType/file.cjs");
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+//#region scripts/dataStructure/type/file.ts
+const fileTypeKind = require_kind.createKind("file-type");
+const FileType = _duplojs_lang_dataStructure.createType(require_file.TheFile, fileTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => _duplojs_lang_dataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.FileType = FileType;
+exports.fileTypeKind = fileTypeKind;

package/dist/dataStructure/type/file.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DSFile from '../../file';
+import * as FundamentalType from "../fundamentalType";
+export declare const fileTypeKind: DKind.Handler<DKind.Definition<"@DuplojsServerDataStructure/file-type", unknown>>;
+export interface TimeTypeDefinition extends DDataStructure.TypeDefinition {
+}
+export interface FileType extends DCommon.UnionToIntersection<DDataStructure.Type<FundamentalType.TheFile, DSFile.FileInterface, TimeTypeDefinition> & DKind.Kind<typeof fileTypeKind>> {
+}
+export declare const FileType: () => FileType;

package/dist/dataStructure/type/file.mjs

@@ -0,0 +1,11 @@
+import { createKind } from "../kind.mjs";
+import { TheFile } from "../fundamentalType/file.mjs";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+//#region scripts/dataStructure/type/file.ts
+const fileTypeKind = createKind("file-type");
+const FileType = DDataStructure.createType(TheFile, fileTypeKind, ({ init }) => () => init({}, {
+	executeCheck: () => DDataStructure.SuccessSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { FileType, fileTypeKind };

package/dist/dataStructure/type/index.d.ts

@@ -0,0 +1,2 @@
+export * from './file';
+export type * from './types';

package/dist/dataStructure/type/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './types';

package/dist/dataStructure/type/types/types.d.ts

@@ -0,0 +1,6 @@
+import { FileType } from '../file';
+declare module "@duplojs/lang/dataStructure" {
+    interface TypesStore {
+        serverFile: FileType;
+    }
+}

package/dist/file/appendFile.cjs

@@ -0,0 +1,43 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/appendFile.ts
+function handleNodeAppendFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-append-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-append-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-append-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-append-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-append-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-append-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-append-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-append-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-append-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-append-file-error", error);
+}
+function handleDenoAppendFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-append-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-append-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-append-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-append-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-append-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-append-file-busy", error);
+	return _duplojs_lang_either.left("file-system-append-file-error", error);
+}
+const appendFileImplementation = require_implementor.implementFunction("appendFile", {
+	NODE: async (path, data) => {
+		return (await require_implementor.nodeFileSystem.value).appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleNodeAppendFileError);
+	},
+	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => _duplojs_lang_either.right("file-system-append-file")).catch(handleDenoAppendFileError)
+});
+function appendFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendFileImplementation(path, data);
+	}
+	return appendFileImplementation(...args);
+}
+//#endregion
+exports.appendFile = appendFile;

package/dist/file/appendFile.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type AppendFileResult = FileSystemEither<DEither.Right<"append-file", void> | DEither.Left<"append-file-not-found", unknown> | DEither.Left<"append-file-permission-denied", unknown> | DEither.Left<"append-file-is-directory", unknown> | DEither.Left<"append-file-not-directory", unknown> | DEither.Left<"append-file-no-space", unknown> | DEither.Left<"append-file-read-only", unknown> | DEither.Left<"append-file-invalid-argument", unknown> | DEither.Left<"append-file-too-many-open-files", unknown> | DEither.Left<"append-file-busy", unknown> | DEither.Left<"append-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;
+    }
+}
+export declare function appendFile(data: Uint8Array): (path: string & DPath.Path) => Promise<AppendFileResult>;
+export declare function appendFile(path: string & DPath.Path, data: Uint8Array): Promise<AppendFileResult>;

package/dist/file/appendFile.mjs

@@ -0,0 +1,41 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/appendFile.ts
+function handleNodeAppendFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-append-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-append-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-append-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-append-file-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-append-file-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-append-file-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-append-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-append-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-append-file-busy", error);
+	}
+	return DEither.left("file-system-append-file-error", error);
+}
+function handleDenoAppendFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-append-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-append-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-append-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-append-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-append-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-append-file-busy", error);
+	return DEither.left("file-system-append-file-error", error);
+}
+const appendFileImplementation = implementFunction("appendFile", {
+	NODE: async (path, data) => {
+		return (await nodeFileSystem.value).appendFile(path, data).then(() => DEither.right("file-system-append-file")).catch(handleNodeAppendFileError);
+	},
+	DENO: (path, data) => Deno.writeFile(path, data, { append: true }).then(() => DEither.right("file-system-append-file")).catch(handleDenoAppendFileError)
+});
+function appendFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendFileImplementation(path, data);
+	}
+	return appendFileImplementation(...args);
+}
+//#endregion
+export { appendFile };

package/dist/file/appendTextFile.cjs

@@ -0,0 +1,43 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/file/appendTextFile.ts
+function handleNodeAppendTextFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return _duplojs_lang_either.left("file-system-append-text-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return _duplojs_lang_either.left("file-system-append-text-file-permission-denied", error);
+		else if (error.code === "EISDIR") return _duplojs_lang_either.left("file-system-append-text-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return _duplojs_lang_either.left("file-system-append-text-file-not-directory", error);
+		else if (error.code === "ENOSPC") return _duplojs_lang_either.left("file-system-append-text-file-no-space", error);
+		else if (error.code === "EROFS") return _duplojs_lang_either.left("file-system-append-text-file-read-only", error);
+		else if (error.code === "EINVAL") return _duplojs_lang_either.left("file-system-append-text-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return _duplojs_lang_either.left("file-system-append-text-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return _duplojs_lang_either.left("file-system-append-text-file-busy", error);
+	}
+	return _duplojs_lang_either.left("file-system-append-text-file-error", error);
+}
+function handleDenoAppendTextFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return _duplojs_lang_either.left("file-system-append-text-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return _duplojs_lang_either.left("file-system-append-text-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return _duplojs_lang_either.left("file-system-append-text-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return _duplojs_lang_either.left("file-system-append-text-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return _duplojs_lang_either.left("file-system-append-text-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return _duplojs_lang_either.left("file-system-append-text-file-busy", error);
+	return _duplojs_lang_either.left("file-system-append-text-file-error", error);
+}
+const appendTextFileImplementation = require_implementor.implementFunction("appendTextFile", {
+	NODE: async (path, data) => {
+		return (await require_implementor.nodeFileSystem.value).appendFile(path, data).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleNodeAppendTextFileError);
+	},
+	DENO: (path, data) => Deno.writeTextFile(path, data, { append: true }).then(() => _duplojs_lang_either.right("file-system-append-text-file")).catch(handleDenoAppendTextFileError)
+});
+function appendTextFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => appendTextFileImplementation(path, data);
+	}
+	return appendTextFileImplementation(...args);
+}
+//#endregion
+exports.appendTextFile = appendTextFile;

package/dist/file/appendTextFile.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type AppendTextFileResult = FileSystemEither<DEither.Right<"append-text-file", void> | DEither.Left<"append-text-file-not-found", unknown> | DEither.Left<"append-text-file-permission-denied", unknown> | DEither.Left<"append-text-file-is-directory", unknown> | DEither.Left<"append-text-file-not-directory", unknown> | DEither.Left<"append-text-file-no-space", unknown> | DEither.Left<"append-text-file-read-only", unknown> | DEither.Left<"append-text-file-invalid-argument", unknown> | DEither.Left<"append-text-file-too-many-open-files", unknown> | DEither.Left<"append-text-file-busy", unknown> | DEither.Left<"append-text-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        appendTextFile(path: string & DPath.Path, data: string): Promise<AppendTextFileResult>;
+    }
+}
+export declare function appendTextFile(data: string): (path: string & DPath.Path) => Promise<AppendTextFileResult>;
+export declare function appendTextFile(path: string & DPath.Path, data: string): Promise<AppendTextFileResult>;