@camstack/server 1.2.89 → 1.2.91

package/dist/launcher-framework-swap.js

@@ -0,0 +1,408 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePendingFrameworkSwap = writePendingFrameworkSwap;
+exports.applyPendingFrameworkSwap = applyPendingFrameworkSwap;
+exports.rollbackUnconfirmedFrameworkSwap = rollbackUnconfirmedFrameworkSwap;
+exports.confirmFrameworkSwapHealthy = confirmFrameworkSwapHealthy;
+/**
+ * Launcher zero-dep framework swap/rollback helpers.
+ *
+ * These run before @camstack/system is imported — zero @camstack imports.
+ * Only node:fs + node:path. All writes are atomic (tmpfile+rename).
+ * All reads tolerate missing/corrupt files (no-op result).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const lifecycle_journal_path_js_1 = require("./lifecycle-journal-path.js");
+// ---------------------------------------------------------------------------
+// Marker file names
+// ---------------------------------------------------------------------------
+const PENDING_SWAP_MARKER = '.pending-framework-swap.json';
+const SWAP_CONFIRM_MARKER = '.framework-swap-confirm.json';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Write a JSON file atomically via a tmp sibling + rename. */
+function writeJsonAtomic(filePath, value) {
+    const tmp = `${filePath}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(value), 'utf-8');
+    fs.renameSync(tmp, filePath);
+}
+/** Read + parse JSON, returning null on any error (missing / corrupt). */
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Validate that a parsed value matches the PendingSwapMarker shape. */
+function isPendingSwapMarker(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const v = value;
+    if (typeof v['jobId'] !== 'string')
+        return false;
+    if (typeof v['taskId'] !== 'string')
+        return false;
+    if (!Array.isArray(v['packages']))
+        return false;
+    for (const pkg of v['packages']) {
+        if (typeof pkg !== 'object' || pkg === null)
+            return false;
+        const p = pkg;
+        if (typeof p['name'] !== 'string')
+            return false;
+        if (typeof p['stagedPath'] !== 'string')
+            return false;
+        if (typeof p['backupPath'] !== 'string')
+            return false;
+    }
+    if (typeof v['requestedAtMs'] !== 'number')
+        return false;
+    if (v['schemaVersion'] !== 1)
+        return false;
+    return true;
+}
+/** Validate that a parsed value matches the SwapConfirmMarker shape. */
+function isSwapConfirmMarker(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const v = value;
+    if (typeof v['jobId'] !== 'string')
+        return false;
+    if (typeof v['taskId'] !== 'string')
+        return false;
+    if (!Array.isArray(v['backups']))
+        return false;
+    for (const b of v['backups']) {
+        if (typeof b !== 'object' || b === null)
+            return false;
+        const entry = b;
+        if (typeof entry['name'] !== 'string')
+            return false;
+        if (typeof entry['backupPath'] !== 'string')
+            return false;
+        if (typeof entry['livePath'] !== 'string')
+            return false;
+    }
+    if (typeof v['appliedAtMs'] !== 'number')
+        return false;
+    if (typeof v['bootAttempts'] !== 'number')
+        return false;
+    if (v['schemaVersion'] !== 1)
+        return false;
+    return true;
+}
+/**
+ * Patch a specific task inside a journal job file atomically.
+ * Reads `<dataDir>/lifecycle/jobs/<jobId>.json`, updates tasks[taskId],
+ * and writes back atomically. Silently no-ops on any read/write error.
+ */
+function patchJournalTask(dataDir, jobId, taskId, patch) {
+    const jobFile = path.join((0, lifecycle_journal_path_js_1.lifecycleJobsDir)(dataDir), `${jobId}.json`);
+    const raw = readJsonSafe(jobFile);
+    if (typeof raw !== 'object' || raw === null)
+        return;
+    const job = raw;
+    const tasks = job['tasks'];
+    if (!Array.isArray(tasks))
+        return;
+    const updatedTasks = tasks.map((task) => {
+        if (typeof task !== 'object' || task === null)
+            return task;
+        const t = task;
+        if (t['taskId'] !== taskId)
+            return task;
+        const updated = { ...t, phase: patch.phase };
+        if (patch.error !== undefined)
+            updated['error'] = patch.error;
+        if (patch.finishedAtMs !== undefined)
+            updated['finishedAtMs'] = patch.finishedAtMs;
+        return updated;
+    });
+    try {
+        writeJsonAtomic(jobFile, { ...job, tasks: updatedTasks });
+    }
+    catch {
+        // journal patch is best-effort — never crash the launcher
+    }
+}
+/** Copy a directory tree cross-device (fallback for EXDEV rename errors). */
+function moveDirCrossDevice(src, dest) {
+    fs.cpSync(src, dest, { recursive: true });
+    fs.rmSync(src, { recursive: true, force: true });
+}
+/**
+ * Write the `.pending-framework-swap.json` marker atomically.
+ * Co-located with the reader (`applyPendingFrameworkSwap`) for symmetry.
+ * Zero @camstack deps — this file runs before @camstack/system is imported.
+ */
+function writePendingFrameworkSwap(dataDir, marker) {
+    const markerPath = path.join(dataDir, PENDING_SWAP_MARKER);
+    writeJsonAtomic(markerPath, marker);
+}
+/**
+ * Apply a pending framework swap if a `.pending-framework-swap.json` marker
+ * exists in `dataDir`. Swaps each listed package atomically:
+ *   1. Backup: rename live → backupPath
+ *   2. Swap: rename staged → live (EXDEV fallback: cpSync + rmSync)
+ *
+ * On any mid-loop failure: restores already-swapped packages, deletes the
+ * marker, returns `{ applied: false }`.
+ * On success: writes `.framework-swap-confirm.json`, patches the journal
+ * task to `applied`, deletes the swap marker, returns `{ applied: true, jobId }`.
+ */
+function applyPendingFrameworkSwap(dataDir, frameworkDir) {
+    if (!frameworkDir)
+        return { applied: false };
+    const markerPath = path.join(dataDir, PENDING_SWAP_MARKER);
+    if (!fs.existsSync(markerPath))
+        return { applied: false };
+    const raw = readJsonSafe(markerPath);
+    if (!isPendingSwapMarker(raw)) {
+        // malformed — delete to prevent blocking future updates
+        try {
+            fs.rmSync(markerPath, { force: true });
+        }
+        catch {
+            // ignore deletion error
+        }
+        return { applied: false };
+    }
+    const marker = raw;
+    const swapped = [];
+    for (const pkg of marker.packages) {
+        const livePath = path.join(frameworkDir, 'node_modules', pkg.name);
+        try {
+            // Step 1: backup live dir if it exists
+            if (fs.existsSync(livePath)) {
+                fs.mkdirSync(path.dirname(pkg.backupPath), { recursive: true });
+                fs.renameSync(livePath, pkg.backupPath);
+            }
+            // Step 2: move staged dir to live
+            try {
+                fs.mkdirSync(path.dirname(livePath), { recursive: true });
+                fs.renameSync(pkg.stagedPath, livePath);
+            }
+            catch (err) {
+                if (err.code === 'EXDEV') {
+                    fs.mkdirSync(path.dirname(livePath), { recursive: true });
+                    moveDirCrossDevice(pkg.stagedPath, livePath);
+                }
+                else {
+                    throw err;
+                }
+            }
+            swapped.push({ livePath, backupPath: pkg.backupPath });
+        }
+        catch {
+            // Restore all already-swapped packages
+            for (const done of swapped) {
+                try {
+                    if (fs.existsSync(done.livePath)) {
+                        fs.rmSync(done.livePath, { recursive: true, force: true });
+                    }
+                    if (fs.existsSync(done.backupPath)) {
+                        fs.mkdirSync(path.dirname(done.livePath), { recursive: true });
+                        fs.renameSync(done.backupPath, done.livePath);
+                    }
+                }
+                catch {
+                    // best-effort restore
+                }
+            }
+            // Delete the pending marker so the next boot doesn't retry a broken swap
+            try {
+                fs.rmSync(markerPath, { force: true });
+            }
+            catch {
+                // ignore
+            }
+            return { applied: false };
+        }
+    }
+    // All packages swapped successfully — write confirm marker
+    const backups = marker.packages.map((pkg) => ({
+        name: pkg.name,
+        backupPath: pkg.backupPath,
+        livePath: path.join(frameworkDir, 'node_modules', pkg.name),
+    }));
+    const confirmMarker = {
+        jobId: marker.jobId,
+        taskId: marker.taskId,
+        backups,
+        appliedAtMs: Date.now(),
+        bootAttempts: 0,
+        schemaVersion: 1,
+    };
+    // Write confirm marker — if this fails, restore everything and fail the apply
+    try {
+        writeJsonAtomic(path.join(dataDir, SWAP_CONFIRM_MARKER), confirmMarker);
+    }
+    catch {
+        // Confirm marker write failed — restore all swapped packages and fail the apply
+        for (const done of swapped) {
+            try {
+                if (fs.existsSync(done.livePath)) {
+                    fs.rmSync(done.livePath, { recursive: true, force: true });
+                }
+                if (fs.existsSync(done.backupPath)) {
+                    fs.mkdirSync(path.dirname(done.livePath), { recursive: true });
+                    fs.renameSync(done.backupPath, done.livePath);
+                }
+            }
+            catch {
+                // best-effort restore
+            }
+        }
+        // Delete the pending marker so the next boot doesn't retry
+        try {
+            fs.rmSync(markerPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        return { applied: false };
+    }
+    // Patch journal task → applied (best-effort, doesn't fail the apply)
+    patchJournalTask(dataDir, marker.jobId, marker.taskId, { phase: 'applied' });
+    // Delete the swap marker
+    try {
+        fs.rmSync(markerPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+    return { applied: true, jobId: marker.jobId };
+}
+/**
+ * Check for an unconfirmed framework swap on boot.
+ *
+ * - `bootAttempts === 0`: this is the probation boot. Increment to 1,
+ *   rewrite the marker, return `{ rolledBack: false }`.
+ * - `bootAttempts >= 1`: the previous probation boot crashed / didn't call
+ *   `confirmFrameworkSwapHealthy`. Restore all backups, patch the journal
+ *   task to `failed`, delete the confirm marker, return `{ rolledBack: true }`.
+ */
+function rollbackUnconfirmedFrameworkSwap(dataDir, frameworkDir) {
+    if (!frameworkDir)
+        return { rolledBack: false };
+    const confirmPath = path.join(dataDir, SWAP_CONFIRM_MARKER);
+    if (!fs.existsSync(confirmPath))
+        return { rolledBack: false };
+    const raw = readJsonSafe(confirmPath);
+    if (!isSwapConfirmMarker(raw))
+        return { rolledBack: false };
+    const confirm = raw;
+    if (confirm.bootAttempts === 0) {
+        // Probation boot — increment attempts and let this boot proceed
+        const updated = { ...confirm, bootAttempts: 1 };
+        try {
+            writeJsonAtomic(confirmPath, updated);
+        }
+        catch {
+            // ignore write failure
+        }
+        return { rolledBack: false };
+    }
+    // bootAttempts >= 1: probation boot didn't become healthy — rollback
+    for (const backup of confirm.backups) {
+        try {
+            if (fs.existsSync(backup.livePath)) {
+                fs.rmSync(backup.livePath, { recursive: true, force: true });
+            }
+            if (fs.existsSync(backup.backupPath)) {
+                fs.mkdirSync(path.dirname(backup.livePath), { recursive: true });
+                fs.renameSync(backup.backupPath, backup.livePath);
+            }
+        }
+        catch {
+            // best-effort restore
+        }
+    }
+    patchJournalTask(dataDir, confirm.jobId, confirm.taskId, {
+        phase: 'failed',
+        error: 'framework update rolled back — boot did not become healthy',
+        finishedAtMs: Date.now(),
+    });
+    try {
+        fs.rmSync(confirmPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+    return { rolledBack: true };
+}
+/**
+ * Called by post-boot health check once the hub is confirmed healthy after
+ * a framework swap. Deletes all backups and the confirm marker so the old
+ * framework packages are cleaned up.
+ */
+function confirmFrameworkSwapHealthy(dataDir) {
+    const confirmPath = path.join(dataDir, SWAP_CONFIRM_MARKER);
+    if (!fs.existsSync(confirmPath))
+        return;
+    const raw = readJsonSafe(confirmPath);
+    if (!isSwapConfirmMarker(raw)) {
+        // corrupt marker — still delete it
+        try {
+            fs.rmSync(confirmPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        return;
+    }
+    const confirm = raw;
+    // Delete all backup dirs
+    for (const backup of confirm.backups) {
+        try {
+            fs.rmSync(backup.backupPath, { recursive: true, force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+    // Delete the confirm marker
+    try {
+        fs.rmSync(confirmPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/main.js

@@ -867,17 +867,26 @@ async function bootstrap() {
                 const upstreamPath = `/${subPath}${queryString}`;
                 // Take over the socket — `proxyToUpstream` drives the raw response.
                 reply.hijack();
+                const replayBody = request.body === undefined
+                    ? undefined
+                    : Buffer.isBuffer(request.body)
+                        ? request.body
+                        : Buffer.from(typeof request.body === 'string' ? request.body : JSON.stringify(request.body));
                 (0, system_3.proxyToUpstream)({
                     baseUrl: dpMatch.endpoint.baseUrl,
                     secret: dpMatch.endpoint.secret,
                     upstreamPath,
                     clientReq: request.raw,
                     clientRes: reply.raw,
+                    ...(replayBody !== undefined ? { replayBody } : {}),
                 });
                 return;
             }
             const match = addonRouteRegistry.matchRoute(method, fullPath);
             if (!match) {
+                if ((0, spa_static_1.isRetiredPublicPath)(fullPath)) {
+                    return reply.status(404).send({ error: 'Not found' });
+                }
                 if (method === 'GET' && spaIndexHtml) {
                     return reply.type('text/html').send(fs.createReadStream(spaIndexHtml));
                 }
@@ -1111,6 +1120,8 @@ async function bootstrap() {
     });
     fastify.get('/*', async (request, reply) => {
         const url = request.url;
+        if ((0, spa_static_1.isRetiredPublicPath)(url))
+            return reply.callNotFound();
         if (url.startsWith('/trpc') ||
             url.startsWith('/api/') ||
             url.startsWith('/agent') ||

package/dist/manual-boot.js

@@ -220,6 +220,7 @@ async function bootManual(opts) {
     const serverUpdateService = new server_update_service_1.ServerUpdateService({
         logger: loggingService.createLogger('ServerUpdate'),
         restartServer: (requestedBy) => addonPackageService.restartServer(requestedBy),
+        eventBus: eventBusService,
     });
     const topologyEmitterService = new topology_emitter_service_1.TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService, (0, cap_providers_1.createNodeRootPackageLookup)(moleculerService, serverUpdateService));
     const postBootService = new post_boot_service_1.PostBootService(addonRegistryService, eventBusService, loggingService);

package/dist/request-framework-swap.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestFrameworkSwapAndRestart = requestFrameworkSwapAndRestart;
+/**
+ * The single seam that joins the two halves of a framework-swap request:
+ *   1. write the durable `.pending-framework-swap.json` marker (consumed by the
+ *      zero-dep launcher on the NEXT boot), and
+ *   2. schedule the self-restart that makes the launcher actually run.
+ *
+ * The launcher (`launcher-framework-swap.ts`) runs before `@camstack/system`
+ * is imported and is deliberately zero-dep, so it cannot own the restart — that
+ * lives in `@camstack/system`. This module is the ONLY owner of "stage a
+ * framework swap → reboot": every engine path that stages the framework (single
+ * `updateFrameworkPackage`, the "Update all" bulk job, and the auto-update
+ * scheduler) wires its `requestFrameworkSwap` dep to this helper and gets the
+ * reboot for free. The lifecycle engine assumes the process exits after
+ * `requestFrameworkSwap` returns; without the restart here the marker is written
+ * but never applied, silently stranding the update on disk.
+ */
+const system_1 = require("@camstack/system");
+const launcher_framework_swap_js_1 = require("./launcher-framework-swap.js");
+/** Delay before the hub exits — lets the in-flight startJob reply drain first. */
+const FRAMEWORK_SWAP_RESTART_DELAY_MS = 500;
+/**
+ * Write the pending-swap marker, then schedule the self-restart. The restart is
+ * UNCONDITIONAL: a staged framework swap is inert until the launcher applies it
+ * on reboot, so staging without restarting would silently lose the update.
+ */
+function requestFrameworkSwapAndRestart(dataDir, input, deps = {}) {
+    const writeMarker = deps.writeMarker ?? launcher_framework_swap_js_1.writePendingFrameworkSwap;
+    const scheduleRestart = deps.scheduleRestart ?? system_1.scheduleSelfRestart;
+    const now = deps.now ?? Date.now;
+    writeMarker(dataDir, {
+        jobId: input.jobId,
+        taskId: input.taskId,
+        packages: input.packages,
+        requestedAtMs: now(),
+        schemaVersion: 1,
+    });
+    scheduleRestart({ delayMs: FRAMEWORK_SWAP_RESTART_DELAY_MS });
+}

package/dist/server-root/boot-plan.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planBoot = planBoot;
+/**
+ * Decide the boot target. Never throws; never mutates `state`.
+ * `stateToWrite` is non-null whenever the durable state must change
+ * (probation counter bump, rollback, invalid-version eviction).
+ */
+function planBoot(state, isValidVersion, now) {
+    if (state === null) {
+        return { kind: 'baked', reason: 'no server-root state', stateToWrite: null };
+    }
+    let next = state;
+    let changed = false;
+    // ── Pending (freshly-staged) version ──────────────────────────────────
+    if (next.pendingBoot !== null) {
+        const pending = next.pendingBoot;
+        if (pending.bootAttempts >= 1) {
+            // Previous probation boot never confirmed healthy — roll back.
+            next = {
+                ...next,
+                pendingBoot: null,
+                rolledBack: {
+                    fromVersion: pending.version,
+                    toVersion: next.currentVersion,
+                    atMs: now(),
+                    reason: 'probation boot did not reach ready — rolled back',
+                },
+            };
+            changed = true;
+        }
+        else if (!isValidVersion(pending.version)) {
+            next = {
+                ...next,
+                pendingBoot: null,
+                rolledBack: {
+                    fromVersion: pending.version,
+                    toVersion: next.currentVersion,
+                    atMs: now(),
+                    reason: 'staged version failed validation',
+                },
+            };
+            changed = true;
+        }
+        else {
+            // Probation boot: bump the attempt counter durably, keep currentVersion
+            // untouched until the hub confirms the boot healthy.
+            return {
+                kind: 'data-root',
+                version: pending.version,
+                probation: true,
+                stateToWrite: {
+                    ...next,
+                    pendingBoot: { ...pending, bootAttempts: pending.bootAttempts + 1 },
+                },
+            };
+        }
+    }
+    // ── Confirmed current version ──────────────────────────────────────────
+    if (next.currentVersion !== null) {
+        if (isValidVersion(next.currentVersion)) {
+            return {
+                kind: 'data-root',
+                version: next.currentVersion,
+                probation: false,
+                stateToWrite: changed ? next : null,
+            };
+        }
+        // Current version dir is broken — try N-1, else baked.
+        const broken = next.currentVersion;
+        if (next.previousVersion !== null && isValidVersion(next.previousVersion)) {
+            const fallback = next.previousVersion;
+            return {
+                kind: 'data-root',
+                version: fallback,
+                probation: false,
+                stateToWrite: {
+                    ...next,
+                    currentVersion: fallback,
+                    previousVersion: null,
+                    rolledBack: {
+                        fromVersion: broken,
+                        toVersion: fallback,
+                        atMs: now(),
+                        reason: 'active version failed validation',
+                    },
+                },
+            };
+        }
+        return {
+            kind: 'baked',
+            reason: `active version ${broken} failed validation and no valid previous version exists`,
+            stateToWrite: {
+                ...next,
+                currentVersion: null,
+                rolledBack: {
+                    fromVersion: broken,
+                    toVersion: null,
+                    atMs: now(),
+                    reason: 'active version failed validation',
+                },
+            },
+        };
+    }
+    return {
+        kind: 'baked',
+        reason: 'no active data-root version',
+        stateToWrite: changed ? next : null,
+    };
+}

package/dist/server-root/semver-compare.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Minimal semver comparison — zero-dep (used by the starter, which must never
+ * import from node_modules). Handles `MAJOR.MINOR.PATCH[-prerelease]`:
+ * numeric segment compare, missing segments = 0, prerelease < its release,
+ * prereleases of the same base compare lexically. Malformed segments compare
+ * as 0 (best effort — never throws).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSemver = compareSemver;
+function parse(version) {
+    const dashIdx = version.indexOf('-');
+    const base = dashIdx === -1 ? version : version.slice(0, dashIdx);
+    const prerelease = dashIdx === -1 ? null : version.slice(dashIdx + 1);
+    const nums = base.split('.').map((seg) => {
+        const n = Number.parseInt(seg, 10);
+        return Number.isNaN(n) ? 0 : n;
+    });
+    return { nums, prerelease };
+}
+/** Returns -1 when a < b, 0 when equal, 1 when a > b. */
+function compareSemver(a, b) {
+    const pa = parse(a);
+    const pb = parse(b);
+    const len = Math.max(pa.nums.length, pb.nums.length);
+    for (let i = 0; i < len; i++) {
+        const na = pa.nums[i] ?? 0;
+        const nb = pb.nums[i] ?? 0;
+        if (na < nb)
+            return -1;
+        if (na > nb)
+            return 1;
+    }
+    if (pa.prerelease === null && pb.prerelease === null)
+        return 0;
+    if (pa.prerelease === null)
+        return 1;
+    if (pb.prerelease === null)
+        return -1;
+    if (pa.prerelease < pb.prerelease)
+        return -1;
+    if (pa.prerelease > pb.prerelease)
+        return 1;
+    return 0;
+}