@shipworthy/openapi-parser 0.0.1 → 1.0.0

package/README.md

@@ -4,6 +4,10 @@ Load an OpenAPI 3.0 or 3.1 document from a file path, a URL, a JSON or YAML stri
 
 The API is Effect-native. Every entry point is an `Effect` or an Effect `Schema` codec, so you need [`effect`](https://www.npmjs.com/package/effect) v4 to run it.
 
+Bundling preserves OpenAPI 3.1 schema keywords alongside `$ref`, including descriptions,
+constraints, and extensions. It rewrites external references to internal references without
+introducing `allOf` wrappers for their sibling keywords.
+
 ## Installation
 
 ```sh
@@ -12,12 +16,11 @@ bun add @shipworthy/openapi-parser effect @effect/platform-node
 
 ### Requirements
 
-| Requirement   | Details                                                                                                                                                                                                                                                                                                                                           |
-| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `effect`      | `^4.0.0`, a peer dependency. Install it yourself so your application and the parser share one copy to run the returned effects and to use the schemas.                                                                                                                                                                                            |
-| Platform      | `@effect/platform-node` `^4.0.0` is a regular dependency. Install it yourself only if your code imports it, as the examples here do for `NodeServices`. The parser imports `node:stream`, `node:url`, `node:path`, `node:dns/promises`, `node:net`, and the `Buffer` global, so it needs Node.js `>=22.19.0` or Bun. It does not run in browsers. |
-| Module format | ESM only (`"type": "module"`). Ships compiled JavaScript with `.d.ts` declarations; no TypeScript loader or bundler is needed.                                                                                                                                                                                                                    |
-| Peer deps     | `effect` `^4.0.0`.                                                                                                                                                                                                                                                                                                                                |
+| Requirement   | Details                                                                                                                                                                                                                                                                                                                                          |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `effect`      | `4.1.4`, a regular dependency. Add a compatible version to your own `package.json` so your application and the parser resolve to one copy to run the returned effects and to use the schemas.                                                                                                                                                    |
+| Platform      | `@effect/platform-node` `4.1.4` is a regular dependency. Install it yourself only if your code imports it, as the examples here do for `NodeServices`. The parser imports `node:stream`, `node:url`, `node:path`, `node:dns/promises`, `node:net`, and the `Buffer` global, so it needs Node.js `>=22.19.0` or Bun. It does not run in browsers. |
+| Module format | ESM only (`"type": "module"`). Ships compiled JavaScript with `.d.ts` declarations; no TypeScript loader or bundler is needed.                                                                                                                                                                                                                   |
 
 ## Quick start
 
@@ -354,7 +357,7 @@ None of these settings can be configured through the public API.
 - Load files with `URL` or `file://` strings. Bare strings are parsed as JSON or YAML text.
 - Input can be OpenAPI 3.0 or 3.1. Output is always bundled and upgraded OpenAPI 3.1 (`openapi: "3.1.0"` when upgraded from 3.0), with external refs moved into `components`.
 - Every error is a `Schema.SchemaError`. Read `error.message`.
-- Requires `effect` `^4.0.0` (peer dependency), ESM, and Node.js `>=22.19.0` or Bun. Ships compiled JavaScript. It does not run in browsers.
+- Depends on `effect` `4.1.4`. ESM only, and Node.js `>=22.19.0` or Bun. Ships compiled JavaScript. It does not run in browsers.
 - Next step in the toolchain: pass the result to `decode` from `@shipworthy/openapi-transformer` to get a `ParsedService` for code generators.
 
 ## License

package/dist/errors.d.ts

@@ -3,7 +3,9 @@ declare const ParserFailure_base: Schema.Class<ParserFailure, Schema.TaggedStruc
     readonly message: Schema.String;
     readonly source: Schema.String;
     readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class ParserFailure extends ParserFailure_base {
 }
 declare const ResolverFailure_base: Schema.Class<ResolverFailure, Schema.TaggedStruct<"ResolverFailure", {
@@ -11,19 +13,25 @@ declare const ResolverFailure_base: Schema.Class<ResolverFailure, Schema.TaggedS
     readonly source: Schema.String;
     readonly ioErrorCode: Schema.optionalKey<Schema.String>;
     readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class ResolverFailure extends ResolverFailure_base {
 }
 declare const UnmatchedParserFailure_base: Schema.Class<UnmatchedParserFailure, Schema.TaggedStruct<"UnmatchedParserFailure", {
     message: Schema.String;
     source: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class UnmatchedParserFailure extends UnmatchedParserFailure_base {
 }
 declare const UnmatchedResolverFailure_base: Schema.Class<UnmatchedResolverFailure, Schema.TaggedStruct<"UnmatchedResolverFailure", {
     message: Schema.String;
     source: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class UnmatchedResolverFailure extends UnmatchedResolverFailure_base {
 }
 declare const MissingPointerFailure_base: Schema.Class<MissingPointerFailure, Schema.TaggedStruct<"MissingPointerFailure", {
@@ -33,31 +41,41 @@ declare const MissingPointerFailure_base: Schema.Class<MissingPointerFailure, Sc
     readonly targetRef: Schema.String;
     readonly targetFound: Schema.String;
     readonly parentPath: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class MissingPointerFailure extends MissingPointerFailure_base {
 }
 declare const InvalidPointerFailure_base: Schema.Class<InvalidPointerFailure, Schema.TaggedStruct<"InvalidPointerFailure", {
     readonly message: Schema.String;
     readonly source: Schema.String;
     readonly pointer: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class InvalidPointerFailure extends InvalidPointerFailure_base {
 }
 declare const CircularAliasFailure_base: Schema.Class<CircularAliasFailure, Schema.TaggedStruct<"CircularAliasFailure", {
     readonly message: Schema.String;
     readonly definition: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class CircularAliasFailure extends CircularAliasFailure_base {
 }
 declare const BundleFailure_base: Schema.Class<BundleFailure, Schema.TaggedStruct<"BundleFailure", {
     readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class BundleFailure extends BundleFailure_base {
 }
 declare const TimeoutFailure_base: Schema.Class<TimeoutFailure, Schema.TaggedStruct<"TimeoutFailure", {
     readonly message: Schema.String;
     readonly timeout: Schema.Finite;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class TimeoutFailure extends TimeoutFailure_base {
 }
 declare const leafFailure: Schema.Union<readonly [typeof ParserFailure, typeof ResolverFailure, typeof UnmatchedParserFailure, typeof UnmatchedResolverFailure, typeof MissingPointerFailure, typeof InvalidPointerFailure, typeof CircularAliasFailure, typeof BundleFailure, typeof TimeoutFailure]>;
@@ -65,7 +83,9 @@ declare const GroupFailure_base: Schema.Class<GroupFailure, Schema.TaggedStruct<
     readonly source: Schema.String;
     readonly message: Schema.String;
     readonly errors: Schema.$Array<Schema.Union<readonly [typeof ParserFailure, typeof ResolverFailure, typeof UnmatchedParserFailure, typeof UnmatchedResolverFailure, typeof MissingPointerFailure, typeof InvalidPointerFailure, typeof CircularAliasFailure, typeof BundleFailure, typeof TimeoutFailure]>>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class GroupFailure extends GroupFailure_base {
 }
 export type LeafFailure = typeof leafFailure.Type;
@@ -82,23 +102,31 @@ export declare function groupFailure(source: string, errors: ReadonlyArray<LeafF
 export declare function syncFailure(cause: unknown): TaggedFailure;
 declare const EmptySource_base: Schema.Class<EmptySource, Schema.TaggedStruct<"EmptySource", {
     readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class EmptySource extends EmptySource_base {
 }
 declare const InvalidSource_base: Schema.Class<InvalidSource, Schema.TaggedStruct<"InvalidSource", {
     readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class InvalidSource extends InvalidSource_base {
 }
 declare const UnsupportedVersion_base: Schema.Class<UnsupportedVersion, Schema.TaggedStruct<"UnsupportedVersion", {
     readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class UnsupportedVersion extends UnsupportedVersion_base {
 }
 declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"ParseError", {
     readonly message: Schema.String;
     readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class ParseError extends ParseError_base {
 }
 export type LoadError = EmptySource | InvalidSource | UnsupportedVersion | ParseError;

package/dist/errors.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Formatter, Option, pipe, Schema, String as Str } from "effect";
 const failureFields = {
     message: Schema.String,
     source: Schema.String,
@@ -97,7 +97,7 @@ function errorCode(cause) {
     return undefined;
 }
 export function missingPointerFailure(token, source, targetRef = "", targetFound = "", parentPath = "") {
-    const hash = source.includes("#") ? source.slice(source.indexOf("#")) : source;
+    const hash = pipe(source, Str.indexOf("#"), Option.match({ onNone: () => source, onSome: (index) => Str.slice(index)(source) }));
     return new MissingPointerFailure({
         message: `Missing $ref pointer "${hash}". Token "${token}" does not exist.`,
         source,
@@ -116,7 +116,7 @@ export function invalidPointerFailure(pointer, source = pointer) {
 }
 export function circularAliasFailure(definition) {
     return new CircularAliasFailure({
-        message: `Definition ${JSON.stringify(definition)} is a circular alias.`,
+        message: `Definition ${Formatter.formatJson(definition)} is a circular alias.`,
         definition,
     });
 }

package/dist/hoist.js

@@ -1,4 +1,4 @@
-import { Predicate, Schema } from "effect";
+import { Array as Arr, Option, pipe, Predicate, Record as Rec, Schema, String as Str, } from "effect";
 import { MissingPointerFailure, bundleFailure } from "./errors.js";
 import { cloneData, getAt, joinPointer, parsePointer, setAt } from "./pointer.js";
 import { getHash, isFileSystemPath, isHttp, stripHash } from "./url.js";
@@ -17,7 +17,7 @@ export function findExternalRef(root, keep, abandoned = new Set()) {
         if (seen.has(current.node))
             continue;
         seen.add(current.node);
-        if (Array.isArray(current.node)) {
+        if (Arr.isArray(current.node)) {
             for (let index = current.node.length - 1; index >= 0; index--) {
                 stack.push({
                     node: current.node[index],
@@ -32,7 +32,7 @@ export function findExternalRef(root, keep, abandoned = new Set()) {
         if (current.parent &&
             current.key &&
             typeof record.$ref === "string" &&
-            !record.$ref.startsWith("#") &&
+            !Str.startsWith("#")(record.$ref) &&
             !keep(record.$ref) &&
             !abandoned.has(current.pointer)) {
             return {
@@ -42,7 +42,7 @@ export function findExternalRef(root, keep, abandoned = new Set()) {
                 pointer: current.pointer,
             };
         }
-        const keys = Object.keys(record);
+        const keys = Rec.keys(record);
         for (let index = keys.length - 1; index >= 0; index--) {
             const key = keys[index];
             stack.push({
@@ -121,15 +121,15 @@ function rebaseInternalRefs(value, fileUrl, seen = new Set()) {
     if (typeof value !== "object" || value === null || seen.has(value))
         return;
     seen.add(value);
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         for (const item of value)
             rebaseInternalRefs(item, fileUrl, seen);
         return;
     }
     const record = value;
-    if (typeof record.$ref === "string" && record.$ref.startsWith("#"))
+    if (typeof record.$ref === "string" && Str.startsWith("#")(record.$ref))
         record.$ref = `${fileUrl}${record.$ref}`;
-    for (const child of Object.values(record))
+    for (const child of Rec.values(record))
         rebaseInternalRefs(child, fileUrl, seen);
 }
 function collapseRefChains(root) {
@@ -139,20 +139,20 @@ function collapseRefChains(root) {
             if (typeof value !== "object" || value === null || seen.has(value))
                 return;
             seen.add(value);
-            if (Array.isArray(value)) {
+            if (Arr.isArray(value)) {
                 for (const item of value)
                     visit(item, seen);
                 return;
             }
             const record = value;
             if (typeof record.$ref === "string" &&
-                record.$ref.startsWith("#") &&
-                Object.keys(record).length === 1) {
+                Str.startsWith("#")(record.$ref) &&
+                Rec.size(record) === 1) {
                 try {
                     const target = asRecord(getAt(root, record.$ref, record.$ref));
                     if (target &&
                         typeof target.$ref === "string" &&
-                        Object.keys(target).length === 1 &&
+                        Rec.size(target) === 1 &&
                         target.$ref !== record.$ref) {
                         record.$ref = target.$ref;
                         changed = true;
@@ -163,7 +163,7 @@ function collapseRefChains(root) {
                         throw error;
                 }
             }
-            for (const child of Object.values(record))
+            for (const child of Rec.values(record))
                 visit(child, seen);
         };
         visit(root);
@@ -183,11 +183,11 @@ function inlineRef(found, value, hooks) {
     const current = asRecord(found.parent[found.key]);
     const siblings = { ...current };
     delete siblings.$ref;
-    if (Object.keys(siblings).length === 0) {
+    if (Rec.isEmptyRecord(siblings)) {
         found.parent[found.key] = value;
     }
     else if (oas3DefaultRoot(found.pointer) === "#/components/schemas" ||
-        found.pointer.includes("/schema")) {
+        Str.includes("/schema")(found.pointer)) {
         found.parent[found.key] = { allOf: [value, siblings] };
     }
     else if (asRecord(value)) {
@@ -204,7 +204,7 @@ function generateKey(schema, file, hash, pathFromRoot, buckets, childReservesBas
     const root = oas3DefaultRoot(pathFromRoot);
     if (!root)
         return null;
-    if (!isFileSystemPath(file) && !isHttp(file) && !file.includes("://"))
+    if (!isFileSystemPath(file) && !isHttp(file) && !Str.includes("://")(file))
         return null;
     if (hash === "#" && isUnderDirectRoot(pathFromRoot, root))
         return null;
@@ -221,7 +221,7 @@ function generateKey(schema, file, hash, pathFromRoot, buckets, childReservesBas
         const filePointer = keyForFile(schema, file, root, buckets);
         if (filePointer == null)
             return null;
-        return keyForPointer(schema, filePointer + hash.slice(1), root, buckets);
+        return keyForPointer(schema, filePointer + Str.slice(1)(hash), root, buckets);
     }
     return keyForFile(schema, file, root, buckets, hash === "#" && childReservesBase);
 }
@@ -229,7 +229,7 @@ function isOpenApiDocument(schema) {
     return typeof schema.openapi === "string";
 }
 export function oas3DefaultRoot(pathFromRoot) {
-    const path = pathFromRoot.split("/");
+    const path = Str.split(pathFromRoot, "/");
     if (canReferenceParameter(path))
         return "#/components/parameters";
     if (canReferenceResponse(path))
@@ -283,16 +283,16 @@ function isUnderDirectRoot(pathFromRoot, root) {
     const pointer = pointerTokens(pathFromRoot);
     const rootTokens = pointerTokens(root);
     return (pointer.length === rootTokens.length + 1 &&
-        rootTokens.every((token, index) => pointer[index] === token));
+        Arr.every(rootTokens, (token, index) => pointer[index] === token));
 }
 function isInRoot(pointer, root) {
     const pointerTokens_ = pointerTokens(pointer);
     const rootTokens = pointerTokens(root);
     return (pointerTokens_.length > rootTokens.length &&
-        rootTokens.every((token, index) => pointerTokens_[index] === token));
+        Arr.every(rootTokens, (token, index) => pointerTokens_[index] === token));
 }
 function pointerTokens(pointer) {
-    if (!pointer.startsWith("#"))
+    if (!Str.startsWith("#")(pointer))
         return [];
     try {
         return parsePointer(pointer);
@@ -305,11 +305,11 @@ function existingComponentPointer(schema, file, hash, root) {
     const map = asRecord(valueAtSafe(schema, root));
     if (!map)
         return undefined;
-    for (const [key, child] of Object.entries(map)) {
+    for (const [key, child] of Rec.toEntries(map)) {
         const record = asRecord(child);
         if (!record || typeof record.$ref !== "string")
             continue;
-        const extras = Object.keys(record).filter((name) => name !== "$ref" && name !== "summary" && name !== "description");
+        const extras = Arr.filter(Rec.keys(record), (name) => name !== "$ref" && name !== "summary" && name !== "description");
         if (extras.length > 0)
             continue;
         if (stripHash(record.$ref) !== file || getHash(record.$ref) !== hash)
@@ -338,17 +338,17 @@ function childReservesName(value, base) {
         if (typeof current !== "object" || current === null || seen.has(current))
             continue;
         seen.add(current);
-        if (Array.isArray(current)) {
+        if (Arr.isArray(current)) {
             stack.push(...current);
             continue;
         }
         const record = current;
-        if (typeof record.$ref === "string" && !record.$ref.startsWith("#")) {
-            const token = getHash(record.$ref).split("/").at(-1);
+        if (typeof record.$ref === "string" && !Str.startsWith("#")(record.$ref)) {
+            const token = pipe(getHash(record.$ref), Str.split("/"), Arr.lastNonEmpty);
             if (token === base)
                 return true;
         }
-        stack.push(...Object.values(record));
+        stack.push(...Rec.values(record));
     }
     return false;
 }
@@ -356,9 +356,8 @@ function keyForPointer(schema, pointer, root, buckets) {
     const names = bucket(schema, root, buckets);
     if (names.generated.has(pointer))
         return names.generated.get(pointer) ?? null;
-    const fragment = `${root.slice(1)}/`;
-    const actualPath = pointer.split(fragment).slice(1);
-    const base = prettify(actualPath.join("/"));
+    const fragment = `${Str.slice(1)(root)}/`;
+    const base = prettify(pipe(pointer, Str.split(fragment), Arr.drop(1), Arr.join("/")));
     if (!base)
         return register(schema, root, pointer, null, buckets);
     return register(schema, root, pointer, suggest(names.taken, base), buckets);
@@ -380,9 +379,9 @@ function bucket(schema, root, buckets) {
     if (existing)
         return existing;
     const taken = new Set();
-    const value = valueAtSafe(schema, root);
-    if (asRecord(value)) {
-        for (const key of Object.keys(value))
+    const value = asRecord(valueAtSafe(schema, root));
+    if (value) {
+        for (const key of Rec.keys(value))
             taken.add(key);
     }
     const created = { taken, generated: new Map() };
@@ -419,17 +418,25 @@ function matchingComponent(_schema, _root, _value, _source, _componentSource) {
     // schema. DigitalOcean repeats one enum as apps_domain_phase and app_alert_phase.
     return undefined;
 }
+/**
+ * Replaces each `.` or run of slashes with `_`, uppercasing a following lowercase
+ * letter. A leading separator without a following letter is dropped.
+ */
 function prettify(key) {
-    const pretty = key.replace(/(?:\.|[\\/]+)([a-z])?/g, (_match, letter, index) => {
-        if (letter === undefined)
-            return index === 0 ? "" : "_";
-        return `_${letter.toUpperCase()}`;
-    });
-    return pretty;
+    let pretty = "";
+    let last = 0;
+    for (const match of Str.matchAll(/(?:\.|[\\/]+)([a-z])?/g)(key)) {
+        const index = match.index ?? last;
+        const letter = match[1];
+        const replacement = letter === undefined ? (index === 0 ? "" : "_") : `_${Str.toUpperCase(letter)}`;
+        pretty += `${Str.slice(last, index)(key)}${replacement}`;
+        last = index + match[0].length;
+    }
+    return `${pretty}${Str.slice(last)(key)}`;
 }
 function fileBaseName(file) {
     let pathname = file;
-    if (file.includes("://")) {
+    if (Str.includes("://")(file)) {
         try {
             pathname = decodeURIComponent(new URL(file).pathname);
         }
@@ -437,8 +444,6 @@ function fileBaseName(file) {
             pathname = file;
         }
     }
-    const slash = Math.max(pathname.lastIndexOf("/"), pathname.lastIndexOf("\\"));
-    const base = slash >= 0 ? pathname.slice(slash + 1) : pathname;
-    const dot = base.lastIndexOf(".");
-    return dot > 0 ? base.slice(0, dot) : base;
+    const base = pipe(pathname, Str.split(/[/\\]/), Arr.lastNonEmpty);
+    return pipe(base, Str.lastIndexOf("."), Option.filter((dot) => dot > 0), Option.match({ onNone: () => base, onSome: (dot) => Str.slice(0, dot)(base) }));
 }

package/dist/http.js

@@ -1,6 +1,6 @@
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import { Agent } from "@effect/platform-node/Undici";
-import { Cause, Effect, Schedule } from "effect";
+import { Array as Arr, Cause, Effect, pipe, Record as Rec, Schedule, String as Str, } from "effect";
 import { HttpClient } from "effect/http";
 import { ResolverFailure, nodeErrorCode, timeoutFailure } from "./errors.js";
 import { httpOrigin, isAllowedOrigin, isHttp, isUnsafeUrl, resolveUrlSafety, } from "./url.js";
@@ -94,7 +94,7 @@ const receive = Effect.fnUntraced(function* (client, href, http, redirects) {
     if (response.status >= 300) {
         if (http.redirects !== undefined && redirects.length > http.redirects) {
             return yield* new ResolverFailure({
-                message: `Error downloading ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`,
+                message: `Error downloading ${redirects[0]}. \nToo many redirects: \n  ${Arr.join(redirects, " \n  ")}`,
                 source: href,
                 ioErrorCode: String(response.status),
             });
@@ -119,7 +119,7 @@ function pinnedLookup(href, addresses) {
     return (hostname, options, callback) => {
         const normalizedHostname = normalizeLookupHostname(hostname);
         const requestedFamily = options.family === "IPv4" ? 4 : options.family === "IPv6" ? 6 : options.family || 0;
-        const candidates = addresses.filter(({ family }) => requestedFamily === 0 || family === requestedFamily);
+        const candidates = Arr.filter(addresses, ({ family }) => requestedFamily === 0 || family === requestedFamily);
         if (normalizedHostname !== expectedHostname || candidates.length === 0) {
             const error = new Error(`No validated address is available for ${hostname}`);
             error.code = "ENOTFOUND";
@@ -135,10 +135,7 @@ function pinnedLookup(href, addresses) {
     };
 }
 function normalizeLookupHostname(hostname) {
-    return hostname
-        .replace(/^\[|\]$/g, "")
-        .replace(/\.+$/, "")
-        .toLowerCase();
+    return pipe(hostname, Str.replace(/^\[|\]$/g, ""), Str.replace(/\.+$/, ""), Str.toLowerCase);
 }
 function withoutSensitiveHeaders(http) {
     if (!http.headers)
@@ -147,13 +144,13 @@ function withoutSensitiveHeaders(http) {
     headers.delete("authorization");
     headers.delete("proxy-authorization");
     headers.delete("cookie");
-    return { ...http, headers: Object.fromEntries(headers.entries()) };
+    return { ...http, headers: Rec.fromEntries(headers.entries()) };
 }
 function resolverFailure(href, cause) {
     const message = cause instanceof Error ? cause.message : String(cause);
     const ioErrorCode = nodeErrorCode(cause);
     return new ResolverFailure({
-        message: message.startsWith("Error downloading")
+        message: Str.startsWith("Error downloading")(message)
             ? message
             : `Error downloading ${href}: ${message}`,
         source: href,

package/dist/load.js

@@ -1,7 +1,7 @@
 // oxlint-disable-next-line effecttsgo/node-builtin-import -- Detect the public Node Readable input before adapting it with NodeStream.
 import { Readable } from "node:stream";
 import * as NodeStream from "@effect/platform-node/NodeStream";
-import { Effect, Path, Predicate, Schema, Stream } from "effect";
+import { Array as Arr, Effect, Path, Predicate, Schema, Stream, String as Str, } from "effect";
 import { decodeDocument } from "./document.js";
 import { EmptySource, InvalidSource, ParseError } from "./errors.js";
 import { loadDocument as loadResolvedDocument, makeContext } from "./loader.js";
@@ -37,9 +37,9 @@ const parseSource = Effect.fnUntraced(function* (source, absoluteRef) {
     if (source instanceof Buffer)
         return yield* parseSource(source.toString("utf8"), absoluteRef);
     if (typeof source === "string") {
-        if (source.startsWith("http://") ||
-            source.startsWith("https://") ||
-            source.startsWith("file://")) {
+        if (Str.startsWith("http://")(source) ||
+            Str.startsWith("https://")(source) ||
+            Str.startsWith("file://")(source)) {
             const url = yield* Effect.try({
                 try: () => new URL(source),
                 catch: (cause) => new InvalidSource({
@@ -66,25 +66,25 @@ const parseSource = Effect.fnUntraced(function* (source, absoluteRef) {
  * matches: one-line YAML needs `key: value` or `{...}`, and JSON starts with `{`.
  */
 function isFilePath(source, path) {
-    const value = source.trim();
+    const value = Str.trim(source);
     if (value === "" || /[\r\n]/.test(value))
         return false;
     if (path.isAbsolute(value) ||
-        value.startsWith("./") ||
-        value.startsWith("../") ||
-        value.startsWith(".\\") ||
-        value.startsWith("..\\"))
+        Str.startsWith("./")(value) ||
+        Str.startsWith("../")(value) ||
+        Str.startsWith(".\\")(value) ||
+        Str.startsWith("..\\")(value))
         return true;
-    return ([".json", ".yaml", ".yml"].includes(path.extname(value).toLowerCase()) &&
-        !value.includes(": ") &&
-        !value.startsWith("{") &&
-        !value.startsWith("["));
+    return ([".json", ".yaml", ".yml"].includes(Str.toLowerCase(path.extname(value))) &&
+        !Str.includes(": ")(value) &&
+        !Str.startsWith("{")(value) &&
+        !Str.startsWith("[")(value));
 }
 /** Resolve a path string against the `cwd` directory URL. */
 const fileUrl = Effect.fnUntraced(function* (source, cwd) {
     const path = yield* Path.Path;
-    const value = source.trim();
-    if (!path.isAbsolute(value) && !cwd.startsWith("file:")) {
+    const value = Str.trim(source);
+    if (!path.isAbsolute(value) && !Str.startsWith("file:")(cwd)) {
         return yield* Effect.try({ try: () => new URL(value, cwd), catch: parseFailure });
     }
     const directory = path.isAbsolute(value) ? "" : yield* filePath(new URL(cwd));
@@ -95,7 +95,7 @@ const resolveCwd = Effect.fnUntraced(function* (path, cwd) {
         return cwd.href;
     }
     const directory = typeof cwd === "string" ? path.resolve(cwd) : path.resolve(".");
-    return yield* path.toFileUrl(directory).pipe(Effect.map((url) => (url.href.endsWith("/") ? url.href : `${url.href}/`)), Effect.mapError(parseFailure));
+    return yield* path.toFileUrl(directory).pipe(Effect.map((url) => (Str.endsWith("/")(url.href) ? url.href : `${url.href}/`)), Effect.mapError(parseFailure));
 });
 const filePath = Effect.fnUntraced(function* (url) {
     const path = yield* Path.Path;
@@ -105,7 +105,7 @@ const readReadable = Effect.fnUntraced(function* (source) {
     return yield* NodeStream.fromReadable({
         evaluate: () => source,
         onError: parseFailure,
-    }).pipe(Stream.decodeText, Stream.mkString, Effect.map((text) => text.trim()));
+    }).pipe(Stream.decodeText, Stream.mkString, Effect.map(Str.trim));
 });
 const documentObject = Schema.Record(Schema.String, Schema.Unknown);
 const requireDocument = Effect.fnUntraced(function* (value) {
@@ -122,7 +122,7 @@ function parseFailure(cause) {
 function valueKind(value) {
     if (value === null)
         return "null";
-    if (Array.isArray(value))
+    if (Arr.isArray(value))
         return "Array";
     return typeof value;
 }

package/dist/loader.js

@@ -1,4 +1,4 @@
-import { Effect, FileSystem } from "effect";
+import { Array as Arr, Effect, FileSystem, String as Str } from "effect";
 import { ParserFailure, ResolverFailure, UnmatchedParserFailure, UnmatchedResolverFailure, nodeErrorCode, } from "./errors.js";
 import { httpResolver } from "./http.js";
 import { parserPlugins, parseText } from "./parsers.js";
@@ -13,19 +13,19 @@ export function makeContext(rootUrl, options, policy = "reference") {
 }
 export const loadDocument = Effect.fnUntraced(function* (url, context) {
     const file = fileInfo(url);
-    const resolvers = context.resolvers.filter((plugin) => plugin.can(file));
+    const resolvers = Arr.filter(context.resolvers, (plugin) => plugin.can(file));
     if (resolvers.length === 0) {
         return yield* new UnmatchedResolverFailure({
             message: `Could not find resolver for "${url}"`,
             source: url,
         });
     }
-    const bytes = yield* Effect.firstSuccessOf(resolvers.map((plugin) => plugin.run(file)));
+    const bytes = yield* Effect.firstSuccessOf(Arr.map(resolvers, (plugin) => plugin.run(file)));
     if (context.policy === "root") {
         return yield* parseText(bytes).pipe(Effect.mapError((cause) => new ParserFailure({ message: cause.message, source: url, cause })));
     }
     const parsedFile = { ...file, data: bytes };
-    const parsers = context.parsers.filter((plugin) => plugin.can(parsedFile));
+    const parsers = Arr.filter(context.parsers, (plugin) => plugin.can(parsedFile));
     const selected = parsers.length > 0 ? parsers : context.parsers;
     if (selected.length === 0) {
         return yield* new UnmatchedParserFailure({
@@ -33,7 +33,7 @@ export const loadDocument = Effect.fnUntraced(function* (url, context) {
             source: url,
         });
     }
-    const parsed = yield* Effect.firstSuccessOf(selected.map((plugin) => plugin.run(parsedFile)));
+    const parsed = yield* Effect.firstSuccessOf(Arr.map(selected, (plugin) => plugin.run(parsedFile)));
     return parsed;
 });
 function resolversFor(rootUrl, options, policy) {
@@ -50,8 +50,8 @@ function resolversFor(rootUrl, options, policy) {
 const readResolvedFile = Effect.fnUntraced(function* (file) {
     const fs = yield* FileSystem.FileSystem;
     let filePath = toFileSystemPath(file.url);
-    if (filePath.endsWith("/") || filePath.endsWith("\\"))
-        filePath = filePath.slice(0, -1);
+    if (Str.endsWith("/")(filePath) || Str.endsWith("\\")(filePath))
+        filePath = Str.slice(0, -1)(filePath);
     return yield* fs.readFile(filePath).pipe(Effect.mapError((error) => new ResolverFailure({
         message: `Error opening file ${filePath}: ${error.message}`,
         source: filePath,