@owlmeans/viable-common 0.0.43 → 0.0.45

package/src/connect/conversion/types.ts

@@ -0,0 +1,96 @@
+import type {
+  ArchitectureCase, ConversionDecision, ConversionStage, ConversionStatus, ConvertibilityReason,
+  ConvertibilityVerdict, OriginKind, OriginShape, OriginState
+} from '../../convert/consts.js'
+import type { ConversionEstimate, StoryEstimateBand } from '../../convert/estimate/types.js'
+import type { ConversionStackRef } from '../../convert/record/types.js'
+import type { ConnectTarget, ConnectWaitReason } from '../consts.js'
+import type { InquiryPayload } from '../ops/types.js'
+
+/** Start a conversion of an existing project's code. */
+export interface ConnectConvertCreateBody {
+  name?: string
+  about?: string
+  /** Where the converted target's tree will live. */
+  target?: ConnectTarget
+  /**
+   * Where the code comes from.
+   *
+   * Absent for a LOCAL target the connector is already attached to: the tree is the directory the
+   * session opened on, and there is nothing to fetch.
+   */
+  origin?: { kind: OriginKind, repoUrl?: string, branch?: string }
+}
+
+/**
+ * Start the conversion of a project already filed.
+ *
+ * `confirm` says a PERSON agreed to what the start uses: without it, a start that would spend the
+ * organization's `conversions` unit is refused with `ConnectConfirmationRequired` and nothing runs.
+ * A delegated conversion spends nothing and is never asked.
+ */
+export interface ConnectConvertStartBody {
+  confirm?: boolean
+}
+
+/** Decide what happens at a stage boundary. */
+export interface ConnectConvertProceedBody {
+  decision: ConversionDecision
+  /** Free text the user added to the decision; recorded, never parsed. */
+  note?: string
+  /**
+   * A person agreed to what the stage costs. Without it, a stage that would spend credit limits or
+   * topped-up credits (its estimate past what is left of the conversion limit) is refused with
+   * `ConnectConfirmationRequired` — its estimate split packed — and nothing runs.
+   */
+  confirm?: boolean
+}
+
+/**
+ * Whether this origin can be converted, and what it will cost.
+ *
+ * Answered BEFORE anything is provisioned or charged, from the census alone — which is why it
+ * carries the counts it was decided from rather than a bare verdict.
+ */
+export interface ConvertCheck {
+  projectId: string
+  verdict: ConvertibilityVerdict
+  reasons: ConvertibilityReason[]
+  stack?: ConversionStackRef
+  architecture?: ArchitectureCase
+  shape: OriginShape
+  monorepo: boolean
+  /** Workspace members and directories nothing declares. Named, because each one is a decision. */
+  unlinked: string[]
+  files: number
+  bytes: number
+  /** Bulk data files found — sampled and described, never carried. */
+  bulk: number
+  estimate?: ConversionEstimate
+}
+
+/** Everything a caller needs to draw the conversion's current state in one call. */
+export interface ConversionStatusView {
+  projectId: string
+  stage: ConversionStage
+  status: ConversionStatus
+  /** The last decision the user made. */
+  decision?: ConversionDecision
+  verdict?: ConvertibilityVerdict
+  stack?: ConversionStackRef
+  /** What the conversion is rebuilding the project ONTO. Always the Viable stack today. */
+  targetStack?: ConversionStackRef
+  architecture?: ArchitectureCase
+  /** One per stage that has been estimated, newest last. */
+  estimates: ConversionEstimate[]
+  storyEstimate?: StoryEstimateBand
+  originState: OriginState
+  /** How many questions the conversion answered for itself. Each one is readable in the docs. */
+  assumptions: number
+  runId?: string
+  /** Set exactly when `status` is `Waiting`: the question the run stopped on. */
+  pendingInquiry?: InquiryPayload
+  waitingFor?: ConnectWaitReason
+  lastError?: string
+  updatedAt: string
+}

package/src/connect/entrypoints/types.ts

