@shipworthy/openapi-parser 0.0.2 → 1.0.0

package/dist/parsers.js

@@ -1,4 +1,4 @@
-import { Effect, Predicate } from "effect";
+import { Effect, Predicate, Schema, String as Str } from "effect";
 import { ParseError, ParserFailure } from "./errors.js";
 import { promisePlugin } from "./plugins.js";
 import { extensionOf } from "./url.js";
@@ -7,19 +7,18 @@ function decodeData(data) {
     if (data === undefined)
         return "";
     const text = typeof data === "string" ? data : new TextDecoder().decode(data);
-    return text.replace(/^\uFEFF/, "");
+    return Str.replace(/^\uFEFF/, "")(text);
 }
+const decodeJsonText = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
 function parseJsonText(text) {
-    if (text.trim().length === 0)
-        return null;
-    return JSON.parse(text);
+    return Str.isEmpty(Str.trim(text)) ? Effect.succeed(null) : decodeJsonText(text);
 }
 export const parseText = Effect.fnUntraced(function* (source) {
     const text = decodeData(source);
-    const first = text.trimStart()[0];
+    const first = Str.trimStart(text)[0];
     const yaml = () => Effect.try({ try: () => parseYamlDocument(text), catch: parseFailure });
     if (first === "{" || first === "[") {
-        return yield* Effect.try({ try: () => parseJsonText(text), catch: parseFailure }).pipe(Effect.catch(yaml));
+        return yield* parseJsonText(text).pipe(Effect.catch(yaml));
     }
     return yield* yaml();
 });
@@ -45,20 +44,10 @@ function jsonParser() {
         order: 100,
         can: (file) => extensionOf(file.url) === ".json" || extensionOf(file.url) === "",
         run(file) {
-            return Effect.try({
-                try: () => parseJson(file),
-                catch: (cause) => new ParserFailure({
-                    message: cause instanceof Error ? cause.message : "Parser Error",
-                    source: file.url,
-                    cause,
-                }),
-            });
+            return parseJsonText(decodeData(file.data)).pipe(Effect.mapError((cause) => new ParserFailure({ message: cause.message, source: file.url, cause })));
         },
     };
 }
