@amritk/asyncapi 0.1.0 → 0.2.0

package/AI.md

@@ -1,8 +1,9 @@
 # @amritk/asyncapi — notes for AI coding agents
 
 Extract every message payload/headers schema from an AsyncAPI 2.x/3.0 document
-as self-contained JSON Schema 2020-12, ready for the mjst generators. Full
-reference is [README.md](./README.md).
+as self-contained JSON Schema 2020-12 for the mjst generators, and project each
+channel onto an `@amritk/api` `defineMessages` contract. Full reference is
+[README.md](./README.md).
 
 > Pre-alpha: APIs change in **minor** versions.
 
@@ -16,6 +17,19 @@ const schemas = listMessageSchemas(model)
 // → [{ subDir: 'channels/lighting-measured/light-measured', rootTypeName: 'LightMeasured', schema }, ...]
 ```
 
+## Channel contracts
+
+```ts
+import { buildChannelContract } from '@amritk/asyncapi'
+
+const contract = buildChannelContract(model.channels[0], { discriminator: 'event' })
+// → { exportName: 'lobbyMessages', discriminator: 'event',
+//     clientToServer: { say: schema }, serverToClient: { said: schema }, issues: [] }
+```
+
+Hand the two direction maps straight to `defineMessages` — that is what
+`mjst --input asyncapi --message-contracts` writes out.
+
 ## Gotchas — where agents fail
 
 1. **It takes an already-parsed document.** No filesystem, no YAML, no network —
@@ -33,3 +47,14 @@ const schemas = listMessageSchemas(model)
    message's schema never affects another.
 5. **Root type names come from message identity**, not schema `title` — two
    messages titled "Event" stay distinct.
+6. **A contract's map key is the wire tag.** `receive` → `clientToServer`,
+   `send` → `serverToClient`, and the discriminator property is *stripped* from
+   each payload: `@amritk/api` reads the tag off the frame to pick the message,
+   then removes it before validating, and refuses a schema that still declares
+   it. A payload pinning the tag to something other than the message name is an
+   issue, not a rewrite — Slack's RTM document renames nearly every one, and
+   only three of its messages survive.
+7. **The discriminator has a priority order**: `x-mjst: { discriminator }` on
+   the channel, then the caller's argument, then `'type'`. The document wins
+   over the argument on purpose — one override covers a whole run, and a run
+   may span channels that disagree.

package/README.md

@@ -2,7 +2,7 @@
 
 # @amritk/asyncapi
 
-**Extract JSON Schemas from AsyncAPI 2.x/3.0 documents for the mjst generators.**
+**Extract JSON Schemas — and `@amritk/api` channel contracts — from AsyncAPI 2.x/3.0 documents.**
 
 ![status](https://img.shields.io/badge/status-pre--alpha-ef4444?style=flat-square) 
 ![version](https://img.shields.io/npm/v/@amritk/asyncapi?style=flat-square&logo=npm&logoColor=white&label=version&color=6366f1) 
@@ -21,6 +21,8 @@
 
 What "self-contained" buys: the AsyncAPI default schema dialect (a draft-07 superset) is upgraded to 2020-12 conventions, OpenAPI-format payloads get `nullable` folded into their `type`, and every `$ref` into the document's `#/components/schemas/...` is rebased into a local `$defs` with the referenced components copied in transitively — so each extracted schema stands alone as a generator input.
 
+It also projects each channel onto a [`@amritk/api`](../api) **messages contract**: the two directions AsyncAPI declares become `clientToServer`/`serverToClient`, each message's name becomes its wire discriminator value, and the discriminator property is stripped out of the payload — which is exactly the shape `defineMessages` takes. That projection is what `mjst --input asyncapi --message-contracts` writes to disk.
+
 Both majors normalize into one 3.0-shaped model. Directions are named from the application's point of view (2.x `publish` → `receive`, `subscribe` → `send`), matching [`@amritk/api`](../api)'s message contracts. Non-JSON-Schema payloads (`schemaFormat`: Avro, Protobuf, …) are skipped per message with a recorded issue — one Avro payload never costs the document's other messages.
 
 ---
