@aigne/afs 1.11.0-beta → 1.11.0-beta.10

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.cts

@@ -0,0 +1,141 @@
+//#region ../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7TypeName = "string" //
+| "number" | "integer" | "boolean" | "object" | "array" | "null";
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7Type = string //
+| number | boolean | JSONSchema7Object | JSONSchema7Array | null;
+// Workaround for infinite type recursion
+interface JSONSchema7Object {
+  [key: string]: JSONSchema7Type;
+}
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema7Version = string;
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+type JSONSchema7Definition = JSONSchema7 | boolean;
+interface JSONSchema7 {
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: JSONSchema7Version | undefined;
+  $comment?: string | undefined;
+  /**
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
+   */
+  $defs?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+   */
+  type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
+  enum?: JSONSchema7Type[] | undefined;
+  const?: JSONSchema7Type | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+   */
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+   */
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+   */
+  items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+  additionalItems?: JSONSchema7Definition | undefined;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  contains?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+   */
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: string[] | undefined;
+  properties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  patternProperties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  additionalProperties?: JSONSchema7Definition | undefined;
+  dependencies?: {
+    [key: string]: JSONSchema7Definition | string[];
+  } | undefined;
+  propertyNames?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+   */
+  if?: JSONSchema7Definition | undefined;
+  then?: JSONSchema7Definition | undefined;
+  else?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+   */
+  allOf?: JSONSchema7Definition[] | undefined;
+  anyOf?: JSONSchema7Definition[] | undefined;
+  oneOf?: JSONSchema7Definition[] | undefined;
+  not?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+   */
+  format?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+   */
+  contentMediaType?: string | undefined;
+  contentEncoding?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+   */
+  definitions?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+   */
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: JSONSchema7Type | undefined;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: JSONSchema7Type | undefined;
+}
+//#endregion
+export { JSONSchema7 };
+//# sourceMappingURL=index.d.cts.map

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["JSONSchema4TypeName","JSONSchema4Type","JSONSchema4Object","JSONSchema4Array","key","Array","JSONSchema4Version","JSONSchema4","id","$ref","$schema","title","description","default","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","additionalItems","items","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","additionalProperties","definitions","k","properties","patternProperties","dependencies","enum","type","allOf","anyOf","oneOf","not","extends","format","JSONSchema6TypeName","JSONSchema6Type","JSONSchema6Object","JSONSchema6Array","JSONSchema6Version","JSONSchema6Definition","JSONSchema6","$id","contains","propertyNames","const","examples","JSONSchema7TypeName","JSONSchema7Type","JSONSchema7Object","JSONSchema7Array","JSONSchema7Version","JSONSchema7Definition","JSONSchema7","$comment","$defs","if","then","else","contentMediaType","contentEncoding","readOnly","writeOnly","ValidationResult","ValidationError","valid","errors","property","message","validate","instance","schema","checkPropertyChange","value","mustBeValid","result"],"sources":["../../../../../../../../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;KA+iBYwD,mBAAAA;AAAAA;;;;;KAaAC,eAAAA;AAAAA,qBAINC,iBAAAA,GACAC,gBAAAA;AAAAA;AAAAA,UAIWD,iBAAAA;EAAAA,CACZtD,GAAAA,WAAcqD,eAAAA;AAAAA;AAAAA;AAAAA;AAAAA,UAKFE,gBAAAA,SAAyBtD,KAAAA,CAAMoD,eAAAA;;;;;;;;;;;;KAapCG,kBAAAA;;;;;KAMAC,qBAAAA,GAAwBC,WAAAA;AAAAA,UACnBA,WAAAA;EACbX,GAAAA;EACA1C,IAAAA;EACAC,OAAAA,GAAUkD,kBAAAA;EACVG,QAAAA;;;;;EAMAC,KAAAA;IAAAA,CACK5D,GAAAA,WAAcyD,qBAAAA;EAAAA;;;;EAMnBxB,IAAAA,GAAOmB,mBAAAA,GAAsBA,mBAAAA;EAC7BpB,IAAAA,GAAOqB,eAAAA;EACPH,KAAAA,GAAQG,eAAAA;;;;EAKR3C,UAAAA;EACAC,OAAAA;EACAC,gBAAAA;EACAC,OAAAA;EACAC,gBAAAA;;;;EAKAC,SAAAA;EACAC,SAAAA;EACAC,OAAAA;;;;EAKAE,KAAAA,GAAQsC,qBAAAA,GAAwBA,qBAAAA;EAChCvC,eAAAA,GAAkBuC,qBAAAA;EAClBrC,QAAAA;EACAC,QAAAA;EACAC,WAAAA;EACA0B,QAAAA,GAAWS,qBAAAA;;;;EAKXlC,aAAAA;EACAC,aAAAA;EACAC,QAAAA;EACAI,UAAAA;IAAAA,CACK7B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnB3B,iBAAAA;IAAAA,CACK9B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnB/B,oBAAAA,GAAuB+B,qBAAAA;EACvB1B,YAAAA;IAAAA,CACK/B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnBR,aAAAA,GAAgBQ,qBAAAA;;;;EAKhBI,EAAAA,GAAKJ,qBAAAA;EACLK,IAAAA,GAAOL,qBAAAA;EACPM,IAAAA,GAAON,qBAAAA;;;;EAKPvB,KAAAA,GAAQuB,qBAAAA;EACRtB,KAAAA,GAAQsB,qBAAAA;EACRrB,KAAAA,GAAQqB,qBAAAA;EACRpB,GAAAA,GAAMoB,qBAAAA;;;;EAKNlB,MAAAA;;;;EAKAyB,gBAAAA;EACAC,eAAAA;;;;EAKAtC,WAAAA;IAAAA,CACK3B,GAAAA,WAAcyD,qBAAAA;EAAAA;;;;EAMnBlD,KAAAA;EACAC,WAAAA;EACAC,OAAAA,GAAU4C,eAAAA;EACVa,QAAAA;EACAC,SAAAA;EACAhB,QAAAA,GAAWE,eAAAA;AAAAA"}

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.mts

