@kbediako/codex-orchestrator 0.1.0

package/dist/orchestrator/src/manager.js

@@ -0,0 +1,388 @@
+import { EventBus } from './events/EventBus.js';
+import { PersistenceCoordinator } from './persistence/PersistenceCoordinator.js';
+import { TaskStateStore } from './persistence/TaskStateStore.js';
+import { RunManifestWriter } from './persistence/RunManifestWriter.js';
+import { sanitizeRunId } from './persistence/sanitizeRunId.js';
+import { normalizeErrorMessage } from './utils/errorMessage.js';
+import { MANAGER_EXECUTION_MODE_PARSER, resolveRequiresCloudPolicy } from './utils/executionMode.js';
+import { EnvUtils } from '../../packages/shared/config/index.js';
+const defaultModePolicy = (task, subtask) => {
+    const requiresCloudFlag = resolveRequiresCloud(subtask);
+    if (requiresCloudFlag) {
+        return 'cloud';
+    }
+    if (task.metadata?.execution?.parallel) {
+        return 'cloud';
+    }
+    return 'mcp';
+};
+function resolveRequiresCloud(subtask) {
+    const requiresCloudFlag = resolveRequiresCloudPolicy({
+        boolFlags: [subtask.requires_cloud, subtask.requiresCloud],
+        metadata: {
+            mode: typeof subtask.metadata?.mode === 'string' ? subtask.metadata.mode : null,
+            executionMode: typeof subtask.metadata?.executionMode === 'string'
+                ? subtask.metadata.executionMode
+                : null
+        },
+        metadataOrder: ['mode', 'executionMode'],
+        parseMode: MANAGER_EXECUTION_MODE_PARSER
+    });
+    return requiresCloudFlag ?? false;
+}
+const defaultRunIdFactory = (taskId) => {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return sanitizeRunId(`${taskId}-${timestamp}`);
+};
+export class TaskManager {
+    options;
+    eventBus;
+    modePolicy;
+    runIdFactory;
+    _persistenceCoordinator;
+    groupExecutionEnabled;
+    constructor(options) {
+        this.options = options;
+        this.eventBus = options.eventBus ?? new EventBus();
+        this.modePolicy = options.modePolicy ?? defaultModePolicy;
+        this.runIdFactory = options.runIdFactory ?? defaultRunIdFactory;
+        this.groupExecutionEnabled = EnvUtils.getBoolean('FEATURE_TFGRPO_GROUP');
+        if (options.persistence) {
+            const stateStore = options.persistence.stateStore ?? new TaskStateStore();
+            const manifestWriter = options.persistence.manifestWriter ?? new RunManifestWriter();
+            const coordinatorOptions = options.persistence.coordinatorOptions;
+            this._persistenceCoordinator = new PersistenceCoordinator(this.eventBus, stateStore, manifestWriter, coordinatorOptions);
+            if (options.persistence.autoStart !== false) {
+                this._persistenceCoordinator.start();
+            }
+        }
+    }
+    get bus() {
+        return this.eventBus;
+    }
+    startPersistence() {
+        this._persistenceCoordinator?.start();
+    }
+    stopPersistence() {
+        this._persistenceCoordinator?.stop();
+    }
+    dispose() {
+        this.stopPersistence();
+    }
+    get persistenceCoordinator() {
+        return this._persistenceCoordinator;
+    }
+    async execute(task) {
+        const runId = this.runIdFactory(task.id);
+        const { plan, failed, error } = await this.executePlanner(task, runId);
+        if (failed) {
+            return this.completeFromPlannerFailure(task, plan, runId, error);
+        }
+        const targets = this.selectExecutableSubtasks(plan);
+        const shouldRunGroup = this.groupExecutionEnabled && targets.length > 1;
+        const result = shouldRunGroup
+            ? await this.executeGroup(task, plan, targets, runId)
+            : await this.runPipelineStages(task, plan, targets[0], runId);
+        this.eventBus.emit({ type: 'run:completed', payload: result.summary });
+        return result.summary;
+    }
+    selectExecutableSubtasks(plan) {
+        if (!this.groupExecutionEnabled) {
+            return [this.selectSingleSubtask(plan)];
+        }
+        if (plan.items.length === 0) {
+            throw new Error('Planner returned no executable subtasks.');
+        }
+        const runnable = plan.items.filter((item) => item.runnable !== false);
+        if (runnable.length === 0) {
+            throw new Error('Planner returned no runnable subtasks after applying selection and target hints.');
+        }
+        return this.prioritizeGroupTargets(plan, runnable);
+    }
+    selectSingleSubtask(plan) {
+        if (plan.items.length === 0) {
+            throw new Error('Planner returned no executable subtasks.');
+        }
+        const selected = plan.items.find((item) => item.selected === true);
+        if (selected) {
+            return selected;
+        }
+        if (plan.targetId) {
+            const targeted = plan.items.find((item) => item.id === plan.targetId);
+            if (targeted) {
+                return targeted;
+            }
+        }
+        const runnable = plan.items.filter((item) => item.runnable !== false);
+        if (runnable.length === 1) {
+            return runnable[0];
+        }
+        if (runnable.length > 1) {
+            const available = runnable.map((item) => item.id).join(', ');
+            throw new Error(`Planner returned multiple runnable subtasks without a selection (${available}). ` +
+                'Specify a target stage or update the planner configuration.');
+        }
+        throw new Error('Planner returned no runnable subtasks after applying selection and target hints.');
+    }
+    prioritizeGroupTargets(plan, runnable) {
+        const prioritized = [];
+        const seen = new Set();
+        const preferred = (plan.targetId ? runnable.find((item) => item.id === plan.targetId) : undefined) ??
+            plan.items.find((item) => item.selected === true && item.runnable !== false);
+        if (preferred) {
+            prioritized.push(preferred);
+            seen.add(preferred.id);
+        }
+        for (const item of runnable) {
+            if (!seen.has(item.id)) {
+                prioritized.push(item);
+                seen.add(item.id);
+            }
+        }
+        return prioritized;
+    }
+    createRunSummary(task, mode, plan, build, test, review, runId) {
+        const timestamp = new Date().toISOString();
+        return {
+            taskId: task.id,
+            runId,
+            mode,
+            plan,
+            build,
+            test,
+            review,
+            timestamp
+        };
+    }
+    async runPipelineStages(task, plan, target, runId) {
+        const mode = this.modePolicy(task, target);
+        const build = await this.executeBuilder(task, plan, target, mode, runId);
+        if (!build.success) {
+            const skippedTest = this.createSkippedTestResult(build, runId);
+            const skippedReview = this.createSkippedReviewResult('build-failed');
+            const summary = this.createRunSummary(task, mode, plan, build, skippedTest, skippedReview, runId);
+            return { target, mode, build, test: skippedTest, review: skippedReview, summary };
+        }
+        const test = await this.executeTester(task, build, mode, runId);
+        if (!test.success) {
+            const skippedReview = this.createSkippedReviewResult('test-failed');
+            const summary = this.createRunSummary(task, mode, plan, build, test, skippedReview, runId);
+            return { target, mode, build, test, review: skippedReview, summary };
+        }
+        const review = await this.executeReviewer(task, plan, build, test, mode, runId);
+        const summary = this.createRunSummary(task, mode, plan, build, test, review, runId);
+        return { target, mode, build, test, review, summary };
+    }
+    async executeGroup(task, plan, targets, runId) {
+        const entries = [];
+        const buildResults = [];
+        const testResults = [];
+        const reviewResults = [];
+        let finalResult = null;
+        for (let index = 0; index < targets.length; index += 1) {
+            const target = targets[index];
+            const result = await this.runPipelineStages(task, plan, target, runId);
+            buildResults.push(result.build);
+            testResults.push(result.test);
+            reviewResults.push(result.review);
+            entries.push({
+                index: index + 1,
+                subtaskId: target.id,
+                mode: result.mode,
+                buildSuccess: result.build.success,
+                testSuccess: result.test.success,
+                reviewApproved: Boolean(result.review.decision?.approved),
+                status: result.build.success && result.test.success ? 'succeeded' : 'failed'
+            });
+            finalResult = result;
+            if (!result.build.success || !result.test.success) {
+                break;
+            }
+        }
+        if (!finalResult) {
+            throw new Error('Group execution produced no runnable subtasks.');
+        }
+        const groupMode = entries.some((entry) => entry.mode === 'cloud') ? 'cloud' : finalResult.mode;
+        finalResult.summary.mode = groupMode;
+        finalResult.summary.group = {
+            enabled: true,
+            size: targets.length,
+            processed: entries.length,
+            entries
+        };
+        finalResult.summary.builds = buildResults;
+        finalResult.summary.tests = testResults;
+        finalResult.summary.reviews = reviewResults;
+        return finalResult;
+    }
+    normalizeBuildResult(build, mode, runId) {
+        if (typeof build.success !== 'boolean') {
+            throw new Error('Builder result missing success flag');
+        }
+        return { ...build, mode, runId };
+    }
+    normalizeTestResult(test, runId) {
+        return { ...test, runId };
+    }
+    createSkippedTestResult(build, runId) {
+        return {
+            subtaskId: build.subtaskId,
+            success: false,
+            reports: [
+                {
+                    name: 'tests',
+                    status: 'failed',
+                    details: 'Skipped because the build stage failed.'
+                }
+            ],
+            runId
+        };
+    }
+    createSkippedReviewResult(reason) {
+        if (reason === 'build-failed') {
+            return {
+                summary: 'Review skipped: build stage failed.',
+                decision: {
+                    approved: false,
+                    feedback: 'Build stage failed; review skipped.'
+                }
+            };
+        }
+        return {
+            summary: 'Review skipped: tests failed.',
+            decision: {
+                approved: false,
+                feedback: 'Tests failed; review skipped.'
+            }
+        };
+    }
+    async executePlanner(task, runId) {
+        try {
+            const plan = await this.options.planner.plan(task);
+            this.eventBus.emit({
+                type: 'plan:completed',
+                payload: { task, plan, runId }
+            });
+            return { plan, failed: false, error: null };
+        }
+        catch (error) {
+            const plan = this.createPlannerFailurePlan(error);
+            this.eventBus.emit({
+                type: 'plan:completed',
+                payload: { task, plan, runId }
+            });
+            return { plan, failed: true, error };
+        }
+    }
+    async executeBuilder(task, plan, target, mode, runId) {
+        const input = { task, plan, target, mode, runId };
+        try {
+            const build = this.normalizeBuildResult(await this.options.builder.build(input), mode, runId);
+            this.eventBus.emit({
+                type: 'build:completed',
+                payload: { task, plan, build, runId }
+            });
+            return build;
+        }
+        catch (error) {
+            const failure = this.createBuilderErrorResult(target.id, mode, runId, error);
+            this.eventBus.emit({
+                type: 'build:completed',
+                payload: { task, plan, build: failure, runId }
+            });
+            return failure;
+        }
+    }
+    async executeTester(task, build, mode, runId) {
+        try {
+            const test = this.normalizeTestResult(await this.options.tester.test({ task, build, mode, runId }), runId);
+            this.eventBus.emit({
+                type: 'test:completed',
+                payload: { task, build, test, runId }
+            });
+            return test;
+        }
+        catch (error) {
+            const failure = this.createTesterErrorResult(build.subtaskId, runId, error);
+            this.eventBus.emit({
+                type: 'test:completed',
+                payload: { task, build, test: failure, runId }
+            });
+            return failure;
+        }
+    }
+    async executeReviewer(task, plan, build, test, mode, runId) {
+        try {
+            const review = await this.options.reviewer.review({ task, plan, build, test, mode, runId });
+            this.eventBus.emit({
+                type: 'review:completed',
+                payload: { task, review, runId }
+            });
+            return review;
+        }
+        catch (error) {
+            const failure = this.createReviewerErrorResult(error);
+            this.eventBus.emit({
+                type: 'review:completed',
+                payload: { task, review: failure, runId }
+            });
+            return failure;
+        }
+    }
+    completeFromPlannerFailure(task, plan, runId, error) {
+        const mode = 'mcp';
+        const cause = error ?? new Error('Planner stage failed without an error payload');
+        const build = this.createBuilderErrorResult('planner-unavailable', mode, runId, cause);
+        const skippedTest = this.createSkippedTestResult(build, runId);
+        const skippedReview = this.createSkippedReviewResult('build-failed');
+        const summary = this.createRunSummary(task, mode, plan, build, skippedTest, skippedReview, runId);
+        this.eventBus.emit({ type: 'run:completed', payload: summary });
+        return summary;
+    }
+    createPlannerFailurePlan(error) {
+        return {
+            items: [],
+            notes: this.formatStageError('planner', error),
+            targetId: null
+        };
+    }
+    createBuilderErrorResult(subtaskId, mode, runId, error) {
+        return {
+            subtaskId: subtaskId ?? 'unknown',
+            artifacts: [],
+            mode,
+            runId,
+            success: false,
+            notes: this.formatStageError('builder', error)
+        };
+    }
+    createTesterErrorResult(subtaskId, runId, error) {
+        return {
+            subtaskId,
+            success: false,
+            reports: [
+                {
+                    name: 'tests',
+                    status: 'failed',
+                    details: this.formatStageError('tester', error)
+                }
+            ],
+            runId
+        };
+    }
+    createReviewerErrorResult(error) {
+        const summary = this.formatStageError('reviewer', error);
+        return {
+            summary,
+            decision: {
+                approved: false,
+                feedback: summary
+            }
+        };
+    }
+    formatStageError(stage, error) {
+        const message = normalizeErrorMessage(error);
+        const normalizedStage = stage.charAt(0).toUpperCase() + stage.slice(1);
+        return `${normalizedStage} stage error: ${message}`;
+    }
+}

