@atbas/m-mcp 0.1.0

package/dist/catalogue/types.d.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+/**
+ * Machine-readable description of one payment-integration flow.
+ *
+ * Every flow in `knowledge/flows/` is a faithful transcription of a single
+ * official guide. The schema is the contract between the corpus and the code:
+ * validation, code generation and gateway execution all read from it, so a
+ * correction from the provider is a data change rather than a code change.
+ */
+/**
+ * Payment providers whose flows the catalogue can describe.
+ *
+ * A closed set rather than a free string: a mistyped provider would otherwise
+ * create a one-flow provider of its own, and every provider-scoped rule —
+ * signature scheme, endpoint checks, response contract — would silently decline
+ * to apply to it.
+ *
+ * One member today, and the enumeration is kept rather than collapsed into a
+ * literal: every flow file declares `provider` explicitly, and a single-member
+ * enum makes adding a second one a deliberate schema change rather than a
+ * string somebody can mistype into existence.
+ */
+export declare const PROVIDERS: readonly ["jazzcash"];
+export declare const PRODUCTS: readonly ["card", "bnpl", "mwallet", "wallet-linking", "token", "status-inquiry", "refund"];
+/**
+ * How a flow is performed.
+ *
+ *  - `rest` — a server-to-server JSON POST this server can execute headlessly.
+ *  - `form-post` — a browser form POST the customer completes themselves.
+ *
+ * The distinction is not cosmetic. Called `rest`, a form-post flow would be
+ * sent server-side to an endpoint that expects a customer's browser; called
+ * `form-post`, a REST flow would redirect a customer straight at an endpoint
+ * that expects a signed server-side payload.
+ */
+export declare const TRANSPORTS: readonly ["rest", "form-post"];
+export declare const REQUIREMENTS: readonly ["mandatory", "optional", "must-be-empty"];
+/**
+ * Value types as every consumer sees them once a flow has been parsed.
+ *
+ * `pkt-datetime` and `pkt-expiry` name a zone deliberately, and no general alias
+ * is offered alongside them. The timestamp formatter and both validation rules
+ * are fixed to Asia/Karachi (`src/domain/datetime.ts`,
+ * `src/validation/rules/datetime.ts`, `src/validation/rules/expiry.ts`), so a
+ * general spelling would be a promise the code does not keep: a Turkish flow
+ * declaring `zoned-datetime` would still be stamped and validated in Pakistan
+ * Standard Time, two hours out, with nothing to warn the flow author. A name
+ * that is too specific is visibly wrong; a name that is falsely general is not.
+ *
+ * The zone has to travel with the value — as a declared property of the flow,
+ * read by the formatter — before a genuinely non-PKT flow can be transcribed.
+ */
+export declare const VALUE_TYPES: readonly ["constant", "string", "minor-units", "pkt-datetime", "pkt-expiry", "url", "txn-ref", "bill-reference", "request-id", "msisdn", "cnic", "payment-token", "secure-hash"];
+export type Provider = (typeof PROVIDERS)[number];
+export type Product = (typeof PRODUCTS)[number];
+export type Transport = (typeof TRANSPORTS)[number];
+export type Requirement = (typeof REQUIREMENTS)[number];
+export type ValueType = (typeof VALUE_TYPES)[number];
+declare const parameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    requirement: z.ZodEnum<{
+        mandatory: "mandatory";
+        optional: "optional";
+        "must-be-empty": "must-be-empty";
+    }>;
+    valueType: z.ZodEnum<{
+        string: "string";
+        constant: "constant";
+        "minor-units": "minor-units";
+        "pkt-datetime": "pkt-datetime";
+        "pkt-expiry": "pkt-expiry";
+        url: "url";
+        "txn-ref": "txn-ref";
+        "bill-reference": "bill-reference";
+        "request-id": "request-id";
+        msisdn: "msisdn";
+        cnic: "cnic";
+        "payment-token": "payment-token";
+        "secure-hash": "secure-hash";
+    }>;
+    constantValue: z.ZodOptional<z.ZodString>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+    sensitive: z.ZodDefault<z.ZodBoolean>;
+    neverAcceptAsToolArgument: z.ZodDefault<z.ZodBoolean>;
+    notes: z.ZodString;
+}, z.core.$strict>;
+/**
+ * How a flow signs its requests.
+ *
+ * Still a discriminated union with one member, rather than a bare object: the
+ * discriminator is what makes a second construction fail to compile at every
+ * call site reading `flow.hash`, instead of a field quietly reinterpreted.
+ * `requestHashOptions` in `./hash-options.ts` relies on exactly that.
+ *
+ * Every member is read by `src/domain/signature/`. A field here that no code
+ * consumes is worse than no field at all: it reads as configuration, and a
+ * merchant who corrects it sees nothing change.
+ */
+declare const hashSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    algorithm: z.ZodLiteral<"hmac-sha256">;
+    includeFieldPrefixes: z.ZodArray<z.ZodString>;
+    excludeFields: z.ZodArray<z.ZodString>;
+    outputEncoding: z.ZodEnum<{
+        base64: "base64";
+        "hex-lowercase": "hex-lowercase";
+    }>;
+    comparison: z.ZodEnum<{
+        "case-insensitive": "case-insensitive";
+        "case-sensitive": "case-sensitive";
+    }>;
+}, z.core.$strict>], "algorithm">;
+/**
+ * How a flow's response reports its outcome, and whether it is signed.
+ *
+ * `hashVerification` discriminates because the two cases differ in what they
+ * may declare, not merely in a flag: a signed response must name the field
+ * carrying the digest, and an unsigned one has no such field to name.
+ */
+declare const responseSpecSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    hashVerification: z.ZodLiteral<"assumed-all-non-empty">;
+    hashField: z.ZodString;
+    successField: z.ZodString;
+    successValue: z.ZodString;
+    settlement: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        successValue: z.ZodString;
+    }, z.core.$strict>>;
+    messageField: z.ZodOptional<z.ZodString>;
+    hashFieldPrefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    notableFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    hashVerification: z.ZodLiteral<"not-applicable">;
+    hashField: z.ZodOptional<z.ZodString>;
+    successField: z.ZodString;
+    successValue: z.ZodString;
+    settlement: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        successValue: z.ZodString;
+    }, z.core.$strict>>;
+    messageField: z.ZodOptional<z.ZodString>;
+    hashFieldPrefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    notableFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "hashVerification">;
+declare const knownIssueSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodString;
+    detail: z.ZodString;
+    guidance: z.ZodString;
+}, z.core.$strict>;
+export declare const flowSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    provider: z.ZodEnum<{
+        jazzcash: "jazzcash";
+    }>;
+    product: z.ZodEnum<{
+        card: "card";
+        bnpl: "bnpl";
+        mwallet: "mwallet";
+        "wallet-linking": "wallet-linking";
+        token: "token";
+        "status-inquiry": "status-inquiry";
+        refund: "refund";
+    }>;
+    version: z.ZodString;
+    transport: z.ZodEnum<{
+        rest: "rest";
+        "form-post": "form-post";
+    }>;
+    summary: z.ZodString;
+    useWhen: z.ZodString;
+    endpoints: z.ZodObject<{
+        sandbox: z.ZodURL;
+        production: z.ZodURL;
+    }, z.core.$strict>;
+    sameEndpointForBothEnvironments: z.ZodBoolean;
+    movesMoney: z.ZodBoolean;
+    responseContext: z.ZodEnum<{
+        token: "token";
+        refund: "refund";
+        payment: "payment";
+        inquiry: "inquiry";
+        ipn: "ipn";
+    }>;
+    constants: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        requirement: z.ZodEnum<{
+            mandatory: "mandatory";
+            optional: "optional";
+            "must-be-empty": "must-be-empty";
+        }>;
+        valueType: z.ZodEnum<{
+            string: "string";
+            constant: "constant";
+            "minor-units": "minor-units";
+            "pkt-datetime": "pkt-datetime";
+            "pkt-expiry": "pkt-expiry";
+            url: "url";
+            "txn-ref": "txn-ref";
+            "bill-reference": "bill-reference";
+            "request-id": "request-id";
+            msisdn: "msisdn";
+            cnic: "cnic";
+            "payment-token": "payment-token";
+            "secure-hash": "secure-hash";
+        }>;
+        constantValue: z.ZodOptional<z.ZodString>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+        sensitive: z.ZodDefault<z.ZodBoolean>;
+        neverAcceptAsToolArgument: z.ZodDefault<z.ZodBoolean>;
+        notes: z.ZodString;
+    }, z.core.$strict>>;
+    hash: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        algorithm: z.ZodLiteral<"hmac-sha256">;
+        includeFieldPrefixes: z.ZodArray<z.ZodString>;
+        excludeFields: z.ZodArray<z.ZodString>;
+        outputEncoding: z.ZodEnum<{
+            base64: "base64";
+            "hex-lowercase": "hex-lowercase";
+        }>;
+        comparison: z.ZodEnum<{
+            "case-insensitive": "case-insensitive";
+            "case-sensitive": "case-sensitive";
+        }>;
+    }, z.core.$strict>], "algorithm">;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        hashVerification: z.ZodLiteral<"assumed-all-non-empty">;
+        hashField: z.ZodString;
+        successField: z.ZodString;
+        successValue: z.ZodString;
+        settlement: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            successValue: z.ZodString;
+        }, z.core.$strict>>;
+        messageField: z.ZodOptional<z.ZodString>;
+        hashFieldPrefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        notableFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        hashVerification: z.ZodLiteral<"not-applicable">;
+        hashField: z.ZodOptional<z.ZodString>;
+        successField: z.ZodString;
+        successValue: z.ZodString;
+        settlement: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            successValue: z.ZodString;
+        }, z.core.$strict>>;
+        messageField: z.ZodOptional<z.ZodString>;
+        hashFieldPrefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        notableFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>], "hashVerification">;
+    companionFlows: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    docRefs: z.ZodArray<z.ZodObject<{
+        docId: z.ZodString;
+        sectionId: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    knownIssues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        summary: z.ZodString;
+        detail: z.ZodString;
+        guidance: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type FlowParameter = z.infer<typeof parameterSchema>;
+export type FlowHashSpec = z.infer<typeof hashSpecSchema>;
+export type FlowResponseSpec = z.infer<typeof responseSpecSchema>;
+export type FlowKnownIssue = z.infer<typeof knownIssueSchema>;
+export type IntegrationFlow = z.infer<typeof flowSchema>;
+/** Parameter names the caller must supply because they carry business data. */
+export declare function businessParameters(flow: IntegrationFlow): readonly FlowParameter[];
+/** Every parameter name declared by the flow, in documentation order. */
+export declare function parameterNames(flow: IntegrationFlow): readonly string[];
+/** Look up a single parameter definition. */
+export declare function findParameter(flow: IntegrationFlow, name: string): FlowParameter | undefined;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/catalogue/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/catalogue/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,uBAAwB,CAAC;AAE/C,eAAO,MAAM,QAAQ,6FAA8F,CAAC;AAEpH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,gCAAiC,CAAC;AAEzD,eAAO,MAAM,YAAY,qDAAsD,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,kLAcd,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAClD,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAChD,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AACxD,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAQrD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwBnB,CAAC;AAqBH;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc;;;;;;;;;;;;iCAAoE,CAAC;AAwHzF;;;;;;GAMG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;wCAGtB,CAAC;AAcH,QAAA,MAAM,gBAAgB;;;;;kBAKpB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoFnB,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEzD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,aAAa,EAAE,CAOlF;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,MAAM,EAAE,CAEvE;AAED,6CAA6C;AAC7C,wBAAgB,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE5F"}

package/dist/catalogue/types.js

@@ -0,0 +1,360 @@
+import { z } from 'zod';
+/**
+ * Machine-readable description of one payment-integration flow.
+ *
+ * Every flow in `knowledge/flows/` is a faithful transcription of a single
+ * official guide. The schema is the contract between the corpus and the code:
+ * validation, code generation and gateway execution all read from it, so a
+ * correction from the provider is a data change rather than a code change.
+ */
+/**
+ * Payment providers whose flows the catalogue can describe.
+ *
+ * A closed set rather than a free string: a mistyped provider would otherwise
+ * create a one-flow provider of its own, and every provider-scoped rule —
+ * signature scheme, endpoint checks, response contract — would silently decline
+ * to apply to it.
+ *
+ * One member today, and the enumeration is kept rather than collapsed into a
+ * literal: every flow file declares `provider` explicitly, and a single-member
+ * enum makes adding a second one a deliberate schema change rather than a
+ * string somebody can mistype into existence.
+ */
+export const PROVIDERS = ['jazzcash'];
+export const PRODUCTS = ['card', 'bnpl', 'mwallet', 'wallet-linking', 'token', 'status-inquiry', 'refund'];
+/**
+ * How a flow is performed.
+ *
+ *  - `rest` — a server-to-server JSON POST this server can execute headlessly.
+ *  - `form-post` — a browser form POST the customer completes themselves.
+ *
+ * The distinction is not cosmetic. Called `rest`, a form-post flow would be
+ * sent server-side to an endpoint that expects a customer's browser; called
+ * `form-post`, a REST flow would redirect a customer straight at an endpoint
+ * that expects a signed server-side payload.
+ */
+export const TRANSPORTS = ['rest', 'form-post'];
+export const REQUIREMENTS = ['mandatory', 'optional', 'must-be-empty'];
+/**
+ * Value types as every consumer sees them once a flow has been parsed.
+ *
+ * `pkt-datetime` and `pkt-expiry` name a zone deliberately, and no general alias
+ * is offered alongside them. The timestamp formatter and both validation rules
+ * are fixed to Asia/Karachi (`src/domain/datetime.ts`,
+ * `src/validation/rules/datetime.ts`, `src/validation/rules/expiry.ts`), so a
+ * general spelling would be a promise the code does not keep: a Turkish flow
+ * declaring `zoned-datetime` would still be stamped and validated in Pakistan
+ * Standard Time, two hours out, with nothing to warn the flow author. A name
+ * that is too specific is visibly wrong; a name that is falsely general is not.
+ *
+ * The zone has to travel with the value — as a declared property of the flow,
+ * read by the formatter — before a genuinely non-PKT flow can be transcribed.
+ */
+export const VALUE_TYPES = [
+    'constant',
+    'string',
+    'minor-units',
+    'pkt-datetime',
+    'pkt-expiry',
+    'url',
+    'txn-ref',
+    'bill-reference',
+    'request-id',
+    'msisdn',
+    'cnic',
+    'payment-token',
+    'secure-hash',
+];
+const docRefSchema = z.strictObject({
+    docId: z.string().min(1),
+    sectionId: z.string().min(1).optional(),
+    label: z.string().min(1).optional(),
+});
+const parameterSchema = z.strictObject({
+    name: z.string().min(1),
+    requirement: z.enum(REQUIREMENTS),
+    valueType: z.enum(VALUE_TYPES),
+    /** Required value when `valueType` is `constant`. */
+    constantValue: z.string().optional(),
+    maxLength: z.number().int().positive().optional(),
+    /** Additional regular expression the value must satisfy, as a source string. */
+    pattern: z.string().optional(),
+    /** True for credentials and personal data; excluded from logs and echoes. */
+    sensitive: z.boolean().default(false),
+    /**
+     * True for a value that must never cross the MCP boundary as a tool argument.
+     *
+     * Card flows carry the PAN, the expiry and the CVV. `safeHandler` scrubs tool
+     * OUTPUTS, not inputs, so a PAN pasted as a tool argument is already in the
+     * conversation transcript — and in whatever the harness persists — before any
+     * server code runs, and no later redaction can recall it. A parameter marked
+     * here has to reach the gateway by another route: a hosted field, or the
+     * merchant's own server. Distinct from `sensitive`, which says a value may be
+     * handled but never echoed.
+     */
+    neverAcceptAsToolArgument: z.boolean().default(false),
+    notes: z.string().min(1),
+});
+const HASH_OUTPUT_ENCODINGS = ['hex-lowercase', 'base64'];
+const HASH_COMPARISONS = ['case-insensitive', 'case-sensitive'];
+/**
+ * A signature built from prefix-selected fields, keyed with the shared secret.
+ *
+ * The JazzCash construction: sort the selected non-empty parameters by name,
+ * join their values, prepend the Integrity Salt and HMAC the result with it.
+ */
+const prefixSelectedHashSpecSchema = z.strictObject({
+    algorithm: z.literal('hmac-sha256'),
+    /** Assumption A1. See `src/domain/signature/jazzcash.ts`. */
+    includeFieldPrefixes: z.array(z.string()).min(1),
+    excludeFields: z.array(z.string()),
+    outputEncoding: z.enum(HASH_OUTPUT_ENCODINGS),
+    comparison: z.enum(HASH_COMPARISONS),
+});
+/**
+ * How a flow signs its requests.
+ *
+ * Still a discriminated union with one member, rather than a bare object: the
+ * discriminator is what makes a second construction fail to compile at every
+ * call site reading `flow.hash`, instead of a field quietly reinterpreted.
+ * `requestHashOptions` in `./hash-options.ts` relies on exactly that.
+ *
+ * Every member is read by `src/domain/signature/`. A field here that no code
+ * consumes is worse than no field at all: it reads as configuration, and a
+ * merchant who corrects it sees nothing change.
+ */
+const hashSpecSchema = z.discriminatedUnion('algorithm', [prefixSelectedHashSpecSchema]);
+/**
+ * The shape of a response field name.
+ *
+ * A shape check rather than a closed enumeration: a field name is an identifier
+ * the gateway sends, and an empty value, a stray space or a pasted quotation
+ * mark is a transcription slip. The slip is silent — verification and success
+ * checking both read a field that never arrives, and report nothing rather than
+ * complaining.
+ *
+ * Shape cannot catch a MISSPELLED identifier, so `flowSchema` re-pins the exact
+ * JazzCash names below, where the corpus actually documents them.
+ */
+const responseFieldNameSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z][A-Za-z0-9_]*$/u, 'A response field name is an identifier: a letter followed by letters, digits or underscores.');
+/**
+ * The settlement (bank) level of a two-level success rule.
+ *
+ * Some gateways answer a card sale twice over: a service-level code saying the
+ * request was accepted and processed, and an acquirer code saying whether the
+ * card was actually approved. BOTH have to be checked. A contract that names
+ * only the service level classifies a DECLINED card as a successful payment,
+ * and a merchant who releases goods on that classification is never paid.
+ *
+ * The field and the value it must hold travel together as one object, because a
+ * field with no value to compare against cannot be checked at all, and a value
+ * with no field names nothing.
+ */
+const settlementSpecSchema = z.strictObject({
+    field: responseFieldNameSchema,
+    successValue: z.string().min(1),
+});
+/** The parts of a response contract that do not depend on whether it is signed. */
+const responseSpecBase = {
+    successField: responseFieldNameSchema,
+    successValue: z.string().min(1),
+    /**
+     * The bank-level result, where the service-level code is not the whole answer.
+     *
+     * Absent for every JazzCash flow: those report one outcome in one field.
+     */
+    settlement: settlementSpecSchema.optional(),
+    /**
+     * The field carrying the gateway's own explanation of the outcome.
+     *
+     * Declared rather than derived from `successField`. The generator used to read
+     * `successField === 'ResponseCode' ? 'ResponseMessage' : 'pp_ResponseMessage'`,
+     * which is a JazzCash naming convention applied to every provider, so a
+     * generated client for anyone else printed a field its gateway never sends —
+     * silently, because an absent key is an empty line rather than an error.
+     *
+     * Optional, because a provider that sends no message has none to name, and
+     * `src/codegen/generate.ts` then generates no lookup at all. Unlike
+     * `successField` and `hashField` it is not re-pinned per provider below: a
+     * misspelling here prints nothing where an explanation should be, while a
+     * misspelling there misclassifies every response or skips verification
+     * entirely.
+     */
+    messageField: responseFieldNameSchema.optional(),
+    /**
+     * Prefixes that select which RESPONSE fields feed the response hash.
+     *
+     * Empty means no filtering, which is correct for every documented flow: card
+     * and BNPL refund responses use unprefixed field names, so applying the
+     * request filter (`pp_`, `ppmpf_`) would exclude every field and reduce the
+     * hash input to the bare salt. Declared separately from `hash` because the
+     * request and response rules are genuinely different, and present on an
+     * unsigned response too, because `jazzcash_verify_secure_hash` recomputes a
+     * pasted response for any flow and still has to know the selection rule.
+     */
+    hashFieldPrefixes: z.array(z.string()).default([]),
+    notableFields: z.array(z.string()).default([]),
+};
+/**
+ * A response the server recomputes a signature over.
+ *
+ * Assumption A2: no guide states which response fields feed the response hash.
+ * `assumed-all-non-empty` means the server recomputes over all non-empty fields
+ * but reports `unverified` rather than `failed` on a mismatch.
+ */
+const signedResponseSpecSchema = z.strictObject({
+    ...responseSpecBase,
+    hashVerification: z.literal('assumed-all-non-empty'),
+    /**
+     * Card and BNPL refunds return a bare `SecureHash`; every other JazzCash
+     * response returns `pp_SecureHash`. Getting this wrong silently skips
+     * response verification.
+     */
+    hashField: responseFieldNameSchema,
+});
+/**
+ * A response the server does not verify a signature on.
+ *
+ * `hashField` is OPTIONAL here, and that is the whole point of the split.
+ * Requiring it forced a provider whose REST responses are unsigned to name a
+ * field that does not exist, and every call then reported "no hash arrived" —
+ * which reads as a broken integration rather than as the provider's design.
+ *
+ * Optional rather than forbidden: a gateway may return a digest it does not
+ * document how to reproduce, and recording the field a merchant can see in the
+ * payload is still worth something. Absent means there is nothing to read, and
+ * `src/gateway/rest-client.ts` says so instead of hunting for a field.
+ */
+const unsignedResponseSpecSchema = z.strictObject({
+    ...responseSpecBase,
+    hashVerification: z.literal('not-applicable'),
+    hashField: responseFieldNameSchema.optional(),
+});
+/**
+ * How a flow's response reports its outcome, and whether it is signed.
+ *
+ * `hashVerification` discriminates because the two cases differ in what they
+ * may declare, not merely in a flag: a signed response must name the field
+ * carrying the digest, and an unsigned one has no such field to name.
+ */
+const responseSpecSchema = z.discriminatedUnion('hashVerification', [
+    signedResponseSpecSchema,
+    unsignedResponseSpecSchema,
+]);
+/**
+ * The response field names the JazzCash guides actually use.
+ *
+ * The shape check above accepts any identifier, which on its own would drop the
+ * check that caught `pp_ResponceCode` in a flow file. Re-pinned here, where the
+ * corpus documents them: a wrong name is silent otherwise, because the success
+ * check then reads a field that never arrives and every response classifies as
+ * unrecognisable.
+ */
+const JAZZCASH_RESPONSE_HASH_FIELDS = ['pp_SecureHash', 'SecureHash'];
+const JAZZCASH_RESPONSE_SUCCESS_FIELDS = ['pp_ResponseCode', 'ResponseCode'];
+const knownIssueSchema = z.strictObject({
+    id: z.string().min(1),
+    summary: z.string().min(1),
+    detail: z.string().min(1),
+    guidance: z.string().min(1),
+});
+export const flowSchema = z
+    .strictObject({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    /**
+     * The gateway this flow belongs to.
+     *
+     * Required rather than defaulted, even with one provider in the enumeration:
+     * a file that omitted the field would load as JazzCash by accident, and the
+     * day a second provider is added every existing flow would need auditing to
+     * find out which of them had meant it.
+     */
+    provider: z.enum(PROVIDERS),
+    product: z.enum(PRODUCTS),
+    version: z.string().min(1),
+    transport: z.enum(TRANSPORTS),
+    summary: z.string().min(1),
+    useWhen: z.string().min(1),
+    endpoints: z.strictObject({
+        sandbox: z.url(),
+        production: z.url(),
+    }),
+    /** True for every documented flow: the environment lives in the credentials. */
+    sameEndpointForBothEnvironments: z.boolean(),
+    /**
+     * True when a successful call debits, refunds or authorises money, or links
+     * a wallet. Drives the production dual opt-in guard.
+     */
+    movesMoney: z.boolean(),
+    responseContext: z.enum(['payment', 'inquiry', 'refund', 'ipn', 'token']),
+    constants: z.record(z.string(), z.string()).default({}),
+    parameters: z.array(parameterSchema).min(1),
+    hash: hashSpecSchema,
+    response: responseSpecSchema,
+    /** Flows the guides mark as mandatory alongside this one. */
+    companionFlows: z.array(z.string()).default([]),
+    docRefs: z.array(docRefSchema).min(1),
+    knownIssues: z.array(knownIssueSchema).default([]),
+})
+    .superRefine((flow, ctx) => {
+    // Every rule below is JazzCash's, and `PROVIDERS` names only JazzCash, so
+    // they apply to every flow. A second provider added to the enumeration must
+    // reinstate a guard here first: these spellings are JazzCash's, and applied
+    // to another gateway they would reject its correct field names.
+    const { hashField, successField } = flow.response;
+    if (hashField !== undefined && !JAZZCASH_RESPONSE_HASH_FIELDS.includes(hashField)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['response', 'hashField'],
+            message: `A JazzCash response carries its signature in ${JAZZCASH_RESPONSE_HASH_FIELDS.join(' or ')}, not in "${hashField}". Verification against a field the gateway never sends reports "no hash arrived" on every call.`,
+        });
+    }
+    if (!JAZZCASH_RESPONSE_SUCCESS_FIELDS.includes(successField)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['response', 'successField'],
+            message: `A JazzCash response reports its outcome in ${JAZZCASH_RESPONSE_SUCCESS_FIELDS.join(' or ')}, not in "${successField}". Reading the outcome from a field the gateway never sends classifies every response as unrecognisable.`,
+        });
+    }
+    // Every JazzCash response is signed. Declaring otherwise would silently
+    // switch off response verification for a flow the guides say carries a
+    // digest, and the loss is invisible: nothing reports a check that was never
+    // attempted.
+    if (flow.response.hashVerification !== 'assumed-all-non-empty') {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['response', 'hashVerification'],
+            message: `Every JazzCash response carries a signature, so this must be "assumed-all-non-empty". Declaring "${flow.response.hashVerification}" skips response verification silently.`,
+        });
+    }
+    // A JazzCash response reports one outcome in one field. A settlement level
+    // here would make `classifyResponse` demand a bank code the gateway never
+    // sends, so every successful payment would classify as unknown.
+    if (flow.response.settlement !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['response', 'settlement'],
+            message: `A JazzCash response reports one outcome in ${flow.response.successField}, so it has no settlement level. Declaring "${flow.response.settlement.field}" makes every response classify as unknown, because the gateway never sends it.`,
+        });
+    }
+});
+/** Parameter names the caller must supply because they carry business data. */
+export function businessParameters(flow) {
+    return flow.parameters.filter((parameter) => parameter.requirement !== 'must-be-empty' &&
+        parameter.valueType !== 'constant' &&
+        parameter.valueType !== 'secure-hash');
+}
+/** Every parameter name declared by the flow, in documentation order. */
+export function parameterNames(flow) {
+    return flow.parameters.map((parameter) => parameter.name);
+}
+/** Look up a single parameter definition. */
+export function findParameter(flow, name) {
+    return flow.parameters.find((parameter) => parameter.name === name);
+}
+//# sourceMappingURL=types.js.map

package/dist/catalogue/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/catalogue/types.ts"],"names":[],"mappings":"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"}

package/dist/codegen/generate.d.ts

@@ -0,0 +1,14 @@
+import type { IntegrationFlow } from '../catalogue/types.js';
+import type { CodegenRequest, CodegenResult, TemplateKind } from './types.js';
+/** Generate one artefact for a flow. */
+export declare function generateCode(request: CodegenRequest): CodegenResult;
+/**
+ * The artefact kinds that make sense for a flow.
+ *
+ * Every shipped transport has a kind, so this is currently total. It returns a
+ * list rather than one kind because a transport nothing here can generate for
+ * must be able to answer "none" — naming a kind and then refusing it in
+ * `assertKindSuitsFlow` sent the caller round in a circle between the two.
+ */
+export declare function availableKinds(flow: IntegrationFlow): readonly TemplateKind[];
+//# sourceMappingURL=generate.d.ts.map