@arcblock/did 1.29.17 → 1.29.19

package/esm/entity.d.mts

@@ -0,0 +1,28 @@
+//#region src/entity.d.ts
+/**
+ * Cross-Method Entity Association
+ *
+ * Functions for comparing DID identity across different methods.
+ * Two DIDs with different methods but the same identifier represent the same entity.
+ */
+/**
+ * Get the entity identifier from a DID (strips method prefix).
+ * This is the canonical identity across methods.
+ *
+ * @param did - A full DID or bare address
+ * @returns The entity identifier
+ */
+declare function getEntityId(did: string): string;
+/**
+ * Check if two DIDs represent the same entity.
+ * Compares the identifier portion (case-insensitive), ignoring the method prefix.
+ *
+ * For did:name DIDs, performs exact string comparison (names are case-insensitive).
+ *
+ * @param a - First DID or address
+ * @param b - Second DID or address
+ * @returns true if both DIDs refer to the same entity
+ */
+declare function isSameEntity(a: unknown, b: unknown): boolean;
+//#endregion
+export { getEntityId, isSameEntity };

package/esm/entity.mjs

@@ -0,0 +1,39 @@
+import { extractIdentifier } from "./parse.mjs";
+
+//#region src/entity.ts
+/**
+* Cross-Method Entity Association
+*
+* Functions for comparing DID identity across different methods.
+* Two DIDs with different methods but the same identifier represent the same entity.
+*/
+/**
+* Get the entity identifier from a DID (strips method prefix).
+* This is the canonical identity across methods.
+*
+* @param did - A full DID or bare address
+* @returns The entity identifier
+*/
+function getEntityId(did) {
+	return extractIdentifier(did);
+}
+/**
+* Check if two DIDs represent the same entity.
+* Compares the identifier portion (case-insensitive), ignoring the method prefix.
+*
+* For did:name DIDs, performs exact string comparison (names are case-insensitive).
+*
+* @param a - First DID or address
+* @param b - Second DID or address
+* @returns true if both DIDs refer to the same entity
+*/
+function isSameEntity(a, b) {
+	if (typeof a !== "string" || typeof b !== "string" || !a || !b) return false;
+	const idA = extractIdentifier(a);
+	const idB = extractIdentifier(b);
+	if (!idA || !idB) return false;
+	return idA.toLowerCase() === idB.toLowerCase();
+}
+
+//#endregion
+export { getEntityId, isSameEntity };

package/esm/index.d.mts

@@ -1,5 +1,13 @@
+import { getEntityId, isSameEntity } from "./entity.mjs";
 import { DIDType, DIDTypeArg, DIDTypeShortcut, DIDTypeStr, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, RequiredDIDType, fromTypeInfo, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr } from "./type.mjs";
 import { DID_PREFIX, toStrictHex } from "./util.mjs";
+import { ALIAS_METHODS, ALL_METHODS, AliasMethod, CRYPTO_METHODS, CryptoMethod, DEFAULT_METHOD, DIDMethod, isAliasMethod, isCryptoMethod, isKnownMethod } from "./method.mjs";
+import { ParsedDID, extractIdentifier, extractMethod, formatDid, parse } from "./parse.mjs";
+import { isKnownDid } from "./validate.mjs";
+import { expandShortForm, toShortForm } from "./short-form.mjs";
+import { NameHierarchy, ResolveRoute, getResolveRoute, isGlobalName, isLocalName, parseNameHierarchy } from "./name.mjs";
+import { InMemoryNameRegistry, NameRegistry } from "./name-registry.mjs";
+import { DIDNameResolver, DIDNameResolverOptions, ResolveTraceResult } from "./name-resolver.mjs";
 import { types } from "@ocap/mcrypto";
 import { BytesType, toAddress, toDid } from "@ocap/util";
 
@@ -58,4 +66,4 @@ declare const isFromPublicKey: (did: string, pk: BytesType) => boolean;
  */
 declare const isValid: (did: string) => boolean;
 //#endregion