package/dist/orchestrator/src/persistence/ArtifactStager.js

@@ -0,0 +1,95 @@
+import { access, copyFile, mkdir, rename, rm } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { sanitizeTaskId } from './sanitizeTaskId.js';
+import { sanitizeRunId } from './sanitizeRunId.js';
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+async function ensureUniquePath(basePath) {
+    let candidate = basePath;
+    let attempt = 0;
+    const dir = dirname(basePath);
+    const original = basename(basePath);
+    const extension = extname(original);
+    const stem = extension ? original.slice(0, -extension.length) : original;
+    while (attempt < 1000) {
+        if (!(await pathExists(candidate))) {
+            return candidate;
+        }
+        attempt += 1;
+        const suffix = `-${attempt}`;
+        const nextName = `${stem}${suffix}${extension}`;
+        candidate = join(dir, nextName);
+    }
+    throw new Error(`Unable to stage artifact: too many name collisions for ${basePath}`);
+}
+export async function stageArtifacts(params) {
+    const { taskId, runId, artifacts, options } = params;
+    if (artifacts.length === 0) {
+        return artifacts;
+    }
+    const runsDir = options?.runsDir ?? join(process.cwd(), '.runs');
+    const safeTaskId = sanitizeTaskId(taskId);
+    const runDir = join(runsDir, safeTaskId, sanitizeRunId(runId));
+    const artifactsDir = join(runDir, 'artifacts');
+    await mkdir(artifactsDir, { recursive: true });
+    const relativeSegments = options?.relativeDir ? sanitizeRelativeDir(options.relativeDir) : [];
+    const destinationRoot = relativeSegments.length > 0 ? join(artifactsDir, ...relativeSegments) : artifactsDir;
+    await mkdir(destinationRoot, { recursive: true });
+    const results = [];
+    for (const artifact of artifacts) {
+        const sourcePath = resolve(process.cwd(), artifact.path);
+        const relativeToArtifacts = relative(artifactsDir, sourcePath);
+        const isWithinArtifactsDir = relativeToArtifacts.length > 0 &&
+            !relativeToArtifacts.startsWith('..') &&
+            !isAbsolute(relativeToArtifacts);
+        if (isWithinArtifactsDir) {
+            results.push(artifact);
+            continue;
+        }
+        const destinationBase = join(destinationRoot, basename(sourcePath));
+        const destinationPath = options?.overwrite
+            ? await prepareOverwriteDestination(destinationBase)
+            : await ensureUniquePath(destinationBase);
+        if (options?.keepOriginal) {
+            await copyFile(sourcePath, destinationPath);
+        }
+        else {
+            await rename(sourcePath, destinationPath);
+        }
+        const relativePath = relative(process.cwd(), destinationPath);
+        results.push({
+            ...artifact,
+            path: relativePath
+        });
+    }
+    return results;
+}
+async function prepareOverwriteDestination(destinationBase) {
+    if (await pathExists(destinationBase)) {
+        await rm(destinationBase, { recursive: true, force: true });
+    }
+    return destinationBase;
+}
+function sanitizeRelativeDir(relativeDir) {
+    const sanitized = relativeDir.replace(/\\+/g, '/');
+    const segments = sanitized
+        .split('/')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+    for (const segment of segments) {
+        if (segment === '.' || segment === '..' || segment.includes('..')) {
+            throw new Error(`relativeDir contains invalid segment '${segment}'`);
+        }
+    }
+    return segments;
+}