@@ -0,0 +1,141 @@
+//#region ../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7TypeName = "string" //
+| "number" | "integer" | "boolean" | "object" | "array" | "null";
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7Type = string //
+| number | boolean | JSONSchema7Object | JSONSchema7Array | null;
+// Workaround for infinite type recursion
+interface JSONSchema7Object {
+  [key: string]: JSONSchema7Type;
+}
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema7Version = string;
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+type JSONSchema7Definition = JSONSchema7 | boolean;
+interface JSONSchema7 {
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: JSONSchema7Version | undefined;
+  $comment?: string | undefined;
+  /**
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
+   */
+  $defs?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+   */
+  type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
+  enum?: JSONSchema7Type[] | undefined;
+  const?: JSONSchema7Type | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+   */
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+   */
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+   */
+  items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+  additionalItems?: JSONSchema7Definition | undefined;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  contains?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+   */
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: string[] | undefined;
+  properties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  patternProperties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  additionalProperties?: JSONSchema7Definition | undefined;
+  dependencies?: {
+    [key: string]: JSONSchema7Definition | string[];
+  } | undefined;
+  propertyNames?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+   */
+  if?: JSONSchema7Definition | undefined;
+  then?: JSONSchema7Definition | undefined;
+  else?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+   */
+  allOf?: JSONSchema7Definition[] | undefined;
+  anyOf?: JSONSchema7Definition[] | undefined;
+  oneOf?: JSONSchema7Definition[] | undefined;
+  not?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+   */
+  format?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+   */
+  contentMediaType?: string | undefined;
+  contentEncoding?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+   */
+  definitions?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+   */
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: JSONSchema7Type | undefined;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: JSONSchema7Type | undefined;
+}
+//#endregion
+export { JSONSchema7 };
+//# sourceMappingURL=index.d.mts.map

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":["JSONSchema4TypeName","JSONSchema4Type","JSONSchema4Object","JSONSchema4Array","key","Array","JSONSchema4Version","JSONSchema4","id","$ref","$schema","title","description","default","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","additionalItems","items","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","additionalProperties","definitions","k","properties","patternProperties","dependencies","enum","type","allOf","anyOf","oneOf","not","extends","format","JSONSchema6TypeName","JSONSchema6Type","JSONSchema6Object","JSONSchema6Array","JSONSchema6Version","JSONSchema6Definition","JSONSchema6","$id","contains","propertyNames","const","examples","JSONSchema7TypeName","JSONSchema7Type","JSONSchema7Object","JSONSchema7Array","JSONSchema7Version","JSONSchema7Definition","JSONSchema7","$comment","$defs","if","then","else","contentMediaType","contentEncoding","readOnly","writeOnly","ValidationResult","ValidationError","valid","errors","property","message","validate","instance","schema","checkPropertyChange","value","mustBeValid","result"],"sources":["../../../../../../../../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;KA+iBYwD,mBAAAA;AAAAA;;;;;KAaAC,eAAAA;AAAAA,qBAINC,iBAAAA,GACAC,gBAAAA;AAAAA;AAAAA,UAIWD,iBAAAA;EAAAA,CACZtD,GAAAA,WAAcqD,eAAAA;AAAAA;AAAAA;AAAAA;AAAAA,UAKFE,gBAAAA,SAAyBtD,KAAAA,CAAMoD,eAAAA;;;;;;;;;;;;KAapCG,kBAAAA;;;;;KAMAC,qBAAAA,GAAwBC,WAAAA;AAAAA,UACnBA,WAAAA;EACbX,GAAAA;EACA1C,IAAAA;EACAC,OAAAA,GAAUkD,kBAAAA;EACVG,QAAAA;;;;;EAMAC,KAAAA;IAAAA,CACK5D,GAAAA,WAAcyD,qBAAAA;EAAAA;;;;EAMnBxB,IAAAA,GAAOmB,mBAAAA,GAAsBA,mBAAAA;EAC7BpB,IAAAA,GAAOqB,eAAAA;EACPH,KAAAA,GAAQG,eAAAA;;;;EAKR3C,UAAAA;EACAC,OAAAA;EACAC,gBAAAA;EACAC,OAAAA;EACAC,gBAAAA;;;;EAKAC,SAAAA;EACAC,SAAAA;EACAC,OAAAA;;;;EAKAE,KAAAA,GAAQsC,qBAAAA,GAAwBA,qBAAAA;EAChCvC,eAAAA,GAAkBuC,qBAAAA;EAClBrC,QAAAA;EACAC,QAAAA;EACAC,WAAAA;EACA0B,QAAAA,GAAWS,qBAAAA;;;;EAKXlC,aAAAA;EACAC,aAAAA;EACAC,QAAAA;EACAI,UAAAA;IAAAA,CACK7B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnB3B,iBAAAA;IAAAA,CACK9B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnB/B,oBAAAA,GAAuB+B,qBAAAA;EACvB1B,YAAAA;IAAAA,CACK/B,GAAAA,WAAcyD,qBAAAA;EAAAA;EAEnBR,aAAAA,GAAgBQ,qBAAAA;;;;EAKhBI,EAAAA,GAAKJ,qBAAAA;EACLK,IAAAA,GAAOL,qBAAAA;EACPM,IAAAA,GAAON,qBAAAA;;;;EAKPvB,KAAAA,GAAQuB,qBAAAA;EACRtB,KAAAA,GAAQsB,qBAAAA;EACRrB,KAAAA,GAAQqB,qBAAAA;EACRpB,GAAAA,GAAMoB,qBAAAA;;;;EAKNlB,MAAAA;;;;EAKAyB,gBAAAA;EACAC,eAAAA;;;;EAKAtC,WAAAA;IAAAA,CACK3B,GAAAA,WAAcyD,qBAAAA;EAAAA;;;;EAMnBlD,KAAAA;EACAC,WAAAA;EACAC,OAAAA,GAAU4C,eAAAA;EACVa,QAAAA;EACAC,SAAAA;EACAhB,QAAAA,GAAWE,eAAAA;AAAAA"}

