@comfyorg/billing-contract 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Comfy Org
+
+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/dist/contract.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The versioned URL contract every Comfy product uses to hand a customer to
+ * the hosted billing app, and that the app reads back on arrival.
+ *
+ * The entry URL is routing input and nothing more. It never carries a token,
+ * a JWT, a payment-provider secret, an authoritative price, or a caller-chosen
+ * return URL: a product states which billing screen it wants, which product is
+ * asking, and which registered destination the customer should land on
+ * afterwards. Billing resolves everything else against its own environment and
+ * the signed-in session, so a workspace id here is a requested scope and never
+ * an authorization.
+ *
+ * Route and parameter names are provisional while the hosted app is behind a
+ * flag. `BILLING_CONTRACT_VERSION` is what lets them change without stranding
+ * a product that is already deployed against the older shape.
+ *
+ * Whether a payment renders embedded or hosted is not decided here — that is
+ * the SDK core's `hostedDestination` port. This package stays dependency-free
+ * and framework-free so a product, the billing app, and a future non-Vue host
+ * can share exactly one definition of the route surface.
+ */
+export declare const BILLING_CONTRACT_VERSION = "v1";
+export declare const BILLING_INTENTS: readonly ["pricing", "checkout", "subscription", "payment-methods", "invoices", "result"];
+export type BillingIntent = (typeof BILLING_INTENTS)[number];
+export declare function isBillingIntent(value: string | null | undefined): value is BillingIntent;
+/** The route an intent occupies, e.g. `/v1/checkout`. */
+export declare function billingIntentPath(intent: BillingIntent): string;
+/** The surfaces allowed to originate a billing trip. */
+export declare const BILLING_PRODUCTS: readonly ["comfyui", "platform", "workshop", "models"];
+export type BillingProduct = (typeof BILLING_PRODUCTS)[number];
+export declare function isBillingProduct(value: string | null | undefined): value is BillingProduct;
+/**
+ * Which deployment family a return destination belongs to. The backends run
+ * three of them, not two, and pair each origin with exactly one family, so a
+ * product resolves its return target in the same family its session was
+ * minted against.
+ *
+ * A host picks its family by origin, never by the label on its own build: the
+ * cloud app's "staging" distribution points at `testcloud.comfy.org`
+ * (`STAGING_CLOUD_BASE_URL` in `src/config/comfyApi.ts`) and therefore maps to
+ * `test` here, while `staging` means `stagingcloud.comfy.org`.
+ */
+export type BillingEnvironment = 'production' | 'staging' | 'test';

package/dist/contract.js

@@ -0,0 +1,47 @@
+/**
+ * The versioned URL contract every Comfy product uses to hand a customer to
+ * the hosted billing app, and that the app reads back on arrival.
+ *
+ * The entry URL is routing input and nothing more. It never carries a token,
+ * a JWT, a payment-provider secret, an authoritative price, or a caller-chosen
+ * return URL: a product states which billing screen it wants, which product is
+ * asking, and which registered destination the customer should land on
+ * afterwards. Billing resolves everything else against its own environment and
+ * the signed-in session, so a workspace id here is a requested scope and never
+ * an authorization.
+ *
+ * Route and parameter names are provisional while the hosted app is behind a
+ * flag. `BILLING_CONTRACT_VERSION` is what lets them change without stranding
+ * a product that is already deployed against the older shape.
+ *
+ * Whether a payment renders embedded or hosted is not decided here — that is
+ * the SDK core's `hostedDestination` port. This package stays dependency-free
+ * and framework-free so a product, the billing app, and a future non-Vue host
+ * can share exactly one definition of the route surface.
+ */
+export const BILLING_CONTRACT_VERSION = 'v1';
+export const BILLING_INTENTS = [
+    'pricing',
+    'checkout',
+    'subscription',
+    'payment-methods',
+    'invoices',
+    'result'
+];
+export function isBillingIntent(value) {
+    return BILLING_INTENTS.some((intent) => intent === value);
+}
+/** The route an intent occupies, e.g. `/v1/checkout`. */
+export function billingIntentPath(intent) {
+    return `/${BILLING_CONTRACT_VERSION}/${intent}`;
+}
+/** The surfaces allowed to originate a billing trip. */
+export const BILLING_PRODUCTS = [
+    'comfyui',
+    'platform',
+    'workshop',
+    'models'
+];
+export function isBillingProduct(value) {
+    return BILLING_PRODUCTS.some((product) => product === value);
+}

