@glion/lint-profile-segment-order 0.0.0-stage → 0.21.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Rethink Health
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,198 @@
-# Temporary Holding Version
+# @glion/lint-profile-segment-order
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lint rule that validates HL7v2 segment order against the event schema defined by the profile.
+
+## What it does
+
+Walks the parsed tree segment-by-segment, feeding each segment name to a runner over the event schema from `@glion/profiles`. Reports one message for the first segment that is not valid at its position, or for a message that ends before the schema is complete. When no `definition` is given, the rule resolves the schema from MSH-9 and MSH-12.
+
+## Install
+
+```bash
+npm install @glion/lint-profile-segment-order
+```
+
+## Use
+
+```ts
+import { hl7v2Parser } from "@glion/parser";
+import hl7v2LintSegmentOrder from "@glion/lint-profile-segment-order";
+import { unified } from "unified";
+import { reporter } from "vfile-reporter";
+
+const message = [
+  "MSH|^~\\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5",
+  "EVN|A01|20250601120000",
+  "PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F",
+].join("\r");
+
+const file = await unified()
+  .use(hl7v2Parser)
+  .use(hl7v2LintSegmentOrder)
+  .process(message);
+
+console.error(reporter([file]));
+```
+
+With an event schema of your own:
+
+```ts
+import hl7v2LintSegmentOrder from "@glion/lint-profile-segment-order";
+import type { EventSchema } from "@glion/profiles";
+import { unified } from "unified";
+
+const ADT_A01_SITE: EventSchema = {
+  id: "ADT_A01_SITE",
+  elements: [
+    { type: "segment", name: "MSH", optional: false, repeating: false },
+    { type: "segment", name: "EVN", optional: false, repeating: false },
+    { type: "segment", name: "PID", optional: false, repeating: false },
+    { type: "segment", name: "ZPD", optional: true, repeating: false },
+  ],
+};
+
+const processor = unified().use(hl7v2LintSegmentOrder, {
+  definition: ADT_A01_SITE,
+});
+```
+
+With a schema chosen per message, and the one MSH-9 names otherwise:
+
+```ts
+import hl7v2LintSegmentOrder from "@glion/lint-profile-segment-order";
+import { value } from "@glion/util-query";
+import { unified } from "unified";
+
+const processor = unified().use(hl7v2LintSegmentOrder, {
+  definition: ({ tree }) =>
+    value(tree, "MSH-4")?.value === "SITE_A" ? ADT_A01_SITE : undefined,
+});
+```
+
+Reporting every Z-segment the schema does not name:
+
+```ts
+import hl7v2LintSegmentOrder from "@glion/lint-profile-segment-order";
+import { unified } from "unified";
+
+const processor = unified().use(hl7v2LintSegmentOrder, {
+  allowZSegments: false,
+});
+```
+
+## API
+
+### `unified().use(hl7v2LintSegmentOrder[, options])`
+
+A `unified` lint rule plugin.
+
+```ts
+import type { Plugin } from "unified";
+import type { Root } from "@glion/ast";
+import type { EventSchema } from "@glion/profiles";
+import type { VFile } from "vfile";
+
+export interface SegmentOrderContext {
+  tree: Root;
+  file: VFile;
+}
+
+export interface SegmentOrderOptions {
+  /**
+   * The event schema to validate against, or a function that returns the
+   * one to use for a message. Default: the schema MSH-9 names.
+   *
+   * When the function returns `undefined`, the rule uses the schema MSH-9
+   * names. Return the same object for every message that uses a schema: a
+   * new object is compiled on its first run.
+   */
+  definition?:
+    | EventSchema
+    | ((
+        context: SegmentOrderContext
+      ) => EventSchema | undefined | Promise<EventSchema | undefined>);
+  /**
+   * Whether a Z-segment (a segment ID that starts with `Z`) that the event
+   * schema does not name fits at any position. HL7v2 allows local Z-segments
+   * in any message and segment group (v2.5.1 §2.11). When `false`, the rule
+   * reports such a segment as unexpected. Default: `true`.
+   */
+  allowZSegments?: boolean;
+}
+
+declare const hl7v2LintSegmentOrder: Plugin<[SegmentOrderOptions?], Root>;
+export default hl7v2LintSegmentOrder;
+```
+
+All messages use `ruleId: "segment-order"` and `source: "hl7v2-lint"`. The rule reports at most one order error per message: the first segment the schema does not allow.
+
+## What it checks
+
+Segments must appear in an order the event schema allows, and the message must include every segment the schema requires. A Z-segment the schema does not name may appear anywhere, unless `allowZSegments` is `false`; a Z-segment the schema names must appear where the schema allows it.
+
+### Valid
+
+An `ADT_A01` message whose segments follow the schema defined for v2.5:
+
+```hl7
+MSH|^~\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5
+EVN|A01|20250601120000
+PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F
+PV1|1|I|WARD^101^1
+```
+
+The same message with a site's Z-segment, which the schema does not name:
+
+```hl7
+MSH|^~\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5
+EVN|A01|20250601120000
+PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F
+ZPD|1|site patient data
+PV1|1|I|WARD^101^1
+```
+
+### Invalid — unexpected segment
+
+`PID` appears before `EVN` in an `ADT_A01`:
+
+```hl7
+MSH|^~\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5
+PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F
+```
+
+Reported message:
+
+```
+Unexpected segment 'PID'. Expected: EVN, SFT
+```
+
+The offending segment name and the segments valid at that position, sorted, are interpolated.
+
+### Invalid — message ended prematurely
+
+All segments were consumed but the schema still requires more; an `ADT_A01` needs a `PV1`:
+
+```hl7
+MSH|^~\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5
+EVN|A01|20250601120000
+PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F
+```
+
+Reported message:
+
+```
+Message ended prematurely. Expected: NK1, PD1, PV1, ROL
+```
+
+The list is the segments valid after the last one, sorted. Only reported when no other validation error was emitted.
+
+### No schema
+
+When no `definition` is given, or a `definition` function returns `undefined`, the rule uses the schema MSH-9 and MSH-12 name; when they name no bundled schema, it reports nothing.
+
+## Part of Glion
+
+`@glion/lint-profile-segment-order` is part of **[Glion]**, the application framework for HL7v2. See the [Glion README] for the full package catalog and architecture.
+
+[Glion]: https://github.com/rethinkhealth/glion#readme
+[Glion README]: https://github.com/rethinkhealth/glion#readme

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { Root } from "@glion/ast";
+import type { EventSchema } from "@glion/profiles";
+import type { VFile } from "vfile";
+/** The message a `definition` function chooses an event schema for. */
+export interface SegmentOrderContext {
+    tree: Root;
+    file: VFile;
+}
+/**
+ * Options for the segment order lint rule.
+ */
+export interface SegmentOrderOptions {
+    /**
+     * The event schema to validate against, or a function that returns the
+     * one to use for a message. Default: the schema MSH-9 names.
+     *
+     * When the function returns `undefined`, the rule uses the schema MSH-9
+     * names. Return the same object for every message that uses a schema: a
+     * new object is compiled on its first run.
+     */
+    definition?: EventSchema | ((context: SegmentOrderContext) => EventSchema | undefined | Promise<EventSchema | undefined>);
+    /**
+     * Whether a Z-segment (a segment ID that starts with `Z`) that the event
+     * schema does not name fits at any position. HL7v2 allows local Z-segments
+     * in any message and segment group (v2.5.1 §2.11). When `false`, the rule
+     * reports such a segment as unexpected. Default: `true`.
+     */
+    allowZSegments?: boolean;
+}
+declare const hl7v2LintSegmentOrder: import("unified-lint-rule").Plugin<Root, SegmentOrderOptions>;
+export default hl7v2LintSegmentOrder;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,IAAI,EAAW,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,uEAAuE;AACvE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,KAAK,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,UAAU,CAAC,EACP,WAAW,GACX,CAAC,CACC,OAAO,EAAE,mBAAmB,KACzB,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC;IACrE;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAuDD,QAAA,MAAM,qBAAqB,+DAmD1B,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,91 @@
+import { profiles, runner } from "@glion/profiles";
+import { value } from "@glion/util-query";
+import { SKIP, visit } from "@glion/util-visit";
+import { lintRule } from "unified-lint-rule";
+//#region src/index.ts
+/**
+* Lint rule that validates HL7v2 segment order against event schema
+* profiles.
+*
+* Verifies each segment appears in the order the event schema defines.
+*
+* **Resolution**: If no `definition` is provided, the rule resolves the
+* schema from MSH-12 (version) and MSH-9.3 (event schema), or MSH-9.1
+* and MSH-9.2 when MSH-9.3 is empty. If the schema is unavailable, the rule
+* reports nothing.
+*
+* **Behavior**: Reports at most one order error per message: the first segment
+* the schema does not allow. A Z-segment the schema does not name is allowed
+* anywhere unless `allowZSegments` is `false`.
+*
+* @example
+*   ```typescript
+*   // With the schema MSH-9 names:
+*   unified().use(hl7v2LintSegmentOrder);
+*
+*   // With a schema of your own:
+*   unified().use(hl7v2LintSegmentOrder, {
+*     definition: {
+*       elements: [
+*         { name: "MSH", optional: false, repeating: false, type: "segment" },
+*         { name: "PID", optional: false, repeating: false, type: "segment" },
+*       ],
+*       id: "ADT_SITE",
+*     },
+*   });
+*
+*   // With a schema chosen per message, and the one MSH-9 names otherwise:
+*   unified().use(hl7v2LintSegmentOrder, {
+*     definition: ({ tree }) =>
+*       isSiteMessage(tree) ? SITE_STRUCTURE : undefined,
+*   });
+*   ```;
+*/
+/**
+* The event schema MSH-12 and MSH-9 name: MSH-9.3, or MSH-9.1 and MSH-9.2,
+* which the events store resolves through the version's event map.
+*/
+const schemaOf = async (tree) => {
+	const version = value(tree, "MSH-12.1")?.value;
+	if (!version) return;
+	const id = value(tree, "MSH-9.3")?.value || `${value(tree, "MSH-9.1")?.value ?? ""}_${value(tree, "MSH-9.2")?.value ?? ""}`;
+	return await profiles.events.load(version, id);
+};
+const hl7v2LintSegmentOrder = lintRule({ origin: "hl7v2-lint:segment-order" }, async (tree, file, options) => {
+	const definition = options?.definition;
+	const schema = (typeof definition === "function" ? await definition({
+		file,
+		tree
+	}) : definition) ?? await schemaOf(tree);
+	if (!schema) return;
+	const segments = [];
+	visit(tree, "segment", (node, parents) => {
+		segments.push({
+			ancestors: [...parents, node],
+			node
+		});
+		return SKIP;
+	});
+	const result = runner(schema, segments.map(({ node }) => node.name), { allowZSegments: options?.allowZSegments });
+	switch (result.type) {
+		case "matched": break;
+		case "mismatched": {
+			const { ancestors, node } = segments[result.index];
+			file.message(`Unexpected segment '${node.name}'. Expected: ${result.expected.join(", ")}`, {
+				ancestors,
+				place: node.position
+			});
+			break;
+		}
+		case "incomplete":
+			file.message(`Message ended prematurely. Expected: ${result.expected.join(", ")}`, {
+				ancestors: [tree],
+				place: tree.position
+			});
+			break;
+	}
+});
+//#endregion
+export { hl7v2LintSegmentOrder as default };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Nodes, Root, Segment } from \"@glion/ast\";\nimport type { EventSchema } from \"@glion/profiles\";\nimport { profiles, runner } from \"@glion/profiles\";\nimport { value } from \"@glion/util-query\";\nimport { SKIP, visit } from \"@glion/util-visit\";\nimport { lintRule } from \"unified-lint-rule\";\nimport type { VFile } from \"vfile\";\n\n/** The message a `definition` function chooses an event schema for. */\nexport interface SegmentOrderContext {\n  tree: Root;\n  file: VFile;\n}\n\n/**\n * Options for the segment order lint rule.\n */\nexport interface SegmentOrderOptions {\n  /**\n   * The event schema to validate against, or a function that returns the\n   * one to use for a message. Default: the schema MSH-9 names.\n   *\n   * When the function returns `undefined`, the rule uses the schema MSH-9\n   * names. Return the same object for every message that uses a schema: a\n   * new object is compiled on its first run.\n   */\n  definition?:\n    | EventSchema\n    | ((\n        context: SegmentOrderContext\n      ) => EventSchema | undefined | Promise<EventSchema | undefined>);\n  /**\n   * Whether a Z-segment (a segment ID that starts with `Z`) that the event\n   * schema does not name fits at any position. HL7v2 allows local Z-segments\n   * in any message and segment group (v2.5.1 §2.11). When `false`, the rule\n   * reports such a segment as unexpected. Default: `true`.\n   */\n  allowZSegments?: boolean;\n}\n\n/**\n * Lint rule that validates HL7v2 segment order against event schema\n * profiles.\n *\n * Verifies each segment appears in the order the event schema defines.\n *\n * **Resolution**: If no `definition` is provided, the rule resolves the\n * schema from MSH-12 (version) and MSH-9.3 (event schema), or MSH-9.1\n * and MSH-9.2 when MSH-9.3 is empty. If the schema is unavailable, the rule\n * reports nothing.\n *\n * **Behavior**: Reports at most one order error per message: the first segment\n * the schema does not allow. A Z-segment the schema does not name is allowed\n * anywhere unless `allowZSegments` is `false`.\n *\n * @example\n *   ```typescript\n *   // With the schema MSH-9 names:\n *   unified().use(hl7v2LintSegmentOrder);\n *\n *   // With a schema of your own:\n *   unified().use(hl7v2LintSegmentOrder, {\n *     definition: {\n *       elements: [\n *         { name: \"MSH\", optional: false, repeating: false, type: \"segment\" },\n *         { name: \"PID\", optional: false, repeating: false, type: \"segment\" },\n *       ],\n *       id: \"ADT_SITE\",\n *     },\n *   });\n *\n *   // With a schema chosen per message, and the one MSH-9 names otherwise:\n *   unified().use(hl7v2LintSegmentOrder, {\n *     definition: ({ tree }) =>\n *       isSiteMessage(tree) ? SITE_STRUCTURE : undefined,\n *   });\n *   ```;\n */\n/**\n * The event schema MSH-12 and MSH-9 name: MSH-9.3, or MSH-9.1 and MSH-9.2,\n * which the events store resolves through the version's event map.\n */\nconst schemaOf = async (tree: Root): Promise<EventSchema | undefined> => {\n  const version = value(tree, \"MSH-12.1\")?.value;\n  if (!version) {\n    return;\n  }\n  const id =\n    value(tree, \"MSH-9.3\")?.value ||\n    `${value(tree, \"MSH-9.1\")?.value ?? \"\"}_${value(tree, \"MSH-9.2\")?.value ?? \"\"}`;\n  return await profiles.events.load(version, id);\n};\n\nconst hl7v2LintSegmentOrder = lintRule<Root, SegmentOrderOptions>(\n  {\n    origin: \"hl7v2-lint:segment-order\",\n  },\n  async (tree, file, options) => {\n    const definition = options?.definition;\n    const chosen =\n      typeof definition === \"function\"\n        ? await definition({ file, tree })\n        : definition;\n    const schema = chosen ?? (await schemaOf(tree));\n\n    if (!schema) {\n      return;\n    }\n\n    const segments: { node: Segment; ancestors: Nodes[] }[] = [];\n    visit(tree, \"segment\", (node, parents) => {\n      segments.push({ ancestors: [...parents, node], node });\n      return SKIP;\n    });\n\n    const result = runner(\n      schema,\n      segments.map(({ node }) => node.name),\n      { allowZSegments: options?.allowZSegments }\n    );\n\n    switch (result.type) {\n      case \"matched\": {\n        break;\n      }\n      case \"mismatched\": {\n        const { ancestors, node } = segments[\n          result.index\n        ] as (typeof segments)[number];\n        file.message(\n          `Unexpected segment '${node.name}'. Expected: ${result.expected.join(\", \")}`,\n          { ancestors, place: node.position }\n        );\n        break;\n      }\n      case \"incomplete\": {\n        file.message(\n          `Message ended prematurely. Expected: ${result.expected.join(\", \")}`,\n          { ancestors: [tree], place: tree.position }\n        );\n        break;\n      }\n    }\n  }\n);\n\nexport default hl7v2LintSegmentOrder;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,MAAM,WAAW,OAAO,SAAiD;CACvE,MAAM,UAAU,MAAM,MAAM,WAAW,EAAE;AACzC,KAAI,CAAC,QACH;CAEF,MAAM,KACJ,MAAM,MAAM,UAAU,EAAE,SACxB,GAAG,MAAM,MAAM,UAAU,EAAE,SAAS,GAAG,GAAG,MAAM,MAAM,UAAU,EAAE,SAAS;AAC7E,QAAO,MAAM,SAAS,OAAO,KAAK,SAAS,GAAG;;AAGhD,MAAM,wBAAwB,SAC5B,EACE,QAAQ,4BACT,EACD,OAAO,MAAM,MAAM,YAAY;CAC7B,MAAM,aAAa,SAAS;CAK5B,MAAM,UAHJ,OAAO,eAAe,aAClB,MAAM,WAAW;EAAE;EAAM;EAAM,CAAC,GAChC,eACoB,MAAM,SAAS,KAAK;AAE9C,KAAI,CAAC,OACH;CAGF,MAAM,WAAoD,EAAE;AAC5D,OAAM,MAAM,YAAY,MAAM,YAAY;AACxC,WAAS,KAAK;GAAE,WAAW,CAAC,GAAG,SAAS,KAAK;GAAE;GAAM,CAAC;AACtD,SAAO;GACP;CAEF,MAAM,SAAS,OACb,QACA,SAAS,KAAK,EAAE,WAAW,KAAK,KAAK,EACrC,EAAE,gBAAgB,SAAS,gBAAgB,CAC5C;AAED,SAAQ,OAAO,MAAf;EACE,KAAK,UACH;EAEF,KAAK,cAAc;GACjB,MAAM,EAAE,WAAW,SAAS,SAC1B,OAAO;AAET,QAAK,QACH,uBAAuB,KAAK,KAAK,eAAe,OAAO,SAAS,KAAK,KAAK,IAC1E;IAAE;IAAW,OAAO,KAAK;IAAU,CACpC;AACD;;EAEF,KAAK;AACH,QAAK,QACH,wCAAwC,OAAO,SAAS,KAAK,KAAK,IAClE;IAAE,WAAW,CAAC,KAAK;IAAE,OAAO,KAAK;IAAU,CAC5C;AACD;;EAIP"}

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@glion/lint-profile-segment-order",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.21.0",
+  "description": "Lints the segment order of an HL7v2 message against its message structure",
+  "keywords": [
+    "health",
+    "healthcare",
+    "hl7",
+    "hl7v2",
+    "nodejs",
+    "typescript"
+  ],
+  "homepage": "https://glion.dev",
+  "license": "MIT",
+  "author": {
+    "name": "Melek Somai",
+    "email": "melek@rethinkhealth.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rethinkhealth/glion.git",
+    "directory": "packages/lint-profile-segment-order"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "unified-lint-rule": "3.0.1",
+    "vfile": "6.0.3",
+    "@glion/ast": "0.21.0",
+    "@glion/util-query": "0.21.0",
+    "@glion/util-visit": "0.21.0",
+    "@glion/profiles": "0.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.6.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "publint": "0.3.18",
+    "tsdown": "0.21.10",
+    "typescript": "6.0.3",
+    "unified": "^11.0.5",
+    "vitest": "4.1.11",
+    "@glion/builder": "0.21.0",
+    "@glion/check-readme": "0.18.0",
+    "@glion/tsconfig": "0.18.0",
+    "@glion/testing": "0.18.0",
+    "@glion/parser": "0.21.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsdown && tsc --emitDeclarationOnly",
+    "check-types": "tsc --noEmit && tsc --noEmit -p tests/tsconfig.json",
+    "check:readme": "glion-check-readme",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "publint": "publint --strict"
+  }
 }