@superdurable/connector-jotform 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,5 @@
-# Temporary Holding Version
+# Jotform TypeScript connector
 
-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.
+This package implements `listForms` and `getSubmission` for Dex TypeScript Flows. Both Queries replay Go-recorded provider requests, branches, retries, and exact outputs. Submission answers stay outside Flow results.
+
+Create a read-only API key in [Jotform My Account > API](https://www.jotform.com/myaccount/api) and save it in the Dex Web secret `api_key` field. Select the US, EU, or HIPAA endpoint for your account. See the [connector README](../README.md) and the [runnable form inspection Flow](examples/form-inspection/README.md). Live Jotform authorization remains unverified.

package/dex-connector.json

@@ -0,0 +1,118 @@
+{
+  "connectorId": "jotform",
+  "releaseTag": "connectors/jotform/go/v0.1.0",
+  "package": {
+    "ecosystem": "npm",
+    "name": "@superdurable/connector-jotform",
+    "version": "0.1.0"
+  },
+  "factories": [
+    {
+      "name": "newListFormsStep",
+      "kind": "query",
+      "operationId": "listForms",
+      "inputType": "ListFormsInput",
+      "description": "List one page of form titles and IDs without submission answers.",
+      "fields": {
+        "stepType": "stepType",
+        "annotations": "annotations",
+        "connectionName": "connectionName",
+        "resultAttribute": "resultAttribute"
+      },
+      "branches": [
+        {
+          "id": "listed",
+          "field": "listed",
+          "optional": false
+        },
+        {
+          "id": "providerRejected",
+          "field": "providerRejected",
+          "optional": true
+        },
+        {
+          "id": "invalidResponse",
+          "field": "invalidResponse",
+          "optional": true
+        },
+        {
+          "id": "defect",
+          "field": "defect",
+          "optional": true
+        }
+      ],
+      "inputSchema": {
+        "additionalProperties": false,
+        "description": "ListFormsInput selects a zero-based page of at most 100 forms.",
+        "properties": {
+          "limit": {
+            "description": "Limit is the maximum form count; zero defaults to 20.",
+            "type": "integer"
+          },
+          "offset": {
+            "description": "Offset is the zero-based form offset; zero starts the first page.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "offset"
+        ],
+        "type": "object"
+      }
+    },
+    {
+      "name": "newGetSubmissionStep",
+      "kind": "query",
+      "operationId": "getSubmission",
+      "inputType": "GetSubmissionInput",
+      "description": "Read one submission's ID, form ID, status, and creation timestamp; answers are intentionally excluded.",
+      "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
+        }
+      ],
+      "inputSchema": {
+        "additionalProperties": false,
+        "description": "GetSubmissionInput selects one numeric Jotform submission ID.",
+        "properties": {
+          "submissionId": {
+            "description": "SubmissionID is the numeric ID from Jotform's submission URL or API.",
+            "type": "string"
+          }
+        },
+        "required": [
+          "submissionId"
+        ],
+        "type": "object"
+      }
+    }
+  ]
+}

package/dist/chunk-ZKAGZX4P.js