package/dist/entryFields.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The query shape of an entry URL, in one table so the builder and the parser
+ * cannot drift apart: a field is written and read under the same name, and a
+ * value that fails the shared charset reports the same code on both sides.
+ */
+/** Names are provisional; see `contract.ts`. */
+export declare const ENTRY_PARAM_PRODUCT = "product";
+export declare const ENTRY_PARAM_RETURN_TO = "return_to";
+export type OptionalEntryKey = 'plan' | 'correlationId' | 'workspaceId';
+export type InvalidIdentifierCode = 'INVALID_PLAN' | 'INVALID_CORRELATION_ID' | 'INVALID_WORKSPACE_ID';
+interface OptionalEntryField {
+    readonly key: OptionalEntryKey;
+    readonly param: string;
+    readonly code: InvalidIdentifierCode;
+}
+export declare const OPTIONAL_ENTRY_FIELDS: readonly OptionalEntryField[];
+export type OptionalEntryValues = {
+    readonly [K in OptionalEntryKey]?: string;
+};
+export {};

package/dist/entryFields.js

@@ -0,0 +1,17 @@
+/**
+ * The query shape of an entry URL, in one table so the builder and the parser
+ * cannot drift apart: a field is written and read under the same name, and a
+ * value that fails the shared charset reports the same code on both sides.
+ */
+/** Names are provisional; see `contract.ts`. */
+export const ENTRY_PARAM_PRODUCT = 'product';
+export const ENTRY_PARAM_RETURN_TO = 'return_to';
+export const OPTIONAL_ENTRY_FIELDS = [
+    { key: 'plan', param: 'plan', code: 'INVALID_PLAN' },
+    {
+        key: 'correlationId',
+        param: 'correlation_id',
+        code: 'INVALID_CORRELATION_ID'
+    },
+    { key: 'workspaceId', param: 'workspace_id', code: 'INVALID_WORKSPACE_ID' }
+];

package/dist/entryParser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The billing-web side of the contract: read an arriving URL back into the
+ * request a product meant to make. Unknown query parameters are ignored, so a
+ * product may add analytics noise without breaking the app; everything the
+ * contract names is validated, because this is untrusted input.
+ */
+import type { BillingIntent, BillingProduct } from './contract.js';
+import { BILLING_CONTRACT_VERSION } from './contract.js';
+import type { InvalidIdentifierCode, OptionalEntryValues } from './entryFields.js';
+import type { ReturnTarget } from './returnTargets.js';
+export interface BillingEntry extends OptionalEntryValues {
+    readonly version: typeof BILLING_CONTRACT_VERSION;
+    readonly intent: BillingIntent;
+    readonly product: BillingProduct;
+    readonly returnTo: ReturnTarget;
+}
+export type BillingEntryErrorCode = 'UNSUPPORTED_VERSION' | 'UNKNOWN_INTENT' | 'UNKNOWN_PRODUCT' | 'UNKNOWN_RETURN_TARGET' | InvalidIdentifierCode;
+export type BillingEntryResult = {
+    readonly status: 'ok';
+    readonly entry: BillingEntry;
+} | {
+    readonly status: 'error';
+    readonly code: BillingEntryErrorCode;
+};
+/**
+ * Accepts a full href or the path-and-query form a router hands over. Input
+ * that is not a `/v1` billing route at all — a malformed string included —
+ * reports `UNSUPPORTED_VERSION`, because from the app's side it is a URL the
+ * contract does not describe.
+ */
+export declare function parseBillingEntry(url: string | URL): BillingEntryResult;

package/dist/entryParser.js

