@glion/transform-profile-groups 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,167 @@
-# Temporary Holding Version
+# @glion/transform-profile-groups
 
-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.
+Unified plugin that nests HL7v2 segments in the segment groups their event schema defines.
+
+## What it does
+
+The parser produces a flat list of segments. This plugin nests them in `Group` nodes the way the HL7v2 standard defines the event's message structure: in an `ORU_R01`, each order's `OBR` and its results go in an `ORDER_OBSERVATION`, inside a `PATIENT_RESULT`. It reads the event schema MSH-12 and MSH-9 name and moves the existing segment nodes; it does not copy or change them.
+
+## Install
+
+```bash
+npm install @glion/transform-profile-groups
+```
+
+## Use
+
+```ts
+import { parseHL7v2 } from "@glion/parser";
+import { hl7v2TransformProfileGroups } from "@glion/transform-profile-groups";
+import { unified } from "unified";
+import { VFile } from "vfile";
+
+const tree = parseHL7v2(
+  [
+    "MSH|^~\\&|LAB|FAC|EMR|RFAC|20241201120000||ORU^R01^ORU_R01|MSG1|P|2.5",
+    "PID|1||12345^^^MRN||Doe^John",
+    "PV1|1|I",
+    "ORC|RE|ORD1",
+    "OBR|1|ORD1||CBC",
+    "OBX|1|NM|WBC||5.0",
+    "OBX|2|NM|RBC||4.1",
+  ].join("\r")
+);
+
+await unified().use(hl7v2TransformProfileGroups).run(tree, new VFile());
+```
+
+The root now holds:
+
+```
+MSH
+PATIENT_RESULT
+  PATIENT
+    PID
+    VISIT
+      PV1
+  ORDER_OBSERVATION
+    ORC
+    OBR
+    OBSERVATION
+      OBX
+    OBSERVATION
+      OBX
+```
+
+Paths from `@glion/util-query` address the groups:
+
+```ts
+import { selectAll, value } from "@glion/util-query";
+
+selectAll(tree, "PATIENT_RESULT-ORDER_OBSERVATION"); // each order
+value(tree, "PATIENT_RESULT-ORDER_OBSERVATION[1]-OBX[2]-5")?.value; // => "4.1"
+```
+
+## Options
+
+| Option           | Type                                                   | Default                | Description                                                                                                                                                 |
+| ---------------- | ------------------------------------------------------ | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `definition`     | `EventSchema \| (context) => EventSchema \| undefined` | the schema MSH-9 names | The event schema to group by, or a function of `{ tree, file }` that returns one, sync or async. `undefined` falls back to the schema MSH-9 names.          |
+| `allowZSegments` | `boolean`                                              | `true`                 | Whether a Z-segment the event schema does not name fits at any position, as HL7v2 allows (v2.5.1 §2.11). When `false`, such a segment leaves the tree flat. |
+
+An event schema of your own groups a message the bundled schemas do not define, such as one with a site's Z-segment:
+
+```ts
+import type { EventSchema } from "@glion/profiles";
+
+const definition: EventSchema = {
+  id: "ZAD_Z01",
+  elements: [
+    { type: "segment", name: "MSH", optional: false, repeating: false },
+    { type: "segment", name: "PID", optional: false, repeating: false },
+    {
+      type: "group",
+      name: "VISIT",
+      optional: false,
+      repeating: false,
+      elements: [
+        { type: "segment", name: "PV1", optional: false, repeating: false },
+        { type: "segment", name: "ZPV", optional: true, repeating: false },
+      ],
+    },
+  ],
+};
+
+await unified()
+  .use(hl7v2TransformProfileGroups, { definition })
+  .run(tree, new VFile());
+// MSH, PID, VISIT(PV1, ZPV)
+```
+
+## API
+
+### `unified().use(hl7v2TransformProfileGroups[, options])`
+
+Replaces the root's segments with nested `Group` nodes holding the same segment nodes, in the same order.
+
+```ts
+import type { Root } from "@glion/ast";
+import type { EventSchema } from "@glion/profiles";
+import type { Plugin } from "unified";
+import type { VFile } from "vfile";
+
+interface TransformProfileGroupsContext {
+  tree: Root;
+  file: VFile;
+}
+
+interface TransformProfileGroupsOptions {
+  definition?:
+    | EventSchema
+    | ((
+        context: TransformProfileGroupsContext
+      ) => EventSchema | undefined | Promise<EventSchema | undefined>);
+  allowZSegments?: boolean;
+}
+
+declare const hl7v2TransformProfileGroups: Plugin<
+  [TransformProfileGroupsOptions?],
+  Root,
+  Root
+>;
+export default hl7v2TransformProfileGroups;
+```
+
+###### Requires
+
+Without `options.definition`: a message whose MSH-12 and MSH-9 name a bundled event schema. MSH-9.3 names the schema; when it is empty, MSH-9.1 and MSH-9.2 name the event, and the version's event map gives its schema.
+
+###### Returns
+
+Async transformer. Mutates the tree in place and returns it.
+
+###### Throws
+
+When the event schema is invalid: it has no elements, a segment or group has no name, a group has no elements, a choice has no alternatives, or a choice alternative can match no segment. When a bundled event schema fails to load.
+
+## Behavior
+
+- Each `Group` has `type: "group"`, the group's `name` from the standard, such as `ORDER_OBSERVATION`, and a `position` from the start of its first segment to the end of its last.
+- Each occurrence of a repeating group is its own `Group` node: two results give two `OBSERVATION` nodes.
+- A choice, the standard's `< OBR | RXO >`, adds no node: the chosen segment sits in the enclosing group.
+- A group occurrence that holds no segment is left out.
+- Where the schema admits more than one grouping, the plugin enters an optional element rather than skip it, repeats an element rather than leave it, and takes the earlier alternative of a choice. A segment therefore continues the group it is in before it starts a new enclosing one: in an `ORU_R01`, an `ORC` after an `OBX` starts a new `ORDER_OBSERVATION` in the current `PATIENT_RESULT`.
+- A Z-segment, a segment ID that starts with `Z`, that the schema does not name goes right after the segment before it, in that segment's group: in an `ORU_R01`, a `ZPI` after the `PID` sits in `PATIENT`, and a `ZDS` after the `OBR` in `ORDER_OBSERVATION`. Consecutive Z-segments stay together, in order, and a Z-segment before every segment the schema names stays at the top level. A Z-segment the schema names is placed where the schema puts it. With `allowZSegments: false`, a Z-segment the schema does not name leaves the tree flat.
+- A tree that already holds a group, from a first run or from another plugin, is left as it is, and `definition` is not called for it.
+- The tree is also left unchanged when there is no event schema, or when the segments do not fit the schema: a segment out of order, a required segment missing, or a segment the schema does not define that is not a Z-segment. `@glion/lint-profile-segment-order` reports those messages.
+- Running it twice changes nothing.
+
+Grouping changes neither serialization nor segment paths: `toHl7v2` writes the same text, and `value(tree, "PID-3.1")` and `value(tree, "OBX[2]-5")` resolve the same nodes. Profile annotation and lint plugins read segments at any depth, so they run before or after it.
+
+## Part of Glion
+
+`@glion/transform-profile-groups` 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,53 @@
+import type { Root } from "@glion/ast";
+import type { EventSchema } from "@glion/profiles";
+import type { Plugin } from "unified";
+import type { VFile } from "vfile";
+/** The message a `definition` function chooses an event schema for. */
+export interface TransformProfileGroupsContext {
+    tree: Root;
+    file: VFile;
+}
+/** Options for {@link hl7v2TransformProfileGroups}. */
+export interface TransformProfileGroupsOptions {
+    /**
+     * The event schema to group by, or a function that returns the one to use
+     * for a message. Default: the schema MSH-9 names.
+     *
+     * When the function returns `undefined`, the plugin 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: TransformProfileGroupsContext) => 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`, such a
+     * segment leaves the tree flat. Default: `true`.
+     */
+    allowZSegments?: boolean;
+}
+/**
+ * Unified plugin that nests a message's segments in the segment groups its
+ * event schema defines, such as `PATIENT_RESULT` and `ORDER_OBSERVATION`.
+ *
+ * Groups by `options.definition`, or else by the schema MSH-12 and MSH-9
+ * name. Replaces the root's children with `Group` nodes holding the same
+ * segment nodes, in the same order. A group's position spans its first to its
+ * last segment. A Z-segment the schema does not name goes right after the
+ * segment before it, in that segment's group, unless `options.allowZSegments`
+ * is `false`.
+ *
+ * Runs only on a tree that holds segments and no group: a tree that already
+ * holds a group, from this plugin or another, is left as it is, and
+ * `options.definition` is not called for it. Also leaves the tree
+ * unchanged when there is no event schema or when the segments do not fit
+ * it. Idempotent.
+ *
+ * @throws {Error} When the event schema is invalid (see `runner`), or a
+ *   bundled event schema fails to load.
+ */
+export declare const hl7v2TransformProfileGroups: Plugin<[
+    TransformProfileGroupsOptions?
+], Root, Root>;
+export default hl7v2TransformProfileGroups;
+//# 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,EAAgB,MAAM,iBAAiB,CAAC;AAIjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,uEAAuE;AACvE,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,KAAK,CAAC;CACb;AAED,uDAAuD;AACvD,MAAM,WAAW,6BAA6B;IAC5C;;;;;;;OAOG;IACH,UAAU,CAAC,EACP,WAAW,GACX,CAAC,CACC,OAAO,EAAE,6BAA6B,KACnC,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC;IACrE;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAgDD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAC9C;IAAC,6BAA6B,CAAC;CAAC,EAChC,IAAI,EACJ,IAAI,CA6CL,CAAC;AAEF,eAAe,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,94 @@
+import { profiles, runner } from "@glion/profiles";
+import { value } from "@glion/util-query";
+import { EXIT, SKIP, visit } from "@glion/util-visit";
+//#region src/index.ts
+/**
+* The bundled 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.
+* `undefined` when MSH-12 is empty or the version bundles no such schema.
+*/
+const bundledEventSchema = 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);
+};
+/**
+* The tree node of one match: the segment it indexes, or a `Group` of its
+* children's nodes, positioned from the start of its first segment to the
+* end of its last.
+*/
+const nodeOf = (match, segments) => {
+	if (typeof match === "number") {
+		const segment = segments[match];
+		if (!segment) throw new Error(`@glion/transform-profile-groups: a match indexes segment ${match} of ${segments.length}; this is a bug, please report it`);
+		return segment;
+	}
+	const children = match.children.map((child) => nodeOf(child, segments));
+	const group = {
+		children,
+		name: match.name,
+		type: "group"
+	};
+	const start = children[0]?.position?.start;
+	const end = children.at(-1)?.position?.end;
+	if (start && end) group.position = {
+		end,
+		start
+	};
+	return group;
+};
+/**
+* Unified plugin that nests a message's segments in the segment groups its
+* event schema defines, such as `PATIENT_RESULT` and `ORDER_OBSERVATION`.
+*
+* Groups by `options.definition`, or else by the schema MSH-12 and MSH-9
+* name. Replaces the root's children with `Group` nodes holding the same
+* segment nodes, in the same order. A group's position spans its first to its
+* last segment. A Z-segment the schema does not name goes right after the
+* segment before it, in that segment's group, unless `options.allowZSegments`
+* is `false`.
+*
+* Runs only on a tree that holds segments and no group: a tree that already
+* holds a group, from this plugin or another, is left as it is, and
+* `options.definition` is not called for it. Also leaves the tree
+* unchanged when there is no event schema or when the segments do not fit
+* it. Idempotent.
+*
+* @throws {Error} When the event schema is invalid (see `runner`), or a
+*   bundled event schema fails to load.
+*/
+const hl7v2TransformProfileGroups = (options) => async (tree, file) => {
+	let grouped = false;
+	const segments = [];
+	visit(tree, (node) => {
+		if (node.type === "group") {
+			grouped = true;
+			return EXIT;
+		}
+		if (node.type === "segment") {
+			segments.push(node);
+			return SKIP;
+		}
+	});
+	if (grouped || segments.length === 0) return tree;
+	const definition = options?.definition;
+	const schema = (typeof definition === "function" ? await definition({
+		file,
+		tree
+	}) : definition) ?? await bundledEventSchema(tree);
+	if (!schema) return tree;
+	const result = runner(schema, segments.map((segment) => segment.name), { allowZSegments: options?.allowZSegments });
+	switch (result.type) {
+		case "matched":
+			tree.children = result.groups.map((match) => nodeOf(match, segments));
+			break;
+		case "mismatched":
+		case "incomplete": break;
+	}
+	return tree;
+};
+//#endregion
+export { hl7v2TransformProfileGroups as default, hl7v2TransformProfileGroups };
+
+//# 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 { Group, Root, Segment } from \"@glion/ast\";\nimport type { EventSchema, SegmentMatch } from \"@glion/profiles\";\nimport { profiles, runner } from \"@glion/profiles\";\nimport { value } from \"@glion/util-query\";\nimport { EXIT, SKIP, visit } from \"@glion/util-visit\";\nimport type { Plugin } from \"unified\";\nimport type { VFile } from \"vfile\";\n\n/** The message a `definition` function chooses an event schema for. */\nexport interface TransformProfileGroupsContext {\n  tree: Root;\n  file: VFile;\n}\n\n/** Options for {@link hl7v2TransformProfileGroups}. */\nexport interface TransformProfileGroupsOptions {\n  /**\n   * The event schema to group by, or a function that returns the one to use\n   * for a message. Default: the schema MSH-9 names.\n   *\n   * When the function returns `undefined`, the plugin 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: TransformProfileGroupsContext\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`, such a\n   * segment leaves the tree flat. Default: `true`.\n   */\n  allowZSegments?: boolean;\n}\n\n/**\n * The bundled event schema MSH-12 and MSH-9 name: MSH-9.3, or MSH-9.1 and\n * MSH-9.2, which the events store resolves through the version's event map.\n * `undefined` when MSH-12 is empty or the version bundles no such schema.\n */\nconst bundledEventSchema = async (\n  tree: Root\n): 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\n/**\n * The tree node of one match: the segment it indexes, or a `Group` of its\n * children's nodes, positioned from the start of its first segment to the\n * end of its last.\n */\nconst nodeOf = (\n  match: SegmentMatch,\n  segments: readonly Segment[]\n): Group | Segment => {\n  if (typeof match === \"number\") {\n    const segment = segments[match];\n    if (!segment) {\n      throw new Error(\n        `@glion/transform-profile-groups: a match indexes segment ${match} of ${segments.length}; this is a bug, please report it`\n      );\n    }\n    return segment;\n  }\n  const children = match.children.map((child) => nodeOf(child, segments));\n  const group: Group = { children, name: match.name, type: \"group\" };\n  const start = children[0]?.position?.start;\n  const end = children.at(-1)?.position?.end;\n  if (start && end) {\n    group.position = { end, start };\n  }\n  return group;\n};\n\n/**\n * Unified plugin that nests a message's segments in the segment groups its\n * event schema defines, such as `PATIENT_RESULT` and `ORDER_OBSERVATION`.\n *\n * Groups by `options.definition`, or else by the schema MSH-12 and MSH-9\n * name. Replaces the root's children with `Group` nodes holding the same\n * segment nodes, in the same order. A group's position spans its first to its\n * last segment. A Z-segment the schema does not name goes right after the\n * segment before it, in that segment's group, unless `options.allowZSegments`\n * is `false`.\n *\n * Runs only on a tree that holds segments and no group: a tree that already\n * holds a group, from this plugin or another, is left as it is, and\n * `options.definition` is not called for it. Also leaves the tree\n * unchanged when there is no event schema or when the segments do not fit\n * it. Idempotent.\n *\n * @throws {Error} When the event schema is invalid (see `runner`), or a\n *   bundled event schema fails to load.\n */\nexport const hl7v2TransformProfileGroups: Plugin<\n  [TransformProfileGroupsOptions?],\n  Root,\n  Root\n> = (options) => async (tree, file) => {\n  // A group means the tree is grouped already, by this plugin or another.\n  let grouped = false;\n  const segments: Segment[] = [];\n  visit(tree, (node) => {\n    if (node.type === \"group\") {\n      grouped = true;\n      return EXIT;\n    }\n    if (node.type === \"segment\") {\n      segments.push(node);\n      return SKIP;\n    }\n  });\n  if (grouped || segments.length === 0) {\n    return tree;\n  }\n\n  const definition = options?.definition;\n  const chosen =\n    typeof definition === \"function\"\n      ? await definition({ file, tree })\n      : definition;\n  const schema = chosen ?? (await bundledEventSchema(tree));\n  if (!schema) {\n    return tree;\n  }\n\n  const result = runner(\n    schema,\n    segments.map((segment) => segment.name),\n    { allowZSegments: options?.allowZSegments }\n  );\n  switch (result.type) {\n    case \"matched\": {\n      tree.children = result.groups.map((match) => nodeOf(match, segments));\n      break;\n    }\n    case \"mismatched\":\n    case \"incomplete\": {\n      break;\n    }\n  }\n  return tree;\n};\n\nexport default hl7v2TransformProfileGroups;\n"],"mappings":";;;;;;;;;AA2CA,MAAM,qBAAqB,OACzB,SACqC;CACrC,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;;;;;;;AAQhD,MAAM,UACJ,OACA,aACoB;AACpB,KAAI,OAAO,UAAU,UAAU;EAC7B,MAAM,UAAU,SAAS;AACzB,MAAI,CAAC,QACH,OAAM,IAAI,MACR,4DAA4D,MAAM,MAAM,SAAS,OAAO,mCACzF;AAEH,SAAO;;CAET,MAAM,WAAW,MAAM,SAAS,KAAK,UAAU,OAAO,OAAO,SAAS,CAAC;CACvE,MAAM,QAAe;EAAE;EAAU,MAAM,MAAM;EAAM,MAAM;EAAS;CAClE,MAAM,QAAQ,SAAS,IAAI,UAAU;CACrC,MAAM,MAAM,SAAS,GAAG,GAAG,EAAE,UAAU;AACvC,KAAI,SAAS,IACX,OAAM,WAAW;EAAE;EAAK;EAAO;AAEjC,QAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,MAAa,+BAIR,YAAY,OAAO,MAAM,SAAS;CAErC,IAAI,UAAU;CACd,MAAM,WAAsB,EAAE;AAC9B,OAAM,OAAO,SAAS;AACpB,MAAI,KAAK,SAAS,SAAS;AACzB,aAAU;AACV,UAAO;;AAET,MAAI,KAAK,SAAS,WAAW;AAC3B,YAAS,KAAK,KAAK;AACnB,UAAO;;GAET;AACF,KAAI,WAAW,SAAS,WAAW,EACjC,QAAO;CAGT,MAAM,aAAa,SAAS;CAK5B,MAAM,UAHJ,OAAO,eAAe,aAClB,MAAM,WAAW;EAAE;EAAM;EAAM,CAAC,GAChC,eACoB,MAAM,mBAAmB,KAAK;AACxD,KAAI,CAAC,OACH,QAAO;CAGT,MAAM,SAAS,OACb,QACA,SAAS,KAAK,YAAY,QAAQ,KAAK,EACvC,EAAE,gBAAgB,SAAS,gBAAgB,CAC5C;AACD,SAAQ,OAAO,MAAf;EACE,KAAK;AACH,QAAK,WAAW,OAAO,OAAO,KAAK,UAAU,OAAO,OAAO,SAAS,CAAC;AACrE;EAEF,KAAK;EACL,KAAK,aACH;;AAGJ,QAAO"}

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@glion/transform-profile-groups",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.21.0",
+  "description": "Unified plugin to group HL7v2 segments into the segment groups their event schema defines",
+  "keywords": [
+    "group",
+    "health",
+    "healthcare",
+    "hl7",
+    "hl7v2",
+    "nodejs",
+    "plugin",
+    "profile",
+    "transform",
+    "typescript",
+    "unified"
+  ],
+  "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/transform-profile-groups"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "unified": "11.0.5",
+    "vfile": "6.0.3",
+    "@glion/ast": "0.21.0",
+    "@glion/profiles": "0.21.0",
+    "@glion/util-visit": "0.21.0",
+    "@glion/util-query": "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",
+    "vitest": "4.1.11",
+    "@glion/check-readme": "0.18.0",
+    "@glion/annotate-profile-context": "0.21.0",
+    "@glion/annotate-profile-fields": "0.21.0",
+    "@glion/parser": "0.21.0",
+    "@glion/testing": "0.18.0",
+    "@glion/tsconfig": "0.18.0",
+    "@glion/to-hl7v2": "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"
+  }
 }