-export { type DIDType, type DIDTypeArg, type DIDTypeShortcut, type DIDTypeStr, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, type RequiredDIDType, fromHash, fromPublicKey, fromPublicKeyHash, fromSecretKey, fromTypeInfo, isEthereumDid, isEthereumType, isFromPublicKey, isValid, toAddress, toDid, toStrictHex, toTypeInfo, toTypeInfoStr, types };
+export { ALIAS_METHODS, ALL_METHODS, type AliasMethod, CRYPTO_METHODS, type CryptoMethod, DEFAULT_METHOD, type DIDMethod, DIDNameResolver, type DIDNameResolverOptions, type DIDType, type DIDTypeArg, type DIDTypeShortcut, type DIDTypeStr, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, InMemoryNameRegistry, type NameHierarchy, type NameRegistry, type ParsedDID, type RequiredDIDType, type ResolveRoute, type ResolveTraceResult, expandShortForm, extractIdentifier, extractMethod, formatDid, fromHash, fromPublicKey, fromPublicKeyHash, fromSecretKey, fromTypeInfo, getEntityId, getResolveRoute, isAliasMethod, isCryptoMethod, isEthereumDid, isEthereumType, isFromPublicKey, isGlobalName, isKnownDid, isKnownMethod, isLocalName, isSameEntity, isValid, parse, parseNameHierarchy, toAddress, toDid, toShortForm, toStrictHex, toTypeInfo, toTypeInfoStr, types };

package/esm/index.mjs

@@ -1,5 +1,13 @@
+import { ALIAS_METHODS, ALL_METHODS, CRYPTO_METHODS, DEFAULT_METHOD, isAliasMethod, isCryptoMethod, isKnownMethod } from "./method.mjs";
+import { extractIdentifier, extractMethod, formatDid, parse } from "./parse.mjs";
+import { getEntityId, isSameEntity } from "./entity.mjs";
 import { DID_PREFIX, toBytes, toStrictHex } from "./util.mjs";
 import { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromTypeInfo, isEthereumDid, isEthereumType, toChecksumAddress, toTypeInfo, toTypeInfoStr } from "./type.mjs";
+import { isKnownDid } from "./validate.mjs";
+import { expandShortForm, toShortForm } from "./short-form.mjs";
+import { getResolveRoute, isGlobalName, isLocalName, parseNameHierarchy } from "./name.mjs";
+import { InMemoryNameRegistry } from "./name-registry.mjs";
+import { DIDNameResolver } from "./name-resolver.mjs";
 import { getHasher, getSigner, types } from "@ocap/mcrypto";
 import { stripHexPrefix, toAddress, toBase58, toDid } from "@ocap/util";
 
