@zenfs/core 0.17.1 → 0.18.0

package/src/emulation/sync.ts

@@ -2,14 +2,16 @@ import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
-import { isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
+import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
+import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { credentials } from '../credentials.js';
+import { emitChange } from './watchers.js';
 
 /**
  * Synchronous rename.
@@ -19,18 +21,23 @@ import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount
 export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 	oldPath = normalizePath(oldPath);
 	newPath = normalizePath(newPath);
-	const _old = resolveMount(oldPath);
-	const _new = resolveMount(newPath);
-	const paths = { [_old.path]: oldPath, [_new.path]: newPath };
+	const oldMount = resolveMount(oldPath);
+	const newMount = resolveMount(newPath);
+	if (!statSync(dirname(oldPath)).hasAccess(constants.W_OK, credentials)) {
+		throw ErrnoError.With('EACCES', oldPath, 'rename');
+	}
 	try {
-		if (_old === _new) {
-			return _old.fs.renameSync(_old.path, _new.path, cred);
+		if (oldMount === newMount) {
+			oldMount.fs.renameSync(oldMount.path, newMount.path);
+			emitChange('rename', oldPath.toString());
+			return;
 		}
 
 		writeFileSync(newPath, readFileSync(oldPath));
 		unlinkSync(oldPath);
+		emitChange('rename', oldPath.toString());
 	} catch (e) {
-		throw fixError(e as Error, paths);
+		throw fixError(e as Error, { [oldMount.path]: oldPath, [newMount.path]: newPath });
 	}
 }
 renameSync satisfies typeof fs.renameSync;
@@ -43,7 +50,7 @@ export function existsSync(path: fs.PathLike): boolean {
 	path = normalizePath(path);
 	try {
 		const { fs, path: resolvedPath } = resolveMount(realpathSync(path));
-		return fs.existsSync(resolvedPath, cred);
+		return fs.existsSync(resolvedPath);
 	} catch (e) {
 		if ((e as ErrnoError).errno == Errno.ENOENT) {
 			return false;
@@ -65,7 +72,10 @@ export function statSync(path: fs.PathLike, options?: fs.StatOptions): Stats | B
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	try {
-		const stats = fs.statSync(resolved, cred);
+		const stats = fs.statSync(resolved);
+		if (!stats.hasAccess(constants.R_OK, credentials)) {
+			throw ErrnoError.With('EACCES', path, 'stat');
+		}
 		return options?.bigint ? new BigIntStats(stats) : stats;
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
@@ -85,7 +95,7 @@ export function lstatSync(path: fs.PathLike, options?: fs.StatOptions): Stats |
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		const stats = fs.statSync(resolved, cred);
+		const stats = fs.statSync(resolved);
 		return options?.bigint ? new BigIntStats(stats) : stats;
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
@@ -116,7 +126,11 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		return fs.unlinkSync(resolved, cred);
+		if (!fs.statSync(resolved).hasAccess(constants.W_OK, credentials)) {
+			throw ErrnoError.With('EACCES', resolved, 'unlink');
+		}
+		fs.unlinkSync(resolved);
+		emitChange('rename', path.toString());
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
 	}
@@ -131,21 +145,24 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 	path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
 
-	if (!fs.existsSync(resolved, cred)) {
+	if (!fs.existsSync(resolved)) {
 		if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
 			throw ErrnoError.With('ENOENT', path, '_open');
 		}
 		// Create the file
-		const parentStats: Stats = fs.statSync(dirname(resolved), cred);
+		const parentStats: Stats = fs.statSync(dirname(resolved));
+		if (!parentStats.hasAccess(constants.W_OK, credentials)) {
+			throw ErrnoError.With('EACCES', dirname(path), '_open');
+		}
 		if (!parentStats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
 		}
-		return fs.createFileSync(resolved, flag, mode, cred);
+		return fs.createFileSync(resolved, flag, mode);
 	}
 
-	const stats: Stats = fs.statSync(resolved, cred);
+	const stats: Stats = fs.statSync(resolved);
 
-	if (!stats.hasAccess(mode, cred)) {
+	if (!stats.hasAccess(mode, credentials) || !stats.hasAccess(flagToMode(flag), credentials)) {
 		throw ErrnoError.With('EACCES', path, '_open');
 	}
 
@@ -153,19 +170,14 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 		throw ErrnoError.With('EEXIST', path, '_open');
 	}
 
-	if (!isTruncating(flag)) {
-		return fs.openFileSync(resolved, flag, cred);
+	const file = fs.openFileSync(resolved, flag);
+
+	if (isTruncating(flag)) {
+		file.truncateSync(0);
+		file.syncSync();
 	}
 
-	// Delete file.
-	fs.unlinkSync(resolved, cred);
-	/*
-		Create file. Use the same mode as the old file.
-		Node itself modifies the ctime when this occurs, so this action
-		will preserve that behavior if the underlying file system
-		supports those properties.
-	*/
-	return fs.createFileSync(resolved, flag, stats.mode, cred);
+	return file;
 }
 
 /**
@@ -176,7 +188,7 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
  * @param mode Mode to use to open the file. Can be ignored if the
  *   filesystem doesn't support permissions.
  */
