@superdurable/connector-posthog 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,6 @@
-# Temporary Holding Version
+# PostHog 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 `captureEvent` and `listInsights` for Dex TypeScript
+Flows. The project token sends events; a personal API key with `insight:read`
+lists saved insight identities. Both operations replay the Go provider
+conformance scenarios. Runnable Flows are under `examples/`.

package/dex-connector.json

@@ -0,0 +1,135 @@
+{
+  "connectorId": "posthog",
+  "releaseTag": "connectors/posthog/go/v0.1.0",
+  "package": {
+    "ecosystem": "npm",
+    "name": "@superdurable/connector-posthog",
+    "version": "0.1.0"
+  },
+  "factories": [
+    {
+      "name": "newCaptureEventStep",
+      "kind": "mutation",
+      "operationId": "captureEvent",
+      "inputType": "CaptureEventInput",
+      "description": "Submit one event with stable timestamp, distinct ID, and derived UUID; acknowledgment does not guarantee later ingestion.",
+      "fields": {
+        "stepType": "stepType",
+        "annotations": "annotations",
+        "connectionName": "connectionName",
+        "resultAttribute": "resultAttribute"
+      },
+      "branches": [
+        {
+          "id": "accepted",
+          "field": "accepted",
+          "optional": false
+        },
+        {
+          "id": "quotaLimited",
+          "field": "quotaLimited",
+          "optional": true
+        },
+        {
+          "id": "providerRejected",
+          "field": "providerRejected",
+          "optional": true
+        },
+        {
+          "id": "defect",
+          "field": "defect",
+          "optional": true
+        }
+      ],
+      "inputSchema": {
+        "additionalProperties": false,
+        "description": "CaptureEventInput is one event with stable identity and time across retries.",
+        "properties": {
+          "distinctId": {
+            "description": "DistinctID is the stable person or anonymous identity.",
+            "type": "string"
+          },
+          "event": {
+            "description": "Event is a nonempty custom event name.",
+            "type": "string"
+          },
+          "properties": {
+            "additionalProperties": {
+              "type": "string"
+            },
+            "description": "Properties contains non-secret string dimensions, excluding identity and person mutations.",
+            "type": "object"
+          },
+          "timestamp": {
+            "description": "Timestamp is the event time in RFC3339 format and must remain fixed across retries.",
+            "type": "string"
+          }
+        },
+        "required": [
+          "distinctId",
+          "event",
+          "timestamp"
+        ],
+        "type": "object"
+      }
+    },
+    {
+      "name": "newListInsightsStep",
+      "kind": "query",
+      "operationId": "listInsights",
+      "inputType": "ListInsightsInput",
+      "description": "List one bounded page of saved insight IDs and names without query results or private metadata.",
+      "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": "ListInsightsInput selects a project and bounded offset page of saved insights.",
+        "properties": {
+          "limit": {
+            "description": "Limit is the maximum count from 1 through 100; zero uses 20.",
+            "type": "integer"
+          },
+          "offset": {
+            "description": "Offset is the zero-based page offset.",
+            "type": "integer"
+          },
+          "projectId": {
+            "description": "ProjectID is the positive ID shown in the PostHog project URL or settings.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "offset",
+          "projectId"
+        ],
+        "type": "object"
+      }
+    }
+  ]
+}

package/dist/chunk-JWKU3SHH.js