@@ -0,0 +1,25 @@
+
+
+/**
+ * What the platform injects when it mounts the connector routes.
+ *
+ * The names of the guard and the gates belong to the deployment, not to the contract: a connector
+ * API on another platform would guard the same paths with its own vocabulary. Everything else —
+ * paths, methods, schemas, parents — is fixed here so a client cannot address them differently.
+ */
+export interface ConnectEntrypointOptions {
+  /** The guard alias every connector route carries. */
+  guard: string
+  /** The gate alias and parameters that decide project ownership. */
+  gate?: { alias: string, params: string[] }
+  /**
+   * The gate that decides whether the caller may use the local-LLM mode.
+   *
+   * Applied to the one route that turns it on — opening a delegated session. Everything else is
+   * free: `cloud` is the default, and a project's own override is the platform's browser surface,
+   * not the connector's.
+   */
+  localLlm?: { alias: string, params: string[] }
+  /** Path prefix; defaults to `/connect`. */
+  path?: string
+}

package/src/connect/entrypoints.ts

@@ -3,46 +3,26 @@ import { route, RouteMethod } from '@owlmeans/route'
 import { connect } from './consts.js'
 import {
   ConnectAttachBodySchema, ConnectConfirmBodySchema, ConnectConvertCreateBodySchema,
-  ConnectConvertProceedBodySchema, ConnectCreateBodySchema, ConnectInquiryParamsSchema, ConnectKitApplyBodySchema,
+  ConnectConvertProceedBodySchema, ConnectConvertStartBodySchema, ConnectCreateBodySchema,
+  ConnectInquiryParamsSchema, ConnectKitApplyBodySchema,
   ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
   ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectBrandingSaveSchema,
   ConnectProjectIdSchema, ConnectSessionOpenSchema, ConnectSessionParamsSchema, ConnectPullQuerySchema,
   ConnectStoryParamsSchema, InquiryAnswerSchema,
 } from './schemas.js'
+import type { ConnectProjectBranding, ConnectProjectBrandingSave } from './branding/types.js'
 import type {
-  ConnectAttachBody, ConnectConfirmBody, ConnectConvertCreateBody, ConnectConvertProceedBody,
-  ConnectCreateBody, ConnectInquiryAnswerBody, ConnectKitApplyBody, ConnectKitApplyResult, ConnectKitDescribe,
-  ConnectModifyBody,
-  ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectBranding,
-  ConnectProjectBrandingSave, ConnectSessionOpen,
-  ConnectPipelineState, ConnectProjectStatus, ConnectPullQuery, ConnectSessionParams,
-  ConnectStoryStatus, ConversionStatusView, ConvertCheck,
-} from './types.js'
-import type { ConnectOpResult } from './ops.js'
-
-/**
- * What the platform injects when it mounts the connector routes.
- *
- * The names of the guard and the gates belong to the deployment, not to the contract: a connector
- * API on another platform would guard the same paths with its own vocabulary. Everything else —
- * paths, methods, schemas, parents — is fixed here so a client cannot address them differently.
- */
-export interface ConnectEntrypointOptions {
-  /** The guard alias every connector route carries. */
-  guard: string
-  /** The gate alias and parameters that decide project ownership. */
-  gate?: { alias: string, params: string[] }
-  /**
-   * The gate that decides whether the caller may use the local-LLM mode.
-   *
-   * Applied to the one route that turns it on — opening a delegated session. Everything else is
-   * free: `cloud` is the default, and a project's own override is the platform's browser surface,
-   * not the connector's.
-   */
-  localLlm?: { alias: string, params: string[] }
-  /** Path prefix; defaults to `/connect`. */
-  path?: string
-}
+  ConnectConvertCreateBody, ConnectConvertProceedBody, ConnectConvertStartBody, ConversionStatusView, ConvertCheck
+} from './conversion/types.js'
+import type { ConnectEntrypointOptions } from './entrypoints/types.js'
+import type { ConnectKitApplyBody, ConnectKitApplyResult, ConnectKitDescribe } from './kit/types.js'
+import type { ConnectInquiryAnswerBody, ConnectOpResult } from './ops/types.js'
+import type { ConnectPipelineParams, ConnectPipelineResumeBody, ConnectPipelineState } from './pipeline/types.js'
+import type {
+  ConnectAttachBody, ConnectConfirmBody, ConnectCreateBody, ConnectModifyBody, ConnectProjectStatus,
+  ConnectStoryStatus
+} from './project/types.js'
+import type { ConnectPullQuery, ConnectSessionOpen, ConnectSessionParams } from './session/types.js'
 
 /**
  * Declare the connector's HTTP surface — exactly the routes a connector calls: the session (long
@@ -216,7 +196,10 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
     ),
     start: protocol(
       route(connect.convert.start, '/convert/:id/start', { parent: base, method: RouteMethod.POST }),
-      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConversionStatusView>()),
+      contract.request({
+        params: typed<{ id: string }>(ConnectProjectIdSchema),
+        body: typed<ConnectConvertStartBody>(ConnectConvertStartBodySchema),
+      }, typed<ConversionStatusView>()),
     ),
     proceed: protocol(
       route(connect.convert.proceed, '/convert/:id/proceed', { parent: base, method: RouteMethod.POST }),

package/src/connect/errors/types.ts

@@ -0,0 +1,22 @@
+
+
+/** The conversion verb a {@link ConnectConfirmationRequired} stopped. */
+export type ConnectConfirmationAction = 'convert-start' | 'convert-proceed'
+
+/**
+ * What a person is asked to agree to before a conversion verb spends anything — credits, except
+ * `moneyUsd`. `cap` is the plan's conversion limit this conversion runs under (`0` when no plan unit
+ * covers it) and `spent` what the conversion has used of it so far; `estimate` is the stage's
+ * estimate (`0` while nothing has priced it), of which `fromAllowance` comes from the conversion
+ * limit, `fromCreditLimits` from the organization's open credit limits, and the rest from topped-up
+ * credits — `moneyUsd`, the only money figure.
+ */
+export interface ConnectConfirmation {
+  action: ConnectConfirmationAction
+  cap: number
+  spent: number
+  estimate: number
+  fromAllowance: number
+  fromCreditLimits: number
+  moneyUsd: number
+}

