@superdurable/connector-productboard 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
+# Productboard 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 the `listFeatures` Query for Dex TypeScript Flows. It reads one Productboard REST API v2 feature page and returns only feature IDs, names, and an opaque next-page cursor. The Go-recorded conformance scenarios verify exact requests, branches, retries, and outputs.
+
+Create a Personal Access Token in [Productboard Workspace Settings > Integrations > Public APIs > Access Token](https://developer.productboard.com/reference/api-token) and enter it in Dex Web secret `api_token`. Leave `baseUrl` blank for the public API endpoint. See the [connector README](../README.md) and [runnable example](examples/feature-discovery/README.md). Real Productboard authorization remains unverified.

package/dex-connector.json

@@ -0,0 +1,60 @@
+{
+  "connectorId": "productboard",
+  "releaseTag": "connectors/productboard/go/v0.1.0",
+  "package": {
+    "ecosystem": "npm",
+    "name": "@superdurable/connector-productboard",
+    "version": "0.1.0"
+  },
+  "factories": [
+    {
+      "name": "newListFeaturesStep",
+      "kind": "query",
+      "operationId": "listFeatures",
+      "inputType": "ListFeaturesInput",
+      "description": "List one page of feature IDs and names, with an opaque next-page cursor.",
+      "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": "ListFeaturesInput selects a page by its opaque, non-secret cursor.",
+        "properties": {
+          "pageCursor": {
+            "description": "PageCursor is blank for the first page or a previous NextCursor value.",
+            "type": "string"
+          }
+        },
+        "required": [
+          "pageCursor"
+        ],
+        "type": "object"
+      }
+    }
+  ]
+}

package/dist/chunk-GDHSBL3L.js

