@grayhaven/nerve-cli 0.1.0 → 0.2.1

package/dist/index.js

@@ -18,6 +18,30 @@ import {
   assemblyInstructions,
   boardSvg,
   bomCsv,
+  bopCsv,
+  bopJson,
+  analysisCsv,
+  analysisJson,
+  analyzeHarness,
+  builtinAdapters,
+  buildRecordJson,
+  contractJson,
+  createBuildRecord,
+  createRedline,
+  createRelease,
+  formboardSheets,
+  releaseJson,
+  ReleaseBlockedError,
+  resolveRedline,
+  suggestPatch,
+  validateRedlineTarget,
+  exportConnectorContract,
+  findAdapter,
+  generateQuote,
+  importPinoutCsv,
+  quoteCsv,
+  quoteJson,
+  validateContract,
   buildPacket,
   canRelease,
   cutListCsv,
@@ -92,9 +116,17 @@ Usage:
   nerve init [dir]
   nerve compile  <file.harness.ts> [--out dir]
   nerve validate <file.harness.ts>
-  nerve render   <file.harness.ts> [--format svg] [--view schematic|board] [--out dir]
+  nerve render   <file.harness.ts> [--format svg] [--view schematic|board|formboard] [--paper letter|a4] [--out dir]
   nerve export   <file.harness.ts> [--target manufacturing-packet|wireviz] [--out dir]
   nerve import   <file.yml> [--id harness-id] [--out dir]   (WireViz YAML \u2192 HIR)
+  nerve quote    <file.harness.ts> [--out dir]   (requires costing in nerve.config.ts)
+  nerve analyze  <file.harness.ts> [--out dir]   (resistance, drop, bundle, weight \xA734)
+  nerve machine  <adapter-id> <file.harness.ts> [--out dir]   (shop-floor exports \xA731)
+  nerve contract <file.harness.ts> --connector <ref> [--against contract.json|pinout.csv] [--out dir]
+  nerve release  <file.harness.ts> --eco <id> --reason <text> --date <iso> [--against release.json] [--out dir]
+  nerve record   <file.harness.ts> --release <release.json> --serial <sn> --operator <name> --date <iso> --results <measurements.json> [--out dir]
+  nerve redline  add <file.harness.ts> --target <hir-ref> --type <type> --description <text> [--value v] [--release id] [--serial sn]
+  nerve redline  resolve <redlines.json> --id <id> --accept|--reject --reason <text> --date <iso>
   nerve diff     <revA> <revB> [--json]   (each: harness.json, .harness.ts, or revision dir)
   nerve inspect  <harness.json>`;
 var loadHirForDiff = async (path, io) => {
@@ -150,13 +182,22 @@ var run = async (argv, io = realIo) => {
         return 2;
       }
       const view = flags["view"] ?? "schematic";
-      if (view !== "schematic" && view !== "board") {
-        io.err(`Unsupported render view: ${view} (supported: schematic, board)`);
+      if (view !== "schematic" && view !== "board" && view !== "formboard") {
+        io.err(`Unsupported render view: ${view} (supported: schematic, board, formboard)`);
         return 2;
       }
       const result = await compileOrExit(file, io);
       if (typeof result === "number") return result;
       const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+      if (view === "formboard") {
+        const paper = flags["paper"] === "a4" ? "a4" : "letter";
+        const board = formboardSheets(result.hir, { paper });
+        for (const sheet of board.sheets) writeOut(outDir, sheet.name, sheet.svg, io);
+        io.out(
+          `formboard ${board.boardWidthMm}x${board.boardHeightMm} mm \u2192 ${board.rows}x${board.cols} ${paper} sheet(s) at 1:1. Print at 100% and verify the calibration ruler.`
+        );
+        return 0;
+      }
       if (view === "board") {
         writeOut(outDir, "board.svg", boardSvg(result.hir), io);
       } else {
@@ -192,7 +233,10 @@ var run = async (argv, io = realIo) => {
       }
       const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
       const tolerance = result.config.defaultWireTolerance;
-      const options = tolerance !== void 0 ? { defaultWireTolerance: tolerance } : {};
+      const options = {
+        ...tolerance !== void 0 ? { defaultWireTolerance: tolerance } : {},
+        ...result.config.costing !== void 0 ? { costing: result.config.costing } : {}
+      };
       const plan = generateTestPlan(result.hir);
       writeOut(outDir, "harness.json", JSON.stringify(result.hir, null, 2) + "\n", io);
       writeOut(outDir, "schematic.svg", schematicSvg(result.hir), io);
@@ -200,9 +244,15 @@ var run = async (argv, io = realIo) => {
       writeOut(outDir, "bom.csv", bomCsv(result.hir), io);
       writeOut(outDir, "cut-list.csv", cutListCsv(result.hir, options), io);
       writeOut(outDir, "labels.csv", labelScheduleCsv(result.hir), io);
+      writeOut(outDir, "bop.csv", bopCsv(result.hir), io);
+      writeOut(outDir, "bop.json", bopJson(result.hir), io);
       writeOut(outDir, "tests.csv", testPlanCsv(plan), io);
       writeOut(outDir, "test-plan.json", testPlanJson(result.hir), io);
       writeOut(outDir, "assembly-instructions.txt", assemblyInstructions(result.hir), io);
+      if (result.config.costing !== void 0) {
+        writeOut(outDir, "quote.csv", quoteCsv(result.hir, result.config.costing), io);
+        writeOut(outDir, "quote.json", quoteJson(result.hir, result.config.costing), io);
+      }
       writeOut(outDir, "manufacturing-packet.pdf", await manufacturingPacketPdf(result.hir, options), io);
       writeOut(outDir, "manufacturing-packet.zip", (await buildPacket(result.hir, options)).zip, io);
       io.out(summarize(result.hir));
@@ -232,6 +282,233 @@ var run = async (argv, io = realIo) => {
       io.out(summarize(full));
       return hasErrors(diagnostics) ? 1 : 0;
     }
+    case "quote": {
+      const file = positional[0];
+      if (file === void 0) return usage(io);
+      const result = await compileOrExit(file, io);
+      if (typeof result === "number") return result;
+      const model = result.config.costing;
+      if (model === void 0) {
+        io.err("No costing model: add `costing: { laborRatePerHour, ... }` to nerve.config.ts (PRD \xA729).");
+        return 2;
+      }
+      const quote = generateQuote(result.hir, model);
+      const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+      writeOut(outDir, "quote.csv", quoteCsv(result.hir, model), io);
+      writeOut(outDir, "quote.json", quoteJson(result.hir, model), io);
+      io.out(
+        `${quote.harness.id} rev ${quote.harness.revision} \u2014 material ${quote.materialCost.toFixed(2)} + scrap ${quote.scrapCost.toFixed(2)} + labor ${quote.laborCost.toFixed(2)} = ${quote.totalCost.toFixed(2)} ${quote.currency} (${quote.perUnitCost.toFixed(2)}/unit @ ${(quote.assumptions.yield * 100).toFixed(0)}% yield)`
+      );
+      for (const mpn of quote.longLeadItems) io.out(`LONG-LEAD: ${mpn}`);
+      for (const mpn of quote.lifecycleRisks) io.out(`LIFECYCLE: ${mpn}`);
+      for (const item of quote.unpricedItems) io.out(`UNPRICED: ${item}`);
+      return 0;
+    }
+    case "analyze": {
+      const file = positional[0];
+      if (file === void 0) return usage(io);
+      const result = await compileOrExit(file, io);
+      if (typeof result === "number") return result;
+      const report = analyzeHarness(result.hir);
+      const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+      writeOut(outDir, "analysis.csv", analysisCsv(result.hir), io);
+      writeOut(outDir, "analysis.json", analysisJson(result.hir), io);
+      io.out(
+        `${report.harness.id} rev ${report.harness.revision} \u2014 ${report.totals.wireLengthM} m wire, ~${report.totals.estimatedWeightG} g, ${report.branches.map((b) => `${b.id}: \xD8${b.bundleDiameterMm}mm`).join(", ")}`
+      );
+      return 0;
+    }
+    case "machine": {
+      const [adapterId, file] = positional;
+      if (adapterId === void 0 || file === void 0) return usage(io);
+      const adapter = findAdapter(adapterId);
+      if (adapter === void 0) {
+        io.err(`Unknown adapter: ${adapterId}. Available: ${builtinAdapters.map((a) => a.id).join(", ")}`);
+        return 2;
+      }
+      const result = await compileOrExit(file, io);
+      if (typeof result === "number") return result;
+      const { files, diagnostics } = adapter.generate(result.hir);
+      printDiagnostics(diagnostics, io);
+      if (hasErrors(diagnostics)) return 1;
+      const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+      for (const [name, contents] of files) writeOut(outDir, name, contents, io);
+      return 0;
+    }
+    case "contract": {
+      const file = positional[0];
+      const connectorRef = flags["connector"];
+      if (file === void 0 || connectorRef === void 0) return usage(io);
+      const result = await compileOrExit(file, io);
+      if (typeof result === "number") return result;
+      const against = flags["against"];
+      if (against !== void 0) {
+        let contract2;
+        try {
+          const raw = readFileSync(resolve(against), "utf8");
+          contract2 = against.endsWith(".csv") ? importPinoutCsv(raw, { connector: connectorRef }) : JSON.parse(raw);
+        } catch (cause) {
+          io.err(`Failed to load contract ${against}: ${cause instanceof Error ? cause.message : String(cause)}`);
+          return 2;
+        }
+        const diagnostics = validateContract(result.hir, contract2);
+        printDiagnostics(diagnostics, io);
+        io.out(
+          diagnostics.length === 0 ? `Connector ${connectorRef} conforms to ${against}.` : `${diagnostics.length} contract issue(s) for ${connectorRef}.`
+        );
+        return hasErrors(diagnostics) ? 1 : 0;
+      }
+      const contract = exportConnectorContract(result.hir, connectorRef);
+      if (contract === void 0) {
+        io.err(`Connector ${connectorRef} not found in ${result.hir.harness.id}.`);
+        return 2;
+      }
+      const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+      writeOut(outDir, `contract-${connectorRef}.json`, contractJson(contract), io);
+      return 0;
+    }
+    case "release": {
+      const file = positional[0];
+      const eco = flags["eco"];
+      const reason = flags["reason"];
+      const date = flags["date"];
+      if (file === void 0 || eco === void 0 || reason === void 0 || date === void 0) return usage(io);
+      const result = await compileOrExit(file, io);
+      if (typeof result === "number") return result;
+      let previous;
+      if (flags["against"] !== void 0) {
+        try {
+          const prevRelease = JSON.parse(readFileSync(resolve(flags["against"]), "utf8"));
+          const prevDir = resolve(flags["against"], "..");
+          const prevHir = decodeHir(JSON.parse(readFileSync(join(prevDir, "harness.json"), "utf8")));
+          previous = { hir: prevHir, releaseId: prevRelease.releaseId };
+        } catch (cause) {
+          io.err(`Failed to load previous release: ${cause instanceof Error ? cause.message : String(cause)}`);
+          return 2;
+        }
+      }
+      try {
+        const release = createRelease(result.hir, {
+          eco: { id: eco, reason, ...flags["author"] !== void 0 ? { author: flags["author"] } : {} },
+          createdAt: date,
+          ...previous !== void 0 ? { previous } : {}
+        });
+        const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+        writeOut(outDir, "harness.json", JSON.stringify(result.hir, null, 2) + "\n", io);
+        writeOut(outDir, `release-${result.hir.harness.revision}.json`, releaseJson(release), io);
+        io.out(
+          `Release ${release.releaseId} (${eco}) \u2014 fingerprint ${release.hirFingerprint}` + (release.impact !== void 0 ? ` \u2014 impact: ${release.impact.riskScore} (${release.impact.risk}), ${release.impact.pinoutChanges} pinout / ${release.impact.wireChanges} wire change(s)` : "")
+        );
+        return 0;
+      } catch (cause) {
+        if (cause instanceof ReleaseBlockedError) {
+          io.err(cause.message);
+          return 1;
+        }
+        throw cause;
+      }
+    }
+    case "record": {
+      const file = positional[0];
+      const releasePath = flags["release"];
+      const serial = flags["serial"];
+      const operator = flags["operator"];
+      const date = flags["date"];
+      const resultsPath = flags["results"];
+      if (file === void 0 || releasePath === void 0 || serial === void 0 || operator === void 0 || date === void 0 || resultsPath === void 0) {
+        return usage(io);
+      }
+      const result = await compileOrExit(file, io);
+      if (typeof result === "number") return result;
+      let release, measurements;
+      try {
+        release = JSON.parse(readFileSync(resolve(releasePath), "utf8"));
+        measurements = JSON.parse(readFileSync(resolve(resultsPath), "utf8"));
+      } catch (cause) {
+        io.err(`Failed to load inputs: ${cause instanceof Error ? cause.message : String(cause)}`);
+        return 2;
+      }
+      const record = createBuildRecord(result.hir, release, measurements, {
+        serial,
+        operator,
+        buildDate: date,
+        ...flags["lot"] !== void 0 ? { lot: flags["lot"] } : {},
+        ...flags["workstation"] !== void 0 ? { workstation: flags["workstation"] } : {}
+      });
+      const outDir = resolve(flags["out"] ?? result.config.outputDir ?? "dist");
+      writeOut(outDir, `build-record-${serial}.json`, buildRecordJson(record), io);
+      io.out(
+        `${serial}: ${record.summary.pass} pass / ${record.summary.fail} fail / ${record.summary.notRun} not run \u2192 ${record.summary.status.toUpperCase()}`
+      );
+      return record.summary.status === "fail" ? 1 : 0;
+    }
+    case "redline": {
+      const sub = positional[0];
+      if (sub === "add") {
+        const file = positional[1];
+        const target = flags["target"];
+        const type = flags["type"];
+        const description = flags["description"];
+        if (file === void 0 || target === void 0 || type === void 0 || description === void 0) return usage(io);
+        const result = await compileOrExit(file, io);
+        if (typeof result === "number") return result;
+        const invalid = validateRedlineTarget(result.hir, target);
+        if (invalid !== void 0) {
+          printDiagnostics([invalid], io);
+          return 1;
+        }
+        const redlinesPath = resolve(flags["file"] ?? "redlines.json");
+        const existing = existsSync(redlinesPath) ? JSON.parse(readFileSync(redlinesPath, "utf8")) : [];
+        const redline = createRedline({
+          id: `RL-${String(existing.length + 1).padStart(3, "0")}`,
+          target,
+          type,
+          description,
+          ...flags["value"] !== void 0 ? { proposedValue: flags["value"] } : {},
+          release: flags["release"] ?? `${result.hir.harness.id}@${result.hir.harness.revision}`,
+          ...flags["serial"] !== void 0 ? { serial: flags["serial"] } : {},
+          ...flags["by"] !== void 0 ? { reportedBy: flags["by"] } : {}
+        });
+        writeFileSync(redlinesPath, JSON.stringify([...existing, redline], null, 2) + "\n");
+        io.out(`Recorded ${redline.id} against ${target} in ${redlinesPath}`);
+        return 0;
+      }
+      if (sub === "resolve") {
+        const redlinesPath = positional[1];
+        const id = flags["id"];
+        const reason = flags["reason"];
+        const date = flags["date"];
+        const accept = flags["accept"] === "true";
+        const reject = flags["reject"] === "true";
+        if (redlinesPath === void 0 || id === void 0 || reason === void 0 || date === void 0 || accept === reject) return usage(io);
+        const redlines = JSON.parse(readFileSync(resolve(redlinesPath), "utf8"));
+        const existing = redlines.find((r) => r.id === id);
+        const index = redlines.findIndex((r) => r.id === id);
+        if (existing === void 0) {
+          io.err(`Redline ${id} not found in ${redlinesPath}.`);
+          return 2;
+        }
+        const resolved = resolveRedline(existing, {
+          accept,
+          reason,
+          resolvedAt: date,
+          ...flags["by"] !== void 0 ? { by: flags["by"] } : {}
+        });
+        const updated = [...redlines];
+        updated[index] = resolved;
+        writeFileSync(resolve(redlinesPath), JSON.stringify(updated, null, 2) + "\n");
+        io.out(`${id} ${resolved.status}.`);
+        if (resolved.status === "accepted") {
+          const patch = suggestPatch(resolved);
+          if (patch !== void 0) {
+            io.out("Structured patch (apply via variant() or edit the source):");
+            io.out(JSON.stringify(patch, null, 2));
+          }
+        }
+        return 0;
+      }
+      return usage(io);
+    }
     case "diff": {
       const [pathA, pathB] = positional;
       if (pathA === void 0 || pathB === void 0) return usage(io);

package/package.json

@@ -1,47 +1,50 @@
 {
   "name": "@grayhaven/nerve-cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Grayhaven Nerve CLI: compile, validate, render, and export harnesses locally and in CI.",
   "bin": {
     "nerve": "./bin/nerve.js"
   },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+    ".": "./src/index.ts"
   },
   "dependencies": {
+    "@grayhaven/nerve": "0.2.0",
+    "@grayhaven/nerve-compiler": "0.2.0",
+    "@grayhaven/nerve-exporters": "0.2.0",
+    "@grayhaven/nerve-wireviz": "0.2.0",
     "effect": "^3.16.0",
-    "jiti": "^2.4.2",
-    "@grayhaven/nerve-exporters": "0.1.0",
-    "@grayhaven/nerve": "0.1.0",
-    "@grayhaven/nerve-wireviz": "0.1.0",
-    "@grayhaven/nerve-compiler": "0.1.0"
+    "jiti": "^2.4.2"
   },
   "devDependencies": {
+    "@grayhaven/nerve-connectors": "0.2.0",
     "@types/node": "^25.9.2",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.4",
-    "@grayhaven/nerve-connectors": "0.1.0"
+    "vitest": "^3.2.4"
   },
   "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  },
   "files": [
     "dist"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tylergibbs1/nerve.git",
     "directory": "packages/nerve-cli"
   },
-  "homepage": "https://github.com/tylergibbs1/nerve#readme",
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts"
-}
+  "homepage": "https://github.com/tylergibbs1/nerve#readme"
+}

package/LICENSE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.