package/src/connect/errors.ts

@@ -1,4 +1,5 @@
 import { ResilientError } from '@owlmeans/error'
+import type { ConnectConfirmation, ConnectConfirmationAction } from './errors/types.js'
 
 export class ConnectError extends ResilientError {
   public static override typeName = `ViableConnect${ResilientError.typeName}`
@@ -191,6 +192,79 @@ export class ConnectConsentRequired extends ConnectError {
   }
 }
 
+/** A packed number read back: anything unreadable is `0`, never `NaN`. */
+const packedNumber = (value: string | undefined): number => {
+  const parsed = Number(value ?? 0)
+
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+/**
+ * A conversion verb would spend the plan's conversion or credits, and the caller has not said that a
+ * person agreed (`confirm: true`): a start that would use the organization's `conversions` unit, or a
+ * stage whose estimate reaches past what is left of the conversion limit into credit limits or
+ * topped-up credits. Nothing was started. The caller tells the person what it costs and repeats the
+ * call with `confirm: true` once they agree — unlike {@link ConnectConsentRequired}, this is agreed
+ * to in the conversation, not in the browser.
+ *
+ * Packed like the other two refusals a connector phrases for a person, because only `type` and
+ * `message` survive a marshal:
+ * `confirmation-required:<action>:<cap>:<spent>:<estimate>:<fromAllowance>:<fromCreditLimits>:<moneyUsd>`.
+ */
+export class ConnectConfirmationRequired extends ConnectError {
+  public static override typeName = `ConfirmationRequired${ConnectError.typeName}`
+  /** A precondition only a person can meet, not a fault: answered 428. */
+  public static httpStatus = 428
+
+  public action: ConnectConfirmationAction = 'convert-start'
+  public cap = 0
+  public spent = 0
+  public estimate = 0
+  public fromAllowance = 0
+  public fromCreditLimits = 0
+  public moneyUsd = 0
+
+  /** Build the packed message a caller passes to the constructor. */
+  static encode(fields: ConnectConfirmation): string {
+    return [
+      fields.action, fields.cap, fields.spent, fields.estimate, fields.fromAllowance, fields.fromCreditLimits,
+      fields.moneyUsd,
+    ].map(value => typeof value === 'number' && !Number.isFinite(value) ? 0 : value).join(':')
+  }
+
+  /** Read the packed fields back — what follows the marker, the inverse of {@link encode}. */
+  static decode(packed: string): ConnectConfirmation {
+    const [action, cap, spent, estimate, fromAllowance, fromCreditLimits, moneyUsd] = packed.split(':')
+
+    return {
+      action: (action ?? '') as ConnectConfirmationAction,
+      cap: packedNumber(cap),
+      spent: packedNumber(spent),
+      estimate: packedNumber(estimate),
+      fromAllowance: packedNumber(fromAllowance),
+      fromCreditLimits: packedNumber(fromCreditLimits),
+      moneyUsd: packedNumber(moneyUsd),
+    }
+  }
+
+  constructor(message: string = 'error') {
+    super(`confirmation-required:${message}`)
+    this.type = ConnectConfirmationRequired.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    const marker = 'confirmation-required:'
+    const at = this.message.lastIndexOf(marker)
+    if (at < 0) return
+    Object.assign(this, ConnectConfirmationRequired.decode(this.message.slice(at + marker.length)))
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
 ResilientError.registerErrorClass(ConnectError)
 ResilientError.registerErrorClass(ConnectSessionNotFound)
 ResilientError.registerErrorClass(ConnectSessionGone)
@@ -200,3 +274,4 @@ ResilientError.registerErrorClass(LocalSlotUnsupported)
 ResilientError.registerErrorClass(ConnectOpUnknown)
 ResilientError.registerErrorClass(ConnectOutOfCredits)
 ResilientError.registerErrorClass(ConnectConsentRequired)
+ResilientError.registerErrorClass(ConnectConfirmationRequired)

package/src/connect/index.ts

@@ -1,7 +1,18 @@
 export * from './consts.js'
+export * from './model-tier.js'
 export * from './schemas.js'
 export * from './errors.js'
 export * from './entrypoints.js'
 export * from './references.js'
-export type * from './types.js'
-export type * from './ops.js'
+export type * from './session/types.js'
+export type * from './ops/types.js'
+export type * from './project/types.js'
+export type * from './settings/types.js'
+export type * from './branding/types.js'
+export type * from './pipeline/types.js'
+export type * from './conversion/types.js'
+export type * from './kit/types.js'
+export type * from './entrypoints/types.js'
+export type * from './errors/types.js'
+export type * from './references/types.js'
+export type * from './model-tier/types.js'

package/src/connect/kit/types.ts

@@ -0,0 +1,56 @@
+
+
+/** One status of a planning kit's flow. `intrinsic` is the planning intrinsic it maps to. */
+export interface PlanningKitStatusView {
+  key: string
+  label: string
+  intrinsic: string
+}
+
+/** One status flow a planning kit declares. */
+export interface PlanningKitFlowView {
+  key: string
+  label: string
+  statuses: PlanningKitStatusView[]
+}
+
+/** One card type a planning kit declares; `flow` is the key of its main flow. */
+export interface PlanningKitTypeView {
+  key: string
+  label: string
+  flow: string
+}
+
+/**
+ * A planning kit as a connector sees it: a ready set of card types and status flows for one kind
+ * of work-management product, written into the target's common package on `apply`.
+ */
+export interface PlanningKitView {
+  id: string
+  /** The work kind the kit serves — a bare string, so a newer kind never fails an older reader. */
+  kind: string
+  title: string
+  purpose: string
+  /** The project-level container type the kit's cards live in. */
+  container: { key: string, label: string }
+  types: PlanningKitTypeView[]
+  flows: PlanningKitFlowView[]
+}
+
+/** What `project.kit.describe` answers. */
+export interface ConnectKitDescribe {
+  kits: PlanningKitView[]
+}
+
+/** Apply one kit; `types` keeps only these card-type keys of it (every type when omitted). */
+export interface ConnectKitApplyBody {
+  kit: string
+  types?: string[]
+}
+
+/** What `project.kit.apply` answers: the type keys written, those left out, and warnings. */
+export interface ConnectKitApplyResult {
+  applied: string[]
+  skipped: string[]
+  warnings: string[]
+}

package/src/connect/model-tier/types.ts

@@ -0,0 +1,16 @@
+import type { ModelTier } from '../consts.js'
+
+/** Which model tier a platform role runs on, and how a tier is placed on what a parent offers. */
+export interface ModelTierHelper {
+  /** The tier a platform role asks for; a role the table does not name is `Standard`. */
+  tierOfRole: (role: string) => ModelTier
+  /**
+   * Pick the best tier a parent actually offers, never below what was asked for by more than the
+   * offer allows.
+   *
+   * A parent that offers only one model answers every task with it; a parent that offers two gets
+   * the nearer of the two. Silence is not an option — a task the connector cannot place is a run
+   * that stops.
+   */
+  clampTier: (wanted: ModelTier, offered: ModelTier[]) => ModelTier
+}

package/src/connect/model-tier.ts

@@ -0,0 +1,22 @@
+import { MODEL_TIER_ROLES, ModelTier } from './consts.js'
+import type { ModelTierHelper } from './model-tier/types.js'
+
+export const createModelTierHelper = (): ModelTierHelper => {
+  const tierOfRole = (role: string): ModelTier =>
+    MODEL_TIER_ROLES[role] ?? ModelTier.Standard
+
+  const clampTier = (wanted: ModelTier, offered: ModelTier[]): ModelTier => {
+    if (offered.length < 1 || offered.includes(wanted)) return wanted
+    const ladder = [ModelTier.Strong, ModelTier.Standard, ModelTier.Cheap]
+    const from = ladder.indexOf(wanted)
+    // Prefer a stronger model over a weaker one: the task was sized for `wanted`.
+    for (let i = from; i >= 0; --i) if (offered.includes(ladder[i])) return ladder[i]
+    for (let i = from + 1; i < ladder.length; ++i) if (offered.includes(ladder[i])) return ladder[i]
+
+    return wanted
+  }
+
+  return { tierOfRole, clampTier }
+}
+
+export const modelTierHelper = createModelTierHelper()

package/src/connect/{ops.ts → ops/types.ts}

@@ -1,9 +1,9 @@
-import type { SlotCommandPayload } from '../slot/index.js'
+import type { SlotCommandPayload } from '../../slot/types.js'
 import type {
   ConnectInquiryKind, ConnectOpErrorKind, ConnectOpKind, ModelTaskMode, ModelTaskResultKind,
   ModelTaskRole, ModelTier
-} from './consts.js'
-import type { ConnectServices } from './types.js'
+} from '../consts.js'
+import type { ConnectServices } from '../session/types.js'
 
 /**
  * One thing the platform asks a connector to do.
@@ -48,6 +48,13 @@ export interface ConnectOpError {
   kind?: ConnectOpErrorKind
 }
 
+/** The acknowledgement returned when a connector submits an operation result. */
+export interface ConnectOpSubmission {
+  ok: boolean
+  /** The operation was already resolved; retrying a lost HTTP response is safe. */
+  ignored?: boolean
+}
+
 /**
  * The configuration a local target needs, as file CONTENT rather than as keys.
  *
@@ -203,3 +210,6 @@ export interface InquiryAnswerPayload {
   text?: string
   declined?: boolean
 }
+
+/** Answer one question a parked run is waiting on. */
+export interface ConnectInquiryAnswerBody extends InquiryAnswerPayload {}

package/src/connect/pipeline/types.ts

@@ -0,0 +1,41 @@
+import type { ConnectWaitReason } from '../consts.js'
+import type { InquiryAnswerPayload, InquiryPayload } from '../ops/types.js'
+
+export interface ConnectPipelineParams {
+  id: string
+  runId: string
+}
+
+export interface ConnectPipelineResumeBody {
+  from?: string
+  force?: boolean
+  /**
+   * Answers to the questions a parked run is waiting on, keyed by inquiry id.
+   *
+   * A run stops at `Waiting` because a step asked something; resuming it without what it asked for
+   * makes it ask again. The runner MERGES these into whatever the run already carries rather than
+   * replacing them, so a resume that answers one of two outstanding questions keeps the other.
+   */
+  answers?: Record<string, InquiryAnswerPayload>
+}
+
+/** The persistent state of one pipeline run, read by a connector without platform internals. */
+export interface ConnectPipelineState {
+  runId: string
+  pipeline: string
+  version: number
+  status: string
+  step?: string
+  completed: string[]
+  pending: string[]
+  warnings: string[]
+  failedAt?: string
+  error?: string
+  note?: string
+  waitingFor?: ConnectWaitReason
+  pendingInquiry?: InquiryPayload
+  attempts: number
+  startedAt: string
+  heartbeatAt: string
+  updatedAt: string
+}

package/src/connect/project/types.ts

@@ -0,0 +1,127 @@
+import type { ConnectTarget, ConnectWaitReason } from '../consts.js'
+import type { InquiryPayload } from '../ops/types.js'
+import type { ConnectSessionView } from '../session/types.js'
+
+export interface ConnectRunStatus {
+  runId: string
+  pipeline: string
+  status: string
+  step?: string
+  completed: string[]
+  pending: string[]
+  warnings?: string[]
+  error?: string
+  startedAt?: string
+  updatedAt?: string
+}
+
+/** What a connector needs to know about a project in one call. */
+export interface ConnectProjectStatus {
+  /**
+   * The project card, flattened into the names a parent agent already reads.
+   *
+   * `name` is the card's `title` and `alias` its `code`; the three brief parts are the bodies of
+   * the project's `specification`, `vision` and `design-system` specifications. `status` and
+   * `intrinsic` are the card's own — a key of the project flow and the intrinsic state it maps to —
+   * typed as plain strings because this view crosses a version skew and a newer platform may
+   * answer with a status an older connector has never heard of.
+   */
+  project: {
+    id: string
+    name: string
+    alias: string
+    description?: string
+    status: string
+    intrinsic: string
+    specification?: string
+    vision?: string
+    designSystem?: string
+  }
+  slot?: {
+    id: string
+    kind: string
+    status: string
+    slug: string
+    host?: string
+    initialized?: boolean
+    lastError?: string
+    buildWarning?: string
+    backendWarning?: string
+  }
+  production?: { id: string, status: string, host?: string }
+  agent: { locked: boolean, task?: string, lockedAt?: string }
+  run?: ConnectRunStatus
+  waitingFor?: ConnectWaitReason
+  pendingInquiry?: InquiryPayload
+  session?: ConnectSessionView
+  /** Set for a local target: the connector should not offer cloud-only operations. */
+  local: boolean
+  updatedAt: string
+}
+
+/** A story card composed with its deterministic development run. */
+export interface ConnectStoryStatus {
+  projectId: string
+  story: {
+    id: string
+    code: string
+    title: string
+    status: string
+    intrinsic: string
+    warning?: string
+  }
+  run?: ConnectRunStatus
+  waitingFor?: ConnectWaitReason
+  pendingInquiry?: InquiryPayload
+  updatedAt: string
+}
+
+/** The record a local project keeps so a later session knows what it is. */
+export interface ConnectMarker {
+  version: 1
+  apiUrl: string
+  projectId: string
+  slug: string
+  entitySlug?: string
+  createdAt: string
+}
+
+/** The deliberate small projection returned by the connector project list. */
+export interface ConnectProjectSummary {
+  id: string
+  name: string
+  alias: string
+}
+
+/** Attach an existing project to a session. */
+export interface ConnectAttachBody {
+  projectId?: string
+  slug?: string
+  projectDir?: string
+}
+
+/** Create a project through the connector; `target` decides where its tree will live. */
+export interface ConnectCreateBody {
+  prompt: string
+  target?: ConnectTarget
+}
+
+/**
+ * Confirm a drafted project, optionally editing what the analysis produced.
+ *
+ * The keys are a parent agent's vocabulary and stay as they are: `name` becomes the card's
+ * `title`, and each brief part present is written into the project's specification of that
+ * category before the confirm transition runs.
+ */
+export interface ConnectConfirmBody {
+  name?: string
+  description?: string
+  specification?: string
+  vision?: string
+  designSystem?: string
+  target?: ConnectTarget
+}
+
+export interface ConnectModifyBody {
+  prompt: string
+}

package/src/connect/references/types.local.ts

@@ -0,0 +1,5 @@
+import type { EntrypointReference } from '@owlmeans/context'
+import type { RegisteredEntrypoint, RequestShape } from '@owlmeans/entrypoint'
+
+export interface ConnectReference<Request extends RequestShape, Response>
+  extends EntrypointReference<RegisteredEntrypoint<Request, Response>> {}