@@ -69,7 +77,7 @@ const fromHash = (hash, role = types.RoleType.ROLE_ACCOUNT) => {
 */
 const isFromPublicKey = (did, pk) => {
 	if (isValid(did) === false) return false;
-	return fromPublicKey(pk, toTypeInfo(did)) === did.replace(DID_PREFIX, "");
+	return fromPublicKey(pk, toTypeInfo(did)) === toAddress(did);
 };
 /**
 * Check if a DID string is valid
@@ -92,4 +100,4 @@ const isValid = (did) => {
 };
 
 //#endregion
-export { DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromHash, fromPublicKey, fromPublicKeyHash, fromSecretKey, fromTypeInfo, isEthereumDid, isEthereumType, isFromPublicKey, isValid, toAddress, toDid, toStrictHex, toTypeInfo, toTypeInfoStr, types };
+export { ALIAS_METHODS, ALL_METHODS, CRYPTO_METHODS, DEFAULT_METHOD, DIDNameResolver, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, InMemoryNameRegistry, expandShortForm, extractIdentifier, extractMethod, formatDid, fromHash, fromPublicKey, fromPublicKeyHash, fromSecretKey, fromTypeInfo, getEntityId, getResolveRoute, isAliasMethod, isCryptoMethod, isEthereumDid, isEthereumType, isFromPublicKey, isGlobalName, isKnownDid, isKnownMethod, isLocalName, isSameEntity, isValid, parse, parseNameHierarchy, toAddress, toDid, toShortForm, toStrictHex, toTypeInfo, toTypeInfoStr, types };

package/esm/method.d.mts

@@ -0,0 +1,30 @@
+//#region src/method.d.ts
+/**
+ * DID Method Registry
+ *
+ * Defines supported DID methods, their categories, and helper functions.
+ * Crypto methods (abt, afs, aos, spaces) share a unified identifier encoding.
+ * Alias methods (name) use human-readable identifiers with DNS-style hierarchy.
+ */
+/** Crypto methods share unified identifier encoding */
+type CryptoMethod = 'abt' | 'afs' | 'aos' | 'spaces';
+/** Alias methods use human-readable identifiers */
+type AliasMethod = 'name';
+/** All supported DID methods */
+type DIDMethod = CryptoMethod | AliasMethod;
+/** Crypto methods: share unified identifier encoding (base58 checksum / ethereum / base16) */
+declare const CRYPTO_METHODS: readonly CryptoMethod[];
+/** Alias methods: human-readable identifiers */
+declare const ALIAS_METHODS: readonly AliasMethod[];
+/** All supported methods */
+declare const ALL_METHODS: readonly DIDMethod[];
+/** Default method when none is specified */
+declare const DEFAULT_METHOD: CryptoMethod;
+/** Check if a value is a known crypto method */
+declare function isCryptoMethod(method: unknown): method is CryptoMethod;
+/** Check if a value is a known alias method */
+declare function isAliasMethod(method: unknown): method is AliasMethod;
+/** Check if a value is any known method */
+declare function isKnownMethod(method: unknown): method is DIDMethod;
+//#endregion
+export { ALIAS_METHODS, ALL_METHODS, AliasMethod, CRYPTO_METHODS, CryptoMethod, DEFAULT_METHOD, DIDMethod, isAliasMethod, isCryptoMethod, isKnownMethod };

package/esm/method.mjs

@@ -0,0 +1,32 @@
+//#region src/method.ts
+/** Crypto methods: share unified identifier encoding (base58 checksum / ethereum / base16) */
+const CRYPTO_METHODS = Object.freeze([
+	"abt",
+	"afs",
+	"aos",
+	"spaces"
+]);
+/** Alias methods: human-readable identifiers */
+const ALIAS_METHODS = Object.freeze(["name"]);
+/** All supported methods */
+const ALL_METHODS = Object.freeze([...CRYPTO_METHODS, ...ALIAS_METHODS]);
+/** Default method when none is specified */
+const DEFAULT_METHOD = "abt";
+/** Check if a value is a known crypto method */
+function isCryptoMethod(method) {
+	if (typeof method !== "string") return false;
+	return CRYPTO_METHODS.includes(method);
+}
+/** Check if a value is a known alias method */
+function isAliasMethod(method) {
+	if (typeof method !== "string") return false;
+	return ALIAS_METHODS.includes(method);
+}
+/** Check if a value is any known method */
+function isKnownMethod(method) {
+	if (typeof method !== "string") return false;
+	return ALL_METHODS.includes(method);
+}
+
+//#endregion
+export { ALIAS_METHODS, ALL_METHODS, CRYPTO_METHODS, DEFAULT_METHOD, isAliasMethod, isCryptoMethod, isKnownMethod };

package/esm/name-registry.d.mts

@@ -0,0 +1,31 @@
+//#region src/name-registry.d.ts
+/**
+ * NameRegistry Interface and InMemoryNameRegistry Implementation
+ *
+ * Provides a synchronous interface for name→DID registration and lookup.
+ * InMemoryNameRegistry is a Map-based implementation for testing.
+ */
+/** Name registry interface (synchronous) */
+interface NameRegistry {
+  resolve(name: string): string | null;
+  register(name: string, did: string): void;
+  unregister(name: string): void;
+  has(name: string): boolean;
+  list(): string[];
+  clear(): void;
+}
+/**
+ * In-memory name registry implementation.
+ * Uses upsert semantics: re-registering a name overwrites the previous value.
+ */
+declare class InMemoryNameRegistry implements NameRegistry {
+  private store;
+  resolve(name: string): string | null;
+  register(name: string, did: string): void;
+  unregister(name: string): void;
+  has(name: string): boolean;
+  list(): string[];
+  clear(): void;
+}
+//#endregion
+export { InMemoryNameRegistry, NameRegistry };

package/esm/name-registry.mjs

@@ -0,0 +1,37 @@
+//#region src/name-registry.ts
+const MAX_NAME_LENGTH = 1024;
+/**
+* In-memory name registry implementation.
+* Uses upsert semantics: re-registering a name overwrites the previous value.
+*/
+var InMemoryNameRegistry = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map();
+	}
+	resolve(name) {
+		return this.store.get(name) ?? null;
+	}
+	register(name, did) {
+		if (!name || typeof name !== "string") throw new Error("Name must be a non-empty string");
+		if (name.length > MAX_NAME_LENGTH) throw new Error("Name exceeds maximum length");
+		if (name.startsWith(".") || name.endsWith(".")) throw new Error("Name cannot start or end with a dot");
+		if (!did || typeof did !== "string") throw new Error("DID must be a non-empty string");
+		if (!did.startsWith("did:")) throw new Error("DID must have a valid did: prefix");
+		this.store.set(name, did);
+	}
+	unregister(name) {
+		this.store.delete(name);
+	}
+	has(name) {
+		return this.store.has(name);
+	}
+	list() {
+		return [...this.store.keys()];
+	}
+	clear() {
+		this.store.clear();
+	}
+};
+
+//#endregion
+export { InMemoryNameRegistry };