package/dist/path.cjs

@@ -0,0 +1,255 @@
+
+//#region src/path.ts
+/**
+* AFS Path Validation and Normalization
+*
+* All AFS paths must follow Unix filesystem semantics:
+* - Must be absolute paths (start with /)
+* - Use / as path separator (not Windows \)
+* - No NUL characters in path components
+* - Consistent semantics regardless of underlying platform
+*/
+/**
+* Error thrown when path validation fails
+*/
+var AFSPathError = class extends Error {
+	constructor(message, path) {
+		super(message);
+		this.path = path;
+		this.name = "AFSPathError";
+	}
+};
+/**
+* Characters that are not allowed in AFS paths
+*/
+const FORBIDDEN_CHARS = [
+	"\0",
+	"
",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"\x07",
+	"\b",
+	"	",
+	"\n",
+	"\v",
+	"\f",
+	"\r",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"\x1B",
+	"",
+	"",
+	"",
+	""
+];
+/**
+* Check if a string contains any forbidden control characters
+*/
+function containsForbiddenChars(str) {
+	for (const char of FORBIDDEN_CHARS) if (str.includes(char)) return true;
+	return false;
+}
+/**
+* Normalize a path by:
+* - Collapsing multiple consecutive slashes
+* - Resolving . (current directory)
+* - Resolving .. (parent directory) while preventing escape above root
+* - Removing trailing slashes (except for root /)
+* - Rejecting whitespace-only path segments
+*
+* @throws AFSPathError if a path segment is whitespace-only
+*/
+function normalizePath(path) {
+	const segments = path.split("/").filter((s) => s !== "");
+	const result = [];
+	for (const segment of segments) {
+		if (segment.trim() === "") throw new AFSPathError("Path segment cannot be whitespace-only", path);
+		if (segment === ".") continue;
+		if (segment === "..") {
+			if (result.length > 0) result.pop();
+			continue;
+		}
+		result.push(segment);
+	}
+	return `/${result.join("/")}`;
+}
+/**
+* Validate an AFS path
+*
+* @param path - The path to validate
+* @throws AFSPathError if the path is invalid
+* @returns The normalized path
+*/
+function validatePath(path) {
+	if (!path || path.trim() === "") throw new AFSPathError("Path cannot be empty or whitespace-only", path);
+	if (containsForbiddenChars(path)) throw new AFSPathError("Path contains forbidden control characters", path);
+	if (!path.startsWith("/")) throw new AFSPathError("Path must be absolute (start with /)", path);
+	if (path.replace(/^\/+/, "").startsWith("~")) throw new AFSPathError("Path cannot use tilde expansion", path);
+	return normalizePath(path);
+}
+/**
+* Validate a module name
+*
+* Module names must:
+* - Not be empty or whitespace-only
+* - Not contain / or \
+* - Not contain control characters
+* - Not be "." or ".."
+*
+* @param name - The module name to validate
+* @throws Error if the name is invalid
+*/
+function validateModuleName(name) {
+	if (!name || name.trim() === "") throw new Error("Module name cannot be empty or whitespace-only");
+	if (containsForbiddenChars(name)) throw new Error(`Invalid module name: ${name}. Module name must not contain control characters`);
+	if (name.includes("/")) throw new Error(`Invalid module name: ${name}. Module name must not contain '/'`);
+	if (name.includes("\\")) throw new Error(`Invalid module name: ${name}. Module name must not contain '\\'`);
+	if (name === ".") throw new Error("Invalid module name: '.'. Module name cannot be '.'");
+	if (name === "..") throw new Error("Invalid module name: '..'. Module name cannot be '..'");
+}
+/**
+* Canonical path prefix for AFS
+*/
+const CANONICAL_PREFIX = "$afs";
+/**
+* Characters forbidden in namespace names (security-sensitive)
+*/
+const NAMESPACE_FORBIDDEN_CHARS = [
+	"/",
+	"\\",
+	":",
+	";",
+	"|",
+	"&",
+	"`",
+	"$",
+	"(",
+	")",
+	">",
+	"<",
+	"\n",
+	"\r",
+	"	",
+	"\0",
+	...FORBIDDEN_CHARS
+];
+/**
+* Check if a string contains any namespace-forbidden characters
+*/
+function containsNamespaceForbiddenChars(str) {
+	for (const char of NAMESPACE_FORBIDDEN_CHARS) if (str.includes(char)) return true;
+	return false;
+}
+/**
+* Validate a namespace name
+*
+* @throws AFSPathError if namespace is invalid
+*/
+function validateNamespace(namespace, fullPath) {
+	if (!namespace || namespace.trim() === "") throw new AFSPathError("Namespace cannot be empty or whitespace-only", fullPath);
+	if (containsNamespaceForbiddenChars(namespace)) throw new AFSPathError(`Namespace contains forbidden characters: ${namespace}`, fullPath);
+	if (namespace === "." || namespace === "..") throw new AFSPathError("Namespace cannot be '.' or '..'", fullPath);
+	if (namespace.startsWith("..") || namespace.includes("/..") || namespace.includes("\\..")) throw new AFSPathError("Namespace cannot contain path traversal", fullPath);
+}
+/**
+* Check if a string is a canonical AFS path
+*
+* Canonical paths have the format:
+* - $afs/path (default namespace)
+* - $afs:namespace/path (named namespace)
+*
+* @param input - String to check
+* @returns true if input is a canonical AFS path
+*/
+function isCanonicalPath(input) {
+	if (!input || typeof input !== "string") return false;
+	if (!input.startsWith(CANONICAL_PREFIX)) return false;
+	const afterPrefix = input.slice(4);
+	if (afterPrefix.length === 0) return false;
+	const firstChar = afterPrefix[0];
+	if (firstChar !== "/" && firstChar !== ":") return false;
+	if (firstChar === ":") {
+		const slashIndex = afterPrefix.indexOf("/", 1);
+		if (slashIndex === -1) return false;
+		const namespace = afterPrefix.slice(1, slashIndex);
+		if (!namespace || namespace.trim() === "") return false;
+	}
+	return true;
+}
+/**
+* Parse a canonical AFS path
+*
+* Canonical paths have the format:
+* - $afs/path (default namespace)
+* - $afs:namespace/path (named namespace)
+*
+* @param canonical - Canonical path string
+* @returns Parsed path with namespace and path
+* @throws AFSPathError if path format is invalid
+*/
+function parseCanonicalPath(canonical) {
+	if (!canonical || canonical.trim() === "") throw new AFSPathError("Canonical path cannot be empty", canonical);
+	if (containsForbiddenChars(canonical)) throw new AFSPathError("Canonical path contains forbidden control characters", canonical);
+	if (!canonical.startsWith(CANONICAL_PREFIX)) throw new AFSPathError(`Canonical path must start with '${CANONICAL_PREFIX}', got: ${canonical}`, canonical);
+	const afterPrefix = canonical.slice(4);
+	if (afterPrefix.length === 0) throw new AFSPathError("Canonical path must have '/' or ':' after $afs", canonical);
+	const firstChar = afterPrefix[0];
+	if (firstChar === "/") return {
+		namespace: null,
+		path: normalizePath(afterPrefix)
+	};
+	if (firstChar === ":") {
+		const rest = afterPrefix.slice(1);
+		const slashIndex = rest.indexOf("/");
+		if (slashIndex === -1) throw new AFSPathError("Named namespace path must have '/' after namespace", canonical);
+		const namespace = rest.slice(0, slashIndex);
+		const pathPart = rest.slice(slashIndex);
+		validateNamespace(namespace, canonical);
+		if (namespace.includes(":")) throw new AFSPathError("Namespace cannot contain ':'", canonical);
+		return {
+			namespace,
+			path: normalizePath(pathPart)
+		};
+	}
+	throw new AFSPathError(`Canonical path must have '/' or ':' after $afs, got: '${firstChar}'`, canonical);
+}
+/**
+* Create a canonical AFS path from components
+*
+* @param namespace - Namespace name, or null for default namespace
+* @param path - Path within namespace (must start with /)
+* @returns Canonical path string
+* @throws AFSPathError if namespace or path is invalid
+*/
+function toCanonicalPath(namespace, path) {
+	if (!path || path.trim() === "") throw new AFSPathError("Path cannot be empty", path);
+	if (!path.startsWith("/")) throw new AFSPathError("Path must start with '/'", path);
+	if (containsForbiddenChars(path)) throw new AFSPathError("Path contains forbidden control characters", path);
+	const normalizedPath = normalizePath(path);
+	if (namespace === null || namespace === void 0) return `${CANONICAL_PREFIX}${normalizedPath}`;
+	validateNamespace(namespace, `${CANONICAL_PREFIX}:${namespace}${path}`);
+	return `${CANONICAL_PREFIX}:${namespace}${normalizedPath}`;
+}
+
+//#endregion
+exports.AFSPathError = AFSPathError;
+exports.isCanonicalPath = isCanonicalPath;
+exports.normalizePath = normalizePath;
+exports.parseCanonicalPath = parseCanonicalPath;
+exports.toCanonicalPath = toCanonicalPath;
+exports.validateModuleName = validateModuleName;
+exports.validatePath = validatePath;