@@ -64,6 +66,30 @@ for (const channel of model.channels) {
 const schemas = listMessageSchemas(model)
 ```
 
+### Channel contracts
+
+```ts
+import { buildChannelContract } from '@amritk/asyncapi'
+import { defineMessages } from '@amritk/api'
+
+for (const channel of model.channels) {
+  const contract = buildChannelContract(channel)
+  for (const issue of contract.issues) console.warn(`${issue.path}: ${issue.message}`)
+
+  // The two maps are keyed by wire discriminator value, payloads already
+  // stripped of the tag — hand them straight to defineMessages.
+  const messages = defineMessages({
+    discriminator: contract.discriminator,
+    clientToServer: contract.clientToServer,
+    serverToClient: contract.serverToClient,
+  })
+}
+```
+
+The discriminator is resolved in priority order: `x-mjst: { discriminator }` on the channel, then the `discriminator` option, then `'type'` (matching `@amritk/api`'s default). The document wins over the option deliberately — one option covers a whole run, and a run may span channels that disagree.
+
+A message whose payload pins the tag to something *other* than its own name is skipped with an issue rather than rewritten: the wire tag and the contract key would disagree, so the emitted contract would listen for a frame that never arrives. Slack's RTM document renames nearly every one of its tags this way, and only three of its messages project cleanly.
+
 Cross-file and remote `$ref`s are the loader's job: resolve them first (for example with [`@amritk/resolve-refs`](../resolve-refs)); a still-unresolved external reference is reported as an issue, never fetched.
 
 ---
@@ -72,6 +98,10 @@ Cross-file and remote `$ref`s are the loader's job: resolve them first (for exam
 
 - **`extractAsyncApi(document)`** → `AsyncApiModel` — the normalized document: `version`, `major`, `title?`, `channels` (each with `key`, `address?`, `messages`), and collected `issues`. Throws only when the input is not an AsyncAPI document at all.
 - **`listMessageSchemas(model, issues?)`** → `ExtractedSchema[]` — one `{ subDir, rootTypeName, schema }` per generatable payload/headers, with deterministic collision-suffixed directory tokens; collision issues are appended to `model.issues` (or to the `issues` array you pass).
+- **`buildChannelContract(channel, options?)`** → `ChannelContract` — one channel as `{ exportName, discriminator, clientToServer, serverToClient, issues }`, ready for `defineMessages`.
+- **`resolveDiscriminator(channel, override?)`** / **`DEFAULT_DISCRIMINATOR`** — the priority order above, and the `'type'` fallback.
+- **`stripDiscriminator(payload, discriminator, messageName)`** → `{ schema }` or `{ issue }` — the payload with its tag removed, or why it could not be.
+- **`sanitizeToken(value, fallback)`** — the filesystem- and import-safe token both output layouts name a channel or message with.
 - **`detectAsyncApiVersion(document)`** — the `asyncapi` version and its major, or `undefined`.
 - **`classifySchemaFormat(schemaFormat)`** — which JSON Schema dialect a `schemaFormat` names (`'asyncapi' | 'draft-07' | '2020-12' | 'openapi'`), or `'unsupported'`.
 - **`mergeTraits(target, traits, precedence)`** — trait application as an RFC 7386 JSON Merge Patch (recursive, so nested contributions from both sides survive); `precedence` is `'trait'` for 2.x (traits override the target) or `'target'` for 3.0 (the target wins). Applied before `schemaFormat` is read.

package/dist/build-channel-contract.d.ts

@@ -0,0 +1,48 @@
+import type { ExtractionIssue, NormalizedChannel } from './types.js';
+/** One direction's message map: wire name → payload schema, ready for `defineMessages`. */
+export type ContractDirection = {
+    readonly [name: string]: Record<string, unknown>;
+};
+/**
+ * One channel projected onto an `@amritk/api` messages contract.
+ *
+ * The map keys *are* the wire discriminator values — that is what
+ * `defineMessages` means by a message name — so a message that cannot be given
+ * a legal key or a legal payload is left out and its reason recorded in
+ * {@link ChannelContract.issues} rather than emitted broken.
+ */
+export type ChannelContract = {
+    /** The `export const <name> = defineMessages(...)` identifier for this channel. */
+    readonly exportName: string;
+    readonly discriminator: string;
+    /** What the client may send — AsyncAPI's `receive`, from the application's side. */
+    readonly clientToServer: ContractDirection;
+    /** What the server may send — AsyncAPI's `send`. */
+    readonly serverToClient: ContractDirection;
+    readonly issues: readonly ExtractionIssue[];
+};
+export type BuildChannelContractOptions = {
+    /** Fallback discriminator when the channel does not name one (the CLI's `--discriminator`). */
+    readonly discriminator?: string;
+};
+/**
+ * Projects one normalized channel onto a `defineMessages`-shaped contract.
+ *
+ * The two models nearly line up already — AsyncAPI 3.0 and `@amritk/api` name
+ * directions from the same end — so the work is in the two places they do not:
+ *
+ * - **Direction.** `receive` (the application receives it) is what a client
+ *   sends, hence `clientToServer`; `send` is `serverToClient`. A message no
+ *   operation names has no direction at all, and a contract cannot guess one:
+ *   putting it in the wrong half would validate frames flowing the wrong way
+ *   and reject the ones that arrive.
+ * - **The tag.** The message *name* becomes the wire key, and the payload has
+ *   the tag stripped out of it (see {@link stripDiscriminator}), because the
+ *   runtime removes it from the frame before validating.
+ *
+ * Everything skipped comes back as an issue naming the message and the reason,
+ * so the caller can warn per message instead of failing the channel. A channel
+ * that ends up with no messages at all is still returned: an empty contract is
+ * a truthful one, and the issues say why it is empty.
+ */
+export declare const buildChannelContract: (channel: NormalizedChannel, options?: BuildChannelContractOptions) => ChannelContract;

package/dist/build-channel-contract.js

@@ -0,0 +1,56 @@
+import { resolveDiscriminator } from "./resolve-discriminator.js";
+import { sanitizeToken } from "./sanitize-token.js";
+import { stripDiscriminator } from "./strip-discriminator.js";
+const toExportName = (token) => {
+  const camel = token.replace(/[^A-Za-z0-9]+(.)?/g, (_, next) => next === void 0 ? "" : next.toUpperCase());
+  return `${/^[A-Za-z_$]/.test(camel) ? camel : `_${camel}`}Messages`;
+};
+const buildChannelContract = (channel, options = {}) => {
+  const discriminator = resolveDiscriminator(channel, options.discriminator);
+  const issues = [];
+  const clientToServer = /* @__PURE__ */ new Map();
+  const serverToClient = /* @__PURE__ */ new Map();
+  for (const message of channel.messages) {
+    const path = `#/channels/${channel.key}/messages/${message.name}`;
+    const skip = (reason) => void issues.push({ path, message: reason });
+    if (message.direction === void 0) {
+      skip("message has no direction (no operation names it), so it belongs to neither half of the contract");
+      continue;
+    }
+    if (message.payload === void 0 && message.schemaFormat !== void 0) {
+      skip(`payload was not extracted as JSON Schema (schemaFormat "${message.schemaFormat}")`);
+      continue;
+    }
+    if (message.name === "__proto__") {
+      skip('a message named "__proto__" cannot be written as an object key in the generated contract');
+      continue;
+    }
+    const target = message.direction === "receive" ? clientToServer : serverToClient;
+    if (target.has(message.name)) {
+      skip(`two ${message.direction === "receive" ? "clientToServer" : "serverToClient"} messages share the name`);
+      continue;
+    }
+    if (message.payload === void 0) {
+      target.set(message.name, { type: "object" });
+      continue;
+    }
+    const stripped = stripDiscriminator(message.payload, discriminator, message.name);
+    if (stripped.issue !== void 0) {
+      skip(stripped.issue);
+      continue;
+    }
+    target.set(message.name, stripped.schema);
+  }
+  return {
+    exportName: toExportName(sanitizeToken(channel.key, "channel")),
+    discriminator,
+    // `Object.fromEntries` defines own properties rather than assigning them,
+    // so even a hostile name lands as data on the object it belongs to.
+    clientToServer: Object.fromEntries(clientToServer),
+    serverToClient: Object.fromEntries(serverToClient),
+    issues
+  };
+};
+export {
+  buildChannelContract
+};