-function parseJson(file) {
-    return parseJsonText(decodeData(file.data));
-}
 function yamlParser() {
     return {
         order: 200,

package/dist/pipeline.js

@@ -1,4 +1,4 @@
-import { JsonPointer, JsonSchema, Predicate } from "effect";
+import { Array as Arr, Formatter, JsonPointer, JsonSchema, Predicate, Record as Rec, String as Str, } from "effect";
 import { getAt, joinPointer } from "./pointer.js";
 import { componentSchemas, schemaSlots } from "./upgraders/3.0-to-3.1.js";
 import { bundleFailure, circularAliasFailure, invalidPointerFailure, missingPointerFailure, } from "./errors.js";
@@ -37,7 +37,7 @@ export function runSchemaPipeline(document, mode, hooks) {
     }
     const others = schemaSlots(document, false);
     const slotSchemas = [];
-    const booleanSlots = others.map((slot) => {
+    const booleanSlots = Arr.map(others, (slot) => {
         const value = slot.parent[slot.key];
         return typeof value === "boolean" ? value : undefined;
     });
@@ -48,10 +48,10 @@ export function runSchemaPipeline(document, mode, hooks) {
         slotSchemas.push(normalized.schema);
     }
     const recursive = recursiveNames(definitions);
-    const rootDefs = new Set(Object.keys(asRecord(document.$defs) ?? {}));
+    const rootDefs = new Set(Rec.keys(asRecord(document.$defs) ?? {}));
     const aliases = new Map();
     const resolving = new Set();
-    for (const name of Object.keys(definitions)) {
+    for (const name of Rec.keys(definitions)) {
         definitions[name] = resolveValue(definitions[name], definitions, rootDefs, recursive, aliases, resolving, mode, hooks, `#/$defs/${name}`);
     }
     for (let index = 0; index < slotSchemas.length; index++) {
@@ -61,9 +61,9 @@ export function runSchemaPipeline(document, mode, hooks) {
             slot.parent[slot.key] = slotSchemas[index];
     }
     const parked = [];
-    for (const [name, schema] of Object.entries(definitions))
+    for (const [name, schema] of Rec.toEntries(definitions))
         park(schema, "definition", name, [], parked);
-    slotSchemas.forEach((schema, index) => park(schema, "schema", String(index), [], parked));
+    Arr.forEach(slotSchemas, (schema, index) => park(schema, "schema", String(index), [], parked));
     const schemas = (slotSchemas.length > 0 ? slotSchemas : [{}]);
     const converted = JsonSchema.toMultiDocumentOpenApi3_1({
         dialect: "draft-2020-12",
@@ -79,7 +79,7 @@ export function runSchemaPipeline(document, mode, hooks) {
         if (value !== undefined)
             slot.parent[slot.key] = value;
     }
-    others.forEach((slot, index) => {
+    Arr.forEach(others, (slot, index) => {
         slot.parent[slot.key] = booleanSlots[index] ?? converted.schemas[index];
     });
     rewriteLeftoverDefinitionRefs(document);
@@ -100,20 +100,20 @@ function normalizeSchema(value) {
     if (typeof record.$id === "string")
         return normalized;
     const extracted = asRecord(normalized.definitions);
-    if (!extracted || Object.keys(extracted).length === 0)
+    if (!extracted || Rec.isEmptyRecord(extracted))
         return normalized;
     const schema = asRecord(normalized.schema) ?? {};
     schema.$defs = { ...asRecord(schema.$defs), ...extracted };
     return { dialect: normalized.dialect, schema, definitions: {} };
 }
 function mergeDefinitions(pool, extra, owner, order) {
-    for (const [name, schema] of Object.entries(extra)) {
-        if (!Object.hasOwn(pool, name)) {
+    for (const [name, schema] of Rec.toEntries(extra)) {
+        if (!Rec.has(pool, name)) {
             pool[name] = schema;
             rememberDefinition(order, name);
             continue;
         }
-        if (JSON.stringify(pool[name]) === JSON.stringify(schema))
+        if (Formatter.formatJson(pool[name]) === Formatter.formatJson(schema))
             continue;
         const unique = uniqueName(pool, name);
         pool[unique] = schema;
@@ -132,18 +132,18 @@ function orderDefinitions(definitions, order) {
         return definitions;
     const output = {};
     for (const name of order) {
-        if (Object.hasOwn(source, name))
+        if (Rec.has(source, name))
             output[name] = source[name];
     }
-    for (const name of Object.keys(source)) {
-        if (!Object.hasOwn(output, name))
+    for (const name of Rec.keys(source)) {
+        if (!Rec.has(output, name))
             output[name] = source[name];
     }
     return output;
 }
 function uniqueName(pool, name) {
     let suffix = 2;
-    while (Object.hasOwn(pool, `${name}_${suffix}`))
+    while (Rec.has(pool, `${name}_${suffix}`))
         suffix += 1;
     return `${name}_${suffix}`;
 }
@@ -153,12 +153,12 @@ function rewriteDefName(schema, from, to) {
         return;
     if (record.$ref === `#/$defs/${from}`)
         record.$ref = `#/$defs/${to}`;
-    for (const value of Object.values(record))
+    for (const value of Rec.values(record))
         rewriteDefName(value, from, to);
 }
 function recursiveNames(definitions) {
-    const names = Object.keys(definitions);
-    const dependencies = new Map(names.map((name) => [name, collectDefRefs(definitions[name])]));
+    const names = Rec.keys(definitions);
+    const dependencies = new Map(Arr.map(names, (name) => [name, collectDefRefs(definitions[name])]));
     const recursive = new Set();
     const state = new Map();
     const stack = [];
@@ -167,7 +167,7 @@ function recursiveNames(definitions) {
         if (current === 1) {
             const start = stack.indexOf(name);
             const cycle = stack.slice(start);
-            if (cycle.every((item) => isPureRef(definitions[item]))) {
+            if (Arr.every(cycle, (item) => isPureRef(definitions[item]))) {
                 throw circularAliasFailure(name);
             }
             for (const item of cycle)
@@ -190,27 +190,28 @@ function recursiveNames(definitions) {
     return recursive;
 }
 function collectDefRefs(value, found = new Set(), seen = new Set()) {
-    if (typeof value !== "object" || value === null || seen.has(value))
+    if (!Predicate.isObjectOrArray(value) || seen.has(value))
         return found;
     seen.add(value);
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         for (const item of value)
             collectDefRefs(item, found, seen);
         return found;
     }
-    const ref = value.$ref;
+    const record = value;
+    const ref = record.$ref;
     if (typeof ref === "string") {
         const key = referenceKey(ref);
         if (key)
             found.add(key);
     }
-    for (const child of Object.values(value))
+    for (const child of Rec.values(record))
         collectDefRefs(child, found, seen);
     return found;
 }
 const rootDefRef = (name) => `#/root-defs/${JsonPointer.escapeToken(name)}`;
 function resolveValue(value, definitions, rootDefs, recursive, aliases, resolving, mode, hooks, pointer) {
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         for (let index = 0; index < value.length; index++) {
             value[index] = resolveValue(value[index], definitions, rootDefs, recursive, aliases, resolving, mode, hooks, joinPointer(pointer, String(index)));
         }
@@ -221,7 +222,7 @@ function resolveValue(value, definitions, rootDefs, recursive, aliases, resolvin
         return value;
     if (typeof record.$ref === "string") {
         const key = referenceKey(record.$ref);
-        if (key && !Object.hasOwn(definitions, key)) {
+        if (key && !Rec.has(definitions, key)) {
             if (rootDefs.has(key)) {
                 record.$ref = rootDefRef(key);
             }
@@ -245,7 +246,7 @@ function resolveValue(value, definitions, rootDefs, recursive, aliases, resolvin
                 resolving.delete(final);
                 const siblings = { ...record };
                 delete siblings.$ref;
-                const result = Object.keys(siblings).length === 0
+                const result = Rec.isEmptyRecord(siblings)
                     ? resolved
                     : {
                         allOf: [
@@ -258,7 +259,7 @@ function resolveValue(value, definitions, rootDefs, recursive, aliases, resolvin
             }
         }
     }
-    for (const [key, child] of Object.entries(record)) {
+    for (const [key, child] of Rec.toEntries(record)) {
         record[key] = resolveValue(child, definitions, rootDefs, recursive, aliases, resolving, mode, hooks, joinPointer(pointer, key));
     }
     return record;
@@ -274,7 +275,7 @@ function finalName(name, definitions, aliases) {
     const schema = definitions[name];
     if (isPureRef(schema)) {
         const key = referenceKey(schema.$ref);
-        if (key && Object.hasOwn(definitions, key)) {
+        if (key && Rec.has(definitions, key)) {
             const resolved = finalName(key, definitions, aliases);
             aliases.set(name, resolved);
             return resolved;
@@ -285,10 +286,10 @@ function finalName(name, definitions, aliases) {
 }
 function isPureRef(value) {
     const record = asRecord(value);
-    return Boolean(record && typeof record.$ref === "string" && Object.keys(record).length === 1);
+    return Boolean(record && typeof record.$ref === "string" && Rec.size(record) === 1);
 }
 function referenceKey(ref) {
-    if (!ref.startsWith("#"))
+    if (!Str.startsWith("#")(ref))
         return undefined;
     const tokens = JsonPointer.parseUriFragment(ref);
     if (tokens === undefined)
@@ -300,7 +301,7 @@ function park(value, scope, id, pointer, saved) {
     if (!record)
         return;
     for (const key of ANNOTATIONS) {
-        if (!Object.hasOwn(record, key))
+        if (!Rec.has(record, key))
             continue;
         saved.push({ scope, id, pointer: [...pointer], key, value: record[key] });
         delete record[key];
@@ -308,15 +309,16 @@ function park(value, scope, id, pointer, saved) {
     for (const key of NESTED_SINGLE)
         park(record[key], scope, id, [...pointer, key], saved);
     for (const key of NESTED_ARRAY) {
-        if (!Array.isArray(record[key]))
+        const items = record[key];
+        if (!Arr.isArray(items))
             continue;
-        record[key].forEach((item, index) => park(item, scope, id, [...pointer, key, String(index)], saved));
+        Arr.forEach(items, (item, index) => park(item, scope, id, [...pointer, key, String(index)], saved));
     }
     for (const key of NESTED_MAP) {
         const map = asRecord(record[key]);
         if (!map)
             continue;
-        for (const child of Object.keys(map))
+        for (const child of Rec.keys(map))
             park(map[child], scope, id, [...pointer, key, child], saved);
     }
 }
@@ -334,7 +336,7 @@ function restore(converted, saved) {
 function descend(value, pointer) {
     let current = value;
     for (const token of pointer) {
-        if (Array.isArray(current)) {
+        if (Arr.isArray(current)) {
             current = current[Number(token)];
             continue;
         }
@@ -347,7 +349,7 @@ function descend(value, pointer) {
 }
 function restoreRootDefs(document) {
     const visit = (value) => {
-        if (Array.isArray(value)) {
+        if (Arr.isArray(value)) {
             for (const item of value)
                 visit(item);
             return;
@@ -355,19 +357,19 @@ function restoreRootDefs(document) {
         const record = asRecord(value);
         if (!record)
             return;
-        if (typeof record.$ref === "string" && record.$ref.startsWith("#/root-defs/")) {
-            const name = record.$ref.slice("#/root-defs/".length);
+        if (typeof record.$ref === "string" && Str.startsWith("#/root-defs/")(record.$ref)) {
+            const name = Str.slice("#/root-defs/".length)(record.$ref);
             record.$ref = joinPointer("#/$defs", JsonPointer.unescapeToken(name));
         }
-        for (const child of Object.values(record))
+        for (const child of Rec.values(record))
             visit(child);
     };
     visit(document);
 }
 function rewriteLeftoverDefinitionRefs(document) {
-    const names = new Set(Object.keys(asRecord(asRecord(document.components)?.schemas) ?? {}));
+    const names = new Set(Rec.keys(asRecord(asRecord(document.components)?.schemas) ?? {}));
     const visit = (value) => {
-        if (Array.isArray(value)) {
+        if (Arr.isArray(value)) {
             for (const item of value)
                 visit(item);
             return;
@@ -375,14 +377,14 @@ function rewriteLeftoverDefinitionRefs(document) {
         const record = asRecord(value);
         if (!record)
             return;
-        if (typeof record.$ref === "string" && record.$ref.startsWith("#/$defs/")) {
+        if (typeof record.$ref === "string" && Str.startsWith("#/$defs/")(record.$ref)) {
             const tokens = JsonPointer.parseUriFragment(record.$ref);
             const name = tokens?.[0] === "$defs" ? tokens[1] : undefined;
             if (name && names.has(name)) {
                 record.$ref = joinPointer("#/components/schemas", [name, ...(tokens?.slice(2) ?? [])]);
             }
         }
-        for (const child of Object.values(record))
+        for (const child of Rec.values(record))
             visit(child);
     };
     visit(document);
@@ -390,7 +392,7 @@ function rewriteLeftoverDefinitionRefs(document) {
 export function inlineRemaining(document, recursive, hooks) {
     const visiting = new Set();
     const walk = (value, parent, key, pointer = "#") => {
-        if (Array.isArray(value)) {
+        if (Arr.isArray(value)) {
             for (let index = 0; index < value.length; index++) {
                 walk(value[index], value, String(index), joinPointer(pointer, String(index)));
             }
@@ -399,7 +401,7 @@ export function inlineRemaining(document, recursive, hooks) {
         const record = asRecord(value);
         if (!record)
             return;
-        if (typeof record.$ref === "string" && record.$ref.startsWith("#") && parent && key) {
+        if (typeof record.$ref === "string" && Str.startsWith("#")(record.$ref) && parent && key) {
             const ref = record.$ref;
             const name = componentSchemaName(ref);
             if (name && recursive.has(name)) {
@@ -419,7 +421,7 @@ export function inlineRemaining(document, recursive, hooks) {
             hooks?.onDereference?.(pointer, copy, parent, key);
             return;
         }
-        for (const [childKey, child] of Object.entries(record)) {
+        for (const [childKey, child] of Rec.toEntries(record)) {
             walk(child, record, childKey, joinPointer(pointer, childKey));
         }
     };

package/dist/pointer.d.ts

@@ -1,6 +1,9 @@
+import { Option } from "effect";
 export declare function parsePointer(pointer: string, source?: string): string[];
 /** Join pointer tokens without percent-encoding, so `$` stays literal. */
 export declare function joinPointer(base: string, tokens: string | readonly string[]): string;
+/** Reads the member or array element that a JSON Pointer token names (RFC 6901). */
+export declare function childAt(value: unknown, token: string): Option.Option<unknown>;
 export declare function getAt(root: unknown, pointer: string, source?: string): unknown;
 export declare function setAt(root: object, pointer: string, value: unknown): void;
 /** Copy enumerable data, including cycles, and drop non-enumerable parser symbols. */

package/dist/pointer.js

@@ -1,11 +1,11 @@
-import { JsonPointer } from "effect";
+import { Array as Arr, JsonPointer, Option, pipe, Predicate, Record as Rec, String as Str, } from "effect";
 import { invalidPointerFailure, missingPointerFailure } from "./errors.js";
 const unsafeTokens = new Set(["__proto__", "constructor", "prototype"]);
 export function parsePointer(pointer, source = pointer) {
-    const hash = pointer.includes("#") ? pointer.slice(pointer.indexOf("#")) : pointer;
+    const hash = pipe(pointer, Str.indexOf("#"), Option.match({ onNone: () => pointer, onSome: (index) => Str.slice(index)(pointer) }));
     if (hash === "" || hash === "#")
         return [];
-    const fragment = hash.startsWith("#") ? hash : `#${hash}`;
+    const fragment = Str.startsWith("#")(hash) ? hash : `#${hash}`;
     const tokens = JsonPointer.parseUriFragment(fragment) ?? splitPointer(fragment);
     if (tokens === undefined)
         throw invalidPointerFailure(fragment, source);
@@ -13,46 +13,49 @@ export function parsePointer(pointer, source = pointer) {
 }
 /** Effect's URI-fragment parser rejects spaces. JSON Pointer tokens may contain them. */
 function splitPointer(fragment) {
-    const body = fragment.startsWith("#") ? fragment.slice(1) : fragment;
+    const body = Str.startsWith("#")(fragment) ? Str.slice(1)(fragment) : fragment;
     if (body === "")
         return [];
-    if (!body.startsWith("/"))
+    if (!Str.startsWith("/")(body))
         return undefined;
-    return body
-        .slice(1)
-        .split("/")
-        .map((token) => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return pipe(body, Str.slice(1), Str.split("/"), Arr.map((token) => pipe(token, Str.replace(/~1/g, "/"), Str.replace(/~0/g, "~"))));
 }
 /** Join pointer tokens without percent-encoding, so `$` stays literal. */
 export function joinPointer(base, tokens) {
     const parts = typeof tokens === "string" ? [tokens] : tokens;
-    let pointer = base.includes("#") ? base : `${base}#`;
+    let pointer = Str.includes("#")(base) ? base : `${base}#`;
     for (const token of parts)
         pointer += `/${JsonPointer.escapeToken(token)}`;
     return pointer;
 }
+const arrayIndex = /^(?:0|[1-9]\d*)$/;
+/** Reads the member or array element that a JSON Pointer token names (RFC 6901). */
+export function childAt(value, token) {
+    if (Arr.isArray(value)) {
+        return arrayIndex.test(token) ? Arr.get(value, Number(token)) : Option.none();
+    }
+    return Predicate.isObject(value) ? Rec.get(value, token) : Option.none();
+}
 export function getAt(root, pointer, source = pointer) {
     const tokens = parsePointer(pointer, source);
     let current = root;
     for (const token of tokens) {
-        if (current === null || typeof current !== "object") {
+        const child = childAt(current, token);
+        if (Option.isNone(child))
             throw missingPointerFailure(token, source, pointer);
-        }
-        if (!Object.hasOwn(current, token))
-            throw missingPointerFailure(token, source, pointer);
-        current = current[token];
+        current = child.value;
     }
     return current;
 }
 export function setAt(root, pointer, value) {
     const tokens = parsePointer(pointer, pointer);
-    if (tokens.length === 0 || tokens.some((token) => unsafeTokens.has(token)))
+    if (tokens.length === 0 || Arr.some(tokens, (token) => unsafeTokens.has(token)))
         return;
     let current = root;
     for (let index = 0; index < tokens.length - 1; index++) {
         const token = tokens[index];
         const next = current[token];
-        if (next === null || typeof next !== "object" || Array.isArray(next))
+        if (!Predicate.isObject(next))
             current[token] = {};
         current = current[token];
     }
@@ -60,21 +63,22 @@ export function setAt(root, pointer, value) {
 }
 /** Copy enumerable data, including cycles, and drop non-enumerable parser symbols. */
 export function cloneData(value, seen = new Map()) {
-    if (typeof value !== "object" || value === null)
+    if (!Predicate.isObjectOrArray(value))
         return value;
     const cached = seen.get(value);
     if (cached !== undefined)
         return cached;
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         const copy = [];
         seen.set(value, copy);
         for (const item of value)
             copy.push(cloneData(item, seen));
         return copy;
     }
+    const source = value;
     const copy = {};
-    seen.set(value, copy);
-    for (const key of Object.keys(value))
-        copy[key] = cloneData(value[key], seen);
+    seen.set(source, copy);
+    for (const key of Rec.keys(source))
+        copy[key] = cloneData(source[key], seen);
     return copy;
 }

package/dist/run.js

@@ -1,9 +1,9 @@
-import { Array, Cache, Effect, Predicate, Ref, Schema } from "effect";
+import { Array, Cache, Effect, Option, Predicate, Record as Rec, Ref, Schema, String as Str, } from "effect";
 import { ParserFailure, groupFailure, isLeafFailure, missingPointerFailure, syncFailure, } from "./errors.js";
 import { hoistExternalRefs } from "./hoist.js";
 import { loadDocument, makeContext } from "./loader.js";
 import { Options } from "./plugins.js";
-import { cloneData, joinPointer, parsePointer } from "./pointer.js";
+import { childAt, cloneData, joinPointer, parsePointer } from "./pointer.js";
 import { inlineRemaining, runSchemaPipeline } from "./pipeline.js";
 import { isOpenApi3, upgradeOpenApi3_0 } from "./upgraders/3.0-to-3.1.js";
 import { getHash, isHttp, normalizeRef, resolveAgainst, stripHash } from "./url.js";
@@ -112,7 +112,7 @@ function isBundledRef(record) {
     const ref = record.$ref;
     if (typeof ref !== "string" || !isHttp(ref))
         return true;
-    return Object.keys(record).every((key) => referenceKeys.has(key));
+    return Array.every(Rec.keys(record), (key) => referenceKeys.has(key));
 }
 function* externalRefs(node, kept) {
     const seen = new Set();
@@ -128,14 +128,14 @@ function* externalRefs(node, kept) {
         }
         const record = current;
         if (typeof record.$ref === "string" &&
-            !record.$ref.startsWith("#") &&
+            !Str.startsWith("#")(record.$ref) &&
             !kept.has(record.$ref) &&
             isBundledRef(record)) {
             yield record.$ref;
         }
         if (typeof record.externalValue === "string" && !kept.has(record.externalValue))
             yield record.externalValue;
-        stack.push(...Object.values(record));
+        stack.push(...Rec.values(record));
     }
 }
 function absolutize(node, base, ids, keep, kept, seen = new Set()) {
@@ -153,7 +153,7 @@ function absolutize(node, base, ids, keep, kept, seen = new Set()) {
         next = resolveAgainst(base, record.$id);
         ids.set(stripHash(next), record);
     }
-    if (typeof record.$ref === "string" && !record.$ref.startsWith("#")) {
+    if (typeof record.$ref === "string" && !Str.startsWith("#")(record.$ref)) {
         if (keep(record.$ref))
             kept.add(record.$ref);
         else
@@ -164,8 +164,8 @@ function absolutize(node, base, ids, keep, kept, seen = new Set()) {
         ? discriminator.mapping
         : undefined;
     if (mapping) {
-        for (const [key, value] of Object.entries(mapping)) {
-            if (typeof value !== "string" || value.startsWith("#"))
+        for (const [key, value] of Rec.toEntries(mapping)) {
+            if (typeof value !== "string" || Str.startsWith("#")(value))
                 continue;
             if (keep(value))
                 kept.add(value);
@@ -179,7 +179,7 @@ function absolutize(node, base, ids, keep, kept, seen = new Set()) {
         else
             record.externalValue = resolveAgainst(base, record.externalValue);
     }
-    for (const [key, value] of Object.entries(record)) {
+    for (const [key, value] of Rec.toEntries(record)) {
         if (key === "$ref" || key === "$id")
             continue;
         absolutize(value, next, ids, keep, kept, seen);
@@ -193,7 +193,7 @@ function rewriteIdRefs(root, ids) {
             pointers.set(url, pointer);
     }
     walkRecords(root, (record) => {
-        if (typeof record.$ref !== "string" || record.$ref.startsWith("#"))
+        if (typeof record.$ref !== "string" || Str.startsWith("#")(record.$ref))
             return;
         const url = stripHash(record.$ref);
         const pointer = pointers.get(url);
@@ -225,8 +225,8 @@ function rewriteMappings(root, placed, ids) {
             : undefined;
         if (!mapping)
             return;
-        for (const [key, value] of Object.entries(mapping)) {
-            if (typeof value !== "string" || value.startsWith("#"))
+        for (const [key, value] of Rec.toEntries(mapping)) {
+            if (typeof value !== "string" || Str.startsWith("#")(value))
                 continue;
             const url = stripHash(value);
             const hash = getHash(value);
@@ -242,7 +242,7 @@ function rewriteMappings(root, placed, ids) {
 function findPointer(root, target, pointer = "#", seen = new Set()) {
     if (root === target)
         return pointer;
-    if (typeof root !== "object" || root === null || seen.has(root))
+    if (!Predicate.isObjectOrArray(root) || seen.has(root))
         return undefined;
     seen.add(root);
     if (Array.isArray(root)) {
@@ -253,7 +253,7 @@ function findPointer(root, target, pointer = "#", seen = new Set()) {
         }
         return undefined;
     }
-    for (const [key, value] of Object.entries(root)) {
+    for (const [key, value] of Rec.toEntries(root)) {
         const found = findPointer(value, target, joinPointer(pointer, key), seen);
         if (found)
             return found;
@@ -271,7 +271,7 @@ function walkRecords(node, visit, seen = new Set()) {
     }
     const record = node;
     visit(record);
-    for (const value of Object.values(record))
+    for (const value of Rec.values(record))
         walkRecords(value, visit, seen);
 }
 const inlineExternalValues = Effect.fnUntraced(function* (root, cache, keep, kept, options, failures, recorded) {
@@ -304,10 +304,10 @@ function valueAt(document, hash) {
     const tokens = parsePointer(hash);
     let current = document;
     for (const token of tokens) {
-        if (typeof current !== "object" || current === null || !Object.hasOwn(current, token)) {
+        const child = childAt(current, token);
+        if (Option.isNone(child))
             throw missingPointerFailure(token, hash);
-        }
-        current = current[token];
+        current = child.value;
     }
     return current;
 }

package/dist/schemas/3.1/callback.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Schema, String as Str } from "effect";
 import { openApiMap } from "./object.js";
 import { OpenApiPathItem } from "./path-item.js";
-export const OpenApiCallback = openApiMap(Schema.String.check(Schema.makeFilter((key) => !key.startsWith("x-"))), Schema.suspend(() => OpenApiPathItem));
+export const OpenApiCallback = openApiMap(Schema.String.check(Schema.makeFilter((key) => !Str.startsWith("x-")(key))), Schema.suspend(() => OpenApiPathItem));

package/dist/schemas/3.1/example.js

@@ -1,10 +1,10 @@
-import { Schema } from "effect";
+import { Record as Rec, Schema } from "effect";
 import { openApiObject } from "./object.js";
 export const OpenApiExample = openApiObject({
     summary: Schema.optionalKey(Schema.String),
     description: Schema.optionalKey(Schema.String),
     value: Schema.optionalKey(Schema.Unknown),
     externalValue: Schema.optionalKey(Schema.String),
-}).check(Schema.makeFilter((value) => Object.hasOwn(value, "value") && value.externalValue !== undefined
+}).check(Schema.makeFilter((value) => Rec.has(value, "value") && value.externalValue !== undefined
     ? "Example value and externalValue are mutually exclusive"
     : undefined));

package/dist/schemas/3.1/header.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Record as Rec, Schema } from "effect";
 import { OpenApiExample } from "./example.js";
 import { OpenApiMediaType } from "./media-type.js";
 import { openApiObject } from "./object.js";
@@ -19,10 +19,10 @@ export const OpenApiHeader = openApiObject(fields).check(Schema.makeFilter((valu
     if ((value.schema === undefined) === (value.content === undefined)) {
         return "A header must have exactly one of schema or content";
     }
-    if (value.content !== undefined && Object.keys(value.content).length !== 1) {
+    if (value.content !== undefined && Rec.size(value.content) !== 1) {
         return "Header content must contain exactly one media type";
     }
-    if (Object.hasOwn(value, "example") && value.examples !== undefined) {
+    if (Rec.has(value, "example") && value.examples !== undefined) {
         return "Header example and examples are mutually exclusive";
     }
     return undefined;