ebay-mcp 1.18.0 → 1.18.2

package/build/scripts/downloadSpecs.js

@@ -1,117 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getErrorMessage } from '../utils/errors.js';
-import { httpRequest } from '../utils/http.js';
-import { Effect, Either } from 'effect';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const DOCS_DIR = path.resolve(__dirname, '../../docs');
-const README_PATH = path.resolve(__dirname, '../../docs/sell-apps/README.md');
-const getUrlsFromReadme = (content) => {
-    // Regex to find URLs that end with .json, specifically for OpenAPI specs
-    // This assumes the README will directly link to the JSON spec files, but is less strict to allow for variations.
-    const urlRegex = /(https:\/\/[^\s)]+\.json)/g;
-    const urls = Array.from(content.matchAll(urlRegex)).map((match) => match[1]);
-    console.log('Found URLs:', urls);
-    return urls;
-};
-const getFolderName = (specUrl) => {
-    const fileName = path.basename(specUrl);
-    // mapping from file name to folder name
-    // This mapping is based on the README.md structure and common API groupings
-    const folderMap = {
-        // Application Settings
-        'developer_analytics_v1_beta_oas3.json': 'application-settings',
-        'developer_key_management_v1_oas3.json': 'application-settings',
-        'developer_client_registration_v1_oas3.json': 'application-settings',
-        // Selling Apps - Listing Management
-        'sell_inventory_v1_oas3.json': 'sell-apps/listing-management',
-        'sell_feed_v1_oas3.json': 'sell-apps/listing-management',
-        'commerce_media_v1_beta_oas3.json': 'sell-apps/listing-management',
-        'sell_stores_v1_oas3.json': 'sell-apps/listing-management',
-        // Selling Apps - Listing Metadata & Taxonomy
-        'sell_metadata_v1_oas3.json': 'sell-apps/listing-metadata',
-        'commerce_taxonomy_v1_oas3.json': 'sell-apps/listing-metadata',
-        'commerce_charity_v1_oas3.json': 'sell-apps/listing-metadata',
-        // Selling Apps - Account Management
-        'sell_account_v1_oas3.json': 'sell-apps/account-management',
-        'sell_account_v2_oas3.json': 'sell-apps/account-management',
-        'sell_finances_v1_oas3.json': 'sell-apps/account-management',
-        // Selling Apps - Communication & Negotiation
-        'commerce_message_v1_oas3.json': 'sell-apps/communication',
-        'commerce_notification_v1_oas3.json': 'sell-apps/communication',
-        'sell_negotiation_v1_oas3.json': 'sell-apps/communication',
-        'commerce_feedback_v1_beta_oas3.json': 'sell-apps/communication',
-        // Selling Apps - Order Management
-        'sell_fulfillment_v1_oas3.json': 'sell-apps/order-management',
-        'sell_logistics_v1_oas3.json': 'sell-apps/order-management',
-        // Selling Apps - Marketing & Promotions
-        'sell_marketing_v1_oas3.json': 'sell-apps/marketing-and-promotions',
-        'sell_recommendation_v1_oas3.json': 'sell-apps/marketing-and-promotions',
-        'sell_analytics_v1_oas3.json': 'sell-apps/analytics-and-report',
-        // Selling Apps - Other Selling APIs
-        'commerce_translation_v1_beta_oas3.json': 'sell-apps/other-apis',
-        'sell_compliance_v1_oas3.json': 'sell-apps/other-apis',
-        'commerce_identity_v1_oas3.json': 'sell-apps/other-apis',
-        'sell_edelivery_international_shipping_oas3.json': 'sell-apps/other-apis',
-        'commerce_vero_v1_oas3.json': 'sell-apps/other-apis',
-        // Buying Apps - Inventory Discovery & Refresh
-        'buy_browse_v1_oas3.json': 'buy-apps/inventory-discovery',
-        'buy_feed_v1_beta_oas3.json': 'buy-apps/inventory-discovery',
-        'buy_feed_v1_oas3.json': 'buy-apps/inventory-discovery',
-        // commerce_notification_v1_oas3.json is already mapped under sell-apps,
-        // but it's also relevant here. We'll prioritize the first mapping or create a symlink if needed.
-        // Buying Apps - Marketing & Discounts
-        'buy_deal_v1_oas3.json': 'buy-apps/marketing-and-discounts',
-        'buy_marketing_v1_beta_oas3.json': 'buy-apps/marketing-and-discounts',
-        // Buying Apps - Marketplace Metadata
-        // commerce_taxonomy_v1_oas3.json is already mapped under sell-apps
-        'commerce_catalog_v1_beta_oas3.json': 'buy-apps/marketplace-metadata',
-        // commerce_charity_v1_oas3.json is already mapped under sell-apps
-        // Buying Apps - Checkout & Bidding
-        'buy_order_v2_oas3.json': 'buy-apps/checkout-and-bidding',
-        'buy_offer_v1_beta_oas3.json': 'buy-apps/checkout-and-bidding',
-        // Buying Apps - Other Buying APIs
-        // commerce_translation_v1_beta_oas3.json is already mapped under sell-apps
-        // commerce_identity_v1_oas3.json is already mapped under sell-apps
-    };
-    // Default to 'other-apis' if not found in map, or use the mapped folder
-    return folderMap[fileName] || 'other-apis';
-};
-const downloadFile = async (url, folderPath, fileName) => {
-    const downloaded = await Effect.runPromise(Effect.either(Effect.tryPromise({
-        try: async () => {
-            const response = await httpRequest({ url, responseType: 'arraybuffer' });
-            const filePath = path.join(folderPath, fileName);
-            fs.mkdirSync(folderPath, { recursive: true });
-            fs.writeFileSync(filePath, response.data);
-        },
-        catch: (error) => error,
-    })));
-    if (Either.isLeft(downloaded)) {
-        console.error(`Failed to download ${url}:`, getErrorMessage(downloaded.left));
-        return;
-    }
-    console.log(`Downloaded ${fileName} to ${folderPath}`);
-};
-const main = async () => {
-    const readme = Effect.runSync(Effect.either(Effect.try({
-        try: () => fs.readFileSync(README_PATH, 'utf-8'),
-        catch: (error) => error,
-    })));
-    if (Either.isLeft(readme)) {
-        console.error('Failed to read README.md:', getErrorMessage(readme.left));
-        return;
-    }
-    const urls = getUrlsFromReadme(readme.right);
-    for (const url of urls) {
-        console.log(`Processing URL: ${url}`);
-        const fileName = path.basename(url);
-        const folderName = getFolderName(url);
-        const folderPath = path.join(DOCS_DIR, folderName);
-        await downloadFile(url, folderPath, fileName);
-    }
-};
-void main();