@@ -0,0 +1,106 @@
+// 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_token"]);
+  if (Object.keys(fields).some((key) => !allowed.has(key))) throw new TypeError("stored credential does not match the connector credential fields");
+  if (fields["api_token"] != null && !(typeof fields["api_token"] === "string")) throw new TypeError("credential api_token has an invalid type");
+  const credentials = {};
+  if (!fields["api_token"]) throw new TypeError("credential api_token is required");
+  credentials.apiToken = new SecretString(fields["api_token"] ?? "");
+  return credentials;
+}
+var ListFeaturesInputSchema = z.strictObject({
+  "pageCursor": z.string()
+});
+var FeatureMetadataSchema = z.strictObject({
+  "id": z.string(),
+  "name": z.string()
+});
+var FeaturesPageSchema = z.strictObject({
+  "features": z.array(FeatureMetadataSchema).nullable(),
+  "nextCursor": z.string()
+});
+
+// src/generated/definitions.ts
+var ConnectorID = "productboard";
+var ProviderID = "productboard";
+var ListFeaturesBranch = {
+  Listed: "listed",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var ListFeaturesBranchListed = ListFeaturesBranch.Listed;
+var ListFeaturesBranchProviderRejected = ListFeaturesBranch.ProviderRejected;
+var ListFeaturesBranchInvalidResponse = ListFeaturesBranch.InvalidResponse;
+var ListFeaturesBranchDefect = ListFeaturesBranch.Defect;
+var ListFeaturesDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "listFeatures" },
+  branches: [
+    { id: "listed", description: "Productboard returned one feature page." },
+    { id: "providerRejected", description: "Productboard conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "Productboard 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 ListFeaturesMetadata = { 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,
+  ListFeaturesInputSchema,
+  FeatureMetadataSchema,
+  FeaturesPageSchema,
+  ConnectorID,
+  ProviderID,
+  ListFeaturesBranch,
+  ListFeaturesBranchListed,
+  ListFeaturesBranchProviderRejected,
+  ListFeaturesBranchInvalidResponse,
+  ListFeaturesBranchDefect,
+  ListFeaturesDefinition,
+  ListFeaturesMetadata,
+  Connection,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+};

package/dist/connection-CxSuhl7t.d.ts

@@ -0,0 +1,84 @@
+import { CredentialProvider, SecretString, Query, ConnectionRef } from '@superdurable/connectors-sdk';
+import { z } from 'zod';
+
+/** Connector configuration; omitted fields use manifest defaults. */
+interface Config {
+    /** Productboard REST API v2 root as an absolute HTTPS URL. Blank uses the displayed public endpoint; override only for a trusted local test gateway. */
+    baseUrl?: string;
+    /** Maximum duration of one API request as a positive Go duration such as 15s. Blank uses the displayed default; increase for slow pages. Runtime value in milliseconds. */
+    timeoutMs?: number;
+    /** Maximum complete page response in bytes as a positive integer. Blank uses the displayed default; increase for known larger feature pages. */
+    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 Personal Access Token from Productboard Workspace Settings > Integrations > Public APIs > Access Token. Create a token, copy its opaque value into this secret field; blank prevents calls. Dex sends it only as a Bearer token. */
+    apiToken: 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>;
+/** ListFeaturesInput selects a page by its opaque, non-secret cursor. */
+interface ListFeaturesInput {
+    /** PageCursor is blank for the first page or a previous NextCursor value. */
+    "pageCursor": string;
+}
+/** FeatureMetadata contains only the feature ID and name. */
+interface FeatureMetadata {
+    /** ID is the Productboard entity ID. */
+    "id": string;
+    /** Name is the feature name. */
+    "name": string;
+}
+/** FeaturesPage contains one page and the next opaque cursor, if any. */
+interface FeaturesPage {
+    /** Features excludes descriptions and other provider fields. */
+    "features": Array<FeatureMetadata> | null;
+    /** NextCursor is blank at the last page. */
+    "nextCursor": string;
+}
+/** Runtime validator for ListFeaturesInput. */
+declare const ListFeaturesInputSchema: z.ZodObject<{
+    pageCursor: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for FeatureMetadata. */
+declare const FeatureMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for FeaturesPage. */
+declare const FeaturesPageSchema: z.ZodObject<{
+    features: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    nextCursor: z.ZodString;
+}, z.core.$strict>;
+
+/** Typed operations supplied by a client or mock. */
+interface Operations {
+    /** Invoke listFeatures through this connection. */
+    listFeatures(): Query<ListFeaturesInput, FeaturesPage>;
+}
+/** 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 FeaturesPage as F, type ListFeaturesInput as L, type Operations as O, type Config as a, type Credentials as b, ConfigSchema as c, type CredentialSource as d, type FeatureMetadata as e, FeatureMetadataSchema as f, FeaturesPageSchema as g, ListFeaturesInputSchema as h, decodeCredentials as i, newConnectionWithOperations as j, newConnection as n };

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+import { L as ListFeaturesInput, F as FeaturesPage, C as Connection, O as Operations, a as Config, b as Credentials } from './connection-CxSuhl7t.js';
+export { c as ConfigSchema, d as CredentialSource, e as FeatureMetadata, f as FeatureMetadataSchema, g as FeaturesPageSchema, h as ListFeaturesInputSchema, i as decodeCredentials, n as newConnection, j as newConnectionWithOperations } from './connection-CxSuhl7t.js';
+import { QueryDefinition, QueryStepConfig, Query, QueryResult, QueryStep, CredentialProvider, Call, QueryAttempt } 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 = "productboard";
+/** Provider identity for named connections. */
+declare const ProviderID = "productboard";
+/** Branch IDs for listFeatures. */
+declare const ListFeaturesBranch: {
+    readonly Listed: "listed";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** Productboard returned one feature page. */
+declare const ListFeaturesBranchListed: "listed";
+/** Productboard conclusively rejected the request. */
+declare const ListFeaturesBranchProviderRejected: "providerRejected";
+/** Productboard returned malformed or oversized JSON. */
+declare const ListFeaturesBranchInvalidResponse: "invalidResponse";
+/** Local input or connection credentials are invalid. */
+declare const ListFeaturesBranchDefect: "defect";
+/** Manifest definition for listFeatures. */
+declare const ListFeaturesDefinition: QueryDefinition;
+/** Manifest metadata for listFeatures. */
+declare const ListFeaturesMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+
+/** Configuration for the listFeatures connector Step. */
+interface ListFeaturesStepConfig<StepInput, OperationInput = ListFeaturesInput, OperationOutput = FeaturesPage> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        listFeatures(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** Productboard returned one feature page. */
+    listed: StepTarget<QueryResult<OperationOutput>>;
+    /** Productboard conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** Productboard returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Local input or connection credentials are invalid. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the listFeatures Step from a named connection. */
+declare function newListFeaturesStep<StepInput, OperationInput = ListFeaturesInput, OperationOutput = FeaturesPage>(configuration: ListFeaturesStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+
+/** Open one named Productboard connection from Dex project configuration. */
+declare function newProjectConnection(project: LoadedProject, connectionName: string): Connection<Operations>;
+
+/** Injectable provider sender for tests and local applications. */
+interface ProductboardClientOptions {
+    /** Provider sender; omitted uses the SDK transport. */ send?: (request: ProviderRequest) => Promise<ProviderResponse>;
+}
+interface Exchange {
+    status: number;
+    body: Uint8Array;
+    retryAfterMs: number;
+    error?: 'credential' | 'request' | 'tooLarge';
+}
+/** Authenticated Productboard REST API v2 client for feature pages. */
+declare class ProductboardClient {
+    private readonly credentials;
+    /** Validated provider base URL for requests and next-page links. */ readonly baseURL: string;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    private readonly send;
+    /** Validate provider configuration without contacting Productboard. */
+    constructor(config: Config, credentials: CredentialProvider<Credentials>, options?: ProductboardClientOptions);
+    /** Bind the listFeatures Query. */ listFeatures(): ListFeaturesOperation;
+    /** Resolve the token and send one bounded feature-page request. */
+    get(call: Call, pageCursor: string): Promise<Exchange>;
+}
+/** Read one feature page with IDs, names, and the next opaque cursor. */
+declare class ListFeaturesOperation implements Query<ListFeaturesInput, FeaturesPage> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: ProductboardClient);
+    /** Return the generated Query contract. */ definition(): QueryDefinition;
+    /** Classify provider outcomes consistently with the Go implementation. */
+    invoke(call: Call, input: ListFeaturesInput): Promise<QueryAttempt<FeaturesPage>>;
+}
+
+export { Config, Connection, ConnectorID, Credentials, FeaturesPage, ListFeaturesBranch, ListFeaturesBranchDefect, ListFeaturesBranchInvalidResponse, ListFeaturesBranchListed, ListFeaturesBranchProviderRejected, ListFeaturesDefinition, ListFeaturesInput, ListFeaturesMetadata, ListFeaturesOperation, type ListFeaturesStepConfig, ProductboardClient, type ProductboardClientOptions, ProviderID, newListFeaturesStep, newProjectConnection };

package/dist/index.js

@@ -0,0 +1,250 @@
+import {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  FeatureMetadataSchema,
+  FeaturesPageSchema,
+  ListFeaturesBranch,
+  ListFeaturesBranchDefect,
+  ListFeaturesBranchInvalidResponse,
+  ListFeaturesBranchListed,
+  ListFeaturesBranchProviderRejected,
+  ListFeaturesDefinition,
+  ListFeaturesInputSchema,
+  ListFeaturesMetadata,
+  ProviderID,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+} from "./chunk-GDHSBL3L.js";
+
+// src/generated/steps.ts
+import { goToBranch, newQueryStep } from "@superdurable/connectors-sdk";
+function newListFeaturesStep(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.listFeatures(), connection: connection.reference, branches: [
+    goToBranch("listed", listed),
+    ...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 defaultBaseURL = "https://api.productboard.com/v2";
+var emptyPage = () => ({ features: [], nextCursor: "" });
+var ProductboardClient = class {
+  /** Validate provider configuration without contacting Productboard. */
+  constructor(config, credentials, options = {}) {
+    this.credentials = credentials;
+    if (!config || !credentials) throw new TypeError("Productboard configuration and credentials are required");
+    this.baseURL = validateBaseURL(config.baseUrl || defaultBaseURL);
+    this.timeoutMs = config.timeoutMs || 15e3;
+    this.maxResponseBytes = config.maxResponseBytes || 1048576;
+    if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0 || !Number.isSafeInteger(this.maxResponseBytes) || this.maxResponseBytes <= 0)
+      throw new TypeError("Productboard request limits must be positive integers");
+    this.send = options.send ?? sendProviderRequest;
+  }
+  credentials;
+  /** Validated provider base URL for requests and next-page links. */
+  baseURL;
+  timeoutMs;
+  maxResponseBytes;
+  send;
+  /** Bind the listFeatures Query. */
+  listFeatures() {
+    return new ListFeaturesOperation(this);
+  }
+  /** Resolve the token and send one bounded feature-page request. */
+  async get(call, pageCursor) {
+    let token;
+    try {
+      const credentials = await this.credentials.resolve(call, call.context.cancellationSignal);
+      token = credentials.apiToken instanceof SecretString ? credentials.apiToken.reveal() : "";
+    } catch {
+      return emptyExchange("credential");
+    }
+    if (!token || !isHeaderSafeCredential(token)) return emptyExchange("credential");
+    const url = new URL(`${this.baseURL}/entities`);
+    url.searchParams.set("fields[]", "name");
+    url.searchParams.set("type[]", "feature");
+    if (pageCursor) url.searchParams.set("pageCursor", pageCursor);
+    const request = {
+      url: url.toString(),
+      method: "GET",
+      headers: { Accept: "application/json", Authorization: `Bearer ${token}` },
+      maxResponseBytes: this.maxResponseBytes,
+      timeoutMs: this.timeoutMs,
+      addressPolicy: this.baseURL.startsWith("https://") ? "publicHTTPS" : "privateNetworkHTTP",
+      signal: call.context.cancellationSignal
+    };
+    let response;
+    let isTooLarge = false;
+    try {
+      response = await this.send(request);
+    } catch (error) {
+      if (error instanceof BodyTooLargeError && error.status !== void 0) {
+        response = { status: error.status, headers: error.headers ?? {}, body: new Uint8Array() };
+        isTooLarge = true;
+      } else return emptyExchange("request");
+    }
+    const retryAfterMs = parseRetryAfter(header(response.headers, "retry-after"));
+    if (isTooLarge || response.body.length > this.maxResponseBytes)
+      return { status: response.status, body: new Uint8Array(), retryAfterMs, error: "tooLarge" };
+    return { status: response.status, body: response.body, retryAfterMs };
+  }
+};
+var ListFeaturesOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the generated Query contract. */
+  definition() {
+    return ListFeaturesDefinition;
+  }
+  /** Classify provider outcomes consistently with the Go implementation. */
+  async invoke(call, input) {
+    if (!isValidCursor(input?.pageCursor))
+      return terminal("defect", "VALIDATION", "page cursor contains invalid characters or exceeds 2048 bytes");
+    const exchange = await this.client.get(call, input.pageCursor);
+    if (exchange.error === "credential") return terminal("defect", "AUTHENTICATION", "Productboard credentials are unavailable or invalid");
+    if (exchange.error === "request") return retry("TRANSPORT", "Productboard request failed");
+    if (exchange.status === 429) return retry("RATE_LIMIT", "Productboard rate limited the request", exchange.retryAfterMs);
+    if (exchange.status === 408 || exchange.status >= 500) return retry("AVAILABILITY", "Productboard is temporarily unavailable", exchange.retryAfterMs);
+    if (exchange.status !== 200) return terminal("providerRejected", "PROVIDER_REJECTION", `Productboard rejected HTTP ${exchange.status}`);
+    if (exchange.error === "tooLarge") return terminal("invalidResponse", "RESPONSE_TOO_LARGE", "Productboard response exceeded the configured limit");
+    const page = decodePage(exchange.body, this.client.baseURL);
+    if (!page) return terminal("invalidResponse", "PROTOCOL", "Productboard returned invalid feature JSON");
+    return newQueryBranch("listed", page);
+  }
+};
+function isValidCursor(value) {
+  if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > 2048) return false;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 32 || codePoint >= 127 && codePoint <= 159) return false;
+  }
+  return true;
+}
+function emptyExchange(error) {
+  return { status: 0, body: new Uint8Array(), retryAfterMs: 0, error };
+}
+function failure(kind, message) {
+  return { provider: "productboard", operation: "listFeatures", kind, message };
+}
+function terminal(branch, kind, message) {
+  return newQueryBranch(branch, emptyPage(), {}, failure(kind, message));
+}
+function retry(kind, message, delay = 0) {
+  return newQueryRetry(failure(kind, message), delay);
+}
+function header(headers, name) {
+  const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+  return Array.isArray(entry) ? entry[0] ?? "" : entry ?? "";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNextPageURL(nextURL, baseURL) {
+  if (nextURL.protocol === "https:" && nextURL.host === "api.productboard.com" && nextURL.pathname === "/v2/entities") return true;
+  return `${nextURL.protocol}//${nextURL.host}${nextURL.pathname}` === `${baseURL.replace(/\/+$/, "")}/entities`;
+}
+function decodePage(body, baseURL) {
+  let raw;
+  try {
+    raw = JSON.parse(Buffer.from(body).toString("utf8"));
+  } catch {
+    return void 0;
+  }
+  if (!isObject(raw) || !Array.isArray(raw.data)) return void 0;
+  const features = [];
+  for (const entity of raw.data) {
+    if (!isObject(entity) || typeof entity.id !== "string" || !entity.id || entity.type !== "feature" || !isObject(entity.fields) || typeof entity.fields.name !== "string" || !entity.fields.name.trim()) return void 0;
+    features.push({ id: entity.id, name: entity.fields.name });
+  }
+  const links = raw.links === void 0 ? {} : raw.links;
+  if (!isObject(links) || links.next !== void 0 && typeof links.next !== "string") return void 0;
+  let nextCursor = "";
+  if (links.next) {
+    let nextURL;
+    try {
+      nextURL = new URL(links.next);
+    } catch {
+      return void 0;
+    }
+    if (!isNextPageURL(nextURL, baseURL)) return void 0;
+    const cursors = nextURL.searchParams.getAll("pageCursor");
+    if (cursors.length !== 1 || !cursors[0] || !isValidCursor(cursors[0])) return void 0;
+    nextCursor = cursors[0];
+  }
+  return { features, nextCursor };
+}
+
+// src/project.ts
+function newProjectConnection2(project, connectionName) {
+  return newProjectConnection(project, connectionName, (loadedProject, name) => {
+    const selected = loadedProject.configuration.connections.find((entry) => entry.connectorId === "productboard" && entry.connectionName === name);
+    if (!selected) throw new TypeError("Productboard 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("productboard", name, signal);
+        if (typeof privateFields.api_token !== "string") throw new TypeError("Productboard credentials are unavailable");
+        return { apiToken: new SecretString2(privateFields.api_token) };
+      }
+    };
+    return new ProductboardClient(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("Productboard 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("Productboard timeout must resolve to positive whole milliseconds");
+  return milliseconds;
+}
+export {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  FeatureMetadataSchema,
+  FeaturesPageSchema,
+  ListFeaturesBranch,
+  ListFeaturesBranchDefect,
+  ListFeaturesBranchInvalidResponse,
+  ListFeaturesBranchListed,
+  ListFeaturesBranchProviderRejected,
+  ListFeaturesDefinition,
+  ListFeaturesInputSchema,
+  ListFeaturesMetadata,
+  ListFeaturesOperation,
+  ProductboardClient,
+  ProviderID,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newListFeaturesStep,
+  newProjectConnection2 as newProjectConnection
+};

package/dist/mock.d.ts

@@ -0,0 +1,35 @@
+import { MockQuery, Case } from '@superdurable/connectors-sdk/connectormock';
+import { Failure } from '@superdurable/connectors-sdk';
+import { O as Operations, C as Connection, L as ListFeaturesInput, F as FeaturesPage, e as FeatureMetadata } from './connection-CxSuhl7t.js';
+import 'zod';
+
+/** Go zero value for ListFeaturesInput in scripted cases. */
+declare const emptyListFeaturesInput: ListFeaturesInput;
+/** Go zero value for FeatureMetadata in scripted cases. */
+declare const emptyFeatureMetadata: FeatureMetadata;
+/** Go zero value for FeaturesPage in scripted cases. */
+declare const emptyFeaturesPage: FeaturesPage;
+/** Script the listed branch. */
+declare function listFeaturesListed(value: FeaturesPage, failure?: Failure): Case<FeaturesPage>;
+/** Script the providerRejected branch. */
+declare function listFeaturesProviderRejected(value: FeaturesPage, failure?: Failure): Case<FeaturesPage>;
+/** Script the invalidResponse branch. */
+declare function listFeaturesInvalidResponse(value: FeaturesPage, failure?: Failure): Case<FeaturesPage>;
+/** Script the defect branch. */
+declare function listFeaturesDefect(value: FeaturesPage, failure?: Failure): Case<FeaturesPage>;
+/** Script a safe retry of listFeatures. */
+declare function listFeaturesRetry(failure: Failure, retryAfterMs?: number): Case<FeaturesPage>;
+/** Manifest scenario listedDefault for listFeatures. */
+declare function listFeaturesListedDefault(): Case<FeaturesPage>;
+/** Default listFeatures scenario. */
+declare function listFeaturesDefault(): Case<FeaturesPage>;
+/** Scripted operations and manifest defaults for this connector. */
+declare class GeneratedMock implements Operations {
+    #private;
+    constructor(connectionName: string);
+    connection(): Connection;
+    listFeatures(): MockQuery<ListFeaturesInput, FeaturesPage>;
+    assertNoFailures(): void;
+}
+
+export { GeneratedMock, GeneratedMock as Mock, emptyFeatureMetadata, emptyFeaturesPage, emptyListFeaturesInput, listFeaturesDefault, listFeaturesDefect, listFeaturesInvalidResponse, listFeaturesListed, listFeaturesListedDefault, listFeaturesProviderRejected, listFeaturesRetry };

package/dist/mock.js

@@ -0,0 +1,75 @@
+import {
+  FeatureMetadataSchema,
+  FeaturesPageSchema,
+  ListFeaturesDefinition,
+  ListFeaturesInputSchema,
+  ProviderID,
+  newConnectionWithOperations
+} from "./chunk-GDHSBL3L.js";
+
+// src/generated/mock.ts
+import { branchCase, retryCase, newQuery } from "@superdurable/connectors-sdk/connectormock";
+var emptyListFeaturesInput = ListFeaturesInputSchema.parse({
+  "pageCursor": ""
+});
+var emptyFeatureMetadata = FeatureMetadataSchema.parse({
+  "id": "",
+  "name": ""
+});
+var emptyFeaturesPage = FeaturesPageSchema.parse({
+  "features": [],
+  "nextCursor": ""
+});
+function listFeaturesListed(value, failure) {
+  return branchCase("listed", value, failure);
+}
+function listFeaturesProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function listFeaturesInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function listFeaturesDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function listFeaturesRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function listFeaturesListedDefault() {
+  const value = FeaturesPageSchema.parse({ "features": [{ "id": "123e4567-e89b-12d3-a456-426614174000", "name": "Example feature" }], "nextCursor": "" });
+  return branchCase("listed", value);
+}
+function listFeaturesDefault() {
+  return listFeaturesListedDefault();
+}
+var GeneratedMock = class {
+  #listFeatures;
+  #connection;
+  constructor(connectionName) {
+    this.#listFeatures = newQuery(ListFeaturesDefinition).default(listFeaturesDefault());
+    this.#connection = newConnectionWithOperations(this, { provider: ProviderID, name: connectionName });
+  }
+  connection() {
+    return this.#connection;
+  }
+  listFeatures() {
+    return this.#listFeatures;
+  }
+  assertNoFailures() {
+    this.#listFeatures.assertNoFailures();
+  }
+};
+export {
+  GeneratedMock,
+  GeneratedMock as Mock,
+  emptyFeatureMetadata,
+  emptyFeaturesPage,
+  emptyListFeaturesInput,
+  listFeaturesDefault,
+  listFeaturesDefect,
+  listFeaturesInvalidResponse,
+  listFeaturesListed,
+  listFeaturesListedDefault,
+  listFeaturesProviderRejected,
+  listFeaturesRetry
+};

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@superdurable/connector-productboard",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Productboard connector for Dex TypeScript applications",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superdurable/dex-connectors-library.git",
+    "directory": "connectors/productboard/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/feature-discovery/worker.ts",
+    "example:start": "tsx examples/feature-discovery/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"
+  }
+}