@@ -0,0 +1,58 @@
+import { BILLING_CONTRACT_VERSION, isBillingIntent, isBillingProduct } from './contract.js';
+import { ENTRY_PARAM_PRODUCT, ENTRY_PARAM_RETURN_TO, OPTIONAL_ENTRY_FIELDS } from './entryFields.js';
+import { isContractIdentifier } from './identifiers.js';
+import { isReturnTarget } from './returnTargets.js';
+import { CONTRACT_PARSE_BASE, parseUrl } from './url.js';
+function parseRoute(pathname) {
+    const [version, intent, ...rest] = pathname.split('/').filter(Boolean);
+    if (version !== BILLING_CONTRACT_VERSION)
+        return { status: 'error', code: 'UNSUPPORTED_VERSION' };
+    if (rest.length > 0 || !isBillingIntent(intent))
+        return { status: 'error', code: 'UNKNOWN_INTENT' };
+    return { status: 'ok', intent };
+}
+function parseOptionalFields(params) {
+    const values = {};
+    for (const field of OPTIONAL_ENTRY_FIELDS) {
+        const raw = params.get(field.param);
+        if (raw === null)
+            continue;
+        if (!isContractIdentifier(raw))
+            return { status: 'error', code: field.code };
+        values[field.key] = raw;
+    }
+    return { status: 'ok', values };
+}
+/**
+ * Accepts a full href or the path-and-query form a router hands over. Input
+ * that is not a `/v1` billing route at all — a malformed string included —
+ * reports `UNSUPPORTED_VERSION`, because from the app's side it is a URL the
+ * contract does not describe.
+ */
+export function parseBillingEntry(url) {
+    const parsed = parseUrl(url, CONTRACT_PARSE_BASE);
+    if (!parsed)
+        return { status: 'error', code: 'UNSUPPORTED_VERSION' };
+    const route = parseRoute(parsed.pathname);
+    if (route.status === 'error')
+        return route;
+    const product = parsed.searchParams.get(ENTRY_PARAM_PRODUCT);
+    if (!isBillingProduct(product))
+        return { status: 'error', code: 'UNKNOWN_PRODUCT' };
+    const returnTo = parsed.searchParams.get(ENTRY_PARAM_RETURN_TO);
+    if (returnTo === null || !isReturnTarget(returnTo))
+        return { status: 'error', code: 'UNKNOWN_RETURN_TARGET' };
+    const optional = parseOptionalFields(parsed.searchParams);
+    if (optional.status === 'error')
+        return optional;
+    return {
+        status: 'ok',
+        entry: {
+            version: BILLING_CONTRACT_VERSION,
+            intent: route.intent,
+            product,
+            returnTo,
+            ...optional.values
+        }
+    };
+}

package/dist/entryUrl.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The product side of the contract: turn a billing request into the URL to
+ * navigate to. Failures are coded results in the style of the billing core's
+ * `BillingResult` — the builder never throws, and a code carries no server or
+ * caller text a host could render by accident.
+ */
+import type { BillingIntent, BillingProduct } from './contract.js';
+import type { InvalidIdentifierCode, OptionalEntryValues } from './entryFields.js';
+export interface BillingEntryInput extends OptionalEntryValues {
+    /** Only the origin is used; any path or query on it is discarded. */
+    readonly billingOrigin: string | URL;
+    readonly intent: BillingIntent;
+    readonly product: BillingProduct;
+    /**
+     * A `ReturnTarget`. Typed wide because the registry lookup is the real gate:
+     * a JavaScript host, or a generic that widened the literal, still has to
+     * name a registered target.
+     */
+    readonly returnTo: string;
+}
+export type BillingEntryUrlErrorCode = 'INVALID_ORIGIN' | 'UNKNOWN_RETURN_TARGET' | InvalidIdentifierCode;
+export type BillingEntryUrlResult = {
+    readonly status: 'ok';
+    readonly url: URL;
+} | {
+    readonly status: 'error';
+    readonly code: BillingEntryUrlErrorCode;
+};
+export declare function buildBillingEntryUrl(input: BillingEntryInput): BillingEntryUrlResult;

package/dist/entryUrl.js