package/build/scripts/updateApiStatusDoc.js

@@ -1,71 +0,0 @@
-/**
- * Fetches the eBay API Status RSS feed and writes the latest items to docs/API_STATUS.md.
- * Used by the GitHub Action to keep an in-repo snapshot. Run with: npx tsx src/scripts/updateApiStatusDoc.ts
- */
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { getApiStatusFeed } from '../utils/apiStatusFeed.js';
-import { getErrorMessage } from '../utils/errors.js';
-import { Data, Effect, Either } from 'effect';
-import process from 'node:process';
-const DEFAULT_LIMIT = 15;
-const OUT_PATH = join(process.cwd(), 'docs', 'API_STATUS.md');
-/** Tagged failure raised while updating the checked-in API status snapshot. */
-class ApiStatusDocUpdateError extends Data.TaggedError('ApiStatusDocUpdateError') {
-}
-function escapeCell(s) {
-    return s.replace(/\|/g, '\\|').replace(/\n/g, ' ');
-}
-function buildMarkdown(items) {
-    const lines = [
-        '# eBay API Status (latest)',
-        '',
-        'Auto-updated snapshot from the [eBay API Status RSS feed](https://developer.ebay.com/rss/api-status).',
-        'Full list: [developer.ebay.com/support/api-status](https://developer.ebay.com/support/api-status).',
-        '',
-        `*Last updated: ${new Date().toISOString()}*`,
-        '',
-        '| Title | API | Site | Status | Last updated | Link |',
-        '|-------|-----|------|--------|--------------|------|',
-    ];
-    for (const item of items) {
-        const link = item.link ? `[Details](${item.link})` : '';
-        lines.push(`| ${escapeCell(item.title)} | ${escapeCell(item.api)} | ${escapeCell(item.site)} | ${escapeCell(item.status)} | ${escapeCell(item.lastUpdated)} | ${link} |`);
-    }
-    lines.push('', '---', '', '*Generated by [ebay-mcp](https://github.com/YosefHayim/ebay-mcp) API status sync.*');
-    return lines.join('\n');
-}
-const updateApiStatusDoc = () => Effect.gen(function* () {
-    const { items, error } = yield* getApiStatusFeed({ limit: DEFAULT_LIMIT }).pipe(Effect.mapError((cause) => new ApiStatusDocUpdateError({
-        message: 'Failed to fetch API status feed',
-        cause,
-    })));
-    if (error && items.length === 0) {
-        return yield* Effect.fail(new ApiStatusDocUpdateError({
-            message: `Failed to fetch API status feed: ${error}`,
-            cause: error,
-        }));
-    }
-    const markdown = buildMarkdown(items);
-    yield* Effect.try({
-        try: () => writeFileSync(OUT_PATH, markdown, 'utf8'),
-        catch: (cause) => new ApiStatusDocUpdateError({
-            message: `Failed to write API status doc to ${OUT_PATH}`,
-            cause,
-        }),
-    });
-    return items.length;
-});
-async function main() {
-    const count = await Effect.runPromise(updateApiStatusDoc());
-    console.log(`Wrote ${count} items to ${OUT_PATH}`);
-}
-void Effect.runPromise(Effect.either(Effect.tryPromise({
-    try: main,
-    catch: (error) => error,
-}))).then((result) => {
-    if (Either.isLeft(result)) {
-        console.error(getErrorMessage(result.left, String(result.left)));
-        process.exitCode = 1;
-    }
-});