package/dist/extract-channels-v2.js

@@ -1,3 +1,4 @@
+import { getMjstDiscriminator } from "@amritk/helpers/mjst-extension";
 import { readKey } from "@amritk/helpers/read-key";
 import { mergeTraits } from "./merge-traits.js";
 import { normalizeMessage } from "./normalize-message.js";
@@ -62,7 +63,13 @@ const extractChannelsV2 = (document, issues) => {
         }, document, issues, itemPath));
       }
     }
-    channels.push({ key: channelKey, address: channelKey, messages });
+    const discriminator = getMjstDiscriminator(channel);
+    channels.push({
+      key: channelKey,
+      address: channelKey,
+      ...discriminator !== void 0 ? { discriminator } : {},
+      messages
+    });
   }
   return channels;
 };

package/dist/extract-channels-v3.js

@@ -1,3 +1,4 @@
+import { getMjstDiscriminator } from "@amritk/helpers/mjst-extension";
 import { readKey } from "@amritk/helpers/read-key";
 import { mergeTraits } from "./merge-traits.js";
 import { normalizeMessage } from "./normalize-message.js";
@@ -195,9 +196,11 @@ const extractChannelsV3 = (document, issues) => {
         }, document, issues, messagePath));
       }
     }
+    const discriminator = getMjstDiscriminator(channel);
     channels.push({
       key: channelKey,
       ...typeof address === "string" && address !== "" ? { address } : {},
+      ...discriminator !== void 0 ? { discriminator } : {},
       messages
     });
   }