-export function openSync(path: fs.PathLike, flag: fs.OpenMode, mode: fs.Mode | null = F_OK): number {
+export function openSync(path: fs.PathLike, flag: fs.OpenMode, mode: fs.Mode | null = constants.F_OK): number {
 	return file2fd(_openSync(path, flag, mode, true));
 }
 openSync satisfies typeof fs.openSync;
@@ -252,6 +264,7 @@ export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents,
 	}
 	using file = _openSync(typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true);
 	file.writeSync(encodedData, 0, encodedData.byteLength, 0);
+	emitChange('change', path.toString());
 }
 writeFileSync satisfies typeof fs.writeFileSync;
 
@@ -371,7 +384,9 @@ export function writeSync(fd: number, data: FileContents, posOrOff?: number | nu
 
 	const file = fd2file(fd);
 	position ??= file.position;
-	return file.writeSync(buffer, offset, length, position);
+	const bytesWritten = file.writeSync(buffer, offset, length, position);
+	emitChange('change', file.path);
+	return bytesWritten;
 }
 writeSync satisfies typeof fs.writeSync;
 
@@ -451,7 +466,11 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	try {
-		fs.rmdirSync(resolved, cred);
+		if (!fs.statSync(resolved).hasAccess(constants.W_OK, credentials)) {
+			throw ErrnoError.With('EACCES', resolved, 'rmdir');
+		}
+		fs.rmdirSync(resolved);
+		emitChange('rename', path.toString());
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
 	}
@@ -462,7 +481,6 @@ rmdirSync satisfies typeof fs.rmdirSync;
  * Synchronous `mkdir`.
  * @param path
  * @param mode defaults to o777
- * @todo Implement recursion
  */
 export function mkdirSync(path: fs.PathLike, options: fs.MakeDirectoryOptions & { recursive: true }): string | undefined;
 export function mkdirSync(path: fs.PathLike, options?: fs.Mode | (fs.MakeDirectoryOptions & { recursive?: false }) | null): void;