@@ -0,0 +1,43 @@
+import { billingIntentPath } from './contract.js';
+import { ENTRY_PARAM_PRODUCT, ENTRY_PARAM_RETURN_TO, OPTIONAL_ENTRY_FIELDS } from './entryFields.js';
+import { isContractIdentifier } from './identifiers.js';
+import { isReturnTarget } from './returnTargets.js';
+import { parseUrl } from './url.js';
+const LOCAL_HOSTNAMES = new Set(['localhost', '127.0.0.1', '[::1]']);
+function billingOriginHref(origin) {
+    const url = parseUrl(origin);
+    if (!url || url.username || url.password)
+        return undefined;
+    if (url.protocol === 'https:')
+        return url.origin;
+    if (url.protocol === 'http:' && LOCAL_HOSTNAMES.has(url.hostname))
+        return url.origin;
+    return undefined;
+}
+function invalidIdentifierCode(values) {
+    for (const field of OPTIONAL_ENTRY_FIELDS) {
+        const value = values[field.key];
+        if (value !== undefined && !isContractIdentifier(value))
+            return field.code;
+    }
+    return undefined;
+}
+export function buildBillingEntryUrl(input) {
+    const origin = billingOriginHref(input.billingOrigin);
+    if (origin === undefined)
+        return { status: 'error', code: 'INVALID_ORIGIN' };
+    if (!isReturnTarget(input.returnTo))
+        return { status: 'error', code: 'UNKNOWN_RETURN_TARGET' };
+    const invalid = invalidIdentifierCode(input);
+    if (invalid !== undefined)
+        return { status: 'error', code: invalid };
+    const url = new URL(billingIntentPath(input.intent), origin);
+    url.searchParams.set(ENTRY_PARAM_PRODUCT, input.product);
+    url.searchParams.set(ENTRY_PARAM_RETURN_TO, input.returnTo);
+    for (const field of OPTIONAL_ENTRY_FIELDS) {
+        const value = input[field.key];
+        if (value !== undefined)
+            url.searchParams.set(field.param, value);
+    }
+    return { status: 'ok', url };
+}

package/dist/identifiers.d.ts

@@ -0,0 +1 @@
+export declare function isContractIdentifier(value: string): boolean;

package/dist/identifiers.js