package/esm/name-resolver.d.mts

@@ -0,0 +1,41 @@
+import { NameRegistry } from "./name-registry.mjs";
+
+//#region src/name-resolver.d.ts
+
+interface DIDNameResolverOptions {
+  global?: NameRegistry;
+  local?: NameRegistry;
+  maxDepth?: number;
+}
+interface ResolveTraceResult {
+  result: string | null;
+  trace: string[];
+}
+/**
+ * DID Name Resolver.
+ *
+ * Routes name resolution to the appropriate registry based on the name structure:
+ * - Global names (single segment) → global registry
+ * - .local names → local registry
+ * - Delegated names (multi-segment) → resolve TLD first, then delegate
+ */
+declare class DIDNameResolver {
+  private global?;
+  private local?;
+  private maxDepth;
+  constructor(opts?: DIDNameResolverOptions);
+  /**
+   * Resolve a name to a DID.
+   *
+   * @param name - The name to resolve (can be prefixed with 'did:name:')
+   * @returns The resolved DID, or null if not found
+   */
+  resolve(name: string): Promise<string | null>;
+  /**
+   * Resolve a name with full trace for debugging.
+   */
+  resolveWithTrace(name: string): Promise<ResolveTraceResult>;
+  private _resolve;
+}
+//#endregion
+export { DIDNameResolver, DIDNameResolverOptions, ResolveTraceResult };

package/esm/name-resolver.mjs

