@ecopages/core 0.2.0-beta.30 → 0.2.0-beta.32

package/src/adapters/shared/runtime/application-adapter.js

@@ -1,90 +1,75 @@
-import {
-  AbstractApplicationAdapter
-} from "../../abstract/application-adapter.js";
-class SharedApplicationAdapter extends AbstractApplicationAdapter {
-  register(path, method, handler, options) {
-    return this.addRouteHandler(path, method, handler, options?.middleware, options?.schema);
-  }
-  get(path, handler, options) {
-    return this.register(path, "GET", handler, options);
-  }
-  post(path, handler, options) {
-    return this.register(path, "POST", handler, options);
-  }
-  put(path, handler, options) {
-    return this.register(path, "PUT", handler, options);
-  }
-  delete(path, handler, options) {
-    return this.register(path, "DELETE", handler, options);
-  }
-  patch(path, handler, options) {
-    return this.register(path, "PATCH", handler, options);
-  }
-  options(path, handler, options) {
-    return this.register(path, "OPTIONS", handler, options);
-  }
-  head(path, handler, options) {
-    return this.register(path, "HEAD", handler, options);
-  }
-  route(path, method, handler, options) {
-    return this.register(path, method, handler, options);
-  }
-  add(handler) {
-    return this.addRouteHandler(handler.path, handler.method, handler.handler, handler.middleware, handler.schema);
-  }
-  group(prefixOrGroup, callback, options) {
-    if (typeof prefixOrGroup === "object") {
-      return this.registerGroup(prefixOrGroup);
+import { AbstractApplicationAdapter, } from '../../abstract/application-adapter.js';
+export class SharedApplicationAdapter extends AbstractApplicationAdapter {
+    register(path, method, handler, options) {
+        return this.addRouteHandler(path, method, handler, options?.middleware, options?.schema);
     }
-    const normalizedPrefix = prefixOrGroup.endsWith("/") ? prefixOrGroup.slice(0, -1) : prefixOrGroup;
-    const groupMiddleware = options?.middleware ?? [];
-    const createHandler = (method) => {
-      return ((path, handler, routeOptions) => {
-        const combinedMiddleware = [
-          ...groupMiddleware,
-          ...routeOptions?.middleware ?? []
-        ];
-        const fullPath = path === "/" ? normalizedPrefix : `${normalizedPrefix}${path}`;
-        this.addRouteHandler(
-          fullPath,
-          method,
-          handler,
-          combinedMiddleware.length > 0 ? combinedMiddleware : void 0,
-          routeOptions?.schema
-        );
-        return builder;
-      });
-    };
-    const builder = {
-      get: createHandler("GET"),
-      post: createHandler("POST"),
-      put: createHandler("PUT"),
-      delete: createHandler("DELETE"),
-      patch: createHandler("PATCH"),
-      options: createHandler("OPTIONS"),
-      head: createHandler("HEAD")
-    };
-    callback?.(builder);
-    return this;
-  }
-  registerGroup(group) {
-    const normalizedPrefix = group.prefix.endsWith("/") ? group.prefix.slice(0, -1) : group.prefix;
-    const groupMiddleware = group.middleware ?? [];
-    for (const route of group.routes) {
-      const normalizedPath = route.path.startsWith("/") ? route.path : `/${route.path}`;
-      const fullPath = route.path === "/" ? normalizedPrefix : `${normalizedPrefix}${normalizedPath}`;
-      const combinedMiddleware = [...groupMiddleware, ...route.middleware ?? []];
-      this.addRouteHandler(
-        fullPath,
-        route.method,
-        route.handler,
-        combinedMiddleware.length > 0 ? combinedMiddleware : void 0,
-        route.schema
-      );
+    get(path, handler, options) {
+        return this.register(path, 'GET', handler, options);
+    }
+    post(path, handler, options) {
+        return this.register(path, 'POST', handler, options);
+    }
+    put(path, handler, options) {
+        return this.register(path, 'PUT', handler, options);
+    }
+    delete(path, handler, options) {
+        return this.register(path, 'DELETE', handler, options);
+    }
+    patch(path, handler, options) {
+        return this.register(path, 'PATCH', handler, options);
+    }
+    options(path, handler, options) {
+        return this.register(path, 'OPTIONS', handler, options);
+    }
+    head(path, handler, options) {
+        return this.register(path, 'HEAD', handler, options);
+    }
+    route(path, method, handler, options) {
+        return this.register(path, method, handler, options);
+    }
+    add(handler) {
+        return this.addRouteHandler(handler.path, handler.method, handler.handler, handler.middleware, handler.schema);
+    }
+    group(prefixOrGroup, callback, options) {
+        if (typeof prefixOrGroup === 'object') {
+            return this.registerGroup(prefixOrGroup);
+        }
+        const normalizedPrefix = prefixOrGroup.endsWith('/') ? prefixOrGroup.slice(0, -1) : prefixOrGroup;
+        const groupMiddleware = (options?.middleware ?? []);
+        const createHandler = (method) => {
+            return ((path, handler, routeOptions) => {
+                const combinedMiddleware = [
+                    ...groupMiddleware,
+                    ...(routeOptions?.middleware ?? []),
+                ];
+                const fullPath = path === '/' ? normalizedPrefix : `${normalizedPrefix}${path}`;
+                this.addRouteHandler(fullPath, method, handler, combinedMiddleware.length > 0
+                    ? combinedMiddleware
+                    : undefined, routeOptions?.schema);
+                return builder;
+            });
+        };
+        const builder = {
+            get: createHandler('GET'),
+            post: createHandler('POST'),
+            put: createHandler('PUT'),
+            delete: createHandler('DELETE'),
+            patch: createHandler('PATCH'),
+            options: createHandler('OPTIONS'),
+            head: createHandler('HEAD'),
+        };
+        callback?.(builder);
+        return this;
+    }
+    registerGroup(group) {
+        const normalizedPrefix = group.prefix.endsWith('/') ? group.prefix.slice(0, -1) : group.prefix;
+        const groupMiddleware = group.middleware ?? [];
+        for (const route of group.routes) {
+            const normalizedPath = route.path.startsWith('/') ? route.path : `/${route.path}`;
+            const fullPath = route.path === '/' ? normalizedPrefix : `${normalizedPrefix}${normalizedPath}`;
+            const combinedMiddleware = [...groupMiddleware, ...(route.middleware ?? [])];
+            this.addRouteHandler(fullPath, route.method, route.handler, combinedMiddleware.length > 0 ? combinedMiddleware : undefined, route.schema);
+        }
+        return this;
     }
-    return this;
-  }
 }
-export {
-  SharedApplicationAdapter
-};

package/src/adapters/shared/runtime/copy-runtime-public-dir.js

@@ -1,24 +1,27 @@
-import { readdirSync } from "node:fs";
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-function copyRuntimePublicDirIfChanged(sourceDir, destinationDir) {
-  fileSystem.ensureDir(destinationDir);
-  for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
-    const sourcePath = path.join(sourceDir, entry.name);
-    const destinationPath = path.join(destinationDir, entry.name);
-    if (entry.isDirectory()) {
-      copyRuntimePublicDirIfChanged(sourcePath, destinationPath);
-      continue;
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+/**
+ * Copies a source public directory into the runtime dist dir, skipping unchanged files.
+ *
+ * Dev restarts call this on every boot; byte comparison avoids rewriting identical assets.
+ */
+export function copyRuntimePublicDirIfChanged(sourceDir, destinationDir) {
+    fileSystem.ensureDir(destinationDir);
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const destinationPath = path.join(destinationDir, entry.name);
+        if (entry.isDirectory()) {
+            copyRuntimePublicDirIfChanged(sourcePath, destinationPath);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        if (fileSystem.exists(destinationPath) &&
+            Buffer.compare(fileSystem.readFileAsBuffer(sourcePath), fileSystem.readFileAsBuffer(destinationPath)) === 0) {
+            continue;
+        }
+        fileSystem.copyFile(sourcePath, destinationPath);
     }
-    if (!entry.isFile()) {
-      continue;
-    }
-    if (fileSystem.exists(destinationPath) && Buffer.compare(fileSystem.readFileAsBuffer(sourcePath), fileSystem.readFileAsBuffer(destinationPath)) === 0) {
-      continue;
-    }
-    fileSystem.copyFile(sourcePath, destinationPath);
-  }
 }
-export {
-  copyRuntimePublicDirIfChanged
-};

package/src/adapters/shared/runtime/port-manager.js

@@ -1,196 +1,226 @@
-import { createServer as createNetServer } from "node:net";
-import { createInterface } from "node:readline";
-function isPortInUseError(error) {
-  if (!(error instanceof Error) && (typeof error !== "object" || error === null)) {
+import { createServer as createNetServer } from 'node:net';
+import { createInterface } from 'node:readline';
+/**
+ * Detects whether a thrown error indicates the requested port is already in
+ * use.
+ *
+ * @remarks
+ * Matches Node's `code: 'EADDRINUSE'` and Bun's surface, where the error
+ * carries the same `code` plus a human-readable message such as
+ * `"Failed to start server. Is port 3000 in use?"`. Older Bun builds that do
+ * not set `.code` are covered by a fallback match on `syscall === 'listen'`
+ * plus the message shape.
+ */
+export function isPortInUseError(error) {
+    if (!(error instanceof Error) && (typeof error !== 'object' || error === null)) {
+        return false;
+    }
+    const maybeErr = error;
+    const code = typeof maybeErr.code === 'string' || typeof maybeErr.code === 'number' ? String(maybeErr.code) : undefined;
+    const syscall = typeof maybeErr.syscall === 'string' ? maybeErr.syscall : undefined;
+    const message = error instanceof Error ? error.message : String(maybeErr.message ?? '');
+    if (code === 'EADDRINUSE') {
+        return true;
+    }
+    if (message.includes('EADDRINUSE')) {
+        return true;
+    }
+    if (syscall === 'listen' && /is port \d+ in use\??/i.test(message)) {
+        return true;
+    }
     return false;
-  }
-  const maybeErr = error;
-  const code = typeof maybeErr.code === "string" || typeof maybeErr.code === "number" ? String(maybeErr.code) : void 0;
-  const syscall = typeof maybeErr.syscall === "string" ? maybeErr.syscall : void 0;
-  const message = error instanceof Error ? error.message : String(maybeErr.message ?? "");
-  if (code === "EADDRINUSE") {
-    return true;
-  }
-  if (message.includes("EADDRINUSE")) {
-    return true;
-  }
-  if (syscall === "listen" && /is port \d+ in use\??/i.test(message)) {
-    return true;
-  }
-  return false;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function isPortAvailable(port, hostname = "127.0.0.1") {
-  return new Promise((resolve) => {
-    const tester = createNetServer();
-    tester.once("error", () => resolve(false));
-    tester.once("listening", () => {
-      tester.close(() => resolve(true));
+/**
+ * Probes whether a TCP port is currently bindable from this process. Uses a
+ * short-lived Node `net.Server` so both Node and Bun can run it via their
+ * Node-compatible core.
+ *
+ * @remarks
+ * A successful probe only guarantees the port was free at probe time; callers
+ * must still handle EADDRINUSE when they actually bind, since release races
+ * can flip the answer between probe and bind.
+ */
+export function isPortAvailable(port, hostname = '127.0.0.1') {
+    return new Promise((resolve) => {
+        const tester = createNetServer();
+        tester.once('error', () => resolve(false));
+        tester.once('listening', () => {
+            tester.close(() => resolve(true));
+        });
+        tester.listen(port, hostname);
     });
-    tester.listen(port, hostname);
-  });
 }
 function createDefaultPrompt(stdin, stdout) {
-  return async (message, timeoutMs) => {
-    stdout.write(`${message} `);
-    return await new Promise((resolve) => {
-      const rl = createInterface({ input: stdin, output: void 0, terminal: false });
-      let settled = false;
-      const finish = (value) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(timer);
-        rl.close();
-        stdout.write("\n");
-        resolve(value);
-      };
-      const timer = setTimeout(() => finish(true), timeoutMs);
-      rl.once("line", (line) => {
-        const answer = line.trim().toLowerCase();
-        if (answer === "" || answer === "y" || answer === "yes") {
-          finish(true);
-        } else {
-          finish(false);
-        }
-      });
-      rl.once("close", () => finish(true));
-    });
-  };
+    return async (message, timeoutMs) => {
+        stdout.write(`${message} `);
+        return await new Promise((resolve) => {
+            const rl = createInterface({ input: stdin, output: undefined, terminal: false });
+            let settled = false;
+            const finish = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                rl.close();
+                stdout.write('\n');
+                resolve(value);
+            };
+            const timer = setTimeout(() => finish(true), timeoutMs);
+            rl.once('line', (line) => {
+                const answer = line.trim().toLowerCase();
+                if (answer === '' || answer === 'y' || answer === 'yes') {
+                    finish(true);
+                }
+                else {
+                    finish(false);
+                }
+            });
+            rl.once('close', () => finish(true));
+        });
+    };
 }
 const PREVIEW_PORT_RELEASE_RACE_RETRIES = 2;
 const PREVIEW_PORT_FALLBACK_ATTEMPTS = 20;
 const PREVIEW_PORT_RELEASE_RACE_DELAY_MS = 100;
-const PREVIEW_PORT_AUTO_APPROVE_MS = 1e4;
-class PortManager {
-  startOnPort;
-  warn;
-  probePort;
-  prompt;
-  interactive;
-  autoApproveMs;
-  maxPortOffset;
-  releaseRaceRetries;
-  releaseRaceDelayMs;
-  constructor(options) {
-    this.startOnPort = options.startOnPort;
-    this.warn = options.warn;
-    this.probePort = options.probePort ?? isPortAvailable;
-    this.maxPortOffset = options.maxPortOffset ?? PREVIEW_PORT_FALLBACK_ATTEMPTS - 1;
-    this.releaseRaceRetries = options.releaseRaceRetries ?? PREVIEW_PORT_RELEASE_RACE_RETRIES;
-    this.releaseRaceDelayMs = options.releaseRaceDelayMs ?? PREVIEW_PORT_RELEASE_RACE_DELAY_MS;
-    this.autoApproveMs = options.autoApproveMs ?? PREVIEW_PORT_AUTO_APPROVE_MS;
-    this.interactive = typeof options.interactive === "boolean" ? options.interactive : Boolean(typeof process !== "undefined" && process.stdin?.isTTY && process.stdout?.isTTY);
-    if (options.prompt) {
-      this.prompt = options.prompt;
-    } else if (this.interactive) {
-      this.prompt = createDefaultPrompt(process.stdin, process.stdout);
-    } else {
-      this.prompt = void 0;
-    }
-  }
-  /**
-   * Binds the preview server to the preferred port.
-   *
-   * @remarks
-   * When the preferred port is free, binds it directly — no prompt, no
-   * fallback. The interactive prompt only fires on a genuine EADDRINUSE
-   * collision (TTY runs), and auto-approves after
-   * {@link PortManagerOptions.autoApproveMs}. In non-interactive (CI) runs,
-   * the manager falls back silently only when
-   * {@link BindPortOptions.allowPortFallback} is true (the default-port
-   * path); pinned ports rethrow EADDRINUSE so Docker-style fixed-port
-   * deployments fail loudly instead of silently moving.
-   */
-  async bind(options) {
-    const preferredPort = options.preferredPort;
-    const firstAttempt = await this.tryPort(preferredPort);
-    if (firstAttempt.status === "bound") {
-      return firstAttempt.boundPort;
-    }
-    if (firstAttempt.status === "factory-refused") {
-      return null;
-    }
-    await this.shouldFallback(preferredPort, options.allowPortFallback, firstAttempt.error);
-    return await this.fallForward(preferredPort);
-  }
-  async shouldFallback(preferredPort, allowPortFallback, error) {
-    if (this.interactive && this.prompt) {
-      const nextFree = await this.findNextFreePort(preferredPort);
-      const nextFreeSuffix = typeof nextFree === "number" ? ` (next free: ${nextFree})` : "";
-      const autoApproveHint = `auto-yes in ${Math.round(this.autoApproveMs / 1e3)}s`;
-      const message = `[@ecopages/core] Port ${preferredPort} is already in use${nextFreeSuffix}. Bind there instead? [Y/n] (${autoApproveHint})`;
-      const accepted = await this.prompt(message, this.autoApproveMs);
-      if (!accepted) {
-        throw error;
-      }
-      return;
-    }
-    if (!allowPortFallback) {
-      throw error;
+const PREVIEW_PORT_AUTO_APPROVE_MS = 10_000;
+/**
+ * Owns preview-port assignment: probing, race-release retries, fallback, and
+ * an optional interactive auto-approve prompt.
+ *
+ * @remarks
+ * Single-process API. The manager does not cache ports across calls; each
+ * `bind()` runs fresh from the preferred port.
+ */
+export class PortManager {
+    startOnPort;
+    warn;
+    probePort;
+    prompt;
+    interactive;
+    autoApproveMs;
+    maxPortOffset;
+    releaseRaceRetries;
+    releaseRaceDelayMs;
+    constructor(options) {
+        this.startOnPort = options.startOnPort;
+        this.warn = options.warn;
+        this.probePort = options.probePort ?? isPortAvailable;
+        this.maxPortOffset = options.maxPortOffset ?? PREVIEW_PORT_FALLBACK_ATTEMPTS - 1;
+        this.releaseRaceRetries = options.releaseRaceRetries ?? PREVIEW_PORT_RELEASE_RACE_RETRIES;
+        this.releaseRaceDelayMs = options.releaseRaceDelayMs ?? PREVIEW_PORT_RELEASE_RACE_DELAY_MS;
+        this.autoApproveMs = options.autoApproveMs ?? PREVIEW_PORT_AUTO_APPROVE_MS;
+        this.interactive =
+            typeof options.interactive === 'boolean'
+                ? options.interactive
+                : Boolean(typeof process !== 'undefined' && process.stdin?.isTTY && process.stdout?.isTTY);
+        if (options.prompt) {
+            this.prompt = options.prompt;
+        }
+        else if (this.interactive) {
+            this.prompt = createDefaultPrompt(process.stdin, process.stdout);
+        }
+        else {
+            this.prompt = undefined;
+        }
     }
-  }
-  async fallForward(preferredPort) {
-    for (let offset = 1; offset <= this.maxPortOffset; offset += 1) {
-      const candidatePort = preferredPort + offset;
-      const attempt = await this.tryPort(candidatePort);
-      if (attempt.status === "bound") {
-        this.warn?.(
-          `Port ${preferredPort} is in use; preview serving on port ${attempt.boundPort} instead. Pin the preview port with --port or ECOPAGES_PORT when a fixed binding is required.`
-        );
-        return attempt.boundPort;
-      }
+    /**
+     * Binds the preview server to the preferred port.
+     *
+     * @remarks
+     * When the preferred port is free, binds it directly — no prompt, no
+     * fallback. The interactive prompt only fires on a genuine EADDRINUSE
+     * collision (TTY runs), and auto-approves after
+     * {@link PortManagerOptions.autoApproveMs}. In non-interactive (CI) runs,
+     * the manager falls back silently only when
+     * {@link BindPortOptions.allowPortFallback} is true (the default-port
+     * path); pinned ports rethrow EADDRINUSE so Docker-style fixed-port
+     * deployments fail loudly instead of silently moving.
+     */
+    async bind(options) {
+        const preferredPort = options.preferredPort;
+        const firstAttempt = await this.tryPort(preferredPort);
+        if (firstAttempt.status === 'bound') {
+            return firstAttempt.boundPort;
+        }
+        if (firstAttempt.status === 'factory-refused') {
+            return null;
+        }
+        // firstAttempt.status === 'port-in-use'
+        await this.shouldFallback(preferredPort, options.allowPortFallback, firstAttempt.error);
+        return await this.fallForward(preferredPort);
     }
-    return null;
-  }
-  /**
-   * Attempts to bind via {@link PortManagerOptions.startOnPort} on `port`,
-   * retrying EADDRINUSE collisions up to
-   * {@link PortManagerOptions.releaseRaceRetries} to ride through TIME_WAIT
-   * race release.
-   *
-   * @remarks
-   * Only EADDRINUSE is retryable. Any other error is rethrown synchronously
-   * rather than swallowed as a soft "port taken" result, so a misconfigured
-   * factory surfaces loudly instead of causing a silent fallback. A `null`
-   * return from the factory (no throw) is reported as `factory-refused`, not
-   * conflated with a real collision.
-   */
-  async tryPort(port) {
-    for (let attempt = 0; attempt < this.releaseRaceRetries; attempt += 1) {
-      try {
-        const bound = await this.startOnPort(port);
-        if (bound) {
-          return { status: "bound", boundPort: bound };
+    async shouldFallback(preferredPort, allowPortFallback, error) {
+        if (this.interactive && this.prompt) {
+            const nextFree = await this.findNextFreePort(preferredPort);
+            const nextFreeSuffix = typeof nextFree === 'number' ? ` (next free: ${nextFree})` : '';
+            const autoApproveHint = `auto-yes in ${Math.round(this.autoApproveMs / 1000)}s`;
+            const message = `[@ecopages/core] Port ${preferredPort} is already in use${nextFreeSuffix}. Bind there instead? [Y/n] (${autoApproveHint})`;
+            const accepted = await this.prompt(message, this.autoApproveMs);
+            if (!accepted) {
+                throw error;
+            }
+            return;
         }
-        return { status: "factory-refused" };
-      } catch (error) {
-        if (!isPortInUseError(error)) {
-          throw error;
+        if (!allowPortFallback) {
+            throw error;
         }
-        if (attempt === this.releaseRaceRetries - 1) {
-          return { status: "port-in-use", error };
+    }
+    async fallForward(preferredPort) {
+        for (let offset = 1; offset <= this.maxPortOffset; offset += 1) {
+            const candidatePort = preferredPort + offset;
+            const attempt = await this.tryPort(candidatePort);
+            if (attempt.status === 'bound') {
+                this.warn?.(`Port ${preferredPort} is in use; preview serving on port ${attempt.boundPort} instead. Pin the preview port with --port or ECOPAGES_PORT when a fixed binding is required.`);
+                return attempt.boundPort;
+            }
         }
-        await sleep(this.releaseRaceDelayMs);
-      }
+        return null;
     }
-    return { status: "factory-refused" };
-  }
-  async findNextFreePort(startPort) {
-    for (let offset = 1; offset <= this.maxPortOffset; offset += 1) {
-      const candidate = startPort + offset;
-      if (await this.probePort(candidate)) {
-        return candidate;
-      }
+    /**
+     * Attempts to bind via {@link PortManagerOptions.startOnPort} on `port`,
+     * retrying EADDRINUSE collisions up to
+     * {@link PortManagerOptions.releaseRaceRetries} to ride through TIME_WAIT
+     * race release.
+     *
+     * @remarks
+     * Only EADDRINUSE is retryable. Any other error is rethrown synchronously
+     * rather than swallowed as a soft "port taken" result, so a misconfigured
+     * factory surfaces loudly instead of causing a silent fallback. A `null`
+     * return from the factory (no throw) is reported as `factory-refused`, not
+     * conflated with a real collision.
+     */
+    async tryPort(port) {
+        for (let attempt = 0; attempt < this.releaseRaceRetries; attempt += 1) {
+            try {
+                const bound = await this.startOnPort(port);
+                if (bound) {
+                    return { status: 'bound', boundPort: bound };
+                }
+                return { status: 'factory-refused' };
+            }
+            catch (error) {
+                if (!isPortInUseError(error)) {
+                    throw error;
+                }
+                if (attempt === this.releaseRaceRetries - 1) {
+                    return { status: 'port-in-use', error };
+                }
+                await sleep(this.releaseRaceDelayMs);
+            }
+        }
+        return { status: 'factory-refused' };
+    }
+    async findNextFreePort(startPort) {
+        for (let offset = 1; offset <= this.maxPortOffset; offset += 1) {
+            const candidate = startPort + offset;
+            if (await this.probePort(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
     }
-    return null;
-  }
 }
-export {
-  PortManager,
-  isPortAvailable,
-  isPortInUseError
-};