@@ -0,0 +1,152 @@
+// src/generated/models.ts
+import { z } from "zod";
+import { SecretString } from "@superdurable/connectors-sdk";
+var ConfigSchema = z.object({
+  "baseUrl": z.string().optional(),
+  "timeoutMs": z.number().int().optional(),
+  "maxResponseBytes": z.number().int().optional()
+});
+function decodeCredentials(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("credential fields are invalid");
+  const fields = value;
+  const allowed = /* @__PURE__ */ new Set(["api_key"]);
+  if (Object.keys(fields).some((key) => !allowed.has(key))) throw new TypeError("stored credential does not match the connector credential fields");
+  if (fields["api_key"] != null && !(typeof fields["api_key"] === "string")) throw new TypeError("credential api_key has an invalid type");
+  const credentials = {};
+  if (!fields["api_key"]) throw new TypeError("credential api_key is required");
+  credentials.apiKey = new SecretString(fields["api_key"] ?? "");
+  return credentials;
+}
+var ListFormsInputSchema = z.strictObject({
+  "offset": z.number().int(),
+  "limit": z.number().int().optional()
+});
+var FormMetadataSchema = z.strictObject({
+  "id": z.string(),
+  "title": z.string(),
+  "status": z.string()
+});
+var FormsPageSchema = z.strictObject({
+  "forms": z.array(FormMetadataSchema).nullable(),
+  "offset": z.number().int(),
+  "limit": z.number().int()
+});
+var GetSubmissionInputSchema = z.strictObject({
+  "submissionId": z.string()
+});
+var SubmissionMetadataSchema = z.strictObject({
+  "id": z.string(),
+  "formId": z.string(),
+  "status": z.string(),
+  "createdAt": z.string()
+});
+
+// src/generated/definitions.ts
+var ConnectorID = "jotform";
+var ProviderID = "jotform";
+var ListFormsBranch = {
+  Listed: "listed",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var ListFormsBranchListed = ListFormsBranch.Listed;
+var ListFormsBranchProviderRejected = ListFormsBranch.ProviderRejected;
+var ListFormsBranchInvalidResponse = ListFormsBranch.InvalidResponse;
+var ListFormsBranchDefect = ListFormsBranch.Defect;
+var ListFormsDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "listForms" },
+  branches: [
+    { id: "listed", description: "Jotform returned the selected form page." },
+    { id: "providerRejected", description: "Jotform conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "Jotform 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 ListFormsMetadata = { kind: "query", idempotency: "none", authorization: "required" };
+var GetSubmissionBranch = {
+  Found: "found",
+  NotFound: "notFound",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var GetSubmissionBranchFound = GetSubmissionBranch.Found;
+var GetSubmissionBranchNotFound = GetSubmissionBranch.NotFound;
+var GetSubmissionBranchProviderRejected = GetSubmissionBranch.ProviderRejected;
+var GetSubmissionBranchInvalidResponse = GetSubmissionBranch.InvalidResponse;
+var GetSubmissionBranchDefect = GetSubmissionBranch.Defect;
+var GetSubmissionDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "getSubmission" },
+  branches: [
+    { id: "found", description: "Jotform returned the submission metadata." },
+    { id: "notFound", description: "The submission does not exist or is inaccessible.", optional: true },
+    { id: "providerRejected", description: "Jotform conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "Jotform 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 GetSubmissionMetadata = { 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,
+  decodeCredentials,
+  ListFormsInputSchema,
+  FormMetadataSchema,
+  FormsPageSchema,
+  GetSubmissionInputSchema,
+  SubmissionMetadataSchema,
+  ConnectorID,
+  ProviderID,
+  ListFormsBranch,
+  ListFormsBranchListed,
+  ListFormsBranchProviderRejected,
+  ListFormsBranchInvalidResponse,
+  ListFormsBranchDefect,
+  ListFormsDefinition,
+  ListFormsMetadata,
+  GetSubmissionBranch,
+  GetSubmissionBranchFound,
+  GetSubmissionBranchNotFound,
+  GetSubmissionBranchProviderRejected,
+  GetSubmissionBranchInvalidResponse,
+  GetSubmissionBranchDefect,
+  GetSubmissionDefinition,
+  GetSubmissionMetadata,
+  Connection,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+};

package/dist/connection-D-MiEsWp.d.ts

@@ -0,0 +1,123 @@
+import { CredentialProvider, SecretString, Query, ConnectionRef } from '@superdurable/connectors-sdk';
+import { z } from 'zod';
+
+/** Connector configuration; omitted fields use manifest defaults. */
+interface Config {
+    /** Jotform API endpoint, as an absolute HTTPS URL. Leave blank for the displayed US default; use https://eu-api.jotform.com for an EU account or https://hipaa-api.jotform.com for HIPAA. Override only for your account region or a trusted test gateway. */
+    baseUrl?: string;
+    /** Maximum duration of one API request as a positive Go duration such as 15s or 1m. Blank uses the displayed default; increase only for slow responses. Runtime value in milliseconds. */
+    timeoutMs?: number;
+    /** Positive maximum complete API response in bytes. Blank uses the displayed default; increase for known larger form lists. Oversized responses select invalidResponse. */
+    maxResponseBytes?: number;
+}
+/** Runtime schema for manifest configuration. */
+declare const ConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodOptional<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 provider-issued API key from Jotform My Account > API at https://www.jotform.com/myaccount/api. Create or select a read-only key and copy its full string; blank makes calls select defect. Dex stores it as a secret and sends it only in the APIKEY header. */
+    apiKey: SecretString;
+}
+/** Decode private credential fields for the connector. */
+declare function decodeCredentials(value: unknown): Credentials;
+/** Host-owned source of private connector credentials. */
+type CredentialSource = CredentialProvider<Credentials>;
+/** ListFormsInput selects a zero-based page of at most 100 forms. */
+interface ListFormsInput {
+    /** Offset is the zero-based form offset; zero starts the first page. */
+    "offset": number;
+    /** Limit is the maximum form count; zero defaults to 20. */
+    "limit"?: number | undefined;
+}
+/** FormMetadata contains public form identity and status without questions or answers. */
+interface FormMetadata {
+    /** ID is the provider form ID. */
+    "id": string;
+    /** Title is the form's untrusted display title. */
+    "title": string;
+    /** Status is the provider form status. */
+    "status": string;
+}
+/** FormsPage is one offset-based Jotform form page. */
+interface FormsPage {
+    /** Forms contains the selected page. */
+    "forms": Array<FormMetadata> | null;
+    /** Offset is the requested zero-based offset. */
+    "offset": number;
+    /** Limit is the requested maximum count. */
+    "limit": number;
+}
+/** GetSubmissionInput selects one numeric Jotform submission ID. */
+interface GetSubmissionInput {
+    /** SubmissionID is the numeric ID from Jotform's submission URL or API. */
+    "submissionId": string;
+}
+/** SubmissionMetadata omits answers, which may contain secrets or personal data. */
+interface SubmissionMetadata {
+    /** ID is the stable submission ID. */
+    "id": string;
+    /** FormID identifies the owning form. */
+    "formId": string;
+    /** Status is the provider submission status. */
+    "status": string;
+    /** CreatedAt is Jotform's raw creation timestamp. */
+    "createdAt": string;
+}
+/** Runtime validator for ListFormsInput. */
+declare const ListFormsInputSchema: z.ZodObject<{
+    offset: z.ZodNumber;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** Runtime validator for FormMetadata. */
+declare const FormMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for FormsPage. */
+declare const FormsPageSchema: z.ZodObject<{
+    forms: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$strict>>>;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+/** Runtime validator for GetSubmissionInput. */
+declare const GetSubmissionInputSchema: z.ZodObject<{
+    submissionId: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for SubmissionMetadata. */
+declare const SubmissionMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    formId: z.ZodString;
+    status: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+
+/** Typed operations supplied by a client or mock. */
+interface Operations {
+    /** Invoke listForms through this connection. */
+    listForms(): Query<ListFormsInput, FormsPage>;
+    /** Invoke getSubmission through this connection. */
+    getSubmission(): Query<GetSubmissionInput, SubmissionMetadata>;
+}
+/** 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 FormsPage as F, type GetSubmissionInput as G, type ListFormsInput as L, type Operations as O, type SubmissionMetadata as S, type Config as a, type Credentials as b, ConfigSchema as c, type CredentialSource as d, type FormMetadata as e, FormMetadataSchema as f, FormsPageSchema as g, GetSubmissionInputSchema as h, ListFormsInputSchema as i, SubmissionMetadataSchema as j, decodeCredentials as k, newConnectionWithOperations as l, newConnection as n };

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+import { G as GetSubmissionInput, S as SubmissionMetadata, C as Connection, L as ListFormsInput, F as FormsPage, O as Operations, a as Config, b as Credentials } from './connection-D-MiEsWp.js';
+export { c as ConfigSchema, d as CredentialSource, e as FormMetadata, f as FormMetadataSchema, g as FormsPageSchema, h as GetSubmissionInputSchema, i as ListFormsInputSchema, j as SubmissionMetadataSchema, k as decodeCredentials, n as newConnection, l as newConnectionWithOperations } from './connection-D-MiEsWp.js';
+import { QueryDefinition, QueryStepConfig, Query, QueryResult, QueryStep, CredentialProvider, Call, QueryAttempt, Failure } from '@superdurable/connectors-sdk';
+import { StepTarget } from '@superdurable/dex';
+import { LoadedProject } from '@superdurable/connectors-sdk/projectconfig';
+import { ProviderRequest, ProviderResponse } from '@superdurable/connectors-sdk/providerhttp';
+import 'zod';
+
+/** Stable connector identity. */
+declare const ConnectorID = "jotform";
+/** Provider identity for named connections. */
+declare const ProviderID = "jotform";
+/** Branch IDs for listForms. */
+declare const ListFormsBranch: {
+    readonly Listed: "listed";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** Jotform returned the selected form page. */
+declare const ListFormsBranchListed: "listed";
+/** Jotform conclusively rejected the request. */
+declare const ListFormsBranchProviderRejected: "providerRejected";
+/** Jotform returned malformed or oversized JSON. */
+declare const ListFormsBranchInvalidResponse: "invalidResponse";
+/** Local input or connection credentials are invalid. */
+declare const ListFormsBranchDefect: "defect";
+/** Manifest definition for listForms. */
+declare const ListFormsDefinition: QueryDefinition;
+/** Manifest metadata for listForms. */
+declare const ListFormsMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+/** Branch IDs for getSubmission. */
+declare const GetSubmissionBranch: {
+    readonly Found: "found";
+    readonly NotFound: "notFound";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** Jotform returned the submission metadata. */
+declare const GetSubmissionBranchFound: "found";
+/** The submission does not exist or is inaccessible. */
+declare const GetSubmissionBranchNotFound: "notFound";
+/** Jotform conclusively rejected the request. */
+declare const GetSubmissionBranchProviderRejected: "providerRejected";
+/** Jotform returned malformed or oversized JSON. */
+declare const GetSubmissionBranchInvalidResponse: "invalidResponse";
+/** Local input or connection credentials are invalid. */
+declare const GetSubmissionBranchDefect: "defect";
+/** Manifest definition for getSubmission. */
+declare const GetSubmissionDefinition: QueryDefinition;
+/** Manifest metadata for getSubmission. */
+declare const GetSubmissionMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+
+/** Configuration for the listForms connector Step. */
+interface ListFormsStepConfig<StepInput, OperationInput = ListFormsInput, OperationOutput = FormsPage> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        listForms(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** Jotform returned the selected form page. */
+    listed: StepTarget<QueryResult<OperationOutput>>;
+    /** Jotform conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** Jotform returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Local input or connection credentials are invalid. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the listForms Step from a named connection. */
+declare function newListFormsStep<StepInput, OperationInput = ListFormsInput, OperationOutput = FormsPage>(configuration: ListFormsStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+/** Configuration for the getSubmission connector Step. */
+interface GetSubmissionStepConfig<StepInput, OperationInput = GetSubmissionInput, OperationOutput = SubmissionMetadata> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        getSubmission(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** Jotform returned the submission metadata. */
+    found: StepTarget<QueryResult<OperationOutput>>;
+    /** The submission does not exist or is inaccessible. */
+    notFound?: StepTarget<QueryResult<OperationOutput>>;
+    /** Jotform conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** Jotform returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Local input or connection credentials are invalid. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the getSubmission Step from a named connection. */
+declare function newGetSubmissionStep<StepInput, OperationInput = GetSubmissionInput, OperationOutput = SubmissionMetadata>(configuration: GetSubmissionStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+
+/** Open one named Jotform connection from Dex project configuration. */
+declare function newProjectConnection(project: LoadedProject, connectionName: string): Connection<Operations>;
+
+/** Optional provider transport for local tests and examples. */
+interface JotformClientOptions {
+    /** One bounded provider request sender. */ send?: (request: ProviderRequest) => Promise<ProviderResponse>;
+}
+interface ProviderOutcome {
+    body?: Uint8Array;
+    branch?: string;
+    failure?: Failure;
+    retry?: boolean;
+    retryAfterMs?: number;
+}
+/** Authenticated Jotform client with call-time API key resolution. */
+declare class JotformClient {
+    private readonly credentials;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    private readonly sendRequest;
+    /** Validate configuration without contacting Jotform. */
+    constructor(config: Config, credentials: CredentialProvider<Credentials>, options?: JotformClientOptions);
+    /** Bind the form-list Query. */ listForms(): ListFormsOperation;
+    /** Bind the submission metadata Query. */ getSubmission(): GetSubmissionOperation;
+    /** Fetch one provider response and classify transport and HTTP failures. */
+    exchange(call: Call, operation: string, path: string, hasNotFound: boolean): Promise<ProviderOutcome>;
+}
+/** List form IDs, titles, and statuses without questions or answers. */
+declare class ListFormsOperation implements Query<ListFormsInput, FormsPage> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: JotformClient);
+    /** Return the manifest-generated contract. */ definition(): QueryDefinition;
+    /** Read one page or select a Go-compatible optional branch. */
+    invoke(call: Call, input: ListFormsInput): Promise<QueryAttempt<FormsPage>>;
+}
+/** Read one submission's ID, form ID, status, and timestamp without answers. */
+declare class GetSubmissionOperation implements Query<GetSubmissionInput, SubmissionMetadata> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: JotformClient);
+    /** Return the manifest-generated contract. */ definition(): QueryDefinition;
+    /** Read a submission or select a Go-compatible optional branch. */
+    invoke(call: Call, input: GetSubmissionInput): Promise<QueryAttempt<SubmissionMetadata>>;
+}
+
+export { Config, Connection, ConnectorID, Credentials, FormsPage, GetSubmissionBranch, GetSubmissionBranchDefect, GetSubmissionBranchFound, GetSubmissionBranchInvalidResponse, GetSubmissionBranchNotFound, GetSubmissionBranchProviderRejected, GetSubmissionDefinition, GetSubmissionInput, GetSubmissionMetadata, GetSubmissionOperation, type GetSubmissionStepConfig, JotformClient, type JotformClientOptions, ListFormsBranch, ListFormsBranchDefect, ListFormsBranchInvalidResponse, ListFormsBranchListed, ListFormsBranchProviderRejected, ListFormsDefinition, ListFormsInput, ListFormsMetadata, ListFormsOperation, type ListFormsStepConfig, ProviderID, SubmissionMetadata, newGetSubmissionStep, newListFormsStep, newProjectConnection };

package/dist/index.js

@@ -0,0 +1,287 @@
+import {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  FormMetadataSchema,
+  FormsPageSchema,
+  GetSubmissionBranch,
+  GetSubmissionBranchDefect,
+  GetSubmissionBranchFound,
+  GetSubmissionBranchInvalidResponse,
+  GetSubmissionBranchNotFound,
+  GetSubmissionBranchProviderRejected,
+  GetSubmissionDefinition,
+  GetSubmissionInputSchema,
+  GetSubmissionMetadata,
+  ListFormsBranch,
+  ListFormsBranchDefect,
+  ListFormsBranchInvalidResponse,
+  ListFormsBranchListed,
+  ListFormsBranchProviderRejected,
+  ListFormsDefinition,
+  ListFormsInputSchema,
+  ListFormsMetadata,
+  ProviderID,
+  SubmissionMetadataSchema,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+} from "./chunk-ZKAGZX4P.js";
+
+// src/generated/steps.ts
+import { goToBranch, newQueryStep } from "@superdurable/connectors-sdk";
+function newListFormsStep(configuration) {
+  const { connection, connectionName, listed, 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.listForms(), connection: connection.reference, branches: [
+    goToBranch("listed", listed),
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newGetSubmissionStep(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.getSubmission(), connection: connection.reference, branches: [
+    goToBranch("found", found),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+
+// src/project.ts
+import { SecretString as SecretString2 } from "@superdurable/connectors-sdk";
+import { z } from "zod";
+
+// src/client.ts
+import { SecretString, newQueryBranch, newQueryRetry } from "@superdurable/connectors-sdk";
+import { BodyTooLargeError, isHeaderSafeCredential, parseRetryAfter, sendProviderRequest, validateBaseURL } from "@superdurable/connectors-sdk/providerhttp";
+var emptyPage = () => ({ forms: [], offset: 0, limit: 0 });
+var emptySubmission = () => ({ id: "", formId: "", status: "", createdAt: "" });
+var numericID = /^[0-9]{1,24}$/;
+var JotformClient = class {
+  /** Validate configuration without contacting Jotform. */
+  constructor(config, credentials, options = {}) {
+    this.credentials = credentials;
+    if (!credentials) throw new TypeError("Jotform credential source is required");
+    this.baseUrl = validateBaseURL(config.baseUrl || "https://api.jotform.com");
+    this.timeoutMs = config.timeoutMs || 15e3;
+    this.maxResponseBytes = config.maxResponseBytes || 1048576;
+    if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0) throw new TypeError("Jotform timeout is invalid");
+    if (!Number.isSafeInteger(this.maxResponseBytes) || this.maxResponseBytes <= 0) throw new TypeError("Jotform response limit is invalid");
+    this.sendRequest = options.send ?? sendProviderRequest;
+  }
+  credentials;
+  baseUrl;
+  timeoutMs;
+  maxResponseBytes;
+  sendRequest;
+  /** Bind the form-list Query. */
+  listForms() {
+    return new ListFormsOperation(this);
+  }
+  /** Bind the submission metadata Query. */
+  getSubmission() {
+    return new GetSubmissionOperation(this);
+  }
+  /** Fetch one provider response and classify transport and HTTP failures. */
+  async exchange(call, operation, path, hasNotFound) {
+    let apiKey;
+    try {
+      const resolved = await this.credentials.resolve(call, call.context.cancellationSignal);
+      apiKey = resolved.apiKey instanceof SecretString ? resolved.apiKey.reveal() : "";
+    } catch {
+      return { branch: "defect", failure: failure(operation, "AUTHENTICATION", "connection credentials are unavailable or invalid") };
+    }
+    if (!apiKey || !isHeaderSafeCredential(apiKey)) return { branch: "defect", failure: failure(operation, "AUTHENTICATION", "connection credentials are unavailable or invalid") };
+    const request = {
+      url: `${this.baseUrl}${path}`,
+      method: "GET",
+      headers: { Accept: "application/json", APIKEY: apiKey },
+      maxResponseBytes: this.maxResponseBytes,
+      timeoutMs: this.timeoutMs,
+      addressPolicy: this.baseUrl.startsWith("https://") ? "publicHTTPS" : "privateNetworkHTTP",
+      signal: call.context.cancellationSignal
+    };
+    let response;
+    try {
+      response = await this.sendRequest(request);
+    } catch (error) {
+      if (error instanceof BodyTooLargeError && error.status !== void 0) {
+        response = { status: error.status, headers: error.headers ?? {}, body: new Uint8Array() };
+        if (response.status === 200) return { branch: "invalidResponse", failure: failure(operation, "RESPONSE_TOO_LARGE", "Jotform response exceeded the configured limit") };
+      } else return { retry: true, failure: failure(operation, "TRANSPORT", "Jotform request failed") };
+    }
+    const status = response.status;
+    const retryAfter = parseRetryAfter(headerValue(response.headers["retry-after"]));
+    if (status === 429) return { retry: true, retryAfterMs: retryAfter, failure: failure(operation, "RATE_LIMIT", "Jotform rate limited the request") };
+    if (status === 408 || status >= 500) return { retry: true, retryAfterMs: retryAfter, failure: failure(operation, "AVAILABILITY", "Jotform is temporarily unavailable") };
+    if (status === 404 && hasNotFound) return { branch: "notFound", failure: failure(operation, "NOT_FOUND", "Jotform did not find the submission") };
+    if (status !== 200) return { branch: "providerRejected", failure: failure(operation, "PROVIDER_REJECTION", `Jotform rejected HTTP ${status}`) };
+    if (response.body.length > this.maxResponseBytes) return { branch: "invalidResponse", failure: failure(operation, "RESPONSE_TOO_LARGE", "Jotform response exceeded the configured limit") };
+    return { body: response.body };
+  }
+};
+var ListFormsOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the manifest-generated contract. */
+  definition() {
+    return ListFormsDefinition;
+  }
+  /** Read one page or select a Go-compatible optional branch. */
+  async invoke(call, input) {
+    if (!input || !Number.isSafeInteger(input.offset) || input.offset < 0 || input.limit !== void 0 && (!Number.isSafeInteger(input.limit) || input.limit < 0 || input.limit > 100)) {
+      return terminal("listForms", "defect", "VALIDATION", "offset or limit is invalid", emptyPage());
+    }
+    const limit = input.limit || 20;
+    const path = `/user/forms?${new URLSearchParams({ offset: String(input.offset), limit: String(limit) })}`;
+    const result = await this.client.exchange(call, "listForms", path, false);
+    if (result.retry) return newQueryRetry(result.failure, result.retryAfterMs);
+    if (result.failure) return newQueryBranch(result.branch, emptyPage(), {}, result.failure);
+    const document = parseJSON(result.body);
+    if (!isObject(document)) return invalid("listForms", emptyPage());
+    const providerDecision = responseCodeDecision("listForms", document, emptyPage(), false);
+    if (providerDecision) return providerDecision;
+    if (!Array.isArray(document.content)) return invalid("listForms", emptyPage());
+    const forms = [];
+    for (const item of document.content) {
+      if (!isObject(item) || typeof item.id !== "string" || !numericID.test(item.id) || typeof item.title !== "string" || !item.title || item.status != null && typeof item.status !== "string") return invalid("listForms", emptyPage());
+      forms.push({ id: item.id, title: item.title, status: item.status ?? "" });
+    }
+    return newQueryBranch("listed", { forms, offset: input.offset, limit });
+  }
+};
+var GetSubmissionOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the manifest-generated contract. */
+  definition() {
+    return GetSubmissionDefinition;
+  }
+  /** Read a submission or select a Go-compatible optional branch. */
+  async invoke(call, input) {
+    if (!input || typeof input.submissionId !== "string" || !numericID.test(input.submissionId)) return terminal("getSubmission", "defect", "VALIDATION", "submission ID must be numeric", emptySubmission());
+    const result = await this.client.exchange(call, "getSubmission", `/submission/${input.submissionId}`, true);
+    if (result.retry) return newQueryRetry(result.failure, result.retryAfterMs);
+    if (result.failure) return newQueryBranch(result.branch, emptySubmission(), {}, result.failure);
+    const document = parseJSON(result.body);
+    if (!isObject(document)) return invalid("getSubmission", emptySubmission());
+    const providerDecision = responseCodeDecision("getSubmission", document, emptySubmission(), true);
+    if (providerDecision) return providerDecision;
+    const content = document.content;
+    if (!isObject(content) || typeof content.id !== "string" || !numericID.test(content.id) || typeof content.form_id !== "string" || !numericID.test(content.form_id) || typeof content.created_at !== "string" || !content.created_at || content.status != null && typeof content.status !== "string") return invalid("getSubmission", emptySubmission());
+    return newQueryBranch("found", { id: content.id, formId: content.form_id, status: content.status ?? "", createdAt: content.created_at });
+  }
+};
+function responseCodeDecision(operation, document, empty, hasNotFound) {
+  const code = document.responseCode;
+  if (code != null && (!Number.isInteger(code) || typeof code !== "number")) return invalid(operation, empty);
+  if (code === 200) return void 0;
+  if (code === 429 || typeof code === "number" && code >= 500) return newQueryRetry(failure(operation, "AVAILABILITY", "Jotform reported temporary unavailability"));
+  if (code === 404 && hasNotFound) return terminal(operation, "notFound", "NOT_FOUND", "Jotform did not find the submission", empty);
+  return terminal(operation, "providerRejected", "PROVIDER_REJECTION", "Jotform rejected the request", empty);
+}
+function failure(operation, kind, message) {
+  return { provider: "jotform", operation, kind, message };
+}
+function terminal(operation, branch, kind, message, empty) {
+  return newQueryBranch(branch, empty, {}, failure(operation, kind, message));
+}
+function invalid(operation, empty) {
+  return terminal(operation, "invalidResponse", "PROTOCOL", "Jotform returned invalid JSON", empty);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJSON(body) {
+  try {
+    return JSON.parse(Buffer.from(body).toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function headerValue(value) {
+  return Array.isArray(value) ? value[0] ?? "" : value ?? "";
+}
+
+// src/project.ts
+function newProjectConnection2(project, connectionName) {
+  return newProjectConnection(project, connectionName, (loadedProject, name) => {
+    const selected = loadedProject.configuration.connections.find((entry) => entry.connectorId === "jotform" && entry.connectionName === name);
+    if (!selected) throw new TypeError("Jotform project connection is not configured");
+    const fields = z.strictObject({ baseUrl: z.string().optional(), timeout: z.union([z.string(), z.number().int()]).optional(), maxResponseBytes: z.number().int().optional() }).parse(selected.configuration);
+    const timeoutMs = typeof fields.timeout === "number" ? Math.ceil(fields.timeout / 1e6) : fields.timeout ? parseDurationMilliseconds(fields.timeout) : void 0;
+    const config = {
+      ...fields.baseUrl ? { baseUrl: fields.baseUrl } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {},
+      ...fields.maxResponseBytes !== void 0 ? { maxResponseBytes: fields.maxResponseBytes } : {}
+    };
+    const credentials = {
+      async resolve(_call, signal) {
+        const privateFields = await loadedProject.resolveCredential("jotform", name, signal);
+        if (typeof privateFields.api_key !== "string") throw new TypeError("Jotform API Key is unavailable");
+        return { apiKey: new SecretString2(privateFields.api_key) };
+      }
+    };
+    return new JotformClient(config, credentials);
+  });
+}
+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 part = /^(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/.exec(remaining);
+    if (!part) throw new TypeError("Jotform timeout must be a positive Go duration");
+    milliseconds += Number(part[1]) * (units[part[2] ?? ""] ?? NaN);
+    remaining = remaining.slice(part[0].length);
+  }
+  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) throw new TypeError("Jotform timeout must resolve to positive whole milliseconds");
+  return milliseconds;
+}
+export {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  FormMetadataSchema,
+  FormsPageSchema,
+  GetSubmissionBranch,
+  GetSubmissionBranchDefect,
+  GetSubmissionBranchFound,
+  GetSubmissionBranchInvalidResponse,
+  GetSubmissionBranchNotFound,
+  GetSubmissionBranchProviderRejected,
+  GetSubmissionDefinition,
+  GetSubmissionInputSchema,
+  GetSubmissionMetadata,
+  GetSubmissionOperation,
+  JotformClient,
+  ListFormsBranch,
+  ListFormsBranchDefect,
+  ListFormsBranchInvalidResponse,
+  ListFormsBranchListed,
+  ListFormsBranchProviderRejected,
+  ListFormsDefinition,
+  ListFormsInputSchema,
+  ListFormsMetadata,
+  ListFormsOperation,
+  ProviderID,
+  SubmissionMetadataSchema,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newGetSubmissionStep,
+  newListFormsStep,
+  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 { O as Operations, C as Connection, L as ListFormsInput, F as FormsPage, G as GetSubmissionInput, S as SubmissionMetadata, e as FormMetadata } from './connection-D-MiEsWp.js';
+import 'zod';
+
+/** Go zero value for ListFormsInput in scripted cases. */
+declare const emptyListFormsInput: ListFormsInput;
+/** Go zero value for FormMetadata in scripted cases. */
+declare const emptyFormMetadata: FormMetadata;
+/** Go zero value for FormsPage in scripted cases. */
+declare const emptyFormsPage: FormsPage;
+/** Go zero value for GetSubmissionInput in scripted cases. */
+declare const emptyGetSubmissionInput: GetSubmissionInput;
+/** Go zero value for SubmissionMetadata in scripted cases. */
+declare const emptySubmissionMetadata: SubmissionMetadata;
+/** Script the listed branch. */
+declare function listFormsListed(value: FormsPage, failure?: Failure): Case<FormsPage>;
+/** Script the providerRejected branch. */
+declare function listFormsProviderRejected(value: FormsPage, failure?: Failure): Case<FormsPage>;
+/** Script the invalidResponse branch. */
+declare function listFormsInvalidResponse(value: FormsPage, failure?: Failure): Case<FormsPage>;
+/** Script the defect branch. */
+declare function listFormsDefect(value: FormsPage, failure?: Failure): Case<FormsPage>;
+/** Script a safe retry of listForms. */
+declare function listFormsRetry(failure: Failure, retryAfterMs?: number): Case<FormsPage>;
+/** Manifest scenario listedDefault for listForms. */
+declare function listFormsListedDefault(): Case<FormsPage>;
+/** Default listForms scenario. */
+declare function listFormsDefault(): Case<FormsPage>;
+/** Script the found branch. */
+declare function getSubmissionFound(value: SubmissionMetadata, failure?: Failure): Case<SubmissionMetadata>;
+/** Script the notFound branch. */
+declare function getSubmissionNotFound(value: SubmissionMetadata, failure?: Failure): Case<SubmissionMetadata>;
+/** Script the providerRejected branch. */
+declare function getSubmissionProviderRejected(value: SubmissionMetadata, failure?: Failure): Case<SubmissionMetadata>;
+/** Script the invalidResponse branch. */
+declare function getSubmissionInvalidResponse(value: SubmissionMetadata, failure?: Failure): Case<SubmissionMetadata>;
+/** Script the defect branch. */
+declare function getSubmissionDefect(value: SubmissionMetadata, failure?: Failure): Case<SubmissionMetadata>;
+/** Script a safe retry of getSubmission. */
+declare function getSubmissionRetry(failure: Failure, retryAfterMs?: number): Case<SubmissionMetadata>;
+/** Manifest scenario foundDefault for getSubmission. */
+declare function getSubmissionFoundDefault(): Case<SubmissionMetadata>;
+/** Default getSubmission scenario. */
+declare function getSubmissionDefault(): Case<SubmissionMetadata>;
+/** Scripted operations and manifest defaults for this connector. */
+declare class GeneratedMock implements Operations {
+    #private;
+    constructor(connectionName: string);
+    connection(): Connection;
+    listForms(): MockQuery<ListFormsInput, FormsPage>;
+    getSubmission(): MockQuery<GetSubmissionInput, SubmissionMetadata>;
+    assertNoFailures(): void;
+}
+
+export { GeneratedMock, GeneratedMock as Mock, emptyFormMetadata, emptyFormsPage, emptyGetSubmissionInput, emptyListFormsInput, emptySubmissionMetadata, getSubmissionDefault, getSubmissionDefect, getSubmissionFound, getSubmissionFoundDefault, getSubmissionInvalidResponse, getSubmissionNotFound, getSubmissionProviderRejected, getSubmissionRetry, listFormsDefault, listFormsDefect, listFormsInvalidResponse, listFormsListed, listFormsListedDefault, listFormsProviderRejected, listFormsRetry };

package/dist/mock.js

@@ -0,0 +1,130 @@
+import {
+  FormMetadataSchema,
+  FormsPageSchema,
+  GetSubmissionDefinition,
+  GetSubmissionInputSchema,
+  ListFormsDefinition,
+  ListFormsInputSchema,
+  ProviderID,
+  SubmissionMetadataSchema,
+  newConnectionWithOperations
+} from "./chunk-ZKAGZX4P.js";
+
+// src/generated/mock.ts
+import { branchCase, retryCase, newQuery } from "@superdurable/connectors-sdk/connectormock";
+var emptyListFormsInput = ListFormsInputSchema.parse({
+  "offset": 0
+});
+var emptyFormMetadata = FormMetadataSchema.parse({
+  "id": "",
+  "title": "",
+  "status": ""
+});
+var emptyFormsPage = FormsPageSchema.parse({
+  "forms": [],
+  "offset": 0,
+  "limit": 0
+});
+var emptyGetSubmissionInput = GetSubmissionInputSchema.parse({
+  "submissionId": ""
+});
+var emptySubmissionMetadata = SubmissionMetadataSchema.parse({
+  "id": "",
+  "formId": "",
+  "status": "",
+  "createdAt": ""
+});
+function listFormsListed(value, failure) {
+  return branchCase("listed", value, failure);
+}
+function listFormsProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function listFormsInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function listFormsDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function listFormsRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function listFormsListedDefault() {
+  const value = FormsPageSchema.parse({ "forms": [{ "id": "241234567890123", "status": "ENABLED", "title": "Contact request" }], "limit": 20, "offset": 0 });
+  return branchCase("listed", value);
+}
+function listFormsDefault() {
+  return listFormsListedDefault();
+}
+function getSubmissionFound(value, failure) {
+  return branchCase("found", value, failure);
+}
+function getSubmissionNotFound(value, failure) {
+  return branchCase("notFound", value, failure);
+}
+function getSubmissionProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function getSubmissionInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function getSubmissionDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function getSubmissionRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function getSubmissionFoundDefault() {
+  const value = SubmissionMetadataSchema.parse({ "createdAt": "2026-11-07 10:00:00", "formId": "241234567890123", "id": "241234567890123456", "status": "ACTIVE" });
+  return branchCase("found", value);
+}
+function getSubmissionDefault() {
+  return getSubmissionFoundDefault();
+}
+var GeneratedMock = class {
+  #listForms;
+  #getSubmission;
+  #connection;
+  constructor(connectionName) {
+    this.#listForms = newQuery(ListFormsDefinition).default(listFormsDefault());
+    this.#getSubmission = newQuery(GetSubmissionDefinition).default(getSubmissionDefault());
+    this.#connection = newConnectionWithOperations(this, { provider: ProviderID, name: connectionName });
+  }
+  connection() {
+    return this.#connection;
+  }
+  listForms() {
+    return this.#listForms;
+  }
+  getSubmission() {
+    return this.#getSubmission;
+  }
+  assertNoFailures() {
+    this.#listForms.assertNoFailures();
+    this.#getSubmission.assertNoFailures();
+  }
+};
+export {
+  GeneratedMock,
+  GeneratedMock as Mock,
+  emptyFormMetadata,
+  emptyFormsPage,
+  emptyGetSubmissionInput,
+  emptyListFormsInput,
+  emptySubmissionMetadata,
+  getSubmissionDefault,
+  getSubmissionDefect,
+  getSubmissionFound,
+  getSubmissionFoundDefault,
+  getSubmissionInvalidResponse,
+  getSubmissionNotFound,
+  getSubmissionProviderRejected,
+  getSubmissionRetry,
+  listFormsDefault,
+  listFormsDefect,
+  listFormsInvalidResponse,
+  listFormsListed,
+  listFormsListedDefault,
+  listFormsProviderRejected,
+  listFormsRetry
+};

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@superdurable/connector-jotform",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Jotform connector for Dex TypeScript applications",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superdurable/dex-connectors-library.git",
+    "directory": "connectors/jotform/typescript"
+  },
+  "type": "module",
+  "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"
+    },
+    "./dex-connector.json": "./dex-connector.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "dex-connector.json"
+  ],
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsup src/index.ts src/mock.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test examples",
+    "test": "vitest run --exclude test/integration/**",
+    "test:integration": "vitest run test/integration/*.integration.test.ts",
+    "example:worker": "tsx examples/form-inspection/worker.ts",
+    "example:start": "tsx examples/form-inspection/start.ts",
+    "check": "npm run typecheck && npm run lint && npm test && npm run build"
+  },
+  "dependencies": {
+    "@superdurable/connectors-sdk": "0.1.1",
+    "@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"
+  }
+}