@@ -478,16 +496,23 @@ export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirector
 
 	try {
 		if (!options?.recursive) {
-			return fs.mkdirSync(resolved, mode, cred);
+			if (!fs.statSync(dirname(resolved)).hasAccess(constants.W_OK, credentials)) {
+				throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
+			}
+			return fs.mkdirSync(resolved, mode);
 		}
 
 		const dirs: string[] = [];
-		for (let dir = resolved, original = path; !fs.existsSync(dir, cred); dir = dirname(dir), original = dirname(original)) {
+		for (let dir = resolved, original = path; !fs.existsSync(dir); dir = dirname(dir), original = dirname(original)) {
 			dirs.unshift(dir);
 			errorPaths[dir] = original;
 		}
 		for (const dir of dirs) {
-			fs.mkdirSync(dir, mode, cred);
+			if (!fs.statSync(dirname(dir)).hasAccess(constants.W_OK, credentials)) {
+				throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
+			}
+			fs.mkdirSync(dir, mode);
+			emitChange('rename', dir);
 		}
 		return dirs[0];
 	} catch (e) {
@@ -511,8 +536,11 @@ export function readdirSync(
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	let entries: string[];
+	if (!statSync(path).hasAccess(constants.R_OK, credentials)) {
+		throw ErrnoError.With('EACCES', path, 'readdir');
+	}
 	try {
-		entries = fs.readdirSync(resolved, cred);
+		entries = fs.readdirSync(resolved);
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
 	}
@@ -545,17 +573,31 @@ readdirSync satisfies typeof fs.readdirSync;
 
 /**
  * Synchronous `link`.
- * @param existing
- * @param newpath
+ * @param targetPath
+ * @param linkPath
  */
-export function linkSync(existing: fs.PathLike, newpath: fs.PathLike): void {
-	existing = normalizePath(existing);
-	newpath = normalizePath(newpath);
-	const { fs, path: resolved } = resolveMount(existing);
+export function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void {
+	targetPath = normalizePath(targetPath);
+	if (!statSync(dirname(targetPath)).hasAccess(constants.R_OK, credentials)) {
+		throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
+	}
+	linkPath = normalizePath(linkPath);
+	if (!statSync(dirname(linkPath)).hasAccess(constants.W_OK, credentials)) {
+		throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
+	}
+
+	const { fs, path } = resolveMount(targetPath);
+	const link = resolveMount(linkPath);
+	if (fs != link.fs) {
+		throw ErrnoError.With('EXDEV', linkPath, 'link');
+	}
 	try {
-		return fs.linkSync(resolved, newpath, cred);
+		if (!fs.statSync(path).hasAccess(constants.W_OK, credentials)) {
+			throw ErrnoError.With('EACCES', path, 'link');
+		}
+		return fs.linkSync(path, linkPath);
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: existing });
+		throw fixError(e as Error, { [path]: targetPath, [link.path]: linkPath });
 	}
 }
 linkSync satisfies typeof fs.linkSync;
@@ -576,7 +618,7 @@ export function symlinkSync(target: fs.PathLike, path: fs.PathLike, type: fs.sym
 
 	writeFileSync(path, target.toString());
 	const file = _openSync(path, 'r+', 0o644, false);
-	file._setTypeSync(S_IFLNK);
+	file._setTypeSync(constants.S_IFLNK);
 }
 symlinkSync satisfies typeof fs.symlinkSync;
 
@@ -692,7 +734,7 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs
 	const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
 
 	try {
-		const stats = fs.statSync(resolvedPath, cred);
+		const stats = fs.statSync(resolvedPath);
 		if (!stats.isSymbolicLink()) {
 			return lpath;
 		}
@@ -711,7 +753,7 @@ realpathSync satisfies Omit<typeof fs.realpathSync, 'native'>;
  */
 export function accessSync(path: fs.PathLike, mode: number = 0o600): void {
 	const stats = statSync(path);
-	if (!stats.hasAccess(mode, cred)) {
+	if (!stats.hasAccess(mode, credentials)) {
 		throw new ErrnoError(Errno.EACCES);
 	}
 }
@@ -726,8 +768,8 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions): void {
 
 	const stats = statSync(path);
 
-	switch (stats.mode & S_IFMT) {
-		case S_IFDIR:
+	switch (stats.mode & constants.S_IFMT) {
+		case constants.S_IFDIR:
 			if (options?.recursive) {
 				for (const entry of readdirSync(path)) {
 					rmSync(join(path, entry), options);
@@ -736,14 +778,14 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions): void {
 
 			rmdirSync(path);
 			return;
-		case S_IFREG:
-		case S_IFLNK:
+		case constants.S_IFREG:
+		case constants.S_IFLNK:
 			unlinkSync(path);
 			return;
-		case S_IFBLK:
-		case S_IFCHR:
-		case S_IFIFO:
-		case S_IFSOCK:
+		case constants.S_IFBLK:
+		case constants.S_IFCHR:
+		case constants.S_IFIFO:
+		case constants.S_IFSOCK:
 		default:
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
@@ -780,11 +822,12 @@ export function copyFileSync(src: fs.PathLike, dest: fs.PathLike, flags?: number
 	src = normalizePath(src);
 	dest = normalizePath(dest);
 
-	if (flags && flags & COPYFILE_EXCL && existsSync(dest)) {
+	if (flags && flags & constants.COPYFILE_EXCL && existsSync(dest)) {
 		throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
 	}
 
 	writeFileSync(dest, readFileSync(src));
+	emitChange('rename', dest.toString());
 }
 copyFileSync satisfies typeof fs.copyFileSync;
 
@@ -834,7 +877,7 @@ writevSync satisfies typeof fs.writevSync;
  */
 export function opendirSync(path: fs.PathLike, options?: fs.OpenDirOptions): Dir {
 	path = normalizePath(path);
-	return new Dir(path); // Re-use existing `Dir` class
+	return new Dir(path);
 }
 opendirSync satisfies typeof fs.opendirSync;
 
@@ -860,8 +903,8 @@ export function cpSync(source: fs.PathLike, destination: fs.PathLike, opts?: fs.
 		throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
 	}
 
-	switch (srcStats.mode & S_IFMT) {
-		case S_IFDIR:
+	switch (srcStats.mode & constants.S_IFMT) {
+		case constants.S_IFDIR:
 			if (!opts?.recursive) {
 				throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
 			}
@@ -873,14 +916,14 @@ export function cpSync(source: fs.PathLike, destination: fs.PathLike, opts?: fs.
 				cpSync(join(source, dirent.name), join(destination, dirent.name), opts);
 			}
 			break;
-		case S_IFREG:
-		case S_IFLNK:
+		case constants.S_IFREG:
+		case constants.S_IFLNK:
 			copyFileSync(source, destination);
 			break;
-		case S_IFBLK:
-		case S_IFCHR:
-		case S_IFIFO:
-		case S_IFSOCK:
+		case constants.S_IFBLK:
+		case constants.S_IFCHR:
+		case constants.S_IFIFO:
+		case constants.S_IFSOCK:
 		default:
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', source, 'rm');
 	}

package/src/emulation/watchers.ts

@@ -2,7 +2,17 @@ import { EventEmitter } from 'eventemitter3';
 import type { EventEmitter as NodeEventEmitter } from 'node:events';
 import type * as fs from 'node:fs';
 import { ErrnoError } from '../error.js';
+import { isStatsEqual, type Stats } from '../stats.js';
+import { normalizePath } from '../utils.js';
+import { dirname, basename } from './path.js';
+import { statSync } from './sync.js';
 
+/**
+ * Base class for file system watchers.
+ * Provides event handling capabilities for watching file system changes.
+ *
+ * @template TEvents The type of events emitted by the watcher.
+ */
 class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown[]>> extends EventEmitter<TEvents> implements NodeEventEmitter {
 	/* eslint-disable @typescript-eslint/no-explicit-any */
 	public off<T extends EventEmitter.EventNames<TEvents>>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this {
@@ -14,24 +24,28 @@ class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown
 	}
 	/* eslint-enable @typescript-eslint/no-explicit-any */
 
+	public constructor(public readonly path: string) {
+		super();
+	}
+
 	public setMaxListeners(): never {
-		throw ErrnoError.With('ENOTSUP');
+		throw ErrnoError.With('ENOSYS', this.path, 'Watcher.setMaxListeners');
 	}
 
 	public getMaxListeners(): never {
-		throw ErrnoError.With('ENOTSUP');
+		throw ErrnoError.With('ENOSYS', this.path, 'Watcher.getMaxListeners');
 	}
 
 	public prependListener(): never {
-		throw ErrnoError.With('ENOTSUP');
+		throw ErrnoError.With('ENOSYS', this.path, 'Watcher.prependListener');
 	}
 
 	public prependOnceListener(): never {
-		throw ErrnoError.With('ENOTSUP');
+		throw ErrnoError.With('ENOSYS', this.path, 'Watcher.prependOnceListener');
 	}
 
 	public rawListeners(): never {
-		throw ErrnoError.With('ENOTSUP');
+		throw ErrnoError.With('ENOSYS', this.path, 'Watcher.rawListeners');
 	}
 
 	public ref(): this {
@@ -44,7 +58,9 @@ class Watcher<TEvents extends Record<string, unknown[]> = Record<string, unknown
 }
 
 /**
- * @todo Actually emit events
+ * Watches for changes on the file system.
+ *
+ * @template T The type of the filename, either `string` or `Buffer`.
  */
 export class FSWatcher<T extends string | Buffer = string | Buffer>
 	extends Watcher<{
@@ -54,10 +70,124 @@ export class FSWatcher<T extends string | Buffer = string | Buffer>
 	}>
 	implements fs.FSWatcher
 {
-	public constructor(public readonly options: fs.WatchOptions) {
-		super();
+	public constructor(
+		path: string,
+		public readonly options: fs.WatchOptions
+	) {
+		super(path);
+		addWatcher(path.toString(), this);
+	}
+
+	public close(): void {
+		super.emit('close');
+		removeWatcher(this.path.toString(), this);
+	}
+
+	public [Symbol.dispose](): void {
+		this.close();
+	}
+}
+
+/**
+ * Watches for changes to a file's stats.
+ *
+ * Instances of `StatWatcher` are used by `fs.watchFile()` to monitor changes to a file's statistics.
+ */
+export class StatWatcher
+	extends Watcher<{
+		change: [current: Stats, previous: Stats];
+		close: [];
+		error: [error: Error];
+	}>
+	implements fs.StatWatcher
+{
+	private intervalId?: NodeJS.Timeout | number;
+	private previous?: Stats;
+
+	public constructor(
+		path: string,
+		private options: { persistent?: boolean; interval?: number }
+	) {
+		super(path);
+		this.start();
+	}
+
+	protected onInterval() {
+		try {
+			const current = statSync(this.path);
+			if (!isStatsEqual(this.previous!, current)) {
+				this.emit('change', current, this.previous!);
+				this.previous = current;
+			}
+		} catch (e) {
+			this.emit('error', e as Error);
+		}
+	}
+
+	protected start() {
+		const interval = this.options.interval || 5000;
+		try {
+			this.previous = statSync(this.path);
+		} catch (e) {
+			this.emit('error', e as Error);
+			return;
+		}
+		this.intervalId = setInterval(this.onInterval.bind(this), interval);
+		if (!this.options.persistent && typeof this.intervalId == 'object') {
+			this.intervalId.unref();
+		}
+	}
+
+	/**
+	 * @internal
+	 */
+	public stop() {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+		this.removeAllListeners();
 	}
-	public close(): void {}
 }
 
-export class StatWatcher extends Watcher implements fs.StatWatcher {}
+const watchers: Map<string, Set<FSWatcher>> = new Map();
+
+export function addWatcher(path: string, watcher: FSWatcher) {
+	const normalizedPath = normalizePath(path);
+	if (!watchers.has(normalizedPath)) {
+		watchers.set(normalizedPath, new Set());
+	}
+	watchers.get(normalizedPath)!.add(watcher);
+}
+
+export function removeWatcher(path: string, watcher: FSWatcher) {
+	const normalizedPath = normalizePath(path);
+	if (watchers.has(normalizedPath)) {
+		watchers.get(normalizedPath)!.delete(watcher);
+		if (watchers.get(normalizedPath)!.size === 0) {
+			watchers.delete(normalizedPath);
+		}
+	}
+}
+
+export function emitChange(eventType: fs.WatchEventType, filename: string) {
+	let normalizedFilename: string = normalizePath(filename);
+	// Notify watchers on the specific file
+	if (watchers.has(normalizedFilename)) {
+		for (const watcher of watchers.get(normalizedFilename)!) {
+			watcher.emit('change', eventType, basename(filename));
+		}
+	}
+
+	// Notify watchers on parent directories if they are watching recursively
+	let parent = dirname(normalizedFilename);
+	while (parent !== normalizedFilename && parent !== '/') {
+		if (watchers.has(parent)) {
+			for (const watcher of watchers.get(parent)!) {
+				watcher.emit('change', eventType, basename(filename));
+			}
+		}
+		normalizedFilename = parent;
+		parent = dirname(parent);
+	}
+}

package/src/error.ts

@@ -284,7 +284,7 @@ export class ErrnoError extends Error implements NodeJS.ErrnoException {
 	}
 
 	/**
-	 * @return A friendly error message.
+	 * @returns A friendly error message.
 	 */
 	public toString(): string {
 		return this.message;