@@ -0,0 +1,97 @@
+import { getResolveRoute } from "./name.mjs";
+
+//#region src/name-resolver.ts
+/**
+* DID Name Resolver
+*
+* Orchestrates name resolution across different registries (global, local).
+* Supports delegation chains with cycle detection and depth limiting.
+*/
+const DEFAULT_MAX_DEPTH = 10;
+/**
+* DID Name Resolver.
+*
+* Routes name resolution to the appropriate registry based on the name structure:
+* - Global names (single segment) → global registry
+* - .local names → local registry
+* - Delegated names (multi-segment) → resolve TLD first, then delegate
+*/
+var DIDNameResolver = class {
+	constructor(opts = {}) {
+		this.global = opts.global;
+		this.local = opts.local;
+		this.maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+	}
+	/**
+	* Resolve a name to a DID.
+	*
+	* @param name - The name to resolve (can be prefixed with 'did:name:')
+	* @returns The resolved DID, or null if not found
+	*/
+	async resolve(name) {
+		return (await this.resolveWithTrace(name)).result;
+	}
+	/**
+	* Resolve a name with full trace for debugging.
+	*/
+	async resolveWithTrace(name) {
+		if (!name || typeof name !== "string") throw new Error("Name must be a non-empty string");
+		const cleanName = name.replace(/^did:name:/, "");
+		if (!cleanName) throw new Error("Name cannot be empty after stripping prefix");
+		const visited = /* @__PURE__ */ new Set();
+		return this._resolve(cleanName, visited, [], 0);
+	}
+	async _resolve(name, visited, trace, depth) {
+		if (visited.has(name)) {
+			trace.push(`cycle_detected:${name}`);
+			return {
+				result: null,
+				trace
+			};
+		}
+		if (depth >= this.maxDepth) {
+			trace.push(`max_depth:${name}`);
+			return {
+				result: null,
+				trace
+			};
+		}
+		visited.add(name);
+		const route = getResolveRoute(name);
+		let resolved = null;
+		if (route.type === "local") {
+			trace.push(`local:${name}`);
+			if (this.local) resolved = this.local.resolve(route.name);
+		} else if (route.type === "global") {
+			trace.push(`global:${name}`);
+			if (this.global) resolved = this.global.resolve(route.name);
+		} else {
+			trace.push(`delegated:${name}`);
+			if (this.global) {
+				resolved = this.global.resolve(name);
+				if (!resolved) {
+					const tldResult = this.global.resolve(route.tld);
+					if (tldResult) resolved = tldResult;
+				}
+			}
+		}
+		if (!resolved) {
+			trace.push(`not_found:${name}`);
+			return {
+				result: null,
+				trace
+			};
+		}
+		if (resolved.startsWith("did:name:")) {
+			const nextName = resolved.replace(/^did:name:/, "");
+			return this._resolve(nextName, visited, trace, depth + 1);
+		}
+		return {
+			result: resolved,
+			trace
+		};
+	}
+};
+
+//#endregion
+export { DIDNameResolver };

package/esm/name.d.mts

@@ -0,0 +1,62 @@
+//#region src/name.d.ts
+/**
+ * DID Name Hierarchy Parser
+ *
+ * DNS-style right-to-left name resolution for did:name identifiers.
+ * Supports global names, delegated sub-names, and .local domains.
+ */
+/** Parsed name hierarchy */
+interface NameHierarchy {
+  /** Name segments split by '.' */
+  segments: string[];
+  /** Top-level domain (rightmost segment) */
+  tld: string;
+  /** Whether this is a .local name */
+  isLocal: boolean;
+  /** Whether this is a global name (single segment, not .local) */
+  isGlobal: boolean;
+  /** Number of segments */
+  depth: number;
+}
+/** Resolve route types */
+type ResolveRoute = {
+  type: 'global';
+  name: string;
+} | {
+  type: 'local';
+  name: string;
+} | {
+  type: 'delegated';
+  tld: string;
+  subName: string;
+};
+/**
+ * Parse a name identifier into its hierarchy components.
+ *
+ * @param name - The name to parse (e.g. 'robertmao', 'bob.myorg', 'anything.local')
+ * @returns Parsed hierarchy
+ * @throws If name is invalid
+ */
+declare function parseNameHierarchy(name: unknown): NameHierarchy;
+/**
+ * Determine the resolve route for a name.
+ *
+ * - Single segment (e.g. 'robertmao') → global route
+ * - Ends with '.local' → local route
+ * - Multi-segment (e.g. 'bob.myorg') → delegated route
+ *
+ * @param name - The name to route
+ * @returns The resolve route
+ * @throws If name is invalid
+ */
+declare function getResolveRoute(name: string): ResolveRoute;
+/**
+ * Check if a name is a .local name.
+ */
+declare function isLocalName(name: string): boolean;
+/**
+ * Check if a name is a global name (single segment, not .local).
+ */
+declare function isGlobalName(name: string): boolean;
+//#endregion
+export { NameHierarchy, ResolveRoute, getResolveRoute, isGlobalName, isLocalName, parseNameHierarchy };

