Export public helper types from hardtry/types entrypoint

Author: adelrodriguez

README.md

@@ -9,6 +9,7 @@
 
 ```ts
 import * as try$ from "hardtry"
+import type { FlowExit, SettledResult } from "hardtry/types"
 
 const result = await try$
   .retry(3)
@@ -276,9 +277,18 @@ From `hardtry/errors`:
 - `UnhandledException`
 - `Panic`
 
+From `hardtry/types`:
+
+- `AllSettledResult`
+- `SettledFulfilled`
+- `SettledRejected`
+- `SettledResult`
+- `FlowExit`
+
 ```ts
 import * as try$ from "hardtry"
 import { Panic, TimeoutError, UnhandledException } from "hardtry/errors"
+import type { FlowExit, SettledResult } from "hardtry/types"
 ```
 
 ### Common signatures
@@ -296,6 +306,7 @@ import { Panic, TimeoutError, UnhandledException } from "hardtry/errors"
 - Timeout scope is total execution.
 - `retry()` and `timeout()` only compose with `run()` / `runSync()`. Use nested `run()` calls inside orchestration tasks for leaf policies.
 - Error classes and `PanicCode` are exported from `hardtry/errors`.
+- Public helper types are exported from `hardtry/types`.
 - `flow` requires at least one `$exit(...)` path; otherwise it throws.
 - Control outcomes have precedence over mapped catch results in racing scenarios.
 - `wrap` is only available from `try$.wrap(...)` and can be chained as `.wrap().wrap()`.

bunup.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from "bunup"
 
 export default defineConfig({
   dts: true,
-  entry: ["src/index.ts", "src/errors.ts"],
+  entry: ["src/index.ts", "src/errors.ts", "src/types.ts"],
   format: "esm",
   outDir: "dist",
   sourcemap: true,

package.json

@@ -34,6 +34,10 @@
     "./errors": {
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
     }
   },
   "scripts": {

src/__tests__/types.test.ts

@@ -5,6 +5,7 @@ import type {
   TimeoutError,
   UnhandledException,
 } from "../errors"
+import type { FlowExit, SettledResult } from "../types"
 import * as try$ from "../index"
 
 type Expect<T extends true> = T
@@ -179,9 +180,7 @@ describe("type inference", () => {
         Equal<typeof result, Promise<number | UnhandledException | CancellationError>>
       >
       type _assertAll = Expect<Equal<typeof allResult, Promise<{ a: 1; b: 1 }>>>
-      type _assertSettled = Expect<
-        Equal<typeof settledResult, Promise<{ a: try$.SettledResult<"ok"> }>>
-      >
+      type _assertSettled = Expect<Equal<typeof settledResult, Promise<{ a: SettledResult<"ok"> }>>>
       type _assertFlow = Expect<Equal<typeof flowResult, Promise<"done">>>
 
       if (typecheckOnly()) {
@@ -604,6 +603,16 @@ describe("type inference", () => {
   })
 
   describe("allSettled", () => {
+    it("exports settled result types from the dedicated types entrypoint", () => {
+      if (typecheckOnly()) return
+
+      const settled = { status: "fulfilled", value: "ok" } as const satisfies SettledResult<"ok">
+
+      type _assert = Expect<
+        Equal<typeof settled, { readonly status: "fulfilled"; readonly value: "ok" }>
+      >
+    })
+
     it("infers settled result types", () => {
       if (typecheckOnly()) return
 
@@ -620,8 +629,8 @@ describe("type inference", () => {
         Equal<
           typeof result,
           Promise<{
-            a: try$.SettledResult<number>
-            b: try$.SettledResult<string>
+            a: SettledResult<number>
+            b: SettledResult<string>
           }>
         >
       >
@@ -691,6 +700,14 @@ describe("type inference", () => {
   })
 
   describe("flow", () => {
+    it("exports flow exit types from the dedicated types entrypoint", () => {
+      if (typecheckOnly()) return
+
+      const exitValue = null as unknown as FlowExit<"done">
+
+      type _assert = Expect<Equal<typeof exitValue, FlowExit<"done">>>
+    })
+
     it("infers union of $exit values", () => {
       const result = try$.flow({
         a() {
@@ -756,8 +773,8 @@ describe("type inference", () => {
         Equal<
           typeof result,
           Promise<{
-            a: try$.SettledResult<1>
-            b: try$.SettledResult<"ok">
+            a: SettledResult<1>
+            b: SettledResult<"ok">
           }>
         >
       >
@@ -775,5 +792,14 @@ describe("type inference", () => {
         void try$.retry(3).timeout(1000).signal(signal).flow
       }
     })
+
+    it("does not expose root type exports from the runtime entrypoint", () => {
+      if (typecheckOnly()) {
+        // @ts-expect-error -- settled result types moved to ../types
+        type _settled = try$.SettledResult<"ok">
+        // @ts-expect-error -- flow exit types moved to ../types
+        type _flow = try$.FlowExit<"done">
+      }
+    })
   })
 })

src/types.ts

@@ -0,0 +1,7 @@
+export type {
+  AllSettledResult,
+  SettledFulfilled,
+  SettledRejected,
+  SettledResult,
+} from "./lib/types/all"
+export type { FlowExit } from "./lib/types/flow"