@superdurable/connector-shopify 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Super Durable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# Shopify connector for TypeScript
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Install `@superdurable/connector-shopify@0.1.0`. This package provides the
+`newGetOrderStep` and `newListOrdersStep` Query factories, typed models, a named
+connection, and manifest-generated mocks. The happy branches are `found` and
+`listed`; `notFound`, `providerRejected`, `invalidResponse`, and `defect` are
+optional and fail an unwired Flow.
+
+The client reads `https://<shopSubdomain>.myshopify.com/admin/api/2026-10`.
+`getOrder` requires a positive numeric order ID. `listOrders` requests
+`status=any` and accepts a limit from 1 through 250; zero uses Shopify's
+default. HTTP 408, 429, 5xx, and transport failures retry. Credentials are
+resolved for each attempt and sent only in `X-Shopify-Access-Token`.
+
+Create a private Dex Web connection named `shopify-orders` with the fields in
+the [manifest authorization guide](../README.md#authentication-and-configuration).
+The `timeout` setting is a positive Go duration; the TypeScript client converts
+it to milliseconds. Blank `timeout` and `maxResponseBytes` use manifest defaults.
+
+The [runnable order read example](examples/order-read/README.md) is the
+consuming application. Run `npm ci && npm run check` in this directory for
+the package and Go-recorded provider conformance tests. Run the example's
+integration test against `dexcli dev` to verify a real Worker, Client, and
+unwired rejection. Live Shopify authorization and provider behavior have not
+been verified.

package/dex-connector.json

@@ -0,0 +1,87 @@
+{
+  "connectorId": "shopify",
+  "releaseTag": "connectors/shopify/go/v0.2.0",
+  "package": {
+    "ecosystem": "npm",
+    "name": "@superdurable/connector-shopify",
+    "version": "0.1.0"
+  },
+  "factories": [
+    {
+      "name": "newGetOrderStep",
+      "kind": "query",
+      "operationId": "getOrder",
+      "fields": {
+        "stepType": "stepType",
+        "annotations": "annotations",
+        "connectionName": "connectionName",
+        "resultAttribute": "resultAttribute"
+      },
+      "branches": [
+        {
+          "id": "found",
+          "field": "found",
+          "optional": false
+        },
+        {
+          "id": "notFound",
+          "field": "notFound",
+          "optional": true
+        },
+        {
+          "id": "providerRejected",
+          "field": "providerRejected",
+          "optional": true
+        },
+        {
+          "id": "invalidResponse",
+          "field": "invalidResponse",
+          "optional": true
+        },
+        {
+          "id": "defect",
+          "field": "defect",
+          "optional": true
+        }
+      ]
+    },
+    {
+      "name": "newListOrdersStep",
+      "kind": "query",
+      "operationId": "listOrders",
+      "fields": {
+        "stepType": "stepType",
+        "annotations": "annotations",
+        "connectionName": "connectionName",
+        "resultAttribute": "resultAttribute"
+      },
+      "branches": [
+        {
+          "id": "listed",
+          "field": "listed",
+          "optional": false
+        },
+        {
+          "id": "notFound",
+          "field": "notFound",
+          "optional": true
+        },
+        {
+          "id": "providerRejected",
+          "field": "providerRejected",
+          "optional": true
+        },
+        {
+          "id": "invalidResponse",
+          "field": "invalidResponse",
+          "optional": true
+        },
+        {
+          "id": "defect",
+          "field": "defect",
+          "optional": true
+        }
+      ]
+    }
+  ]
+}

package/dist/chunk-A5SY2SHU.js

@@ -0,0 +1,135 @@
+// src/generated/models.ts
+import { z } from "zod";
+var ConfigSchema = z.object({
+  "shopSubdomain": z.string(),
+  "timeoutMs": z.number().int().optional(),
+  "maxResponseBytes": z.number().int().optional()
+});
+var GetOrderInputSchema = z.strictObject({
+  "orderId": z.number().int()
+});
+var OrderSchema = z.strictObject({
+  "id": z.number().int(),
+  "name": z.string(),
+  "financial_status": z.string(),
+  "total_price": z.string(),
+  "currency": z.string()
+});
+var ListOrdersInputSchema = z.strictObject({
+  "limit": z.number().int().optional()
+});
+var OrderPageSchema = z.strictObject({
+  "orders": z.array(OrderSchema).nullable()
+});
+
+// src/generated/definitions.ts
+var ConnectorID = "shopify";
+var ProviderID = "shopify";
+var GetOrderBranch = {
+  Found: "found",
+  NotFound: "notFound",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var GetOrderBranchFound = GetOrderBranch.Found;
+var GetOrderBranchNotFound = GetOrderBranch.NotFound;
+var GetOrderBranchProviderRejected = GetOrderBranch.ProviderRejected;
+var GetOrderBranchInvalidResponse = GetOrderBranch.InvalidResponse;
+var GetOrderBranchDefect = GetOrderBranch.Defect;
+var GetOrderDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "getOrder" },
+  branches: [
+    { id: "found", description: "Read one Shopify order." },
+    { id: "notFound", description: "The requested resource was not found.", optional: true },
+    { id: "providerRejected", description: "The provider conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "The provider returned malformed or oversized JSON.", optional: true },
+    { id: "defect", description: "Local input or connection credentials are invalid.", optional: true }
+  ],
+  stepDefaults: { executeMethodTimeoutMs: 3e4, executeDurability: "async" }
+};
+var GetOrderMetadata = { kind: "query", idempotency: "none", authorization: "required" };
+var ListOrdersBranch = {
+  Listed: "listed",
+  NotFound: "notFound",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var ListOrdersBranchListed = ListOrdersBranch.Listed;
+var ListOrdersBranchNotFound = ListOrdersBranch.NotFound;
+var ListOrdersBranchProviderRejected = ListOrdersBranch.ProviderRejected;
+var ListOrdersBranchInvalidResponse = ListOrdersBranch.InvalidResponse;
+var ListOrdersBranchDefect = ListOrdersBranch.Defect;
+var ListOrdersDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "listOrders" },
+  branches: [
+    { id: "listed", description: "List one page of Shopify orders." },
+    { id: "notFound", description: "The requested resource was not found.", optional: true },
+    { id: "providerRejected", description: "The provider conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "The provider returned malformed or oversized JSON.", optional: true },
+    { id: "defect", description: "Local input or connection credentials are invalid.", optional: true }
+  ],
+  stepDefaults: { executeMethodTimeoutMs: 3e4, executeDurability: "async" }
+};
+var ListOrdersMetadata = { kind: "query", idempotency: "none", authorization: "required" };
+
+// src/generated/connection.ts
+import { ConnectionRefSchema } from "@superdurable/connectors-sdk";
+var Connection = class {
+  /** Stable provider and connection name. */
+  reference;
+  /** Bound provider operations. */
+  operations;
+  /** Validate a reference and bind operations. */
+  constructor(reference, operations) {
+    this.reference = ConnectionRefSchema.parse(reference);
+    if (this.reference.provider !== ProviderID) throw new TypeError("connection provider differs from the manifest");
+    if (!operations) throw new TypeError("connector operations are required");
+    this.operations = operations;
+  }
+};
+function newConnection(client, reference) {
+  if (!client) throw new TypeError("connector client is required");
+  return new Connection(reference, client);
+}
+function newConnectionWithOperations(operations, reference) {
+  return new Connection(reference, operations);
+}
+function newProjectConnection(project, connectionName, createClient) {
+  if (!project) throw new TypeError("loaded project is required");
+  const reference = ConnectionRefSchema.parse({ provider: ProviderID, name: connectionName });
+  const selected = project.configuration.connections.find((entry) => entry.connectorId === ConnectorID && entry.connectionName === connectionName);
+  if (!selected || selected.provider !== ProviderID) throw new TypeError("project connection is not configured");
+  return newConnection(createClient(project, connectionName), reference);
+}
+
+export {
+  ConfigSchema,
+  GetOrderInputSchema,
+  OrderSchema,
+  ListOrdersInputSchema,
+  OrderPageSchema,
+  ConnectorID,
+  ProviderID,
+  GetOrderBranch,
+  GetOrderBranchFound,
+  GetOrderBranchNotFound,
+  GetOrderBranchProviderRejected,
+  GetOrderBranchInvalidResponse,
+  GetOrderBranchDefect,
+  GetOrderDefinition,
+  GetOrderMetadata,
+  ListOrdersBranch,
+  ListOrdersBranchListed,
+  ListOrdersBranchNotFound,
+  ListOrdersBranchProviderRejected,
+  ListOrdersBranchInvalidResponse,
+  ListOrdersBranchDefect,
+  ListOrdersDefinition,
+  ListOrdersMetadata,
+  Connection,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+};

package/dist/connection-D5oSVoU-.d.ts

@@ -0,0 +1,102 @@
+import { CredentialProvider, SecretString, Query, ConnectionRef } from '@superdurable/connectors-sdk';
+import { z } from 'zod';
+
+/** Connector configuration; omitted fields use manifest defaults. */
+interface Config {
+    /** Non-secret Shopify shop subdomain: the acme in https://acme.myshopify.com. At https://admin.shopify.com > Settings > Domains, find the myshopify.com domain and enter only the part before .myshopify.com, using lowercase letters, digits, and hyphens. Required; blank cannot identify a store. The connector appends /admin/api/2026-10. */
+    shopSubdomain: string;
+    /** Maximum duration of one provider HTTP request as a positive Go duration, such as 15s or 1m. Blank uses the displayed default; override for slow network paths. Runtime value in milliseconds. */
+    timeoutMs?: number;
+    /** Maximum provider JSON response size in bytes as a positive integer. Blank uses the displayed default; raise only for larger result pages. */
+    maxResponseBytes?: number;
+}
+/** Runtime schema for manifest configuration. */
+declare const ConfigSchema: z.ZodObject<{
+    shopSubdomain: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxResponseBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Private connector credentials resolved by the host. */
+interface Credentials {
+    /** Secret Admin API access token of an existing admin-created custom app at https://admin.shopify.com > Settings > Apps and sales channels > Develop apps > the app > API credentials. It is an opaque token sent only in X-Shopify-Access-Token. Blank prevents calls. New admin-created custom apps are unavailable. */
+    accessToken: SecretString;
+}
+/** Host-owned source of private connector credentials. */
+type CredentialSource = CredentialProvider<Credentials>;
+/** GetOrderInput identifies one Shopify order. */
+interface GetOrderInput {
+    /** OrderID is the numeric Shopify order ID. */
+    "orderId": number;
+}
+/** Order is a minimal Shopify order summary; protected customer data is omitted. */
+interface Order {
+    /** ID is the numeric Shopify order ID. */
+    "id": number;
+    /** Name is the human-readable order number. */
+    "name": string;
+    /** FinancialStatus is the payment state. */
+    "financial_status": string;
+    /** TotalPrice is the decimal order total. */
+    "total_price": string;
+    /** Currency is the ISO currency code. */
+    "currency": string;
+}
+/** ListOrdersInput selects one bounded page of Shopify orders. */
+interface ListOrdersInput {
+    /** Limit bounds one page from 1 through 250; zero uses Shopify default. */
+    "limit"?: number | undefined;
+}
+/** OrderPage contains one Shopify order page. */
+interface OrderPage {
+    /** Orders contains the returned orders, possibly none. */
+    "orders": Array<Order> | null;
+}
+/** Runtime validator for GetOrderInput. */
+declare const GetOrderInputSchema: z.ZodObject<{
+    orderId: z.ZodNumber;
+}, z.core.$strict>;
+/** Runtime validator for Order. */
+declare const OrderSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    financial_status: z.ZodString;
+    total_price: z.ZodString;
+    currency: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for ListOrdersInput. */
+declare const ListOrdersInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** Runtime validator for OrderPage. */
+declare const OrderPageSchema: z.ZodObject<{
+    orders: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        financial_status: z.ZodString;
+        total_price: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+
+/** Typed operations supplied by a client or mock. */
+interface Operations {
+    /** Invoke getOrder through this connection. */
+    getOrder(): Query<GetOrderInput, Order>;
+    /** Invoke listOrders through this connection. */
+    listOrders(): Query<ListOrdersInput, OrderPage>;
+}
+/** Named connector connection kept outside Flow state. */
+declare class Connection<BoundOperations = Operations> {
+    /** Stable provider and connection name. */
+    readonly reference: ConnectionRef;
+    /** Bound provider operations. */
+    readonly operations: BoundOperations;
+    /** Validate a reference and bind operations. */
+    constructor(reference: ConnectionRef, operations: BoundOperations);
+}
+/** Bind a client to a named connection. */
+declare function newConnection(client: Operations, reference: ConnectionRef): Connection;
+/** Bind scripted operations to a named connection. */
+declare function newConnectionWithOperations(operations: Operations, reference: ConnectionRef): Connection;
+
+export { Connection as C, type GetOrderInput as G, type ListOrdersInput as L, type Order as O, type OrderPage as a, type Config as b, type Credentials as c, type Operations as d, ConfigSchema as e, type CredentialSource as f, GetOrderInputSchema as g, ListOrdersInputSchema as h, OrderPageSchema as i, OrderSchema as j, newConnectionWithOperations as k, newConnection as n };

package/dist/index.d.ts

@@ -0,0 +1,171 @@
+import { G as GetOrderInput, O as Order, C as Connection, L as ListOrdersInput, a as OrderPage, b as Config, c as Credentials, d as Operations } from './connection-D5oSVoU-.js';
+export { e as ConfigSchema, f as CredentialSource, g as GetOrderInputSchema, h as ListOrdersInputSchema, i as OrderPageSchema, j as OrderSchema, n as newConnection, k as newConnectionWithOperations } from './connection-D5oSVoU-.js';
+import * as _superdurable_connectors_sdk from '@superdurable/connectors-sdk';
+import { QueryDefinition, QueryStepConfig, Query, QueryResult, QueryStep, Call, QueryAttempt, CredentialProvider, Failure } from '@superdurable/connectors-sdk';
+import { StepTarget } from '@superdurable/dex';
+import { ProviderRequest, ProviderResponse } from '@superdurable/connectors-sdk/providerhttp';
+import { LoadedProject } from '@superdurable/connectors-sdk/projectconfig';
+import 'zod';
+
+/** Stable connector identity. */
+declare const ConnectorID = "shopify";
+/** Provider identity for named connections. */
+declare const ProviderID = "shopify";
+/** Branch IDs for getOrder. */
+declare const GetOrderBranch: {
+    readonly Found: "found";
+    readonly NotFound: "notFound";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** Read one Shopify order. */
+declare const GetOrderBranchFound: "found";
+/** The requested resource was not found. */
+declare const GetOrderBranchNotFound: "notFound";
+/** The provider conclusively rejected the request. */
+declare const GetOrderBranchProviderRejected: "providerRejected";
+/** The provider returned malformed or oversized JSON. */
+declare const GetOrderBranchInvalidResponse: "invalidResponse";
+/** Local input or connection credentials are invalid. */
+declare const GetOrderBranchDefect: "defect";
+/** Manifest definition for getOrder. */
+declare const GetOrderDefinition: QueryDefinition;
+/** Manifest metadata for getOrder. */
+declare const GetOrderMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+/** Branch IDs for listOrders. */
+declare const ListOrdersBranch: {
+    readonly Listed: "listed";
+    readonly NotFound: "notFound";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** List one page of Shopify orders. */
+declare const ListOrdersBranchListed: "listed";
+/** The requested resource was not found. */
+declare const ListOrdersBranchNotFound: "notFound";
+/** The provider conclusively rejected the request. */
+declare const ListOrdersBranchProviderRejected: "providerRejected";
+/** The provider returned malformed or oversized JSON. */
+declare const ListOrdersBranchInvalidResponse: "invalidResponse";
+/** Local input or connection credentials are invalid. */
+declare const ListOrdersBranchDefect: "defect";
+/** Manifest definition for listOrders. */
+declare const ListOrdersDefinition: QueryDefinition;
+/** Manifest metadata for listOrders. */
+declare const ListOrdersMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+
+/** Configuration for the getOrder connector Step. */
+interface GetOrderStepConfig<StepInput, OperationInput = GetOrderInput, OperationOutput = Order> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        getOrder(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** Read one Shopify order. */
+    found: StepTarget<QueryResult<OperationOutput>>;
+    /** The requested resource was not found. */
+    notFound?: StepTarget<QueryResult<OperationOutput>>;
+    /** The provider conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** The provider returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Local input or connection credentials are invalid. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the getOrder Step from a named connection. */
+declare function newGetOrderStep<StepInput, OperationInput = GetOrderInput, OperationOutput = Order>(configuration: GetOrderStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+/** Configuration for the listOrders connector Step. */
+interface ListOrdersStepConfig<StepInput, OperationInput = ListOrdersInput, OperationOutput = OrderPage> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        listOrders(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** List one page of Shopify orders. */
+    listed: StepTarget<QueryResult<OperationOutput>>;
+    /** The requested resource was not found. */
+    notFound?: StepTarget<QueryResult<OperationOutput>>;
+    /** The provider conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** The provider returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Local input or connection credentials are invalid. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the listOrders Step from a named connection. */
+declare function newListOrdersStep<StepInput, OperationInput = ListOrdersInput, OperationOutput = OrderPage>(configuration: ListOrdersStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+
+/** Read one Shopify order. */
+declare class GetOrderOperation implements Query<GetOrderInput, Order> {
+    private readonly client;
+    /** Bind the validated client. */ constructor(client: ShopifyClient);
+    /** Return the manifest operation definition. */ definition(): _superdurable_connectors_sdk.QueryDefinition;
+    /** Validate and read one order. */
+    invoke(call: Call, input: GetOrderInput): Promise<QueryAttempt<Order>>;
+}
+/** Read one bounded Shopify order page. */
+declare class ListOrdersOperation implements Query<ListOrdersInput, OrderPage> {
+    private readonly client;
+    /** Bind the validated client. */ constructor(client: ShopifyClient);
+    /** Return the manifest operation definition. */ definition(): _superdurable_connectors_sdk.QueryDefinition;
+    /** Validate and read one page. */
+    invoke(call: Call, input: ListOrdersInput): Promise<QueryAttempt<OrderPage>>;
+}
+
+/** Injectable HTTP sender for provider replay. */
+type ShopifyRequestSender = (request: ProviderRequest) => Promise<ProviderResponse>;
+/** Transport dependency for deterministic tests. */
+interface ShopifyClientOptions {
+    /** Override the default bounded HTTP sender. */
+    send?: ShopifyRequestSender;
+}
+/** One classified provider exchange. */
+interface ShopifyExchangeFailure {
+    /** Retry or a manifest branch. */
+    branch: 'retry' | 'notFound' | 'providerRejected' | 'invalidResponse' | 'defect';
+    /** Secret-safe failure. */
+    failure: Failure;
+    /** Provider delay in milliseconds. */
+    retryAfterMs: number;
+}
+/** Bounded successful body or classified failure. */
+type ShopifyExchangeResult = {
+    body: Uint8Array;
+} | {
+    outcome: ShopifyExchangeFailure;
+};
+/** Validated Shopify order client with call-time credential resolution. */
+declare class ShopifyClient {
+    private readonly baseURL;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    private readonly credentials;
+    private readonly send;
+    /** Validate one shop connection without contacting Shopify. */
+    constructor(config: Config, credentials: CredentialProvider<Credentials>, options?: ShopifyClientOptions);
+    /** Bind one order lookup. */
+    getOrder(): GetOrderOperation;
+    /** Bind one order page lookup. */
+    listOrders(): ListOrdersOperation;
+    /** Send one order read and apply Go's status classification. */
+    read(call: Call, operation: string, path: string, query?: URLSearchParams): Promise<ShopifyExchangeResult>;
+    private classifyStatus;
+    private failure;
+}
+
+/** Open a named Shopify connection from a Dex project. */
+declare function newProjectConnection(project: LoadedProject, connectionName: string, options?: ShopifyClientOptions): Connection<Operations>;
+
+export { Config, Connection, ConnectorID, Credentials, GetOrderBranch, GetOrderBranchDefect, GetOrderBranchFound, GetOrderBranchInvalidResponse, GetOrderBranchNotFound, GetOrderBranchProviderRejected, GetOrderDefinition, GetOrderInput, GetOrderMetadata, GetOrderOperation, type GetOrderStepConfig, ListOrdersBranch, ListOrdersBranchDefect, ListOrdersBranchInvalidResponse, ListOrdersBranchListed, ListOrdersBranchNotFound, ListOrdersBranchProviderRejected, ListOrdersDefinition, ListOrdersInput, ListOrdersMetadata, ListOrdersOperation, type ListOrdersStepConfig, Order, OrderPage, ProviderID, ShopifyClient, type ShopifyClientOptions, type ShopifyRequestSender, newGetOrderStep, newListOrdersStep, newProjectConnection };

package/dist/index.js

@@ -0,0 +1,292 @@
+import {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  GetOrderBranch,
+  GetOrderBranchDefect,
+  GetOrderBranchFound,
+  GetOrderBranchInvalidResponse,
+  GetOrderBranchNotFound,
+  GetOrderBranchProviderRejected,
+  GetOrderDefinition,
+  GetOrderInputSchema,
+  GetOrderMetadata,
+  ListOrdersBranch,
+  ListOrdersBranchDefect,
+  ListOrdersBranchInvalidResponse,
+  ListOrdersBranchListed,
+  ListOrdersBranchNotFound,
+  ListOrdersBranchProviderRejected,
+  ListOrdersDefinition,
+  ListOrdersInputSchema,
+  ListOrdersMetadata,
+  OrderPageSchema,
+  OrderSchema,
+  ProviderID,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+} from "./chunk-A5SY2SHU.js";
+
+// src/generated/steps.ts
+import { goToBranch, newQueryStep } from "@superdurable/connectors-sdk";
+function newGetOrderStep(configuration) {
+  const { connection, connectionName, found, notFound, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newQueryStep({ ...stepConfiguration, operation: connection.operations.getOrder(), connection: connection.reference, branches: [
+    goToBranch("found", found),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newListOrdersStep(configuration) {
+  const { connection, connectionName, listed, notFound, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newQueryStep({ ...stepConfiguration, operation: connection.operations.listOrders(), connection: connection.reference, branches: [
+    goToBranch("listed", listed),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+
+// src/client.ts
+import { SecretString } from "@superdurable/connectors-sdk";
+import { BodyTooLargeError, isHeaderSafeCredential, parseRetryAfter, sendProviderRequest } from "@superdurable/connectors-sdk/providerhttp";
+
+// src/operations.ts
+import { newQueryBranch, newQueryRetry } from "@superdurable/connectors-sdk";
+var emptyOrder = { id: 0, name: "", financial_status: "", total_price: "", currency: "" };
+var emptyPage = { orders: [] };
+var GetOrderOperation = class {
+  /** Bind the validated client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the manifest operation definition. */
+  definition() {
+    return GetOrderDefinition;
+  }
+  /** Validate and read one order. */
+  async invoke(call, input) {
+    if (!Number.isSafeInteger(input.orderId) || input.orderId <= 0) return failed("defect", "getOrder", "VALIDATION", "orderId must be positive", emptyOrder);
+    const result = await this.client.read(call, "getOrder", `/orders/${input.orderId}.json`);
+    if ("outcome" in result) return classify(result.outcome, emptyOrder);
+    try {
+      const body = parseObject(result.body);
+      const order = decodeOrder(body.order);
+      if (order.id <= 0) throw new TypeError("missing order");
+      return newQueryBranch("found", order);
+    } catch {
+      return failed("invalidResponse", "getOrder", "PROTOCOL", "provider returned invalid JSON", emptyOrder);
+    }
+  }
+};
+var ListOrdersOperation = class {
+  /** Bind the validated client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the manifest operation definition. */
+  definition() {
+    return ListOrdersDefinition;
+  }
+  /** Validate and read one page. */
+  async invoke(call, input) {
+    const limit = input.limit ?? 0;
+    if (!Number.isSafeInteger(limit) || limit < 0 || limit > 250) return failed("defect", "listOrders", "VALIDATION", "limit must be 1 through 250, or zero for provider default", emptyPage);
+    const query = new URLSearchParams();
+    if (limit > 0) query.set("limit", String(limit));
+    query.set("status", "any");
+    const result = await this.client.read(call, "listOrders", "/orders.json", query);
+    if ("outcome" in result) return classify(result.outcome, emptyPage);
+    try {
+      const body = parseObject(result.body);
+      if (!Array.isArray(body.orders)) throw new TypeError("missing orders");
+      return newQueryBranch("listed", { orders: body.orders.map(decodeOrder) });
+    } catch {
+      return failed("invalidResponse", "listOrders", "PROTOCOL", "provider returned invalid JSON", emptyPage);
+    }
+  }
+};
+function parseObject(body) {
+  const value = JSON.parse(Buffer.from(body).toString("utf8"));
+  if (value === null || Array.isArray(value) || typeof value !== "object") throw new TypeError("object expected");
+  return value;
+}
+function decodeOrder(value) {
+  if (value === null || Array.isArray(value) || typeof value !== "object") throw new TypeError("order expected");
+  const order = value;
+  const numberField = order.id ?? 0;
+  if (typeof numberField !== "number" || !Number.isSafeInteger(numberField)) throw new TypeError("id must be an integer");
+  const text = (key) => {
+    const field = order[key] ?? "";
+    if (typeof field !== "string") throw new TypeError("order text field expected");
+    return field;
+  };
+  return { id: numberField, name: text("name"), financial_status: text("financial_status"), total_price: text("total_price"), currency: text("currency") };
+}
+function classify(outcome, empty) {
+  if (outcome.branch === "retry") return newQueryRetry(outcome.failure, outcome.retryAfterMs);
+  return newQueryBranch(outcome.branch, empty, {}, outcome.failure);
+}
+function failed(branch, operation, kind, message, empty) {
+  return newQueryBranch(branch, empty, {}, { kind, provider: "shopify", operation, message });
+}
+
+// src/client.ts
+var ShopifyClient = class {
+  baseURL;
+  timeoutMs;
+  maxResponseBytes;
+  credentials;
+  send;
+  /** Validate one shop connection without contacting Shopify. */
+  constructor(config, credentials, options = {}) {
+    if (!credentials) throw new TypeError("Shopify credential source is required");
+    if (!/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(config.shopSubdomain)) throw new TypeError("shopSubdomain must contain lowercase letters, digits, or internal hyphens");
+    this.baseURL = `https://${config.shopSubdomain}.myshopify.com/admin/api/2026-10`;
+    this.timeoutMs = config.timeoutMs ?? 15e3;
+    this.maxResponseBytes = config.maxResponseBytes ?? 2097152;
+    if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0) throw new TypeError("timeout must be positive");
+    if (!Number.isSafeInteger(this.maxResponseBytes) || this.maxResponseBytes <= 0) throw new TypeError("maxResponseBytes must be positive");
+    this.credentials = credentials;
+    this.send = options.send ?? sendProviderRequest;
+  }
+  /** Bind one order lookup. */
+  getOrder() {
+    return new GetOrderOperation(this);
+  }
+  /** Bind one order page lookup. */
+  listOrders() {
+    return new ListOrdersOperation(this);
+  }
+  /** Send one order read and apply Go's status classification. */
+  async read(call, operation, path, query) {
+    let token;
+    try {
+      const credentials = await this.credentials.resolve(call, call.context.cancellationSignal);
+      if (!(credentials.accessToken instanceof SecretString)) throw new TypeError("invalid token");
+      token = credentials.accessToken.reveal();
+      if (!token || !isHeaderSafeCredential(token)) throw new TypeError("invalid token");
+    } catch {
+      return { outcome: this.failure("defect", operation, "AUTHENTICATION", "Shopify credentials are unavailable") };
+    }
+    let response;
+    try {
+      response = await this.send({
+        url: this.baseURL + path + (query?.size ? `?${query.toString()}` : ""),
+        method: "GET",
+        headers: { Accept: "application/json", "X-Shopify-Access-Token": token },
+        maxResponseBytes: this.maxResponseBytes,
+        addressPolicy: "publicHTTPS",
+        timeoutMs: this.timeoutMs,
+        signal: call.context.cancellationSignal
+      });
+    } catch (error) {
+      if (error instanceof BodyTooLargeError) {
+        const statusFailure2 = error.status === void 0 ? null : this.classifyStatus(operation, error.status, error.headers ?? {});
+        return { outcome: statusFailure2 ?? this.failure("invalidResponse", operation, "RESPONSE_TOO_LARGE", "provider response exceeded the configured limit") };
+      }
+      return { outcome: this.failure("retry", operation, "AVAILABILITY", "provider read failed") };
+    }
+    const statusFailure = this.classifyStatus(operation, response.status, response.headers);
+    return statusFailure ? { outcome: statusFailure } : { body: response.body };
+  }
+  classifyStatus(operation, status, headers) {
+    const retryAfter = headers["retry-after"];
+    const delay = parseRetryAfter(Array.isArray(retryAfter) ? retryAfter[0] ?? "" : retryAfter ?? "");
+    if (status === 429) return this.failure("retry", operation, "RATE_LIMIT", "provider rate limited the read", delay);
+    if (status === 408 || status >= 500) return this.failure("retry", operation, "AVAILABILITY", "provider read is temporarily unavailable", delay);
+    if (status === 404) return this.failure("notFound", operation, "PROVIDER_REJECTION", "resource was not found");
+    if (status === 401) return this.failure("providerRejected", operation, "AUTHENTICATION", "provider rejected credentials");
+    if (status === 403) return this.failure("providerRejected", operation, "AUTHORIZATION", "provider denied access");
+    if (status !== 200) return this.failure("providerRejected", operation, "PROVIDER_REJECTION", `provider rejected read with HTTP ${status}`);
+    return null;
+  }
+  failure(branch, operation, kind, message, retryAfterMs = 0) {
+    return { branch, failure: { kind, provider: "shopify", operation, message }, retryAfterMs };
+  }
+};
+
+// src/project.ts
+import { SecretString as SecretString2 } from "@superdurable/connectors-sdk";
+import { z } from "zod";
+var settingsSchema = z.strictObject({
+  shopSubdomain: z.string(),
+  timeout: z.union([z.string(), z.number().int()]).optional(),
+  maxResponseBytes: z.number().int().optional()
+});
+function newProjectConnection2(project, connectionName, options = {}) {
+  return newProjectConnection(project, connectionName, (loadedProject, name) => {
+    const selected = loadedProject.configuration.connections.find((entry) => entry.connectorId === "shopify" && entry.connectionName === name);
+    if (!selected) throw new TypeError("Shopify project connection is not configured");
+    const fields = settingsSchema.parse(selected.configuration);
+    const timeoutMs = typeof fields.timeout === "number" ? Math.ceil(fields.timeout / 1e6) : fields.timeout !== void 0 ? parseDurationMilliseconds(fields.timeout) : void 0;
+    const config = {
+      shopSubdomain: fields.shopSubdomain,
+      ...timeoutMs !== void 0 ? { timeoutMs } : {},
+      ...fields.maxResponseBytes !== void 0 ? { maxResponseBytes: fields.maxResponseBytes } : {}
+    };
+    const credentials = {
+      async resolve(_call, signal) {
+        const fields2 = await loadedProject.resolveCredential("shopify", name, signal);
+        if (typeof fields2.access_token !== "string" || !fields2.access_token) throw new TypeError("Shopify token is unavailable");
+        return { accessToken: new SecretString2(fields2.access_token) };
+      }
+    };
+    return new ShopifyClient(config, credentials, options);
+  });
+}
+function parseDurationMilliseconds(value) {
+  let remaining = value;
+  let milliseconds = 0;
+  const units = { ns: 1e-6, us: 1e-3, "\xB5s": 1e-3, ms: 1, s: 1e3, m: 6e4, h: 36e5 };
+  while (remaining) {
+    const component = /^(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/.exec(remaining);
+    if (!component) throw new TypeError("Shopify timeout must be a positive Go duration");
+    milliseconds += Number(component[1]) * (units[component[2] ?? ""] ?? NaN);
+    remaining = remaining.slice(component[0].length);
+  }
+  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) throw new TypeError("Shopify timeout must resolve to positive whole milliseconds");
+  return milliseconds;
+}
+export {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  GetOrderBranch,
+  GetOrderBranchDefect,
+  GetOrderBranchFound,
+  GetOrderBranchInvalidResponse,
+  GetOrderBranchNotFound,
+  GetOrderBranchProviderRejected,
+  GetOrderDefinition,
+  GetOrderInputSchema,
+  GetOrderMetadata,
+  GetOrderOperation,
+  ListOrdersBranch,
+  ListOrdersBranchDefect,
+  ListOrdersBranchInvalidResponse,
+  ListOrdersBranchListed,
+  ListOrdersBranchNotFound,
+  ListOrdersBranchProviderRejected,
+  ListOrdersDefinition,
+  ListOrdersInputSchema,
+  ListOrdersMetadata,
+  ListOrdersOperation,
+  OrderPageSchema,
+  OrderSchema,
+  ProviderID,
+  ShopifyClient,
+  newConnection,
+  newConnectionWithOperations,
+  newGetOrderStep,
+  newListOrdersStep,
+  newProjectConnection2 as newProjectConnection
+};

package/dist/mock.d.ts

@@ -0,0 +1,56 @@
+import { MockQuery, Case } from '@superdurable/connectors-sdk/connectormock';
+import { Failure } from '@superdurable/connectors-sdk';
+import { d as Operations, C as Connection, G as GetOrderInput, O as Order, L as ListOrdersInput, a as OrderPage } from './connection-D5oSVoU-.js';
+import 'zod';
+
+/** Go zero value for GetOrderInput in scripted cases. */
+declare const emptyGetOrderInput: GetOrderInput;
+/** Go zero value for Order in scripted cases. */
+declare const emptyOrder: Order;
+/** Go zero value for ListOrdersInput in scripted cases. */
+declare const emptyListOrdersInput: ListOrdersInput;
+/** Go zero value for OrderPage in scripted cases. */
+declare const emptyOrderPage: OrderPage;
+/** Script the found branch. */
+declare function getOrderFound(value: Order, failure?: Failure): Case<Order>;
+/** Script the notFound branch. */
+declare function getOrderNotFound(value: Order, failure?: Failure): Case<Order>;
+/** Script the providerRejected branch. */
+declare function getOrderProviderRejected(value: Order, failure?: Failure): Case<Order>;
+/** Script the invalidResponse branch. */
+declare function getOrderInvalidResponse(value: Order, failure?: Failure): Case<Order>;
+/** Script the defect branch. */
+declare function getOrderDefect(value: Order, failure?: Failure): Case<Order>;
+/** Script a safe retry of getOrder. */
+declare function getOrderRetry(failure: Failure, retryAfterMs?: number): Case<Order>;
+/** Manifest scenario defaultAnswer for getOrder. */
+declare function getOrderDefaultAnswer(): Case<Order>;
+/** Default getOrder scenario. */
+declare function getOrderDefault(): Case<Order>;
+/** Script the listed branch. */
+declare function listOrdersListed(value: OrderPage, failure?: Failure): Case<OrderPage>;
+/** Script the notFound branch. */
+declare function listOrdersNotFound(value: OrderPage, failure?: Failure): Case<OrderPage>;
+/** Script the providerRejected branch. */
+declare function listOrdersProviderRejected(value: OrderPage, failure?: Failure): Case<OrderPage>;
+/** Script the invalidResponse branch. */
+declare function listOrdersInvalidResponse(value: OrderPage, failure?: Failure): Case<OrderPage>;
+/** Script the defect branch. */
+declare function listOrdersDefect(value: OrderPage, failure?: Failure): Case<OrderPage>;
+/** Script a safe retry of listOrders. */
+declare function listOrdersRetry(failure: Failure, retryAfterMs?: number): Case<OrderPage>;
+/** Manifest scenario defaultAnswer for listOrders. */
+declare function listOrdersDefaultAnswer(): Case<OrderPage>;
+/** Default listOrders scenario. */
+declare function listOrdersDefault(): Case<OrderPage>;
+/** Scripted operations and manifest defaults for this connector. */
+declare class GeneratedMock implements Operations {
+    #private;
+    constructor(connectionName: string);
+    connection(): Connection;
+    getOrder(): MockQuery<GetOrderInput, Order>;
+    listOrders(): MockQuery<ListOrdersInput, OrderPage>;
+    assertNoFailures(): void;
+}
+
+export { GeneratedMock, emptyGetOrderInput, emptyListOrdersInput, emptyOrder, emptyOrderPage, getOrderDefault, getOrderDefaultAnswer, getOrderDefect, getOrderFound, getOrderInvalidResponse, getOrderNotFound, getOrderProviderRejected, getOrderRetry, listOrdersDefault, listOrdersDefaultAnswer, listOrdersDefect, listOrdersInvalidResponse, listOrdersListed, listOrdersNotFound, listOrdersProviderRejected, listOrdersRetry };

package/dist/mock.js

@@ -0,0 +1,123 @@
+import {
+  GetOrderDefinition,
+  GetOrderInputSchema,
+  ListOrdersDefinition,
+  ListOrdersInputSchema,
+  OrderPageSchema,
+  OrderSchema,
+  ProviderID,
+  newConnectionWithOperations
+} from "./chunk-A5SY2SHU.js";
+
+// src/generated/mock.ts
+import { branchCase, retryCase, newQuery } from "@superdurable/connectors-sdk/connectormock";
+var emptyGetOrderInput = GetOrderInputSchema.parse({
+  "orderId": 0
+});
+var emptyOrder = OrderSchema.parse({
+  "id": 0,
+  "name": "",
+  "financial_status": "",
+  "total_price": "",
+  "currency": ""
+});
+var emptyListOrdersInput = ListOrdersInputSchema.parse({});
+var emptyOrderPage = OrderPageSchema.parse({
+  "orders": []
+});
+function getOrderFound(value, failure) {
+  return branchCase("found", value, failure);
+}
+function getOrderNotFound(value, failure) {
+  return branchCase("notFound", value, failure);
+}
+function getOrderProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function getOrderInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function getOrderDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function getOrderRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function getOrderDefaultAnswer() {
+  const value = OrderSchema.parse({ "currency": "USD", "financial_status": "paid", "id": 101, "name": "#101", "total_price": "29.00" });
+  return branchCase("found", value);
+}
+function getOrderDefault() {
+  return getOrderDefaultAnswer();
+}
+function listOrdersListed(value, failure) {
+  return branchCase("listed", value, failure);
+}
+function listOrdersNotFound(value, failure) {
+  return branchCase("notFound", value, failure);
+}
+function listOrdersProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function listOrdersInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function listOrdersDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function listOrdersRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function listOrdersDefaultAnswer() {
+  const value = OrderPageSchema.parse({ "orders": [{ "currency": "USD", "financial_status": "paid", "id": 101, "name": "#101", "total_price": "29.00" }] });
+  return branchCase("listed", value);
+}
+function listOrdersDefault() {
+  return listOrdersDefaultAnswer();
+}
+var GeneratedMock = class {
+  #getOrder;
+  #listOrders;
+  #connection;
+  constructor(connectionName) {
+    this.#getOrder = newQuery(GetOrderDefinition).default(getOrderDefault());
+    this.#listOrders = newQuery(ListOrdersDefinition).default(listOrdersDefault());
+    this.#connection = newConnectionWithOperations(this, { provider: ProviderID, name: connectionName });
+  }
+  connection() {
+    return this.#connection;
+  }
+  getOrder() {
+    return this.#getOrder;
+  }
+  listOrders() {
+    return this.#listOrders;
+  }
+  assertNoFailures() {
+    this.#getOrder.assertNoFailures();
+    this.#listOrders.assertNoFailures();
+  }
+};
+export {
+  GeneratedMock,
+  emptyGetOrderInput,
+  emptyListOrdersInput,
+  emptyOrder,
+  emptyOrderPage,
+  getOrderDefault,
+  getOrderDefaultAnswer,
+  getOrderDefect,
+  getOrderFound,
+  getOrderInvalidResponse,
+  getOrderNotFound,
+  getOrderProviderRejected,
+  getOrderRetry,
+  listOrdersDefault,
+  listOrdersDefaultAnswer,
+  listOrdersDefect,
+  listOrdersInvalidResponse,
+  listOrdersListed,
+  listOrdersNotFound,
+  listOrdersProviderRejected,
+  listOrdersRetry
+};

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@superdurable/connector-shopify",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Shopify order reads for Dex Flows",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superdurable/dex-connectors-library.git",
+    "directory": "connectors/shopify/typescript"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": "^22.0.0 || ^24.0.0"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mock": {
+      "types": "./dist/mock.d.ts",
+      "import": "./dist/mock.js"
+    }
+  },
+  "files": [
+    "dist",
+    "dex-connector.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/mock.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test examples",
+    "test": "npm run build && vitest run --exclude 'test/integration/**'",
+    "test:integration": "npm run build && vitest run test/integration/*.integration.test.ts",
+    "check": "npm test && npm run typecheck && npm run lint",
+    "example:order": "npm run build && tsx examples/order-read/main.ts",
+    "example:order:start": "npm run build && tsx examples/order-read/start.ts"
+  },
+  "dependencies": {
+    "@superdurable/connectors-sdk": "0.1.0",
+    "@superdurable/dex": ">=1.28.0",
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^22.0.0",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.23.15",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^3.0.0",
+    "yaml": "^2.9.1"
+  }
+}