package/esm/name.mjs

@@ -0,0 +1,73 @@
+//#region src/name.ts
+/**
+* Parse a name identifier into its hierarchy components.
+*
+* @param name - The name to parse (e.g. 'robertmao', 'bob.myorg', 'anything.local')
+* @returns Parsed hierarchy
+* @throws If name is invalid
+*/
+function parseNameHierarchy(name) {
+	if (typeof name !== "string") throw new Error("Name must be a string");
+	if (!name) throw new Error("Name cannot be empty");
+	if (name.startsWith(".")) throw new Error("Name cannot start with a dot");
+	if (name.endsWith(".")) throw new Error("Name cannot end with a dot");
+	if (name.includes("..")) throw new Error("Name cannot contain consecutive dots");
+	const segments = name.split(".");
+	if (segments.some((s) => !s)) throw new Error("Name contains empty segments");
+	const tld = segments[segments.length - 1];
+	const isLocal = tld === "local";
+	const isGlobal = segments.length === 1 && !isLocal;
+	const depth = segments.length;
+	return {
+		segments: [...segments],
+		tld,
+		isLocal,
+		isGlobal,
+		depth
+	};
+}
+/**
+* Determine the resolve route for a name.
+*
+* - Single segment (e.g. 'robertmao') → global route
+* - Ends with '.local' → local route
+* - Multi-segment (e.g. 'bob.myorg') → delegated route
+*
+* @param name - The name to route
+* @returns The resolve route
+* @throws If name is invalid
+*/
+function getResolveRoute(name) {
+	const hierarchy = parseNameHierarchy(name);
+	if (hierarchy.isLocal) return {
+		type: "local",
+		name: hierarchy.segments.slice(0, -1).join(".")
+	};
+	if (hierarchy.isGlobal) return {
+		type: "global",
+		name
+	};
+	const subName = hierarchy.segments.slice(0, -1).join(".");
+	return {
+		type: "delegated",
+		tld: hierarchy.tld,
+		subName
+	};
+}
+/**
+* Check if a name is a .local name.
+*/
+function isLocalName(name) {
+	if (!name || !name.includes(".")) return false;
+	return name.endsWith(".local");
+}
+/**
+* Check if a name is a global name (single segment, not .local).
+*/
+function isGlobalName(name) {
+	if (!name) return false;
+	return !name.includes(".");
+}
+
+//#endregion
+export { getResolveRoute, isGlobalName, isLocalName, parseNameHierarchy };

package/esm/parse.d.mts

@@ -0,0 +1,50 @@
+import { DIDMethod } from "./method.mjs";
+
+//#region src/parse.d.ts
+
+/** Parsed DID structure */
+interface ParsedDID {
+  /** The method component (e.g. 'abt', 'afs', 'name') */
+  method: DIDMethod;
+  /** The identifier component (everything after did:{method}:) */
+  identifier: string;
+  /** The full DID string */
+  full: string;
+}
+/**
+ * Parse a full DID string into its components.
+ *
+ * @param did - Full DID string (e.g. 'did:abt:z1abc...')
+ * @returns Parsed DID object
+ * @throws If the input is not a valid DID string
+ */
+declare function parse(did: unknown): ParsedDID;
+/**
+ * Format an identifier and method into a full DID string.
+ *
+ * Handles idempotency: if the identifier already has a `did:{method}:` prefix
+ * matching the target method, returns it as-is.
+ *
+ * @param identifier - The identifier (address or name)
+ * @param method - The DID method (default: 'abt')
+ * @returns Full DID string
+ * @throws If the method is unknown or identifier is empty
+ */
+declare function formatDid(identifier: string, method?: DIDMethod): string;
+/**
+ * Extract the method from a DID string.
+ *
+ * @param did - A DID string or bare address
+ * @returns The method string, or null if no prefix found
+ */
+declare function extractMethod(did: unknown): DIDMethod | null;
+/**
+ * Extract the identifier from a DID string, stripping the `did:{method}:` prefix.
+ * If the input has no prefix, returns it as-is.
+ *
+ * @param did - A DID string or bare address
+ * @returns The identifier portion
+ */
+declare function extractIdentifier(did: unknown): string;
+//#endregion
+export { ParsedDID, extractIdentifier, extractMethod, formatDid, parse };