package/dist/path.d.cts

@@ -0,0 +1,93 @@
+//#region src/path.d.ts
+/**
+ * AFS Path Validation and Normalization
+ *
+ * All AFS paths must follow Unix filesystem semantics:
+ * - Must be absolute paths (start with /)
+ * - Use / as path separator (not Windows \)
+ * - No NUL characters in path components
+ * - Consistent semantics regardless of underlying platform
+ */
+/**
+ * Error thrown when path validation fails
+ */
+declare class AFSPathError extends Error {
+  readonly path: string;
+  constructor(message: string, path: string);
+}
+/**
+ * Normalize a path by:
+ * - Collapsing multiple consecutive slashes
+ * - Resolving . (current directory)
+ * - Resolving .. (parent directory) while preventing escape above root
+ * - Removing trailing slashes (except for root /)
+ * - Rejecting whitespace-only path segments
+ *
+ * @throws AFSPathError if a path segment is whitespace-only
+ */
+declare function normalizePath(path: string): string;
+/**
+ * Validate an AFS path
+ *
+ * @param path - The path to validate
+ * @throws AFSPathError if the path is invalid
+ * @returns The normalized path
+ */
+declare function validatePath(path: string): string;
+/**
+ * Validate a module name
+ *
+ * Module names must:
+ * - Not be empty or whitespace-only
+ * - Not contain / or \
+ * - Not contain control characters
+ * - Not be "." or ".."
+ *
+ * @param name - The module name to validate
+ * @throws Error if the name is invalid
+ */
+declare function validateModuleName(name: string): void;
+/**
+ * Parsed canonical AFS path
+ */
+interface ParsedCanonicalPath {
+  /** Namespace name, or null for default namespace */
+  namespace: string | null;
+  /** Path within the namespace (always starts with /) */
+  path: string;
+}
+/**
+ * Check if a string is a canonical AFS path
+ *
+ * Canonical paths have the format:
+ * - $afs/path (default namespace)
+ * - $afs:namespace/path (named namespace)
+ *
+ * @param input - String to check
+ * @returns true if input is a canonical AFS path
+ */
+declare function isCanonicalPath(input: string): boolean;
+/**
+ * Parse a canonical AFS path
+ *
+ * Canonical paths have the format:
+ * - $afs/path (default namespace)
+ * - $afs:namespace/path (named namespace)
+ *
+ * @param canonical - Canonical path string
+ * @returns Parsed path with namespace and path
+ * @throws AFSPathError if path format is invalid
+ */
+declare function parseCanonicalPath(canonical: string): ParsedCanonicalPath;
+/**
+ * Create a canonical AFS path from components
+ *
+ * @param namespace - Namespace name, or null for default namespace
+ * @param path - Path within namespace (must start with /)
+ * @returns Canonical path string
+ * @throws AFSPathError if namespace or path is invalid
+ */
+declare function toCanonicalPath(namespace: string | null, path: string): string;
+//#endregion
+export { AFSPathError, ParsedCanonicalPath, isCanonicalPath, normalizePath, parseCanonicalPath, toCanonicalPath, validateModuleName, validatePath };
+//# sourceMappingURL=path.d.cts.map

package/dist/path.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.cts","names":[],"sources":["../src/path.ts"],"mappings":";;AAaA;;;;;;;;;;;cAAa,YAAA,SAAqB,KAAA;EAAA,SAGd,IAAA;cADhB,OAAA,UACgB,IAAA;AAAA;;AAwGpB;;;;;AAyCA;;;;iBA9EgB,aAAA,CAAc,IAAA;AAiJ9B;;;;;AAuDA;;AAvDA,iBA5GgB,YAAA,CAAa,IAAA;;;AAmN7B;;;;;AAoFA;;;;;iBA9PgB,kBAAA,CAAmB,IAAA;;;;UAmElB,mBAAA;;EAEf,SAAA;;EAEA,IAAA;AAAA;;;;;;;;;;;iBAmDc,eAAA,CAAgB,KAAA;;;;;;;;;;;;iBAgDhB,kBAAA,CAAmB,SAAA,WAAoB,mBAAA;;;;;;;;;iBAoFvC,eAAA,CAAgB,SAAA,iBAA0B,IAAA"}