@@ -0,0 +1,153 @@
+// src/generated/models.ts
+import { z } from "zod";
+import { SecretString } from "@superdurable/connectors-sdk";
+var ConfigSchema = z.object({
+  "captureUrl": z.string().optional(),
+  "appUrl": 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(["personal_api_key", "project_token"]);
+  if (Object.keys(fields).some((key) => !allowed.has(key))) throw new TypeError("stored credential does not match the connector credential fields");
+  if (fields["personal_api_key"] != null && !(typeof fields["personal_api_key"] === "string")) throw new TypeError("credential personal_api_key has an invalid type");
+  if (fields["project_token"] != null && !(typeof fields["project_token"] === "string")) throw new TypeError("credential project_token has an invalid type");
+  const credentials = {};
+  if (!fields["project_token"]) throw new TypeError("credential project_token is required");
+  credentials.projectToken = new SecretString(fields["project_token"] ?? "");
+  credentials.personalApiKey = new SecretString(fields["personal_api_key"] ?? "");
+  return credentials;
+}
+var CaptureEventInputSchema = z.strictObject({
+  "event": z.string(),
+  "distinctId": z.string(),
+  "timestamp": z.string(),
+  "properties": z.record(z.string(), z.string()).optional()
+});
+var CapturedEventSchema = z.strictObject({
+  "eventId": z.string(),
+  "accepted": z.boolean()
+});
+var ListInsightsInputSchema = z.strictObject({
+  "projectId": z.number().int(),
+  "offset": z.number().int(),
+  "limit": z.number().int().optional()
+});
+var InsightMetadataSchema = z.strictObject({
+  "id": z.number().int(),
+  "name": z.string()
+});
+var InsightsPageSchema = z.strictObject({
+  "insights": z.array(InsightMetadataSchema).nullable(),
+  "hasMore": z.boolean(),
+  "offset": z.number().int(),
+  "limit": z.number().int()
+});
+
+// src/generated/definitions.ts
+var ConnectorID = "posthog";
+var ProviderID = "posthog";
+var CaptureEventBranch = {
+  Accepted: "accepted",
+  QuotaLimited: "quotaLimited",
+  ProviderRejected: "providerRejected",
+  Defect: "defect"
+};
+var CaptureEventBranchAccepted = CaptureEventBranch.Accepted;
+var CaptureEventBranchQuotaLimited = CaptureEventBranch.QuotaLimited;
+var CaptureEventBranchProviderRejected = CaptureEventBranch.ProviderRejected;
+var CaptureEventBranchDefect = CaptureEventBranch.Defect;
+var CaptureEventDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "captureEvent" },
+  branches: [
+    { id: "accepted", description: "PostHog accepted the event for processing, without confirming ingestion." },
+    { id: "quotaLimited", description: "PostHog reported a billing quota limit and may not ingest the event.", optional: true },
+    { id: "providerRejected", description: "PostHog conclusively rejected the request.", optional: true },
+    { id: "defect", description: "Local event input or project token is invalid.", optional: true }
+  ],
+  stepDefaults: { executeMethodTimeoutMs: 3e4, executeDurability: "async" }
+};
+var CaptureEventMetadata = { kind: "mutation", idempotency: "required", authorization: "required" };
+var ListInsightsBranch = {
+  Listed: "listed",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var ListInsightsBranchListed = ListInsightsBranch.Listed;
+var ListInsightsBranchProviderRejected = ListInsightsBranch.ProviderRejected;
+var ListInsightsBranchInvalidResponse = ListInsightsBranch.InvalidResponse;
+var ListInsightsBranchDefect = ListInsightsBranch.Defect;
+var ListInsightsDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "listInsights" },
+  branches: [
+    { id: "listed", description: "PostHog returned the insight page, possibly empty." },
+    { id: "providerRejected", description: "PostHog denied the query or project access.", optional: true },
+    { id: "invalidResponse", description: "PostHog returned malformed or oversized page JSON.", optional: true },
+    { id: "defect", description: "Local project ID, page input, or personal API key is invalid.", optional: true }
+  ],
+  stepDefaults: { executeMethodTimeoutMs: 3e4, executeDurability: "async" }
+};
+var ListInsightsMetadata = { 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,
+  CaptureEventInputSchema,
+  CapturedEventSchema,
+  ListInsightsInputSchema,
+  InsightMetadataSchema,
+  InsightsPageSchema,
+  ConnectorID,
+  ProviderID,
+  CaptureEventBranch,
+  CaptureEventBranchAccepted,
+  CaptureEventBranchQuotaLimited,
+  CaptureEventBranchProviderRejected,
+  CaptureEventBranchDefect,
+  CaptureEventDefinition,
+  CaptureEventMetadata,
+  ListInsightsBranch,
+  ListInsightsBranchListed,
+  ListInsightsBranchProviderRejected,
+  ListInsightsBranchInvalidResponse,
+  ListInsightsBranchDefect,
+  ListInsightsDefinition,
+  ListInsightsMetadata,
+  Connection,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+};

package/dist/connection-BmXhoEU7.d.ts