@@ -0,0 +1,11 @@
+/**
+ * The charset every free-form identifier in the contract shares: plan slugs,
+ * correlation ids, workspace ids, and the reference billing hands back. It is
+ * deliberately narrower than what a URL permits, so nothing that survives it
+ * can carry a path separator, a query delimiter, or a percent escape into a
+ * downstream URL.
+ */
+const CONTRACT_IDENTIFIER = /^[A-Za-z0-9_-]{1,128}$/;
+export function isContractIdentifier(value) {
+    return CONTRACT_IDENTIFIER.test(value);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export type { BillingEnvironment, BillingIntent, BillingProduct } from './contract.js';
+export { BILLING_CONTRACT_VERSION, BILLING_INTENTS, BILLING_PRODUCTS, billingIntentPath, isBillingIntent, isBillingProduct } from './contract.js';
+export type { BillingEntry, BillingEntryErrorCode, BillingEntryResult } from './entryParser.js';
+export { parseBillingEntry } from './entryParser.js';
+export type { BillingEntryInput, BillingEntryUrlErrorCode, BillingEntryUrlResult } from './entryUrl.js';
+export { buildBillingEntryUrl } from './entryUrl.js';
+export type { ReturnTarget } from './returnTargets.js';
+export { RETURN_TARGETS, isReturnTarget, resolveReturnTarget } from './returnTargets.js';
+export type { BillingOutcome, BillingReturn, ReturnUrlInput } from './returnUrl.js';
+export { buildReturnUrl, parseReturnResult } from './returnUrl.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { BILLING_CONTRACT_VERSION, BILLING_INTENTS, BILLING_PRODUCTS, billingIntentPath, isBillingIntent, isBillingProduct } from './contract.js';
+export { parseBillingEntry } from './entryParser.js';
+export { buildBillingEntryUrl } from './entryUrl.js';
+export { RETURN_TARGETS, isReturnTarget, resolveReturnTarget } from './returnTargets.js';
+export { buildReturnUrl, parseReturnResult } from './returnUrl.js';

package/dist/returnTargets.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Where billing is allowed to send a customer back to. A closed registry, not
+ * a caller-supplied URL: `return_to=<identifier>` names a target, and the
+ * absolute destination is chosen here per environment, so a crafted entry URL
+ * cannot turn the hosted app into an open redirect.
+ *
+ * Every destination below is one this repository already states. A family a
+ * target has no confirmed origin for stays absent rather than being derived
+ * from a sibling's hostname, because an unresolvable target fails closed while
+ * a guessed one sends a customer somewhere nobody serves.
+ *
+ * Localhost and desktop return targets are out of scope: a developer running a
+ * product locally returns to the deployed destination of whichever environment
+ * their backend belongs to.
+ */
+import type { BillingEnvironment } from './contract.js';
+export declare const RETURN_TARGETS: readonly ["comfyui_workspace", "comfyui_credits", "platform_account"];
+export type ReturnTarget = (typeof RETURN_TARGETS)[number];
+export declare function isReturnTarget(value: string): value is ReturnTarget;
+/**
+ * Undefined for an identifier outside the registry, and for a registered
+ * target that has no destination in the requested environment. Each call
+ * returns a fresh `URL` so a caller can append to it without editing the
+ * registry.
+ */
+export declare function resolveReturnTarget(target: string, environment: BillingEnvironment): URL | undefined;

package/dist/returnTargets.js

@@ -0,0 +1,41 @@
+import { parseUrl } from './url.js';
+export const RETURN_TARGETS = [
+    'comfyui_workspace',
+    'comfyui_credits',
+    'platform_account'
+];
+const RETURN_TARGET_DESTINATIONS = {
+    comfyui_workspace: {
+        production: 'https://cloud.comfy.org/',
+        staging: 'https://stagingcloud.comfy.org/',
+        test: 'https://testcloud.comfy.org/'
+    },
+    // The cloud app's credits settings page, the same URL the Workshop builds as
+    // `WORKSHOP_CREDITS_URL`.
+    comfyui_credits: {
+        production: 'https://cloud.comfy.org/?settings=plan-credits',
+        staging: 'https://stagingcloud.comfy.org/?settings=plan-credits',
+        test: 'https://testcloud.comfy.org/?settings=plan-credits'
+    },
+    // Platform lives in its own repository and names no account route here, so
+    // its origin root is the destination until that app names one.
+    platform_account: {
+        production: 'https://platform.comfy.org/',
+        staging: 'https://stagingplatform.comfy.org/'
+    }
+};
+export function isReturnTarget(value) {
+    return RETURN_TARGETS.some((target) => target === value);
+}
+/**
+ * Undefined for an identifier outside the registry, and for a registered
+ * target that has no destination in the requested environment. Each call
+ * returns a fresh `URL` so a caller can append to it without editing the
+ * registry.
+ */
+export function resolveReturnTarget(target, environment) {
+    if (!isReturnTarget(target))
+        return undefined;
+    const destination = RETURN_TARGET_DESTINATIONS[target][environment];
+    return destination === undefined ? undefined : parseUrl(destination);
+}

package/dist/returnUrl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The trip back. Billing resolves a registered target to its environment's
+ * destination and may append a coarse outcome plus an opaque reference; a
+ * consumer reads both back and must work when neither is there, because a
+ * customer can close the tab or arrive by bookmark at any point.
+ */
+import type { BillingEnvironment } from './contract.js';
+declare const BILLING_OUTCOMES: readonly ["success", "cancelled", "pending"];
+/**
+ * Deliberately coarse. A consumer routes on it; the authoritative state of a
+ * subscription is whatever the consumer's own next read of billing says.
+ */
+export type BillingOutcome = (typeof BILLING_OUTCOMES)[number];
+export interface ReturnUrlInput {
+    /** A `ReturnTarget`; see `BillingEntryInput.returnTo` for why it is wide. */
+    readonly target: string;
+    readonly environment: BillingEnvironment;
+    readonly result?: BillingOutcome;
+    /** An operation or correlation reference. Dropped when it is not opaque. */
+    readonly reference?: string;
+}
+export declare function buildReturnUrl(input: ReturnUrlInput): URL | undefined;
+export interface BillingReturn {
+    readonly result?: BillingOutcome;
+    readonly reference?: string;
+}
+export declare function parseReturnResult(url: string | URL): BillingReturn;
+export {};

package/dist/returnUrl.js

@@ -0,0 +1,33 @@
+import { isContractIdentifier } from './identifiers.js';
+import { resolveReturnTarget } from './returnTargets.js';
+import { CONTRACT_PARSE_BASE, parseUrl } from './url.js';
+/** Names are provisional; see `contract.ts`. */
+const RETURN_PARAM_OUTCOME = 'billing_result';
+const RETURN_PARAM_REFERENCE = 'billing_ref';
+const BILLING_OUTCOMES = ['success', 'cancelled', 'pending'];
+function isBillingOutcome(value) {
+    return BILLING_OUTCOMES.some((outcome) => outcome === value);
+}
+export function buildReturnUrl(input) {
+    const url = resolveReturnTarget(input.target, input.environment);
+    if (!url)
+        return undefined;
+    if (input.result !== undefined)
+        url.searchParams.set(RETURN_PARAM_OUTCOME, input.result);
+    if (input.reference !== undefined && isContractIdentifier(input.reference))
+        url.searchParams.set(RETURN_PARAM_REFERENCE, input.reference);
+    return url;
+}
+export function parseReturnResult(url) {
+    const params = parseUrl(url, CONTRACT_PARSE_BASE)?.searchParams;
+    if (!params)
+        return {};
+    const result = params.get(RETURN_PARAM_OUTCOME);
+    const reference = params.get(RETURN_PARAM_REFERENCE);
+    return {
+        ...(isBillingOutcome(result) ? { result } : {}),
+        ...(reference !== null && isContractIdentifier(reference)
+            ? { reference }
+            : {})
+    };
+}

package/dist/url.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The one place a string becomes a `URL` in this package. Every entry point
+ * here takes input that arrived over a URL bar, so a parse failure is a value
+ * to branch on rather than an exception each caller has to remember to catch.
+ */
+export declare function parseUrl(value: string | URL, base?: string): URL | undefined;
+/**
+ * Lets the parsers accept the path-and-query form a router hands them
+ * (`/v1/checkout?...`) as readily as a full href. It is never read back: only
+ * the pathname and the query survive parsing, and `.invalid` is reserved by
+ * RFC 2606 so a bug that leaked it could not reach a real host.
+ */
+export declare const CONTRACT_PARSE_BASE = "https://billing.invalid/";

package/dist/url.js

@@ -0,0 +1,20 @@
+/**
+ * The one place a string becomes a `URL` in this package. Every entry point
+ * here takes input that arrived over a URL bar, so a parse failure is a value
+ * to branch on rather than an exception each caller has to remember to catch.
+ */
+export function parseUrl(value, base) {
+    try {
+        return new URL(value instanceof URL ? value.href : value, base);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Lets the parsers accept the path-and-query form a router hands them
+ * (`/v1/checkout?...`) as readily as a full href. It is never read back: only
+ * the pathname and the query survive parsing, and `.invalid` is reserved by
+ * RFC 2606 so a bug that leaked it could not reach a real host.
+ */
+export const CONTRACT_PARSE_BASE = 'https://billing.invalid/';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@comfyorg/billing-contract",
+  "version": "1.0.0-alpha.0",
+  "description": "The URL contract every Comfy product shares with the hosted billing app: the versioned route builder, the entry parser billing-web reads on arrival, and the closed return_to registry that keeps the trip back off open redirects",
+  "keywords": [],
+  "homepage": "https://comfy.org",
+  "license": "MIT",
+  "author": {
+    "name": "Comfy Org",
+    "email": "support@comfy.org",
+    "url": "https://www.comfy.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Comfy-Org/ComfyUI_frontend.git",
+    "directory": "packages/billing-contract"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.5",
+    "@vitest/coverage-v8": "^4.1.11",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.11"
+  },
+  "scripts": {
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
+    "clean": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
+    "lint": "oxlint src --type-aware && eslint src",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}