package/dist/index.d.ts

@@ -1,6 +1,10 @@
+export { type BuildChannelContractOptions, buildChannelContract, type ChannelContract, type ContractDirection, } from './build-channel-contract.js';
 export { type DetectedVersion, detectAsyncApiVersion } from './detect-version.js';
 export { extractAsyncApi } from './extract-async-api.js';
 export { mergeTraits } from './merge-traits.js';
 export { listMessageSchemas } from './message-schemas.js';
+export { DEFAULT_DISCRIMINATOR, resolveDiscriminator } from './resolve-discriminator.js';
+export { sanitizeToken } from './sanitize-token.js';
 export { classifySchemaFormat, type SchemaFormatFamily } from './schema-format.js';
+export { type StripDiscriminatorResult, stripDiscriminator } from './strip-discriminator.js';
 export type { AsyncApiModel, ExtractedSchema, ExtractionIssue, MessageDirection, NormalizedChannel, NormalizedMessage, } from './types.js';

package/dist/index.js

@@ -1,12 +1,21 @@
+import { buildChannelContract } from "./build-channel-contract.js";
 import { detectAsyncApiVersion } from "./detect-version.js";
 import { extractAsyncApi } from "./extract-async-api.js";
 import { mergeTraits } from "./merge-traits.js";
 import { listMessageSchemas } from "./message-schemas.js";
+import { DEFAULT_DISCRIMINATOR, resolveDiscriminator } from "./resolve-discriminator.js";
+import { sanitizeToken } from "./sanitize-token.js";
 import { classifySchemaFormat } from "./schema-format.js";
+import { stripDiscriminator } from "./strip-discriminator.js";
 export {
+  DEFAULT_DISCRIMINATOR,
+  buildChannelContract,
   classifySchemaFormat,
   detectAsyncApiVersion,
   extractAsyncApi,
   listMessageSchemas,
-  mergeTraits
+  mergeTraits,
+  resolveDiscriminator,
+  sanitizeToken,
+  stripDiscriminator
 };

package/dist/message-schemas.js

@@ -1,9 +1,5 @@
-import { toKebabCase } from "@amritk/helpers/ref-to-filename";
 import { refToName } from "@amritk/helpers/ref-to-name";