package/dist/orchestrator/src/persistence/ExperienceStore.js

@@ -0,0 +1,210 @@
+import { randomBytes } from 'node:crypto';
+import { readFile, mkdir, rm, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { acquireLockWithRetry } from './lockFile.js';
+import { sanitizeTaskId } from './sanitizeTaskId.js';
+import { writeAtomicFile } from './writeAtomicFile.js';
+export class ExperienceStoreLockError extends Error {
+    taskId;
+    constructor(message, taskId) {
+        super(message);
+        this.taskId = taskId;
+        this.name = 'ExperienceStoreLockError';
+    }
+}
+const DEFAULT_MAX_WORDS = 32;
+const HEX_STAMP_PATTERN = /^[a-f0-9]{64}$/i;
+export class ExperienceStore {
+    outDir;
+    runsDir;
+    maxWords;
+    lockRetry;
+    now;
+    constructor(options = {}) {
+        this.outDir = options.outDir ?? join(process.cwd(), 'out');
+        this.runsDir = options.runsDir ?? join(process.cwd(), '.runs');
+        this.maxWords = Math.max(1, options.maxSummaryWords ?? DEFAULT_MAX_WORDS);
+        const defaults = {
+            maxAttempts: 5,
+            initialDelayMs: 100,
+            backoffFactor: 2,
+            maxDelayMs: 1000
+        };
+        const overrides = options.lockRetry ?? {};
+        const sanitizedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== undefined));
+        this.lockRetry = { ...defaults, ...sanitizedOverrides };
+        this.now = options.now ?? (() => new Date());
+    }
+    async recordBatch(inputs, manifestPath) {
+        if (inputs.length === 0) {
+            return [];
+        }
+        const taskIds = new Set(inputs.map((input) => input.taskId));
+        if (taskIds.size !== 1) {
+            throw new Error('Experience batches must target a single taskId.');
+        }
+        const taskId = sanitizeTaskId(inputs[0].taskId);
+        const lockPath = this.buildLockPath(taskId);
+        await this.acquireLock(taskId, lockPath);
+        try {
+            const targetDir = join(this.outDir, taskId);
+            await mkdir(targetDir, { recursive: true });
+            const filePath = join(targetDir, 'experiences.jsonl');
+            const existing = await this.readRecords(filePath);
+            const nextRecords = inputs.map((input) => this.prepareRecord(input, manifestPath));
+            const serialized = [...existing, ...nextRecords].map((record) => JSON.stringify(record)).join('\n');
+            await writeAtomicFile(filePath, `${serialized}\n`);
+            return nextRecords;
+        }
+        finally {
+            await this.releaseLock(lockPath);
+        }
+    }
+    async fetchTop(params) {
+        const safeDomain = params.domain.trim();
+        if (!safeDomain) {
+            return [];
+        }
+        const taskFilter = params.taskId ? sanitizeTaskId(params.taskId) : null;
+        const limit = Math.max(0, params.limit);
+        if (limit === 0) {
+            return [];
+        }
+        const allRecords = taskFilter
+            ? await this.readRecords(join(this.outDir, taskFilter, 'experiences.jsonl'))
+            : await this.readAllRecords();
+        const filtered = allRecords.filter((record) => {
+            if (record.domain !== safeDomain) {
+                return false;
+            }
+            if (taskFilter && record.taskId !== taskFilter) {
+                return false;
+            }
+            return true;
+        });
+        const scored = filtered
+            .map((record) => ({
+            record,
+            score: record.reward.gtScore + record.reward.relativeRank
+        }))
+            .filter((entry) => {
+            if (params.minReward === undefined) {
+                return true;
+            }
+            return entry.score >= params.minReward;
+        })
+            .sort((a, b) => {
+            if (b.score === a.score) {
+                return b.record.createdAt.localeCompare(a.record.createdAt);
+            }
+            return b.score - a.score;
+        });
+        return scored.slice(0, limit).map((entry) => entry.record);
+    }
+    verifyStamp(record) {
+        return HEX_STAMP_PATTERN.test(record.stampSignature);
+    }
+    prepareRecord(input, manifestPath) {
+        if (!HEX_STAMP_PATTERN.test(input.stampSignature)) {
+            throw new Error(`Experience stamp ${input.stampSignature} is not a valid SHA-256 digest`);
+        }
+        if (!input.domain || !input.domain.trim()) {
+            throw new Error('Experience domain cannot be empty.');
+        }
+        const summary32 = truncateSummary(input.summary, this.maxWords);
+        const reward = {
+            gtScore: Number.isFinite(input.reward.gtScore) ? input.reward.gtScore : 0,
+            relativeRank: Number.isFinite(input.reward.relativeRank) ? input.reward.relativeRank : 0
+        };
+        const toolStats = input.toolStats.map((stat) => ({
+            tool: stat.tool,
+            tokens: normalizeNumber(stat.tokens),
+            latencyMs: normalizeNumber(stat.latencyMs),
+            costUsd: normalizeNumber(stat.costUsd)
+        }));
+        return {
+            id: this.generateId(),
+            runId: input.runId,
+            taskId: sanitizeTaskId(input.taskId),
+            epoch: input.epoch ?? null,
+            groupId: input.groupId ?? null,
+            summary32,
+            reward,
+            toolStats,
+            stampSignature: input.stampSignature,
+            domain: input.domain.trim(),
+            createdAt: this.now().toISOString(),
+            manifestPath
+        };
+    }
+    buildLockPath(taskId) {
+        return join(this.runsDir, `${taskId}.experiences.lock`);
+    }
+    async acquireLock(taskId, lockPath) {
+        await acquireLockWithRetry({
+            taskId,
+            lockPath,
+            retry: this.lockRetry,
+            ensureDirectory: async () => {
+                await mkdir(this.runsDir, { recursive: true });
+            },
+            createError: (id, attempts) => new ExperienceStoreLockError(`Failed to acquire experience lock for ${id} after ${attempts} attempts`, id)
+        });
+    }
+    async releaseLock(lockPath) {
+        await rm(lockPath, { force: true });
+    }
+    async readRecords(filePath) {
+        try {
+            const raw = await readFile(filePath, 'utf8');
+            return raw
+                .split('\n')
+                .filter(Boolean)
+                .map((line) => JSON.parse(line));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async readAllRecords() {
+        const directories = await listDirectories(this.outDir);
+        const all = [];
+        for (const dir of directories) {
+            const filePath = join(this.outDir, dir, 'experiences.jsonl');
+            all.push(...(await this.readRecords(filePath)));
+        }
+        return all;
+    }
+    generateId() {
+        const suffix = randomBytes(3).toString('hex');
+        return `exp-${Date.now().toString(36)}-${suffix}`;
+    }
+}
+async function listDirectories(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function truncateSummary(value, maxWords) {
+    const tokens = value.trim().split(/\s+/u).filter(Boolean);
+    if (tokens.length <= maxWords) {
+        return tokens.join(' ');
+    }
+    return tokens.slice(0, maxWords).join(' ');
+}
+function normalizeNumber(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return value;
+}