package/esm/parse.mjs

@@ -0,0 +1,88 @@
+import { DEFAULT_METHOD, isKnownMethod } from "./method.mjs";
+
+//#region src/parse.ts
+/**
+* Universal DID Parser
+*
+* Parses, formats, and extracts components from DID strings.
+* Supports all registered methods (abt, afs, aos, spaces, name).
+*/
+/** DID format regex: did:{method}:{identifier} where method is [a-z0-9]+ */
+const DID_REGEX = /^did:([a-z0-9]+):(.+)$/;
+/**
+* Parse a full DID string into its components.
+*
+* @param did - Full DID string (e.g. 'did:abt:z1abc...')
+* @returns Parsed DID object
+* @throws If the input is not a valid DID string
+*/
+function parse(did) {
+	if (typeof did !== "string") throw new Error("DID must be a string");
+	if (!did) throw new Error("DID string cannot be empty");
+	const match = did.match(DID_REGEX);
+	if (!match) throw new Error("Invalid DID format");
+	const [, method, identifier] = match;
+	if (!method) throw new Error("Invalid DID format");
+	if (!identifier) throw new Error("Invalid DID format");
+	if (!isKnownMethod(method)) throw new Error(`Unknown DID method: ${method}`);
+	return {
+		method,
+		identifier,
+		full: did
+	};
+}
+/**
+* Format an identifier and method into a full DID string.
+*
+* Handles idempotency: if the identifier already has a `did:{method}:` prefix
+* matching the target method, returns it as-is.
+*
+* @param identifier - The identifier (address or name)
+* @param method - The DID method (default: 'abt')
+* @returns Full DID string
+* @throws If the method is unknown or identifier is empty
+*/
+function formatDid(identifier, method = DEFAULT_METHOD) {
+	if (!identifier) throw new Error("Identifier cannot be empty");
+	if (!isKnownMethod(method)) throw new Error(`Unknown DID method: ${method}`);
+	const prefix = `did:${method}:`;
+	if (identifier.startsWith(prefix)) return identifier;
+	if (identifier.startsWith("did:")) {
+		const match = identifier.match(DID_REGEX);
+		if (match) {
+			if (match[1] === method) return identifier;
+			return `did:${method}:${match[2]}`;
+		}
+	}
+	return `did:${method}:${identifier}`;
+}
+/**
+* Extract the method from a DID string.
+*
+* @param did - A DID string or bare address
+* @returns The method string, or null if no prefix found
+*/
+function extractMethod(did) {
+	if (typeof did !== "string" || !did) return null;
+	const match = did.match(DID_REGEX);
+	if (!match) return null;
+	const method = match[1];
+	if (isKnownMethod(method)) return method;
+	return null;
+}
+/**
+* Extract the identifier from a DID string, stripping the `did:{method}:` prefix.
+* If the input has no prefix, returns it as-is.
+*
+* @param did - A DID string or bare address
+* @returns The identifier portion
+*/
+function extractIdentifier(did) {
+	if (typeof did !== "string" || !did) return "";
+	const match = did.match(/^did:[a-z0-9]+:(.+)$/);
+	if (match) return match[1];
+	return did;
+}
+
+//#endregion
+export { extractIdentifier, extractMethod, formatDid, parse };