-const sanitizeToken = (value, fallback) => {
-  const token = toKebabCase(value).replace(/[^\p{ID_Continue}.]+/gu, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
-  return token === "" ? fallback : token;
-};
+import { sanitizeToken } from "./sanitize-token.js";
 const claimToken = (base, taken, issues, path) => {
   let token = base;
   for (let n = 2; taken.has(token); n++) {

package/dist/resolve-discriminator.d.ts

@@ -0,0 +1,29 @@
+import type { NormalizedChannel } from './types.js';
+/**
+ * The property a message contract falls back to when nothing names one.
+ *
+ * Kept as a literal rather than imported from `@amritk/api`: this package's
+ * only dependency is `@amritk/helpers`, and the runtime it feeds must stay a
+ * *peer* of the generated code, not a dependency of the extractor. The value
+ * mirrors `DEFAULT_DISCRIMINATOR` there, and the contract tests hold the two
+ * together.
+ */
+export declare const DEFAULT_DISCRIMINATOR = "type";
+/**
+ * Decides which property tags a channel's messages, in the order the answer
+ * gets more specific:
+ *
+ * 1. `x-mjst: { discriminator }` on the channel itself. The document is the one
+ *    place that knows the wire, and it travels with the document — a consumer
+ *    regenerating from it does not have to be told again.
+ * 2. The caller's override (the CLI's `--discriminator`), for a document you do
+ *    not control and cannot annotate.
+ * 3. `'type'`, matching `@amritk/api`'s default, so the common case needs no
+ *    declaration at all.
+ *
+ * The document wins over the flag deliberately: one `--discriminator` covers a
+ * whole run, and a run may span channels that disagree. A channel that has
+ * written its answer down should not have it overwritten by a blanket default
+ * meant for the channels that have not.
+ */
+export declare const resolveDiscriminator: (channel: NormalizedChannel, override?: string) => string;

package/dist/resolve-discriminator.js

@@ -0,0 +1,6 @@
+const DEFAULT_DISCRIMINATOR = "type";
+const resolveDiscriminator = (channel, override) => channel.discriminator ?? override ?? DEFAULT_DISCRIMINATOR;
+export {
+  DEFAULT_DISCRIMINATOR,
+  resolveDiscriminator
+};

package/dist/sanitize-token.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Folds an arbitrary channel key or message name into a filesystem- and
+ * import-safe kebab token: camelCase splits, and everything a filename cannot
+ * carry — a topic's `/` separators, `{param}` braces, spaces — becomes a
+ * dash. `fallback` covers the value that normalizes away entirely.
+ *
+ * Shared by the schema layout (`channels/<channel>/<message>/`) and the channel
+ * contracts (`contracts/<channel>.ts`) so the two name the same channel the
+ * same way — a reader moving between the trees should not have to translate.
+ */
+export declare const sanitizeToken: (value: string, fallback: string) => string;

package/dist/sanitize-token.js

@@ -0,0 +1,8 @@
+import { toKebabCase } from "@amritk/helpers/ref-to-filename";
+const sanitizeToken = (value, fallback) => {
+  const token = toKebabCase(value).replace(/[^\p{ID_Continue}.]+/gu, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+  return token === "" ? fallback : token;
+};
+export {
+  sanitizeToken
+};

package/dist/strip-discriminator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Either a payload schema fit to stand as a message schema, or the reason it is
+ * not. Never both — a message whose payload cannot be made contract-legal is
+ * skipped with the issue, rather than emitted as something that would throw at
+ * `prepareMessages` time or reject every frame at runtime.
+ */
+export type StripDiscriminatorResult = {
+    readonly schema: Record<string, unknown>;
+    readonly issue?: undefined;
+} | {
+    readonly schema?: undefined;
+    readonly issue: string;
+};
+/**
+ * Removes the discriminator property from a message payload, so what is left
+ * describes the payload alone.
+ *
+ * `@amritk/api` reads the tag off the frame to *select* the message, then
+ * removes it before validating — so a schema that still declares the tag is
+ * refused at setup time by `assertMessageSchema`, and would be unsatisfiable
+ * even if it were not. AsyncAPI documents, meanwhile, almost always declare it:
+ * a channel carrying a `oneOf` of messages has nothing *but* the tag to tell
+ * them apart, so `type: { const: 'hello' }` is how the document says "this is
+ * the hello message". The two conventions are the same fact written twice, and
+ * this reconciles them by trusting the message name — the key the contract is
+ * built on — and dropping the copy.
+ *
+ * Only a declaration that *agrees* with the message name is dropped. Anything
+ * else is an issue rather than a silent rewrite:
+ *
+ * - `type: { const: 'bot_added' }` on a message named `botChanged` means the
+ *   wire tag is not the message name, and stripping it would emit a contract
+ *   that quietly listens for the wrong frame. (Real documents do this: Slack's
+ *   RTM API names two messages after one `bot_added` event.) Give the channel
+ *   an `x-mjst` discriminator naming a different property, or rename the
+ *   message to match the tag.
+ * - `type: { type: 'string' }` constrains the tag without naming a value, so
+ *   nothing here can confirm it ever carries this message's name.
+ * - A payload that is not an object schema has nowhere for a tag to live, which
+ *   `assertMessageSchema` refuses too.
+ *
+ * The input is never mutated: the model's schemas are shared with the parser
+ * generators, which must keep seeing the payload as the document wrote it.
+ */
+export declare const stripDiscriminator: (payload: unknown, discriminator: string, messageName: string) => StripDiscriminatorResult;

package/dist/strip-discriminator.js

@@ -0,0 +1,46 @@
+import { readKey } from "@amritk/helpers/read-key";
+const isSingletonEnum = (enumValue, value) => Array.isArray(enumValue) && enumValue.length === 1 && enumValue[0] === value;
+const stripDiscriminator = (payload, discriminator, messageName) => {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+    return { issue: "payload is not an object schema, so it cannot describe a message" };
+  const schema = payload;
+  const type = readKey(schema, "type");
+  if (type !== void 0 && type !== "object")
+    return { issue: `payload declares type ${JSON.stringify(type)}; a message schema must be type 'object'` };
+  const properties = readKey(schema, "properties");
+  const declaredProperties = typeof properties === "object" && properties !== null ? properties : void 0;
+  const declaration = declaredProperties === void 0 ? void 0 : readKey(declaredProperties, discriminator);
+  const required = readKey(schema, "required");
+  const requiresDiscriminator = Array.isArray(required) && required.includes(discriminator);
+  if (declaration === void 0 && !requiresDiscriminator)
+    return { schema };
+  if (declaration === void 0)
+    return {
+      issue: `payload requires "${discriminator}" without declaring it, so its value cannot be checked against the message name`
+    };
+  if (typeof declaration !== "object" || declaration === null)
+    return { issue: `payload declares "${discriminator}" as ${JSON.stringify(declaration)}, not a schema` };
+  const branch = declaration;
+  const matchesName = readKey(branch, "const") === messageName || isSingletonEnum(readKey(branch, "enum"), messageName);
+  if (!matchesName)
+    return {
+      issue: `payload's "${discriminator}" is not pinned to this message's name, so the wire tag and the contract key would disagree`
+    };
+  const stripped = { ...schema };
+  const remaining = Object.fromEntries(Object.entries(declaredProperties).filter(([key]) => key !== discriminator));
+  if (Object.keys(remaining).length === 0)
+    delete stripped["properties"];
+  else
+    stripped["properties"] = remaining;
+  if (requiresDiscriminator) {
+    const rest = required.filter((entry) => entry !== discriminator);
+    if (rest.length === 0)
+      delete stripped["required"];
+    else
+      stripped["required"] = rest;
+  }
+  return { schema: stripped };
+};
+export {
+  stripDiscriminator
+};

package/dist/types.d.ts

@@ -59,6 +59,14 @@ export type NormalizedChannel = {
     readonly key: string;
     /** The 3.0 `address`; for 2.x the channel key, which *is* the topic/path. */
     readonly address?: string;
+    /**
+     * The property naming which message a frame is, when the channel declares one
+     * via `x-mjst: { discriminator }`. AsyncAPI itself has no way to say this —
+     * it lists a channel's messages and stops — but a message contract has to
+     * pick one property, so a document whose frames are tagged `event` rather
+     * than `type` can say so where the messages are.
+     */
+    readonly discriminator?: string;
     readonly messages: readonly NormalizedMessage[];
 };
 export type AsyncApiModel = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/asyncapi",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Extract JSON Schemas from AsyncAPI 2.x/3.0 documents for the mjst generators.",
   "type": "module",
   "sideEffects": false,
@@ -39,7 +39,7 @@
     "test": "NODE_ENV=production vitest run --root ../.. packages/asyncapi"
   },
   "dependencies": {
-    "@amritk/helpers": "^0.19.0"
+    "@amritk/helpers": "^0.20.0"
   },
   "exports": {
     "./package.json": "./package.json",