akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/workflows/source-files.js

@@ -0,0 +1,373 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Authoritative workflow-source ownership.
+ *
+ * Markdown and the bounded GitHub-shaped YAML subset are peer authoring
+ * formats, but one canonical workflow ref must have exactly one source file.
+ * This module is the shared filesystem arbitration point used before indexing,
+ * cache reuse, lookup/show, and runtime load/start. It never chooses one
+ * extension by priority: two recognized siblings are a hard collision.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { UsageError } from "../core/errors.js";
+import { canonicalizeWorkflowName, WORKFLOW_EXTENSIONS } from "../core/recognition-util.js";
+export class WorkflowSourceRejectionError extends UsageError {
+    sourcePaths;
+    constructor(message, code, sourcePaths) {
+        super(message, code);
+        this.sourcePaths = [...sourcePaths].sort(comparePaths);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourceCollisionError extends WorkflowSourceRejectionError {
+    canonicalName;
+    constructor(canonicalName, sourcePaths) {
+        const sorted = [...sourcePaths].sort(comparePaths);
+        super(`Workflow "${canonicalName}" resolves to multiple workflow source files: ${sorted.join(", ")}. ` +
+            "A canonical workflow ref must be owned by exactly one recognized .md or .yml source; remove or rename the duplicate.", "RESOURCE_ALREADY_EXISTS", sorted);
+        this.name = "WorkflowSourceCollisionError";
+        this.canonicalName = canonicalName;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourceDomainError extends WorkflowSourceRejectionError {
+    canonicalName;
+    constructor(canonicalName, sourcePaths, issues, collidingSourcePaths) {
+        const sortedPaths = [...sourcePaths].sort(comparePaths);
+        const sortedCollisions = [...collidingSourcePaths].sort(comparePaths);
+        const code = issues.some((issue) => issue.code === "PATH_ESCAPE_VIOLATION")
+            ? "PATH_ESCAPE_VIOLATION"
+            : "INVALID_FLAG_VALUE";
+        const collisionDetail = sortedCollisions.length > 1 ? ` Valid owners also collide: ${sortedCollisions.join(", ")}.` : "";
+        super(`Workflow "${canonicalName}" has an invalid source ownership domain across candidates: ${sortedPaths.join(", ")}. ` +
+            `Problems: ${issues.map((issue) => issue.message).join(" ")}${collisionDetail} ` +
+            "Every candidate in the canonical domain is rejected until all invalid or duplicate sources are removed.", code, sortedPaths);
+        this.name = "WorkflowSourceDomainError";
+        this.canonicalName = canonicalName;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourceIdentityError extends UsageError {
+    constructor(ref, indexedPath, authoritativePath) {
+        super(`Indexed workflow source identity for "${ref}" points to ${indexedPath}, but the authoritative source is ${authoritativePath}. ` +
+            "Refusing the stale index/cache identity; run `akm index --full` to reconcile it.", "INVALID_FLAG_VALUE");
+        this.name = "WorkflowSourceIdentityError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourceNameError extends WorkflowSourceRejectionError {
+    constructor(sourcePath, nestedSuffix) {
+        super(`Workflow source filename ${sourcePath} has an extensionless stem ending in recognized workflow suffix "${nestedSuffix}". ` +
+            "Nested workflow suffixes are invalid; remove the inner .md or .yml suffix instead of relying on repeated stripping.", "INVALID_FLAG_VALUE", [sourcePath]);
+        this.name = "WorkflowSourceNameError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourceLinkIdentityError extends WorkflowSourceRejectionError {
+    constructor(sourcePath, targetPath) {
+        super(`Workflow source ${sourcePath} resolves through a symlink to ${targetPath} with a different source format. ` +
+            "The authored workflow path and resolved source must use the same .md or .yml format.", "INVALID_FLAG_VALUE", [sourcePath]);
+        this.name = "WorkflowSourceLinkIdentityError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourceLinkResolutionError extends WorkflowSourceRejectionError {
+    constructor(sourcePath) {
+        super(`Workflow source symlink ${sourcePath} cannot be resolved to a regular file.`, "INVALID_FLAG_VALUE", [
+            sourcePath,
+        ]);
+        this.name = "WorkflowSourceLinkResolutionError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class WorkflowSourcePathIdentityError extends WorkflowSourceRejectionError {
+    constructor(sourcePath, targetPath) {
+        super(`Workflow source ${sourcePath} resolves outside the bundle root to ${targetPath}.`, "PATH_ESCAPE_VIOLATION", [
+            sourcePath,
+        ]);
+        this.name = "WorkflowSourcePathIdentityError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/** Convert an adapter-owned concept id into its extensionless workflow name. */
+export function workflowNameForConceptId(adapterId, conceptId) {
+    if (adapterId === "akm-workflow")
+        return conceptId;
+    if (adapterId !== "akm")
+        return undefined;
+    const prefix = "workflows/";
+    if (!conceptId.startsWith(prefix) || conceptId.length === prefix.length)
+        return undefined;
+    return conceptId.slice(prefix.length);
+}
+/** Derive the once-canonicalizable workflow name from an adapter-owned authored path. */
+export function workflowNameForSourcePath(sourceRoot, adapterId, sourcePath) {
+    if (adapterId !== "akm" && adapterId !== "akm-workflow")
+        return undefined;
+    const relativePath = toPosix(path.relative(path.resolve(sourceRoot), path.resolve(sourcePath)));
+    if (!isSafeRelativeName(relativePath))
+        return undefined;
+    const ownedPath = adapterId === "akm" ? relativePath.replace(/^workflows\//, "") : relativePath;
+    if (adapterId === "akm" && ownedPath === relativePath)
+        return undefined;
+    const extension = path.posix.extname(ownedPath);
+    if (!WORKFLOW_EXTENSIONS.includes(extension.toLowerCase()))
+        return undefined;
+    return ownedPath;
+}
+/**
+ * Enumerate every owned source path that maps to `name` under one component.
+ * Ownership is decided before parsing so a malformed peer cannot be hidden by
+ * a valid source. Results retain authored extension case for diagnostics.
+ */
+export function listWorkflowSourceFiles(sourceRoot, adapterId, name) {
+    if (adapterId !== "akm" && adapterId !== "akm-workflow")
+        return [];
+    const canonicalName = canonicalizeWorkflowName(normalizeName(name));
+    if (!isSafeRelativeName(canonicalName)) {
+        throw new UsageError("Workflow ref resolves outside the bundle root.", "PATH_ESCAPE_VIOLATION");
+    }
+    let realRoot;
+    const authoredRoot = path.resolve(sourceRoot);
+    try {
+        realRoot = fs.realpathSync(authoredRoot);
+    }
+    catch {
+        return [];
+    }
+    const ownershipRoot = adapterId === "akm" ? path.join(authoredRoot, "workflows") : authoredRoot;
+    const parent = path.join(ownershipRoot, path.dirname(canonicalName));
+    if (!isWithinResolved(parent, authoredRoot)) {
+        throw new UsageError("Workflow ref resolves outside the bundle root.", "PATH_ESCAPE_VIOLATION");
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const basename = path.basename(canonicalName);
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            continue;
+        const extension = path.extname(entry.name);
+        const lowerExtension = extension.toLowerCase();
+        if (!WORKFLOW_EXTENSIONS.includes(lowerExtension))
+            continue;
+        if (entry.name.slice(0, -extension.length) !== basename)
+            continue;
+        const candidatePath = path.join(parent, entry.name);
+        candidates.push({
+            path: candidatePath,
+            relativePath: toPosix(path.relative(authoredRoot, candidatePath)),
+            lowerExtension,
+            extensionlessStem: entry.name.slice(0, -extension.length),
+        });
+    }
+    candidates.sort((left, right) => comparePaths(left.relativePath, right.relativePath));
+    const { sources, issues } = inspectWorkflowSourceDomain(candidates, canonicalName, realRoot);
+    if (issues.length > 0) {
+        throw workflowSourceDomainError(adapterId, canonicalName, candidates, sources, issues);
+    }
+    return sources;
+}
+/**
+ * Resolve a pre-enumerated set of authored workflow candidates in one batch.
+ *
+ * Callers that already walked a component (for example full lint/index scans)
+ * must use this surface instead of point-resolving every canonical ref and
+ * re-reading the same parent directory once per workflow. Candidate
+ * inspection, symlink containment/format rules, nested-suffix rejection, and
+ * collision construction remain shared with {@link listWorkflowSourceFiles}.
+ */
+export function resolveWorkflowSourceDomains(sourceRoot, adapterId, sourcePaths) {
+    if (adapterId !== "akm" && adapterId !== "akm-workflow")
+        return [];
+    const authoredRoot = path.resolve(sourceRoot);
+    let realRoot;
+    try {
+        realRoot = fs.realpathSync(authoredRoot);
+    }
+    catch {
+        return [];
+    }
+    const candidatesByName = new Map();
+    const seenAuthoredPaths = new Set();
+    for (const sourcePath of sourcePaths) {
+        // A full walk can legitimately feed the same authored file through more
+        // than one lexical spelling (or a caller may repeat it verbatim). Collapse
+        // only the normalized AUTHORED path here: distinct symlink/case-variant
+        // paths must remain separate ownership candidates even when they resolve to
+        // the same physical inode.
+        const normalizedSourcePath = path.resolve(sourcePath);
+        if (seenAuthoredPaths.has(normalizedSourcePath))
+            continue;
+        seenAuthoredPaths.add(normalizedSourcePath);
+        const authoredName = workflowNameForSourcePath(authoredRoot, adapterId, normalizedSourcePath);
+        if (authoredName === undefined)
+            continue;
+        const canonicalName = canonicalizeWorkflowName(authoredName);
+        if (!isSafeRelativeName(canonicalName))
+            continue;
+        const extension = path.extname(normalizedSourcePath);
+        const lowerExtension = extension.toLowerCase();
+        if (!WORKFLOW_EXTENSIONS.includes(lowerExtension))
+            continue;
+        const candidate = {
+            path: normalizedSourcePath,
+            relativePath: toPosix(path.relative(authoredRoot, normalizedSourcePath)),
+            lowerExtension,
+            extensionlessStem: path.basename(normalizedSourcePath).slice(0, -extension.length),
+        };
+        const domain = candidatesByName.get(canonicalName) ?? [];
+        domain.push(candidate);
+        candidatesByName.set(canonicalName, domain);
+    }
+    const resolutions = [];
+    for (const canonicalName of [...candidatesByName.keys()].sort(comparePaths)) {
+        const candidates = candidatesByName.get(canonicalName) ?? [];
+        candidates.sort((left, right) => comparePaths(left.relativePath, right.relativePath));
+        const { sources, issues } = inspectWorkflowSourceDomain(candidates, canonicalName, realRoot);
+        const sourcePaths = candidates.map((candidate) => candidate.relativePath);
+        if (issues.length > 0) {
+            resolutions.push({
+                canonicalName,
+                sourcePaths,
+                rejection: workflowSourceDomainError(adapterId, canonicalName, candidates, sources, issues),
+            });
+            continue;
+        }
+        if (sources.length > 1) {
+            resolutions.push({
+                canonicalName,
+                sourcePaths,
+                rejection: new WorkflowSourceCollisionError(adapterId === "akm" ? `workflows/${canonicalName}` : canonicalName, sources.map((source) => source.relativePath)),
+            });
+            continue;
+        }
+        resolutions.push({ canonicalName, sourcePaths, source: sources[0] });
+    }
+    return resolutions;
+}
+function inspectWorkflowSourceDomain(candidates, canonicalName, realRoot) {
+    const sources = [];
+    const issues = [];
+    for (const candidate of candidates) {
+        const inspection = inspectWorkflowSourceCandidate(candidate, canonicalName, realRoot);
+        if (inspection.source)
+            sources.push(inspection.source);
+        issues.push(...inspection.issues);
+    }
+    return { sources, issues };
+}
+function workflowSourceDomainError(adapterId, canonicalName, candidates, sources, issues) {
+    return new WorkflowSourceDomainError(adapterId === "akm" ? `workflows/${canonicalName}` : canonicalName, candidates.map((candidate) => candidate.relativePath), issues, sources.map((source) => source.relativePath));
+}
+function inspectWorkflowSourceCandidate(candidate, canonicalName, realRoot) {
+    const issues = [];
+    const nestedSuffix = WORKFLOW_EXTENSIONS.find((suffix) => candidate.extensionlessStem.toLowerCase().endsWith(suffix));
+    if (nestedSuffix)
+        issues.push(new WorkflowSourceNameError(candidate.relativePath, nestedSuffix));
+    let authoredStat;
+    try {
+        authoredStat = fs.lstatSync(candidate.path);
+    }
+    catch {
+        issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
+        return { issues };
+    }
+    const isLink = authoredStat.isSymbolicLink();
+    if (!isLink && !authoredStat.isFile()) {
+        issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
+        return { issues };
+    }
+    let realPath;
+    try {
+        realPath = fs.realpathSync(candidate.path);
+    }
+    catch {
+        issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
+        return { issues };
+    }
+    const targetPath = toPosix(path.relative(realRoot, realPath));
+    const contained = isWithinResolved(realPath, realRoot);
+    if (!contained)
+        issues.push(new WorkflowSourcePathIdentityError(candidate.relativePath, targetPath));
+    if (isLink && path.extname(realPath).toLowerCase() !== candidate.lowerExtension) {
+        issues.push(new WorkflowSourceLinkIdentityError(candidate.relativePath, targetPath));
+    }
+    if (contained) {
+        try {
+            if (!fs.statSync(realPath).isFile())
+                issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
+        }
+        catch {
+            issues.push(new WorkflowSourceLinkResolutionError(candidate.relativePath));
+        }
+    }
+    if (issues.length > 0)
+        return { issues };
+    return {
+        issues,
+        source: {
+            path: candidate.path,
+            realPath,
+            relativePath: candidate.relativePath,
+            canonicalName,
+            format: candidate.lowerExtension === ".md" ? "markdown" : "github-yaml",
+        },
+    };
+}
+/** Return the sole owner, throw on a collision, or return undefined when absent. */
+export function resolveUniqueWorkflowSource(sourceRoot, adapterId, name) {
+    const sources = listWorkflowSourceFiles(sourceRoot, adapterId, name);
+    if (sources.length > 1) {
+        const canonicalName = sources[0]?.canonicalName ?? canonicalizeWorkflowName(normalizeName(name));
+        throw new WorkflowSourceCollisionError(adapterId === "akm" ? `workflows/${canonicalName}` : canonicalName, sources.map((source) => source.relativePath));
+    }
+    return sources[0];
+}
+/** Compare an indexed path with the single authoritative on-disk source. */
+export function assertIndexedWorkflowSourceIdentity(ref, indexedPath, authoritative) {
+    let indexedRealPath;
+    try {
+        indexedRealPath = fs.realpathSync(indexedPath);
+    }
+    catch {
+        throw new WorkflowSourceIdentityError(ref, indexedPath, authoritative.path);
+    }
+    if (path.resolve(indexedPath) !== path.resolve(authoritative.path) ||
+        path.resolve(indexedRealPath) !== path.resolve(authoritative.realPath)) {
+        throw new WorkflowSourceIdentityError(ref, indexedPath, authoritative.path);
+    }
+    const indexedExtension = path.extname(indexedPath).toLowerCase();
+    const authoritativeExtension = authoritative.format === "markdown" ? ".md" : ".yml";
+    if (indexedExtension !== authoritativeExtension) {
+        throw new WorkflowSourceIdentityError(ref, indexedPath, authoritative.path);
+    }
+}
+function normalizeName(name) {
+    return name.replaceAll("\\", "/");
+}
+function isSafeRelativeName(name) {
+    return (name.length > 0 &&
+        !path.posix.isAbsolute(name) &&
+        name !== ".." &&
+        !name.startsWith("../") &&
+        path.posix.normalize(name) === name);
+}
+function isWithinResolved(candidate, root) {
+    const relative = path.relative(root, path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function toPosix(value) {
+    return value.replaceAll("\\", "/");
+}
+function comparePaths(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/workflows/source-ir/compile.js

@@ -0,0 +1,196 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import path from "node:path";
+import { parseFrontmatterBlock } from "../../core/asset/frontmatter.js";
+import { classifyTaskV3Triggers, classifyTaskV3Uses } from "../../tasks/source-v3.js";
+import { parseWorkflow } from "../parser.js";
+import { projectExecCore } from "../program/schema.js";
+import { parseGithubWorkflowSource } from "./github-yaml.js";
+import { sourceFailureResult, WorkflowSourceFailure } from "./result.js";
+import { decodeWorkflowSourceIrV1, } from "./schema.js";
+import { canonicalizeWorkflowWorkingDirectory, WorkflowSourceSemanticError } from "./semantics.js";
+export { looksLikeGithubWorkflowSource } from "./github-yaml.js";
+export function compileGithubWorkflowSource(source, options) {
+    try {
+        return {
+            ok: true,
+            ir: decodeWorkflowSourceIrV1(parseGithubWorkflowSource(source, {
+                ...options,
+                classifyUses: options.classifyUses ?? classifyTaskV3Uses,
+                classifyTriggers: options.classifyTriggers ?? classifyTaskV3Triggers,
+            }), {
+                workspaceRoot: options.workspaceRoot,
+            }),
+        };
+    }
+    catch (cause) {
+        return sourceFailureResult(cause, options.path);
+    }
+}
+export function compileMarkdownWorkflowSource(source, options) {
+    const parsed = parseWorkflow(source, {
+        path: options.path,
+        validateExecCwd: (value) => {
+            try {
+                return { ok: true, value: canonicalizeWorkflowWorkingDirectory(value, options.workspaceRoot) };
+            }
+            catch (cause) {
+                if (cause instanceof WorkflowSourceSemanticError) {
+                    return { ok: false, code: cause.code, message: cause.message };
+                }
+                return {
+                    ok: false,
+                    code: "working-directory-unverifiable",
+                    message: cause instanceof Error ? cause.message : "working-directory cannot be physically verified.",
+                };
+            }
+        },
+    });
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            errors: parsed.errors.map((error) => ({
+                code: error.code ?? "invalid-markdown-workflow",
+                message: error.message,
+                path: options.path,
+                line: error.line,
+            })),
+        };
+    }
+    try {
+        const sourceSpan = wholeSourceSpan(source, options.path);
+        const steps = parsed.document.steps.map((step) => markdownStep(step, options.path));
+        const ir = {
+            sourceIrVersion: 1,
+            name: markdownName(source, options.path),
+            ...(parsed.document.description ? { description: parsed.document.description } : {}),
+            ...(parsed.document.tags ? { tags: [...parsed.document.tags] } : {}),
+            ...(parsed.document.params ? { params: jsonClone(parsed.document.params) } : {}),
+            ...(parsed.document.defaults
+                ? { defaults: jsonClone(parsed.document.defaults) }
+                : {}),
+            ...(parsed.document.budget ? { budget: jsonClone(parsed.document.budget) } : {}),
+            ...(parsed.document.preamble ? { preamble: parsed.document.preamble } : {}),
+            triggers: [{ kind: "workflow_dispatch", source: sourceSpan }],
+            jobs: [
+                {
+                    id: "contract",
+                    needs: [],
+                    steps,
+                    source: sourceSpan,
+                },
+            ],
+            extensions: {
+                "akm.dev/workflow-markdown": jsonExtension({
+                    workflowSchemaVersion: parsed.document.schemaVersion,
+                }),
+            },
+            source: sourceSpan,
+        };
+        return {
+            ok: true,
+            ir: decodeWorkflowSourceIrV1(ir, { workspaceRoot: options.workspaceRoot }),
+        };
+    }
+    catch (cause) {
+        return sourceFailureResult(cause, options.path);
+    }
+}
+/** Compile by authoritative source extension without rewriting either format. */
+export function compileWorkflowSource(source, options) {
+    const extension = path.extname(options.path).toLowerCase();
+    if (extension === ".md")
+        return compileMarkdownWorkflowSource(source, options);
+    if (extension === ".yml")
+        return compileGithubWorkflowSource(source, options);
+    return {
+        ok: false,
+        errors: [
+            {
+                code: "unsupported-workflow-extension",
+                message: `Workflow source ${options.path} must use .md or .yml.`,
+                path: options.path,
+                line: 1,
+            },
+        ],
+    };
+}
+function markdownStep(step, filePath) {
+    const source = step.source ?? { path: filePath, start: 1, end: 1 };
+    const dispatchUnit = step.map?.unit ?? step.unit;
+    const unit = markdownUnit(dispatchUnit);
+    const common = {
+        id: step.id,
+        ...(unit ? { unit } : {}),
+        ...(step.map
+            ? {
+                map: {
+                    over: step.map.over,
+                    ...(step.map.concurrency !== undefined ? { concurrency: step.map.concurrency } : {}),
+                    ...(step.map.reducer !== undefined ? { reducer: step.map.reducer } : {}),
+                },
+            }
+            : {}),
+        ...(step.route ? { route: jsonClone(step.route) } : {}),
+        ...(step.inputs ? { inputs: [...step.inputs] } : {}),
+        ...(step.output ? { output: jsonClone(step.output) } : {}),
+        ...(step.gate || step.gateRubric
+            ? {
+                gate: {
+                    ...(step.gate?.maxLoops !== undefined ? { maxLoops: step.gate.maxLoops } : {}),
+                    ...(step.gateRubric?.text.trim() ? { rubric: step.gateRubric.text } : {}),
+                },
+            }
+            : {}),
+        source,
+    };
+    if (step.route) {
+        return {
+            ...common,
+            ...(step.instructions?.text.trim() ? { instructions: step.instructions.text } : {}),
+        };
+    }
+    if (dispatchUnit?.exec) {
+        return {
+            ...common,
+            exec: projectExecCore(dispatchUnit.exec),
+            ...(step.instructions?.text.trim() ? { instructions: step.instructions.text } : {}),
+        };
+    }
+    const content = step.instructions?.text ?? "";
+    if (content.trim() === "") {
+        throw new WorkflowSourceFailure("markdown-command-content-required", `Markdown step ${JSON.stringify(step.id)} has no executable command content.`, source);
+    }
+    return {
+        ...common,
+        uses: "akm/command",
+        commandMode: "literal",
+        with: { content },
+    };
+}
+function markdownUnit(value) {
+    if (!value)
+        return undefined;
+    const { exec: _exec, source: _source, ...unit } = value;
+    return Object.keys(unit).length > 0
+        ? jsonClone(unit)
+        : undefined;
+}
+function markdownName(source, filePath) {
+    const block = parseFrontmatterBlock(source);
+    const body = block?.content ?? source;
+    const title = body.match(/^#\s+(.+?)\s*$/m)?.[1]?.trim();
+    if (title)
+        return title;
+    return path.basename(filePath, path.extname(filePath));
+}
+function wholeSourceSpan(source, filePath) {
+    return { path: filePath, start: 1, end: Math.max(1, source.split(/\r?\n/).length) };
+}
+function jsonClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function jsonExtension(value) {
+    return JSON.parse(JSON.stringify(value));
+}