package/build/utils/effectSchema.js

@@ -1,203 +0,0 @@
-import { Effect, Schema } from 'effect';
-import { z as zod } from 'zod';
-import { attachEffectSchema, enumValues, getRequiredEffectSchema, literalUnion, objectEffectSchema, } from './effectSchemaAdapter.js';
-import { EffectSchemaDecodeError, getParseMessage, getState, } from './effectSchemaTypes.js';
-/**
- * Returns true when a schema was created by this module and carries Effect metadata.
- *
- * @param schema - Unknown schema-like value to inspect.
- * @returns Whether the value has an attached Effect Schema.
- *
- * @example
- * ```ts
- * const backed = isEffectBackedSchema(z.string());
- * ```
- */
-export const isEffectBackedSchema = (schema) => getState(schema) !== undefined;
-/**
- * Reads the Effect Schema attached to a schema created by this module.
- *
- * @param schema - Effect-backed schema whose Effect metadata should be returned.
- * @returns The attached Effect Schema, or `undefined` when the value is not backed.
- *
- * @example
- * ```ts
- * const schema = getEffectSchema(z.string());
- * ```
- */
-export const getEffectSchema = (schema) => getState(schema)?.schema;
-/**
- * Builds an Effect object schema from an MCP raw-shape object.
- *
- * @param shape - Tool input raw shape where every field was created by this module.
- * @returns Effect Schema that decodes the whole argument object.
- *
- * @example
- * ```ts
- * const argsSchema = effectStructFromShape({ sku: z.string() });
- * ```
- */
-export const effectStructFromShape = (shape) => objectEffectSchema(shape);
-/**
- * Decodes unknown input through the Effect Schema attached to a schema value.
- *
- * @param schema - Effect-backed schema to decode with.
- * @param value - Unknown runtime value from the MCP/client boundary.
- * @returns Effect producing the decoded value or a tagged decode error.
- *
- * @example
- * ```ts
- * const decoded = await Effect.runPromise(decodeEffectSchema(z.object({ sku: z.string() }), args));
- * ```
- */
-export const decodeEffectSchema = (schema, value) => {
-    const effectSchema = getEffectSchema(schema);
-    if (!effectSchema || Schema.isPropertySignature(effectSchema)) {
-        return Effect.fail(new EffectSchemaDecodeError({
-            cause: schema,
-            message: 'Schema does not carry a decodable Effect Schema',
-        }));
-    }
-    const decodableSchema = effectSchema;
-    return Schema.decodeUnknown(decodableSchema)(value).pipe(Effect.map((decoded) => decoded), Effect.mapError((error) => new EffectSchemaDecodeError({
-        cause: error,
-        message: getParseMessage(error),
-    })));
-};
-/**
- * Synchronously decodes unknown input through an attached Effect Schema.
- *
- * @param schema - Effect-backed schema to decode with.
- * @param value - Unknown runtime value from the MCP/client boundary.
- * @returns Decoded value produced by the attached Effect Schema.
- *
- * @example
- * ```ts
- * const args = decodeEffectSchemaSync(z.object({ sku: z.string() }), rawArgs);
- * ```
- */
-export const decodeEffectSchemaSync = (schema, value) => Effect.runSync(decodeEffectSchema(schema, value));
-/**
- * Zod-shaped schema factory backed by Effect Schema metadata.
- *
- * @example
- * ```ts
- * const schema = z.object({
- *   sku: z.string().describe('Seller-defined SKU'),
- *   limit: z.number().int().positive().optional(),
- * });
- * ```
- */
-export const z = {
-    array(schema, options) {
-        const effectSchema = Schema.Array(getRequiredEffectSchema(schema));
-        const baseSchema = options?.description
-            ? effectSchema.annotations({ description: options.description })
-            : effectSchema;
-        return attachEffectSchema(zod.array(schema, options), {
-            kind: 'array',
-            requiredSchema: baseSchema,
-            schema: baseSchema,
-        });
-    },
-    boolean(options) {
-        const baseSchema = options?.description
-            ? Schema.Boolean.annotations({ description: options.description })
-            : Schema.Boolean;
-        return attachEffectSchema(zod.boolean(options), {
-            kind: 'boolean',
-            requiredSchema: baseSchema,
-            schema: baseSchema,
-        });
-    },
-    custom(check, params) {
-        const effectSchema = check
-            ? Schema.filter((value) => check(value))(Schema.Unknown)
-            : Schema.Unknown;
-        return attachEffectSchema(zod.custom(check, params), {
-            kind: 'unknown',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    enum(values) {
-        const effectSchema = literalUnion(values);
-        return attachEffectSchema(zod.enum(values), {
-            kind: 'string',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    nativeEnum(enumLike) {
-        const effectSchema = literalUnion(enumValues(enumLike));
-        return attachEffectSchema(zod.nativeEnum(enumLike), {
-            kind: 'string',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    never() {
-        const effectSchema = Schema.Never;
-        return attachEffectSchema(zod.never(), {
-            kind: 'unknown',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    number(options) {
-        const effectSchema = Schema.Number;
-        return attachEffectSchema(zod.number(options), {
-            kind: 'number',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    object(shape, options) {
-        const effectSchema = objectEffectSchema(shape);
-        const baseSchema = options?.description
-            ? effectSchema.annotations({ description: options.description })
-            : effectSchema;
-        return attachEffectSchema(zod.object(shape, options), {
-            kind: 'object',
-            requiredSchema: baseSchema,
-            schema: baseSchema,
-        });
-    },
-    record(keyOrValue, valueSchema) {
-        const schema = valueSchema ?? keyOrValue;
-        const effectSchema = Schema.Record({
-            key: valueSchema ? getRequiredEffectSchema(keyOrValue) : Schema.String,
-            value: getRequiredEffectSchema(schema),
-        });
-        return attachEffectSchema(valueSchema ? zod.record(keyOrValue, valueSchema) : zod.record(schema), {
-            kind: 'record',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    string(options) {
-        const baseSchema = options?.description
-            ? Schema.String.annotations({ description: options.description })
-            : Schema.String;
-        return attachEffectSchema(zod.string(options), {
-            kind: 'string',
-            requiredSchema: baseSchema,
-            schema: baseSchema,
-        });
-    },
-    union(options) {
-        const effectSchema = Schema.Union(...options.map((option) => getRequiredEffectSchema(option)));
-        return attachEffectSchema(zod.union(options), {
-            kind: 'unknown',
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    },
-    unknown() {
-        return attachEffectSchema(zod.unknown(), {
-            kind: 'unknown',
-            requiredSchema: Schema.Unknown,
-            schema: Schema.Unknown,
-        });
-    },
-};

package/build/utils/effectSchemaAdapter.js

@@ -1,121 +0,0 @@
-import { Schema } from 'effect';
-import { attachChainableEffectMethods } from './effectSchemaChainMethods.js';
-import { EFFECT_SCHEMA_STATE, } from './effectSchemaTypes.js';
-const getEffectState = (schema) => {
-    if (!(typeof schema === 'object' && schema !== null && EFFECT_SCHEMA_STATE in schema)) {
-        return;
-    }
-    return schema[EFFECT_SCHEMA_STATE];
-};
-const buildObjectEffectSchema = (shape) => {
-    const effectShape = {};
-    for (const [key, fieldSchema] of Object.entries(shape)) {
-        effectShape[key] = getFieldEffectSchema(fieldSchema);
-    }
-    return Schema.Struct(effectShape);
-};
-/**
- * Reads the required Effect Schema for an adapter-backed schema value.
- *
- * @param schema - Schema value created by the adapter.
- * @returns Required Effect Schema, or `Schema.Unknown` when metadata is missing.
- *
- * @example
- * ```ts
- * const effectSchema = getRequiredEffectSchema(z.string().optional());
- * ```
- */
-export const getRequiredEffectSchema = (schema) => {
-    const state = getEffectState(schema);
-    if (!state) {
-        return Schema.Unknown;
-    }
-    return state.requiredSchema;
-};
-/**
- * Reads the field-level Effect Schema for an adapter-backed schema value.
- *
- * @param schema - Schema value created by the adapter.
- * @returns Current field Effect Schema, preserving optional/default wrappers when present.
- *
- * @example
- * ```ts
- * const fieldSchema = getFieldEffectSchema(z.string().optional());
- * ```
- */
-export const getFieldEffectSchema = (schema) => {
-    const state = getEffectState(schema);
-    if (!state) {
-        return Schema.Unknown;
-    }
-    return state.schema;
-};
-/**
- * Builds an Effect object schema from an adapter-backed raw shape.
- *
- * @param shape - Zod-compatible raw shape whose fields carry Effect metadata.
- * @returns Effect Schema struct for the object shape.
- *
- * @example
- * ```ts
- * const effectSchema = objectEffectSchema({ sku: z.string() });
- * ```
- */
-export const objectEffectSchema = (shape) => buildObjectEffectSchema(shape);
-/**
- * Extracts string values from a TypeScript enum-like object.
- *
- * @param enumLike - Enum-like object accepted by `z.nativeEnum`.
- * @returns Non-empty tuple of unique string enum values.
- *
- * @example
- * ```ts
- * const values = enumValues(MarketplaceId);
- * ```
- */
-export const enumValues = (enumLike) => {
-    const values = Object.values(enumLike).filter((value) => typeof value === 'string');
-    const [first, ...rest] = [...new Set(values)];
-    if (!first) {
-        return [''];
-    }
-    return [first, ...rest];
-};
-/**
- * Builds an Effect literal union from string values.
- *
- * @param values - Non-empty list of literal string values.
- * @returns Effect Schema accepting exactly those values.
- *
- * @example
- * ```ts
- * const schema = literalUnion(['ACTIVE', 'PAUSED']);
- * ```
- */
-export const literalUnion = (values) => Schema.Literal(...values);
-/**
- * Attaches Effect Schema metadata to a Zod-compatible schema carrier.
- *
- * @param zodSchema - Zod schema object exposed to MCP SDK and JSON-schema tooling.
- * @param state - Effect metadata used for runtime decode and chained refinements.
- * @returns The same schema carrier with hidden Effect metadata attached.
- *
- * @example
- * ```ts
- * const schema = attachEffectSchema(zod.string(), {
- *   kind: 'string',
- *   requiredSchema: Schema.String,
- *   schema: Schema.String,
- * });
- * ```
- */
-export const attachEffectSchema = (zodSchema, state) => {
-    const schema = zodSchema;
-    Object.defineProperty(schema, EFFECT_SCHEMA_STATE, {
-        configurable: false,
-        enumerable: false,
-        value: state,
-    });
-    attachChainableEffectMethods(schema, state, attachEffectSchema, buildObjectEffectSchema);
-    return schema;
-};

package/build/utils/effectSchemaChainMethods.js

@@ -1,146 +0,0 @@
-import { Schema } from 'effect';
-import { annotateSchema, defaultValueGetter, refineInt, refineMax, refineMin, refinePositive, } from './effectSchemaRefinements.js';
-import { attachStringEffectMethods } from './effectSchemaStringMethods.js';
-const patchDescribeMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.describe !== 'function') {
-        return;
-    }
-    const describe = schema.describe.bind(schema);
-    schema.describe = (description) => attachEffectSchema(describe(description), {
-        ...state,
-        requiredSchema: annotateSchema(state.requiredSchema, description),
-        schema: annotateSchema(state.schema, description),
-    });
-};
-const patchOptionalMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.optional !== 'function') {
-        return;
-    }
-    const optional = schema.optional.bind(schema);
-    schema.optional = () => attachEffectSchema(optional(), {
-        ...state,
-        schema: Schema.optional(state.requiredSchema),
-    });
-};
-const patchDefaultMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.default !== 'function') {
-        return;
-    }
-    const defaultSchema = schema.default.bind(schema);
-    schema.default = (value) => attachEffectSchema(defaultSchema(value), {
-        ...state,
-        schema: Schema.optionalWith(state.requiredSchema, { default: defaultValueGetter(value) }),
-    });
-};
-const patchPassthroughMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.passthrough !== 'function') {
-        return;
-    }
-    const passthrough = schema.passthrough.bind(schema);
-    schema.passthrough = () => {
-        const passthroughEffectSchema = Schema.extend(state.requiredSchema, Schema.Record({ key: Schema.String, value: Schema.Unknown }));
-        return attachEffectSchema(passthrough(), {
-            kind: state.kind,
-            requiredSchema: passthroughEffectSchema,
-            schema: passthroughEffectSchema,
-        });
-    };
-};
-const patchExtendMethod = (schema, state, attachEffectSchema, buildObjectEffectSchema) => {
-    if (typeof schema.extend !== 'function') {
-        return;
-    }
-    const extend = schema.extend.bind(schema);
-    schema.extend = (shape) => {
-        const extensionEffectSchema = buildObjectEffectSchema(shape);
-        const effectSchema = Schema.extend(state.requiredSchema, extensionEffectSchema);
-        return attachEffectSchema(extend(shape), {
-            kind: state.kind,
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    };
-};
-const patchMinMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.min !== 'function') {
-        return;
-    }
-    const min = schema.min.bind(schema);
-    schema.min = (value, message) => {
-        const effectSchema = refineMin(state.requiredSchema, state.kind, value);
-        return attachEffectSchema(min(value, message), {
-            ...state,
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    };
-};
-const patchMaxMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.max !== 'function') {
-        return;
-    }
-    const max = schema.max.bind(schema);
-    schema.max = (value, message) => {
-        const effectSchema = refineMax(state.requiredSchema, state.kind, value);
-        return attachEffectSchema(max(value, message), {
-            ...state,
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    };
-};
-const patchPositiveMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.positive !== 'function') {
-        return;
-    }
-    const positive = schema.positive.bind(schema);
-    schema.positive = (message) => {
-        const effectSchema = refinePositive(state.requiredSchema, state.kind);
-        return attachEffectSchema(positive(message), {
-            ...state,
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    };
-};
-const patchIntMethod = (schema, state, attachEffectSchema) => {
-    if (typeof schema.int !== 'function') {
-        return;
-    }
-    const int = schema.int.bind(schema);
-    schema.int = (message) => {
-        const effectSchema = refineInt(state.requiredSchema, state.kind);
-        return attachEffectSchema(int(message), {
-            ...state,
-            requiredSchema: effectSchema,
-            schema: effectSchema,
-        });
-    };
-};
-/**
- * Rebinds chainable Zod compatibility methods so Effect metadata stays attached.
- *
- * @param schemaCarrier - Zod-compatible schema carrier receiving patched chain methods.
- * @param state - Effect metadata that belongs to the current schema carrier.
- * @param attachEffectSchema - Adapter function used to attach metadata to returned schemas.
- * @param buildObjectEffectSchema - Object-shape builder used by `.extend()`.
- * @returns Nothing; the schema carrier is patched in place.
- *
- * @example
- * ```ts
- * attachChainableEffectMethods(schema, state, attachEffectSchema, objectEffectSchema);
- * ```
- */
-export const attachChainableEffectMethods = (schemaCarrier, state, attachEffectSchema, buildObjectEffectSchema) => {
-    const schema = schemaCarrier;
-    patchDescribeMethod(schema, state, attachEffectSchema);
-    patchOptionalMethod(schema, state, attachEffectSchema);
-    patchDefaultMethod(schema, state, attachEffectSchema);
-    patchPassthroughMethod(schema, state, attachEffectSchema);
-    patchExtendMethod(schema, state, attachEffectSchema, buildObjectEffectSchema);
-    patchMinMethod(schema, state, attachEffectSchema);
-    patchMaxMethod(schema, state, attachEffectSchema);
-    patchPositiveMethod(schema, state, attachEffectSchema);
-    patchIntMethod(schema, state, attachEffectSchema);
-    attachStringEffectMethods(schema, state, attachEffectSchema);
-};