@@ -0,0 +1,135 @@
+import { SecretString, CredentialProvider, Mutation, Query, ConnectionRef } from '@superdurable/connectors-sdk';
+import { z } from 'zod';
+
+/** Connector configuration; omitted fields use manifest defaults. */
+interface Config {
+    /** Public capture API base URL. Blank uses the displayed US default; use https://eu.i.posthog.com for an EU Cloud project or your self-hosted HTTPS origin. Find your region in PostHog Project Settings > Project variables. Do not append /i/v0/e. */
+    captureUrl?: string;
+    /** Private API base URL. Blank uses the displayed US default; use https://eu.posthog.com for EU Cloud or your self-hosted HTTPS origin. Find your region in PostHog Project Settings > Project variables. Do not append /api. */
+    appUrl?: string;
+    /** Maximum duration of one 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;
+    /** Maximum complete JSON response in bytes as a positive integer. Blank uses the displayed default; increase only for larger insight pages. Oversized responses select invalidResponse. */
+    maxResponseBytes?: number;
+}
+/** Runtime schema for manifest configuration. */
+declare const ConfigSchema: z.ZodObject<{
+    captureUrl: z.ZodOptional<z.ZodString>;
+    appUrl: 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 API key (phx_ prefix) from your PostHog instance > avatar > Account settings > Personal API Keys > Create personal API key. Select `insight:read` scope, copy the one-time value into Dex, and revoke it there when retired. Blank permits captureEvent but makes listInsights select defect. */
+    personalApiKey?: SecretString;
+    /** PostHog project token (phc_ prefix) from your PostHog project URL > Settings > Project > Project variables > Project API key. Copy the exact value into this Dex secret field; blank prevents capture. It is sent only in the capture request body. */
+    projectToken: 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>;
+/** CaptureEventInput is one event with stable identity and time across retries. */
+interface CaptureEventInput {
+    /** Event is a nonempty custom event name. */
+    "event": string;
+    /** DistinctID is the stable person or anonymous identity. */
+    "distinctId": string;
+    /** Timestamp is the event time in RFC3339 format and must remain fixed across retries. */
+    "timestamp": string;
+    /** Properties contains non-secret string dimensions, excluding identity and person mutations. */
+    "properties"?: {
+        [key: string]: string;
+    } | undefined;
+}
+/** CapturedEvent reports acceptance for processing, not confirmed ingestion. */
+interface CapturedEvent {
+    /** EventID is the stable UUID sent to PostHog for retry deduplication. */
+    "eventId": string;
+    /** Accepted is true only when PostHog acknowledged the event without a quota limit. */
+    "accepted": boolean;
+}
+/** ListInsightsInput selects a project and bounded offset page of saved insights. */
+interface ListInsightsInput {
+    /** ProjectID is the positive ID shown in the PostHog project URL or settings. */
+    "projectId": number;
+    /** Offset is the zero-based page offset. */
+    "offset": number;
+    /** Limit is the maximum count from 1 through 100; zero uses 20. */
+    "limit"?: number | undefined;
+}
+/** InsightMetadata contains only a saved insight's identity and display name. */
+interface InsightMetadata {
+    /** ID is the stable numeric insight ID. */
+    "id": number;
+    /** Name is the untrusted display name. */
+    "name": string;
+}
+/** InsightsPage is one bounded saved-insight page without analysis results. */
+interface InsightsPage {
+    /** Insights contains the selected metadata page. */
+    "insights": Array<InsightMetadata> | null;
+    /** HasMore indicates a provider next page. */
+    "hasMore": boolean;
+    /** Offset is the requested zero-based offset. */
+    "offset": number;
+    /** Limit is the requested maximum count. */
+    "limit": number;
+}
+/** Runtime validator for CaptureEventInput. */
+declare const CaptureEventInputSchema: z.ZodObject<{
+    event: z.ZodString;
+    distinctId: z.ZodString;
+    timestamp: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+/** Runtime validator for CapturedEvent. */
+declare const CapturedEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    accepted: z.ZodBoolean;
+}, z.core.$strict>;
+/** Runtime validator for ListInsightsInput. */
+declare const ListInsightsInputSchema: z.ZodObject<{
+    projectId: z.ZodNumber;
+    offset: z.ZodNumber;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** Runtime validator for InsightMetadata. */
+declare const InsightMetadataSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for InsightsPage. */
+declare const InsightsPageSchema: z.ZodObject<{
+    insights: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    hasMore: z.ZodBoolean;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+
+/** Typed operations supplied by a client or mock. */
+interface Operations {
+    /** Invoke captureEvent through this connection. */
+    captureEvent(): Mutation<CaptureEventInput, CapturedEvent>;
+    /** Invoke listInsights through this connection. */
+    listInsights(): Query<ListInsightsInput, InsightsPage>;
+}
+/** 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 { type CaptureEventInput as C, type InsightsPage as I, type ListInsightsInput as L, type Operations as O, type CapturedEvent as a, Connection as b, type Config as c, type Credentials as d, CaptureEventInputSchema as e, CapturedEventSchema as f, ConfigSchema as g, type CredentialSource as h, type InsightMetadata as i, InsightMetadataSchema as j, InsightsPageSchema as k, ListInsightsInputSchema as l, decodeCredentials as m, newConnection as n, newConnectionWithOperations as o };

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import { C as CaptureEventInput, a as CapturedEvent, b as Connection, L as ListInsightsInput, I as InsightsPage, c as Config, d as Credentials, O as Operations } from './connection-BmXhoEU7.js';
+export { e as CaptureEventInputSchema, f as CapturedEventSchema, g as ConfigSchema, h as CredentialSource, i as InsightMetadata, j as InsightMetadataSchema, k as InsightsPageSchema, l as ListInsightsInputSchema, m as decodeCredentials, n as newConnection, o as newConnectionWithOperations } from './connection-BmXhoEU7.js';
+import * as _superdurable_connectors_sdk from '@superdurable/connectors-sdk';
+import { MutationDefinition, QueryDefinition, MutationStepConfig, Mutation, MutationResult, QueryStepConfig, Query, QueryResult, MutationStep, QueryStep, CredentialProvider, Call, QueryAttempt, MutationAttempt } 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 = "posthog";
+/** Provider identity for named connections. */
+declare const ProviderID = "posthog";
+/** Branch IDs for captureEvent. */
+declare const CaptureEventBranch: {
+    readonly Accepted: "accepted";
+    readonly QuotaLimited: "quotaLimited";
+    readonly ProviderRejected: "providerRejected";
+    readonly Defect: "defect";
+};
+/** PostHog accepted the event for processing, without confirming ingestion. */
+declare const CaptureEventBranchAccepted: "accepted";
+/** PostHog reported a billing quota limit and may not ingest the event. */
+declare const CaptureEventBranchQuotaLimited: "quotaLimited";
+/** PostHog conclusively rejected the request. */
+declare const CaptureEventBranchProviderRejected: "providerRejected";
+/** Local event input or project token is invalid. */
+declare const CaptureEventBranchDefect: "defect";
+/** Manifest definition for captureEvent. */
+declare const CaptureEventDefinition: MutationDefinition;
+/** Manifest metadata for captureEvent. */
+declare const CaptureEventMetadata: {
+    readonly kind: "mutation";
+    readonly idempotency: "required";
+    readonly authorization: "required";
+};
+/** Branch IDs for listInsights. */
+declare const ListInsightsBranch: {
+    readonly Listed: "listed";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** PostHog returned the insight page, possibly empty. */
+declare const ListInsightsBranchListed: "listed";
+/** PostHog denied the query or project access. */
+declare const ListInsightsBranchProviderRejected: "providerRejected";
+/** PostHog returned malformed or oversized page JSON. */
+declare const ListInsightsBranchInvalidResponse: "invalidResponse";
+/** Local project ID, page input, or personal API key is invalid. */
+declare const ListInsightsBranchDefect: "defect";
+/** Manifest definition for listInsights. */
+declare const ListInsightsDefinition: QueryDefinition;
+/** Manifest metadata for listInsights. */
+declare const ListInsightsMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+
+/** Configuration for the captureEvent connector Step. */
+interface CaptureEventStepConfig<StepInput, OperationInput = CaptureEventInput, OperationOutput = CapturedEvent> extends Omit<MutationStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        captureEvent(): Mutation<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** PostHog accepted the event for processing, without confirming ingestion. */
+    accepted: StepTarget<MutationResult<OperationOutput>>;
+    /** PostHog reported a billing quota limit and may not ingest the event. */
+    quotaLimited?: StepTarget<MutationResult<OperationOutput>>;
+    /** PostHog conclusively rejected the request. */
+    providerRejected?: StepTarget<MutationResult<OperationOutput>>;
+    /** Local event input or project token is invalid. */
+    defect?: StepTarget<MutationResult<OperationOutput>>;
+}
+/** Build the captureEvent Step from a named connection. */
+declare function newCaptureEventStep<StepInput, OperationInput = CaptureEventInput, OperationOutput = CapturedEvent>(configuration: CaptureEventStepConfig<StepInput, OperationInput, OperationOutput>): MutationStep<StepInput, OperationInput, OperationOutput>;
+/** Configuration for the listInsights connector Step. */
+interface ListInsightsStepConfig<StepInput, OperationInput = ListInsightsInput, OperationOutput = InsightsPage> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        listInsights(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** PostHog returned the insight page, possibly empty. */
+    listed: StepTarget<QueryResult<OperationOutput>>;
+    /** PostHog denied the query or project access. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** PostHog returned malformed or oversized page JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Local project ID, page input, or personal API key is invalid. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the listInsights Step from a named connection. */
+declare function newListInsightsStep<StepInput, OperationInput = ListInsightsInput, OperationOutput = InsightsPage>(configuration: ListInsightsStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+
+/** Injectable provider transport and clock for deterministic replay. */
+interface PostHogClientOptions {
+    /** Provider sender; omitted uses the SDK's redirect-safe transport. */
+    send?: (request: ProviderRequest) => Promise<ProviderResponse>;
+    /** Clock for Retry-After dates. */
+    now?: () => Date;
+}
+type Exchange = {
+    response: ProviderResponse;
+    tooLarge: boolean;
+} | {
+    transportFailure: true;
+};
+/** PostHog public capture and private insight API client. */
+declare class PostHogClient {
+    /** Public event capture API base URL. */ readonly captureUrl: string;
+    /** Private insight API base URL. */ readonly appUrl: string;
+    /** Complete response bound in bytes. */ readonly maxResponseBytes: number;
+    private readonly timeoutMs;
+    private readonly credentials;
+    private readonly send;
+    private readonly now;
+    /** Validate configuration without contacting the provider. */
+    constructor(config: Config, credentials: CredentialProvider<Credentials>, options?: PostHogClientOptions);
+    /** Bind a deduplicated event Mutation. */
+    captureEvent(): CaptureEventOperation;
+    /** Bind a bounded saved insight Query. */
+    listInsights(): ListInsightsOperation;
+    /** Resolve a project token for an individual provider attempt. */
+    projectToken(call: Call): Promise<string | undefined>;
+    /** Resolve a scoped personal API key for an individual provider attempt. */
+    personalApiKey(call: Call): Promise<string | undefined>;
+    /** Send one bounded provider request, preserving response status on body overflow. */
+    exchange(call: Call, method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: Uint8Array): Promise<Exchange>;
+    /** Parse the provider's Retry-After header in milliseconds. */
+    retryAfter(response: ProviderResponse): number;
+}
+/** Send a stable PostHog capture event. */
+declare class CaptureEventOperation implements Mutation<CaptureEventInput, CapturedEvent> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: PostHogClient);
+    /** Return the generated Mutation contract. */ definition(): _superdurable_connectors_sdk.QueryDefinition;
+    /** Derive Go's UUID-shaped SHA-256 identity from the Dex call ID. */
+    idempotencyKey(callId: string): string;
+    /** Validate, submit, and classify one event with a stable timestamp. */
+    invoke(call: Call, input: CaptureEventInput): Promise<MutationAttempt<CapturedEvent>>;
+}
+/** List saved insight IDs and names for one PostHog project. */
+declare class ListInsightsOperation implements Query<ListInsightsInput, InsightsPage> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: PostHogClient);
+    /** Return the generated Query contract. */ definition(): _superdurable_connectors_sdk.QueryDefinition;
+    /** Validate, request, and classify one bounded insight page. */
+    invoke(call: Call, input: ListInsightsInput): Promise<QueryAttempt<InsightsPage>>;
+}
+
+/** Bind a static PostHog connection declared in a Dex project. */
+declare function newProjectConnection(project: LoadedProject, connectionName: string, options?: PostHogClientOptions): Connection<Operations>;
+
+export { CaptureEventBranch, CaptureEventBranchAccepted, CaptureEventBranchDefect, CaptureEventBranchProviderRejected, CaptureEventBranchQuotaLimited, CaptureEventDefinition, CaptureEventInput, CaptureEventMetadata, CaptureEventOperation, type CaptureEventStepConfig, CapturedEvent, Config, Connection, ConnectorID, Credentials, InsightsPage, ListInsightsBranch, ListInsightsBranchDefect, ListInsightsBranchInvalidResponse, ListInsightsBranchListed, ListInsightsBranchProviderRejected, ListInsightsDefinition, ListInsightsInput, ListInsightsMetadata, ListInsightsOperation, type ListInsightsStepConfig, PostHogClient, type PostHogClientOptions, ProviderID, newCaptureEventStep, newListInsightsStep, newProjectConnection };

package/dist/index.js

@@ -0,0 +1,380 @@
+import {
+  CaptureEventBranch,
+  CaptureEventBranchAccepted,
+  CaptureEventBranchDefect,
+  CaptureEventBranchProviderRejected,
+  CaptureEventBranchQuotaLimited,
+  CaptureEventDefinition,
+  CaptureEventInputSchema,
+  CaptureEventMetadata,
+  CapturedEventSchema,
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  InsightMetadataSchema,
+  InsightsPageSchema,
+  ListInsightsBranch,
+  ListInsightsBranchDefect,
+  ListInsightsBranchInvalidResponse,
+  ListInsightsBranchListed,
+  ListInsightsBranchProviderRejected,
+  ListInsightsDefinition,
+  ListInsightsInputSchema,
+  ListInsightsMetadata,
+  ProviderID,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+} from "./chunk-JWKU3SHH.js";
+
+// src/generated/steps.ts
+import { goToBranch, newMutationStep, newQueryStep } from "@superdurable/connectors-sdk";
+function newCaptureEventStep(configuration) {
+  const { connection, connectionName, accepted, quotaLimited, providerRejected, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newMutationStep({ ...stepConfiguration, operation: connection.operations.captureEvent(), connection: connection.reference, branches: [
+    goToBranch("accepted", accepted),
+    ...quotaLimited ? [goToBranch("quotaLimited", quotaLimited)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newListInsightsStep(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.listInsights(), connection: connection.reference, branches: [
+    goToBranch("listed", listed),
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+
+// src/project.ts
+import { z } from "zod";
+
+// src/client.ts
+import { createHash } from "crypto";
+import {
+  newMutationBranch,
+  newMutationRetry,
+  newQueryBranch,
+  newQueryRetry
+} from "@superdurable/connectors-sdk";
+import {
+  BodyTooLargeError,
+  isHeaderSafeCredential,
+  parseRetryAfter,
+  sendProviderRequest,
+  validateBaseURL
+} from "@superdurable/connectors-sdk/providerhttp";
+var emptyEvent = { eventId: "", accepted: false };
+var emptyPage = { insights: [], hasMore: false, offset: 0, limit: 0 };
+var PostHogClient = class {
+  /** Public event capture API base URL. */
+  captureUrl;
+  /** Private insight API base URL. */
+  appUrl;
+  /** Complete response bound in bytes. */
+  maxResponseBytes;
+  timeoutMs;
+  credentials;
+  send;
+  now;
+  /** Validate configuration without contacting the provider. */
+  constructor(config, credentials, options = {}) {
+    if (!config || !credentials) throw new TypeError("PostHog configuration and credential source are required");
+    this.captureUrl = validateBaseURL(config.captureUrl || "https://us.i.posthog.com");
+    this.appUrl = validateBaseURL(config.appUrl || "https://us.posthog.com");
+    this.timeoutMs = config.timeoutMs || 15e3;
+    this.maxResponseBytes = config.maxResponseBytes || 2097152;
+    if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0 || !Number.isSafeInteger(this.maxResponseBytes) || this.maxResponseBytes <= 0)
+      throw new TypeError("PostHog timeout and response limit must be positive integers");
+    this.credentials = credentials;
+    this.send = options.send ?? sendProviderRequest;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  /** Bind a deduplicated event Mutation. */
+  captureEvent() {
+    return new CaptureEventOperation(this);
+  }
+  /** Bind a bounded saved insight Query. */
+  listInsights() {
+    return new ListInsightsOperation(this);
+  }
+  /** Resolve a project token for an individual provider attempt. */
+  async projectToken(call) {
+    try {
+      const credentials = await this.credentials.resolve(call, call.context.cancellationSignal);
+      const token = credentials.projectToken.reveal();
+      return token && isHeaderSafeCredential(token) ? token : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Resolve a scoped personal API key for an individual provider attempt. */
+  async personalApiKey(call) {
+    try {
+      const credentials = await this.credentials.resolve(call, call.context.cancellationSignal);
+      const key = credentials.personalApiKey?.reveal();
+      return key && isHeaderSafeCredential(key) ? key : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Send one bounded provider request, preserving response status on body overflow. */
+  async exchange(call, method, url, headers, body) {
+    const request = {
+      url,
+      method,
+      headers,
+      maxResponseBytes: this.maxResponseBytes,
+      timeoutMs: this.timeoutMs,
+      addressPolicy: url.startsWith("https://") ? "publicHTTPS" : "privateNetworkHTTP",
+      signal: call.context.cancellationSignal,
+      ...body ? { body } : {}
+    };
+    try {
+      return { response: await this.send(request), tooLarge: false };
+    } catch (error) {
+      if (error instanceof BodyTooLargeError && error.status !== void 0)
+        return { response: { status: error.status, headers: error.headers ?? {}, body: new Uint8Array() }, tooLarge: true };
+      return { transportFailure: true };
+    }
+  }
+  /** Parse the provider's Retry-After header in milliseconds. */
+  retryAfter(response) {
+    const entry = Object.entries(response.headers).find(([key]) => key.toLowerCase() === "retry-after")?.[1];
+    return parseRetryAfter(Array.isArray(entry) ? entry[0] ?? "" : entry ?? "", this.now());
+  }
+};
+var CaptureEventOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the generated Mutation contract. */
+  definition() {
+    return CaptureEventDefinition;
+  }
+  /** Derive Go's UUID-shaped SHA-256 identity from the Dex call ID. */
+  idempotencyKey(callId) {
+    const hex = createHash("sha256").update(callId, "utf8").digest("hex").slice(0, 32);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  /** Validate, submit, and classify one event with a stable timestamp. */
+  async invoke(call, input) {
+    if (!validEvent(input) || call.idempotencyKey?.length !== 36)
+      return eventFailure("defect", "VALIDATION", "event, distinct ID, or stable call identity is invalid");
+    const timestamp = canonicalTimestamp(input.timestamp);
+    if (!timestamp) return eventFailure("defect", "VALIDATION", "timestamp must be an RFC3339 instant");
+    const token = await this.client.projectToken(call);
+    if (!token) return eventFailure("defect", "AUTHENTICATION", "PostHog project token is unavailable or invalid");
+    let body;
+    try {
+      body = Buffer.from(JSON.stringify({
+        token,
+        event: input.event,
+        distinct_id: input.distinctId,
+        timestamp,
+        uuid: call.idempotencyKey,
+        ...input.properties && Object.keys(input.properties).length ? { properties: input.properties } : {}
+      }));
+    } catch {
+      return eventFailure("defect", "VALIDATION", "event payload exceeds the limit");
+    }
+    if (body.byteLength > 1 << 20) return eventFailure("defect", "VALIDATION", "event payload exceeds the limit");
+    const exchange = await this.client.exchange(
+      call,
+      "POST",
+      `${this.client.captureUrl}/i/v0/e/`,
+      { Accept: "application/json", "Content-Type": "application/json" },
+      body
+    );
+    if ("transportFailure" in exchange) return eventRetry("TRANSPORT", "PostHog capture response is unavailable");
+    const { response, tooLarge } = exchange;
+    const retryAfter = this.client.retryAfter(response);
+    if (response.status === 429) return eventRetry("RATE_LIMIT", "PostHog rate limited capture", retryAfter);
+    if (response.status === 408 || response.status >= 500) return eventRetry("AVAILABILITY", "PostHog capture is temporarily unavailable", retryAfter);
+    if (response.status !== 200) return eventFailure("providerRejected", rejectionKind(response.status), `PostHog rejected capture with HTTP ${response.status}`);
+    if (tooLarge || response.body.byteLength > this.client.maxResponseBytes)
+      return eventRetry("RESPONSE_TOO_LARGE", "PostHog capture confirmation exceeded the limit");
+    let answer;
+    try {
+      answer = JSON.parse(Buffer.from(response.body).toString("utf8"));
+    } catch {
+      return eventRetry("PROTOCOL", "PostHog capture confirmation is unusable");
+    }
+    if (!isRecord(answer) || answer.status !== "Ok") return eventRetry("PROTOCOL", "PostHog capture confirmation is unusable");
+    if (answer.quota_limited !== void 0 && answer.quota_limited !== null && JSON.stringify(answer.quota_limited) !== "[]" && JSON.stringify(answer.quota_limited) !== "{}")
+      return eventFailure("quotaLimited", "PROVIDER_REJECTION", "PostHog reported an event quota limit");
+    return newMutationBranch("accepted", { eventId: call.idempotencyKey, accepted: true });
+  }
+};
+var ListInsightsOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the generated Query contract. */
+  definition() {
+    return ListInsightsDefinition;
+  }
+  /** Validate, request, and classify one bounded insight page. */
+  async invoke(call, input) {
+    if (!input || !Number.isSafeInteger(input.projectId) || input.projectId <= 0 || !Number.isSafeInteger(input.offset) || input.offset < 0 || !Number.isSafeInteger(input.limit ?? 0) || (input.limit ?? 0) < 0 || (input.limit ?? 0) > 100)
+      return pageFailure("defect", "VALIDATION", "project ID, offset, or limit is invalid");
+    const limit = input.limit || 20;
+    const key = await this.client.personalApiKey(call);
+    if (!key) return pageFailure("defect", "AUTHENTICATION", "PostHog personal API key is unavailable or invalid");
+    const url = `${this.client.appUrl}/api/projects/${input.projectId}/insights/?limit=${limit}&offset=${input.offset}`;
+    const exchange = await this.client.exchange(
+      call,
+      "GET",
+      url,
+      { Accept: "application/json", Authorization: `Bearer ${key}` }
+    );
+    if ("transportFailure" in exchange) return pageRetry("TRANSPORT", "PostHog insight response is unavailable");
+    const { response, tooLarge } = exchange;
+    const retryAfter = this.client.retryAfter(response);
+    if (response.status === 429) return pageRetry("RATE_LIMIT", "PostHog rate limited insight listing", retryAfter);
+    if (response.status === 408 || response.status >= 500)
+      return pageRetry("AVAILABILITY", "PostHog insight listing is temporarily unavailable", retryAfter);
+    if (response.status !== 200) return pageFailure(
+      "providerRejected",
+      rejectionKind(response.status),
+      `PostHog rejected insight listing with HTTP ${response.status}`
+    );
+    if (tooLarge || response.body.byteLength > this.client.maxResponseBytes)
+      return pageFailure("invalidResponse", "RESPONSE_TOO_LARGE", "PostHog insight page exceeded the limit");
+    let answer;
+    try {
+      answer = JSON.parse(Buffer.from(response.body).toString("utf8"));
+    } catch {
+      return pageFailure("invalidResponse", "PROTOCOL", "PostHog returned an invalid insight page");
+    }
+    const page = decodePage(answer, input.offset, limit);
+    if (!page) return pageFailure("invalidResponse", "PROTOCOL", "PostHog returned an invalid insight page");
+    return newQueryBranch("listed", page);
+  }
+};
+function validEvent(input) {
+  if (!input || typeof input.event !== "string" || !input.event.trim() || typeof input.distinctId !== "string" || !input.distinctId.trim() || Buffer.byteLength(input.event) > 256 || Buffer.byteLength(input.distinctId) > 512) return false;
+  return Object.entries(input.properties ?? {}).every(([name, value]) => !!name.trim() && !name.startsWith("$") && !["token", "api_key", "password", "secret"].includes(name.toLowerCase()) && Buffer.byteLength(name) <= 128 && typeof value === "string" && Buffer.byteLength(value) <= 4096);
+}
+function canonicalTimestamp(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(value)) return void 0;
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds) || milliseconds === 0) return void 0;
+  return new Date(milliseconds).toISOString().replace(/\.000Z$/, "Z");
+}
+function decodePage(value, offset, limit) {
+  if (!isRecord(value) || !Array.isArray(value.results) || value.results.length > limit || value.next !== void 0 && value.next !== null && typeof value.next !== "string") return void 0;
+  const insights = [];
+  for (const raw of value.results) {
+    if (!isRecord(raw) || !Number.isSafeInteger(raw.id) || raw.id <= 0 || raw.name !== void 0 && raw.name !== null && typeof raw.name !== "string") return void 0;
+    insights.push({ id: raw.id, name: typeof raw.name === "string" ? raw.name : "" });
+  }
+  return { insights, hasMore: !!value.next, offset, limit };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectionKind(status) {
+  return status === 401 ? "AUTHENTICATION" : status === 403 ? "AUTHORIZATION" : "PROVIDER_REJECTION";
+}
+function failure(operation, kind, message) {
+  return { kind, provider: "posthog", operation, message };
+}
+function eventFailure(branch, kind, message) {
+  return newMutationBranch(branch, emptyEvent, {}, failure("captureEvent", kind, message));
+}
+function eventRetry(kind, message, after = 0) {
+  return newMutationRetry(failure("captureEvent", kind, message), after);
+}
+function pageFailure(branch, kind, message) {
+  return newQueryBranch(branch, emptyPage, {}, failure("listInsights", kind, message));
+}
+function pageRetry(kind, message, after = 0) {
+  return newQueryRetry(failure("listInsights", kind, message), after);
+}
+
+// src/project.ts
+var settingsSchema = z.strictObject({
+  captureUrl: z.string().optional(),
+  appUrl: z.string().optional(),
+  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 === "posthog" && entry.connectionName === name);
+    if (!selected) throw new TypeError("PostHog project connection is not configured");
+    const settings = settingsSchema.parse(selected.configuration);
+    const timeoutMs = typeof settings.timeout === "number" ? Math.ceil(settings.timeout / 1e6) : settings.timeout !== void 0 ? parseDurationMilliseconds(settings.timeout) : void 0;
+    const config = {
+      ...settings.captureUrl !== void 0 ? { captureUrl: settings.captureUrl } : {},
+      ...settings.appUrl !== void 0 ? { appUrl: settings.appUrl } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {},
+      ...settings.maxResponseBytes !== void 0 ? { maxResponseBytes: settings.maxResponseBytes } : {}
+    };
+    const credentials = {
+      async resolve(call, signal) {
+        void call;
+        return decodeCredentials(await loadedProject.resolveCredential("posthog", name, signal));
+      }
+    };
+    return new PostHogClient(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("PostHog 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("PostHog timeout must resolve to positive whole milliseconds");
+  return milliseconds;
+}
+export {
+  CaptureEventBranch,
+  CaptureEventBranchAccepted,
+  CaptureEventBranchDefect,
+  CaptureEventBranchProviderRejected,
+  CaptureEventBranchQuotaLimited,
+  CaptureEventDefinition,
+  CaptureEventInputSchema,
+  CaptureEventMetadata,
+  CaptureEventOperation,
+  CapturedEventSchema,
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  InsightMetadataSchema,
+  InsightsPageSchema,
+  ListInsightsBranch,
+  ListInsightsBranchDefect,
+  ListInsightsBranchInvalidResponse,
+  ListInsightsBranchListed,
+  ListInsightsBranchProviderRejected,
+  ListInsightsDefinition,
+  ListInsightsInputSchema,
+  ListInsightsMetadata,
+  ListInsightsOperation,
+  PostHogClient,
+  ProviderID,
+  decodeCredentials,
+  newCaptureEventStep,
+  newConnection,
+  newConnectionWithOperations,
+  newListInsightsStep,
+  newProjectConnection2 as newProjectConnection
+};

package/dist/mock.d.ts

@@ -0,0 +1,54 @@
+import { MockMutation, MockQuery, Case } from '@superdurable/connectors-sdk/connectormock';
+import { Failure } from '@superdurable/connectors-sdk';
+import { O as Operations, b as Connection, C as CaptureEventInput, a as CapturedEvent, L as ListInsightsInput, I as InsightsPage, i as InsightMetadata } from './connection-BmXhoEU7.js';
+import 'zod';
+
+/** Go zero value for CaptureEventInput in scripted cases. */
+declare const emptyCaptureEventInput: CaptureEventInput;
+/** Go zero value for CapturedEvent in scripted cases. */
+declare const emptyCapturedEvent: CapturedEvent;
+/** Go zero value for ListInsightsInput in scripted cases. */
+declare const emptyListInsightsInput: ListInsightsInput;
+/** Go zero value for InsightMetadata in scripted cases. */
+declare const emptyInsightMetadata: InsightMetadata;
+/** Go zero value for InsightsPage in scripted cases. */
+declare const emptyInsightsPage: InsightsPage;
+/** Script the accepted branch. */
+declare function captureEventAccepted(value: CapturedEvent, failure?: Failure): Case<CapturedEvent>;
+/** Script the quotaLimited branch. */
+declare function captureEventQuotaLimited(value: CapturedEvent, failure?: Failure): Case<CapturedEvent>;
+/** Script the providerRejected branch. */
+declare function captureEventProviderRejected(value: CapturedEvent, failure?: Failure): Case<CapturedEvent>;
+/** Script the defect branch. */
+declare function captureEventDefect(value: CapturedEvent, failure?: Failure): Case<CapturedEvent>;
+/** Script a safe retry of captureEvent. */
+declare function captureEventRetry(failure: Failure, retryAfterMs?: number): Case<CapturedEvent>;
+/** Manifest scenario acceptedSignup for captureEvent. */
+declare function captureEventAcceptedSignup(): Case<CapturedEvent>;
+/** Default captureEvent scenario. */
+declare function captureEventDefault(): Case<CapturedEvent>;
+/** Script the listed branch. */
+declare function listInsightsListed(value: InsightsPage, failure?: Failure): Case<InsightsPage>;
+/** Script the providerRejected branch. */
+declare function listInsightsProviderRejected(value: InsightsPage, failure?: Failure): Case<InsightsPage>;
+/** Script the invalidResponse branch. */
+declare function listInsightsInvalidResponse(value: InsightsPage, failure?: Failure): Case<InsightsPage>;
+/** Script the defect branch. */
+declare function listInsightsDefect(value: InsightsPage, failure?: Failure): Case<InsightsPage>;
+/** Script a safe retry of listInsights. */
+declare function listInsightsRetry(failure: Failure, retryAfterMs?: number): Case<InsightsPage>;
+/** Manifest scenario listedSignupInsight for listInsights. */
+declare function listInsightsListedSignupInsight(): Case<InsightsPage>;
+/** Default listInsights scenario. */
+declare function listInsightsDefault(): Case<InsightsPage>;
+/** Scripted operations and manifest defaults for this connector. */
+declare class GeneratedMock implements Operations {
+    #private;
+    constructor(connectionName: string);
+    connection(): Connection;
+    captureEvent(): MockMutation<CaptureEventInput, CapturedEvent>;
+    listInsights(): MockQuery<ListInsightsInput, InsightsPage>;
+    assertNoFailures(): void;
+}
+
+export { GeneratedMock, GeneratedMock as Mock, captureEventAccepted, captureEventAcceptedSignup, captureEventDefault, captureEventDefect, captureEventProviderRejected, captureEventQuotaLimited, captureEventRetry, emptyCaptureEventInput, emptyCapturedEvent, emptyInsightMetadata, emptyInsightsPage, emptyListInsightsInput, listInsightsDefault, listInsightsDefect, listInsightsInvalidResponse, listInsightsListed, listInsightsListedSignupInsight, listInsightsProviderRejected, listInsightsRetry };

package/dist/mock.js

@@ -0,0 +1,127 @@
+import {
+  CaptureEventDefinition,
+  CaptureEventInputSchema,
+  CapturedEventSchema,
+  InsightMetadataSchema,
+  InsightsPageSchema,
+  ListInsightsDefinition,
+  ListInsightsInputSchema,
+  ProviderID,
+  newConnectionWithOperations
+} from "./chunk-JWKU3SHH.js";
+
+// src/generated/mock.ts
+import { branchCase, retryCase, newMutation, newQuery } from "@superdurable/connectors-sdk/connectormock";
+var emptyCaptureEventInput = CaptureEventInputSchema.parse({
+  "event": "",
+  "distinctId": "",
+  "timestamp": ""
+});
+var emptyCapturedEvent = CapturedEventSchema.parse({
+  "eventId": "",
+  "accepted": false
+});
+var emptyListInsightsInput = ListInsightsInputSchema.parse({
+  "projectId": 0,
+  "offset": 0
+});
+var emptyInsightMetadata = InsightMetadataSchema.parse({
+  "id": 0,
+  "name": ""
+});
+var emptyInsightsPage = InsightsPageSchema.parse({
+  "insights": [],
+  "hasMore": false,
+  "offset": 0,
+  "limit": 0
+});
+function captureEventAccepted(value, failure) {
+  return branchCase("accepted", value, failure);
+}
+function captureEventQuotaLimited(value, failure) {
+  return branchCase("quotaLimited", value, failure);
+}
+function captureEventProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function captureEventDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function captureEventRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function captureEventAcceptedSignup() {
+  const value = CapturedEventSchema.parse({ "accepted": true, "eventId": "4b5d3f33-2e21-4c1c-b392-2dae2a74a2ed" });
+  return branchCase("accepted", value);
+}
+function captureEventDefault() {
+  return captureEventAcceptedSignup();
+}
+function listInsightsListed(value, failure) {
+  return branchCase("listed", value, failure);
+}
+function listInsightsProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function listInsightsInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function listInsightsDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function listInsightsRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function listInsightsListedSignupInsight() {
+  const value = InsightsPageSchema.parse({ "hasMore": false, "insights": [{ "id": 42, "name": "Signups by day" }], "limit": 20, "offset": 0 });
+  return branchCase("listed", value);
+}
+function listInsightsDefault() {
+  return listInsightsListedSignupInsight();
+}
+var GeneratedMock = class {
+  #captureEvent;
+  #listInsights;
+  #connection;
+  constructor(connectionName) {
+    this.#captureEvent = newMutation(CaptureEventDefinition).default(captureEventDefault());
+    this.#listInsights = newQuery(ListInsightsDefinition).default(listInsightsDefault());
+    this.#connection = newConnectionWithOperations(this, { provider: ProviderID, name: connectionName });
+  }
+  connection() {
+    return this.#connection;
+  }
+  captureEvent() {
+    return this.#captureEvent;
+  }
+  listInsights() {
+    return this.#listInsights;
+  }
+  assertNoFailures() {
+    this.#captureEvent.assertNoFailures();
+    this.#listInsights.assertNoFailures();
+  }
+};
+export {
+  GeneratedMock,
+  GeneratedMock as Mock,
+  captureEventAccepted,
+  captureEventAcceptedSignup,
+  captureEventDefault,
+  captureEventDefect,
+  captureEventProviderRejected,
+  captureEventQuotaLimited,
+  captureEventRetry,
+  emptyCaptureEventInput,
+  emptyCapturedEvent,
+  emptyInsightMetadata,
+  emptyInsightsPage,
+  emptyListInsightsInput,
+  listInsightsDefault,
+  listInsightsDefect,
+  listInsightsInvalidResponse,
+  listInsightsListed,
+  listInsightsListedSignupInsight,
+  listInsightsProviderRejected,
+  listInsightsRetry
+};

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@superdurable/connector-posthog",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "PostHog event capture and saved insight listing for Dex TypeScript applications",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superdurable/dex-connectors-library.git",
+    "directory": "connectors/posthog/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"
+    },
+    "./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/provider-operations/worker.ts",
+    "check": "npm run typecheck && npm run lint && npm test && npm run build"
+  },
+  "dependencies": {
+    "@superdurable/connectors-sdk": "0.7.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"
+  }
+}