polen 0.11.0-next.24 → 0.11.0-next.25

package/build/lib/document/document.d.ts

@@ -33,7 +33,7 @@ export declare class VersionNotFoundInDocumentError extends VersionNotFoundInDoc
 export declare const Document: S.Union<[S.TaggedStruct<"DocumentUnversioned", {
     document: typeof S.String;
 }>, S.TaggedStruct<"DocumentVersioned", {
-    versionDocuments: S.HashMap<S.Union<[S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>, S.HashSet<S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>>]>, typeof S.String>;
+    versionDocuments: S.HashMap<S.Union<[typeof VersionCoverage.VersionCoverageUnversioned, S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>, S.HashSet<S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>>]>, typeof S.String>;
 }>]>;
 export type Document = typeof Document.Type;
 export declare const is: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions | number) => u is {
@@ -41,46 +41,52 @@ export declare const is: (u: unknown, overrideOptions?: import("effect/SchemaAST
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 };
 export declare const decode: (i: {
     readonly _tag: "DocumentUnversioned";
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[], string])[];
+    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[] | {
+        readonly _tag: "VersionCoverageUnversioned";
+    }, string])[];
 }, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly _tag: "DocumentUnversioned";
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 }, import("effect/ParseResult").ParseError, never>;
 export declare const decodeSync: (i: {
     readonly _tag: "DocumentUnversioned";
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[], string])[];
+    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[] | {
+        readonly _tag: "VersionCoverageUnversioned";
+    }, string])[];
 }, overrideOptions?: import("effect/SchemaAST").ParseOptions) => {
     readonly _tag: "DocumentUnversioned";
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 };
 export declare const encode: (a: {
     readonly _tag: "DocumentUnversioned";
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: import("effect/HashMap").HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 }, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly _tag: "DocumentUnversioned";
     readonly document: string;
 } | {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[], string])[];
+    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[] | {
+        readonly _tag: "VersionCoverageUnversioned";
+    }, string])[];
 }, import("effect/ParseResult").ParseError, never>;
 /**
  * Resolve document content for a given version coverage.

package/build/lib/document/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/lib/document/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAQ,MAAM,EAAU,MAAM,QAAQ,CAAA;;;;AAQ7C;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,kCAAiD;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,oCAAmD;IACrG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;AAML;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;IAGpB,CAAA;AAMD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAM3C,eAAO,MAAM,EAAE;;;;;;CAAiB,CAAA;AAMhC,eAAO,MAAM,MAAM;;;;;;;;;;;;kDAAqB,CAAA;AACxC,eAAO,MAAM,UAAU;;;;;;;;;;;;CAAyB,CAAA;AAChD,eAAO,MAAM,MAAM;;;;;;;;;;;;kDAAqB,CAAA;AAMxC;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAU,QAAQ,EAClB,kBAAkB,eAAe,CAAC,eAAe,GAAG,IAAI,KACvD,MAsBF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,QAAQ,EAClB,UAAU,OAAO,CAAC,OAAO,EACzB,kBAAkB,eAAe,CAAC,eAAe,GAAG,IAAI,KACvD,MAAM,CAAC,MAAM,CACd;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAA;CAAE,EACzC,4BAA4B,GAC5B,8BAA8B,GAC9B,OAAO,CAAC,6BAA6B,GACrC,OAAO,CAAC,iBAAiB,CAiD5B,CAAA"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/lib/document/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAQ,MAAM,EAAU,MAAM,QAAQ,CAAA;;;;AAQ7C;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,kCAAiD;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,8BAA+B,SAAQ,oCAAmD;IACrG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;CAAG;AAML;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;IAGpB,CAAA;AAMD,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAM3C,eAAO,MAAM,EAAE;;;;;;CAAiB,CAAA;AAMhC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;kDAAqB,CAAA;AACxC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;CAAyB,CAAA;AAChD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;kDAAqB,CAAA;AAMxC;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAU,QAAQ,EAClB,kBAAkB,eAAe,CAAC,eAAe,GAAG,IAAI,KACvD,MAsBF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,QAAQ,EAClB,UAAU,OAAO,CAAC,OAAO,EACzB,kBAAkB,eAAe,CAAC,eAAe,GAAG,IAAI,KACvD,MAAM,CAAC,MAAM,CACd;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAA;CAAE,EACzC,4BAA4B,GAC5B,8BAA8B,GAC9B,OAAO,CAAC,6BAA6B,GACrC,OAAO,CAAC,iBAAiB,CAiD5B,CAAA"}

package/build/lib/document/versioned.d.ts

@@ -1,4 +1,5 @@
 import { S } from '#lib/kit-temp/effect';
+import { VersionCoverage } from '#lib/version-coverage';
 import { Version } from '#lib/version/$';
 import { HashMap, Option } from 'effect';
 export declare const DocumentVersioned: S.TaggedStruct<"DocumentVersioned", {
@@ -8,40 +9,46 @@ export declare const DocumentVersioned: S.TaggedStruct<"DocumentVersioned", {
      * - Single version → document (e.g., v1 → "query for v1")
      * - Version set → document (e.g., {v2,v3} → "shared query")
      */
-    versionDocuments: S.HashMap<S.Union<[S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>, S.HashSet<S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>>]>, typeof S.String>;
+    versionDocuments: S.HashMap<S.Union<[typeof VersionCoverage.VersionCoverageUnversioned, S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>, S.HashSet<S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof Version.IntegerVersion.Integer, typeof Version.SemverVersion.Semver, typeof Version.DateVersion.Date, typeof Version.CustomVersion.Custom]>, never>>]>, typeof S.String>;
 }>;
 export type DocumentVersioned = typeof DocumentVersioned.Type;
 export declare const make: (props: {
     readonly _tag?: "DocumentVersioned";
-    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 }, options?: S.MakeOptions) => {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 };
 export declare const is: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions | number) => u is {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 };
 export declare const decode: (i: {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[], string])[];
+    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[] | {
+        readonly _tag: "VersionCoverageUnversioned";
+    }, string])[];
 }, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 }, import("effect/ParseResult").ParseError, never>;
 export declare const decodeSync: (i: {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[], string])[];
+    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[] | {
+        readonly _tag: "VersionCoverageUnversioned";
+    }, string])[];
 }, overrideOptions?: import("effect/SchemaAST").ParseOptions) => {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 };
 export declare const encode: (a: {
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
+    readonly versionDocuments: HashMap.HashMap<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver | VersionCoverage.VersionCoverageUnversioned | import("effect/HashSet").HashSet<Version.CustomVersion.Custom | Version.DateVersion.Date | Version.IntegerVersion.Integer | Version.SemverVersion.Semver>, string>;
 }, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
     readonly _tag: "DocumentVersioned";
-    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[], string])[];
+    readonly versionDocuments: readonly (readonly [string | number | readonly (string | number)[] | {
+        readonly _tag: "VersionCoverageUnversioned";
+    }, string])[];
 }, import("effect/ParseResult").ParseError, never>;
 /**
  * Get document for a specific version

package/build/lib/document/versioned.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"versioned.d.ts","sourceRoot":"","sources":["../../../src/lib/document/versioned.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAExC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAMxC,eAAO,MAAM,iBAAiB;IAC5B;;;;;OAKG;;EAKH,CAAA;AAMF,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAM7D,eAAO,MAAM,IAAI;;;;;;CAAyB,CAAA;AAM1C,eAAO,MAAM,EAAE;;;CAA0B,CAAA;AAMzC,eAAO,MAAM,MAAM;;;;;;kDAA8B,CAAA;AACjD,eAAO,MAAM,UAAU;;;;;;CAAkC,CAAA;AACzD,eAAO,MAAM,MAAM;;;;;;kDAA8B,CAAA;AAMjD;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,iBAAiB,EACtB,SAAS,OAAO,CAAC,OAAO,KACvB,MAAM,CAAC,MAAM,CAAC,MAAM,CAetB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,iBAAiB,KAAG,OAAO,CAAC,OAAO,EAQtE,CAAA;AACD;;GAEG;AACH,eAAO,MAAM,iCAAiC,GAAI,KAAK,iBAAiB,KAAG,MAe1E,CAAA"}
+{"version":3,"file":"versioned.d.ts","sourceRoot":"","sources":["../../../src/lib/document/versioned.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAMxC,eAAO,MAAM,iBAAiB;IAC5B;;;;;OAKG;;EAKH,CAAA;AAMF,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAM7D,eAAO,MAAM,IAAI;;;;;;CAAyB,CAAA;AAM1C,eAAO,MAAM,EAAE;;;CAA0B,CAAA;AAMzC,eAAO,MAAM,MAAM;;;;;;;;kDAA8B,CAAA;AACjD,eAAO,MAAM,UAAU;;;;;;;;CAAkC,CAAA;AACzD,eAAO,MAAM,MAAM;;;;;;;;kDAA8B,CAAA;AAMjD;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,iBAAiB,EACtB,SAAS,OAAO,CAAC,OAAO,KACvB,MAAM,CAAC,MAAM,CAAC,MAAM,CAetB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,iBAAiB,KAAG,OAAO,CAAC,OAAO,EAQtE,CAAA;AACD;;GAEG;AACH,eAAO,MAAM,iCAAiC,GAAI,KAAK,iBAAiB,KAAG,MAe1E,CAAA"}

package/build/lib/grafaid/schema/KindMap/_.d.ts

@@ -15,5 +15,5 @@ export declare const Name: {
 export type KindName = keyof KindMap[`list`];
 export declare const getKindMap: (schema: Schema) => KindMap;
 export declare const hasCustomScalars: (typeMapByKind: KindMap) => boolean;
-export declare const getInterfaceImplementors: (typeMap: KindMap, interfaceTypeSearch: GraphQLInterfaceType) => (GraphQLInterfaceType | Type.Object<any, any>)[];
+export declare const getInterfaceImplementors: (typeMap: KindMap, interfaceTypeSearch: GraphQLInterfaceType) => (Type.Object<any, any> | GraphQLInterfaceType)[];
 //# sourceMappingURL=_.d.ts.map

package/build/lib/graphql-path/$$.d.ts

@@ -22,21 +22,15 @@
  * const encoded = GraphQLPath.Definition.encode(userNameFieldPath) // "User.name"
  * const decoded = GraphQLPath.Definition.decode("User.name") // field definition path
  *
- * // Create a query path
- * const queryPath = GraphQLPath.Query.builder()
- *   .type('User')
- *   .field('posts')
- *   .type('Post')
- *   .field('author')
- *   .type('User')
- *   .field('name')
- *   .build()
- *
- * // Encode/decode query paths
- * const encodedQuery = GraphQLPath.Query.encode(queryPath) // "User.posts.Post.author.User.name"
- * const decodedQuery = GraphQLPath.Query.decode("User.posts.Post.author") // query path
+ * // Decode a query path from a string
+ * const queryPath = GraphQLPath.Query.decode("User.posts.Post.author.User.name")
+ * // Returns array of segments: [TypeSegment, FieldSegment, TypeSegment, FieldSegment, ...]
+ *
+ * // Encode query path segments to a string
+ * const encoded = GraphQLPath.Query.encode(queryPath) // "User.posts.Post.author.User.name"
  * ```
  */
 export * as Definition from './definition.js';
 export * as Query from './query.js';
+export * as Schema from './schema.js';
 //# sourceMappingURL=$$.d.ts.map

package/build/lib/graphql-path/$$.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"$$.d.ts","sourceRoot":"","sources":["../../../src/lib/graphql-path/$$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA"}
+{"version":3,"file":"$$.d.ts","sourceRoot":"","sources":["../../../src/lib/graphql-path/$$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA"}

package/build/lib/graphql-path/$$.js

@@ -22,21 +22,15 @@
  * const encoded = GraphQLPath.Definition.encode(userNameFieldPath) // "User.name"
  * const decoded = GraphQLPath.Definition.decode("User.name") // field definition path
  *
- * // Create a query path
- * const queryPath = GraphQLPath.Query.builder()
- *   .type('User')
- *   .field('posts')
- *   .type('Post')
- *   .field('author')
- *   .type('User')
- *   .field('name')
- *   .build()
- *
- * // Encode/decode query paths
- * const encodedQuery = GraphQLPath.Query.encode(queryPath) // "User.posts.Post.author.User.name"
- * const decodedQuery = GraphQLPath.Query.decode("User.posts.Post.author") // query path
+ * // Decode a query path from a string
+ * const queryPath = GraphQLPath.Query.decode("User.posts.Post.author.User.name")
+ * // Returns array of segments: [TypeSegment, FieldSegment, TypeSegment, FieldSegment, ...]
+ *
+ * // Encode query path segments to a string
+ * const encoded = GraphQLPath.Query.encode(queryPath) // "User.posts.Post.author.User.name"
  * ```
  */
 export * as Definition from './definition.js';
 export * as Query from './query.js';
+export * as Schema from './schema.js';
 //# sourceMappingURL=$$.js.map

package/build/lib/graphql-path/$$.js.map

@@ -1 +1 @@
-{"version":3,"file":"$$.js","sourceRoot":"","sources":["../../../src/lib/graphql-path/$$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA"}
+{"version":3,"file":"$$.js","sourceRoot":"","sources":["../../../src/lib/graphql-path/$$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA"}

package/build/lib/graphql-path/definition.d.ts

@@ -1,152 +1,162 @@
 /**
- * Definition path operations
- */
-import type { ArgumentSegment, FieldSegment, TypeSegment } from '#lib/graphql-path/types';
-/**
- * Encode a definition path to a human-readable expression string
- *
- * @param path - The definition path to encode
- * @returns A string expression representation
- * @example
- * encode(field('User', 'name')) // 'User.name'
- * encode(argument('User', 'posts', 'limit')) // 'User.posts(limit)'
- */
-export declare const encode: (path: DefinitionPath) => string;
+ * Definition path operations using Effect Schema transforms
+ */
+import { S } from '#lib/kit-temp/effect';
+/**
+ * Type definition path codec
+ * Encoded: "User"
+ * Decoded: [{ _tag: 'TypeSegment', type: 'User' }]
+ */
+export declare const TypeDefinitionPath: S.transformOrFail<typeof S.String, S.Tuple<[S.TaggedStruct<"TypeSegment", {
+    type: typeof S.String;
+}>]>, never>;
+/**
+ * Field definition path codec
+ * Encoded: "User.name"
+ * Decoded: [{ _tag: 'TypeSegment', type: 'User' }, { _tag: 'FieldSegment', field: 'name' }]
+ */
+export declare const FieldDefinitionPath: S.transformOrFail<typeof S.String, S.Tuple2<S.TaggedStruct<"TypeSegment", {
+    type: typeof S.String;
+}>, S.TaggedStruct<"FieldSegment", {
+    field: typeof S.String;
+}>>, never>;
+/**
+ * Argument definition path codec
+ * Encoded: "User.posts(limit)"
+ * Decoded: [{ _tag: 'TypeSegment', type: 'User' }, { _tag: 'FieldSegment', field: 'posts' }, { _tag: 'ArgumentSegment', argument: 'limit' }]
+ */
+export declare const ArgumentDefinitionPath: S.transformOrFail<typeof S.String, S.Tuple<[S.TaggedStruct<"TypeSegment", {
+    type: typeof S.String;
+}>, S.TaggedStruct<"FieldSegment", {
+    field: typeof S.String;
+}>, S.TaggedStruct<"ArgumentSegment", {
+    argument: typeof S.String;
+}>]>, never>;
+/**
+ * Union of all definition paths
+ * Automatically determines the correct path type from the string format
+ */
+export declare const DefinitionPath: S.Union<[S.transformOrFail<typeof S.String, S.Tuple<[S.TaggedStruct<"TypeSegment", {
+    type: typeof S.String;
+}>, S.TaggedStruct<"FieldSegment", {
+    field: typeof S.String;
+}>, S.TaggedStruct<"ArgumentSegment", {
+    argument: typeof S.String;
+}>]>, never>, S.transformOrFail<typeof S.String, S.Tuple2<S.TaggedStruct<"TypeSegment", {
+    type: typeof S.String;
+}>, S.TaggedStruct<"FieldSegment", {
+    field: typeof S.String;
+}>>, never>, S.transformOrFail<typeof S.String, S.Tuple<[S.TaggedStruct<"TypeSegment", {
+    type: typeof S.String;
+}>]>, never>]>;
+export type TypeDefinitionPath = S.Schema.Type<typeof TypeDefinitionPath>;
+export type FieldDefinitionPath = S.Schema.Type<typeof FieldDefinitionPath>;
+export type ArgumentDefinitionPath = S.Schema.Type<typeof ArgumentDefinitionPath>;
+export type DefinitionPath = S.Schema.Type<typeof DefinitionPath>;
 /**
  * Decode a string expression into a definition path
- *
  * @param expression - The string expression to decode
- * @returns The decoded definition path or null if invalid
+ * @returns The decoded definition path
  * @example
  * decode('User') // type definition path
  * decode('User.name') // field definition path
  * decode('User.posts(limit)') // argument definition path
  */
-export declare const decode: (expression: string) => DefinitionPath | null;
+export declare const decodeSync: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions) => readonly [{
+    readonly _tag: "TypeSegment";
+    readonly type: string;
+}] | readonly [{
+    readonly _tag: "TypeSegment";
+    readonly type: string;
+}, {
+    readonly _tag: "FieldSegment";
+    readonly field: string;
+}] | readonly [{
+    readonly _tag: "TypeSegment";
+    readonly type: string;
+}, {
+    readonly _tag: "FieldSegment";
+    readonly field: string;
+}, {
+    readonly _tag: "ArgumentSegment";
+    readonly argument: string;
+}];
+/**
+ * Encode a definition path to a string expression
+ * @param path - The definition path to encode
+ * @returns A string expression representation
+ * @example
+ * encode([{ _tag: 'TypeSegment', type: 'User' }]) // 'User'
+ * encode([{ _tag: 'TypeSegment', type: 'User' }, { _tag: 'FieldSegment', field: 'name' }]) // 'User.name'
+ */
+export declare const encodeSync: (a: readonly [{
+    readonly _tag: "TypeSegment";
+    readonly type: string;
+}] | readonly [{
+    readonly _tag: "TypeSegment";
+    readonly type: string;
+}, {
+    readonly _tag: "FieldSegment";
+    readonly field: string;
+}] | readonly [{
+    readonly _tag: "TypeSegment";
+    readonly type: string;
+}, {
+    readonly _tag: "FieldSegment";
+    readonly field: string;
+}, {
+    readonly _tag: "ArgumentSegment";
+    readonly argument: string;
+}], overrideOptions?: import("effect/SchemaAST").ParseOptions) => string;
 /**
  * Extract the type name from any definition path
- *
  * @param path - The definition path
  * @returns The type name
- * @example getType([{ kind: 'type', type: 'User' }]) // 'User'
  */
 export declare const getType: (path: DefinitionPath) => string;
 /**
  * Extract the field name from a field or argument definition path
- *
  * @param path - The field or argument definition path
  * @returns The field name
- * @example getField([{ kind: 'type', type: 'User' }, { kind: 'field', field: 'name' }]) // 'name'
  */
 export declare const getField: (path: FieldDefinitionPath | ArgumentDefinitionPath) => string;
 /**
  * Extract the argument name from an argument definition path
- *
  * @param path - The argument definition path
  * @returns The argument name
- * @example getArgument([{ kind: 'type', type: 'User' }, { kind: 'field', field: 'posts' }, { kind: 'argument', argument: 'limit' }]) // 'limit'
  */
 export declare const getArgument: (path: ArgumentDefinitionPath) => string;
-/**
- * Parse field path like "User.email" into type and field names
- */
-export declare const parseFieldPath: (path?: string) => {
-    typeName: string | null;
-    fieldName: string | null;
-};
-/**
- * Definition paths - direct paths to schema definition elements
- * These represent the "address" of a specific schema element
- */
-export type DefinitionPath = TypeDefinitionPath | FieldDefinitionPath | ArgumentDefinitionPath;
-/**
- * Path to a type definition
- * @example [{ kind: 'type', type: 'User' }]
- */
-export type TypeDefinitionPath = [TypeSegment];
-/**
- * Path to a field definition (type + field)
- * @example [{ kind: 'type', type: 'User' }, { kind: 'field', field: 'name' }]
- */
-export type FieldDefinitionPath = [TypeSegment, FieldSegment];
-/**
- * Path to an argument definition (type + field + argument)
- * @example [{ kind: 'type', type: 'User' }, { kind: 'field', field: 'posts' }, { kind: 'argument', argument: 'limit' }]
- */
-export type ArgumentDefinitionPath = [TypeSegment, FieldSegment, ArgumentSegment];
 /**
  * Type guard to check if a path is a type definition path
- *
- * @param path - The path to check
- * @returns True if the path is a type definition path
  */
 export declare const isTypeDefinitionPath: (path: DefinitionPath) => path is TypeDefinitionPath;
 /**
  * Type guard to check if a path is a field definition path
- *
- * @param path - The path to check
- * @returns True if the path is a field definition path
  */
 export declare const isFieldDefinitionPath: (path: DefinitionPath) => path is FieldDefinitionPath;
 /**
  * Type guard to check if a path is an argument definition path
- *
- * @param path - The path to check
- * @returns True if the path is an argument definition path
  */
 export declare const isArgumentDefinitionPath: (path: DefinitionPath) => path is ArgumentDefinitionPath;
-/**
- * Create a path to a type definition
- *
- * @param type - The type name
- * @returns A type definition path
- * @example createTypeDefinitionPath('User') // [{ kind: 'type', type: 'User' }]
- */
-export declare const createTypeDefinitionPath: (type: string) => TypeDefinitionPath;
-/**
- * Create a path to a field definition
- *
- * @param type - The type name
- * @param field - The field name
- * @returns A field definition path
- * @example createFieldDefinitionPath('User', 'name') // [{ kind: 'type', type: 'User' }, { kind: 'field', field: 'name' }]
- */
-export declare const createFieldDefinitionPath: (type: string, field: string) => FieldDefinitionPath;
-/**
- * Create a path to an argument definition
- *
- * @param type - The type name
- * @param field - The field name
- * @param argument - The argument name
- * @returns An argument definition path
- * @example createArgumentDefinitionPath('User', 'posts', 'limit') // [{ kind: 'type', type: 'User' }, { kind: 'field', field: 'posts' }, { kind: 'argument', argument: 'limit' }]
- */
-export declare const createArgumentDefinitionPath: (type: string, field: string, argument: string) => ArgumentDefinitionPath;
 /**
  * Create a type definition path
- *
  * @param type - The type name
  * @returns A type definition path
- * @example type('User') // [{ kind: 'type', type: 'User' }]
  */
-export declare const type: (type: string) => TypeDefinitionPath;
+export declare const type: (typeName: string) => TypeDefinitionPath;
 /**
  * Create a field definition path
- *
  * @param type - The type name
  * @param field - The field name
  * @returns A field definition path
- * @example field('User', 'name') // [{ kind: 'type', type: 'User' }, { kind: 'field', field: 'name' }]
  */
-export declare const field: (type: string, field: string) => FieldDefinitionPath;
+export declare const field: (typeName: string, fieldName: string) => FieldDefinitionPath;
 /**
  * Create an argument definition path
- *
  * @param type - The type name
  * @param field - The field name
  * @param argument - The argument name
  * @returns An argument definition path
- * @example argument('User', 'posts', 'limit') // [{ kind: 'type', type: 'User' }, { kind: 'field', field: 'posts' }, { kind: 'argument', argument: 'limit' }]
  */
-export declare const argument: (type: string, field: string, argument: string) => ArgumentDefinitionPath;
+export declare const argument: (typeName: string, fieldName: string, argumentName: string) => ArgumentDefinitionPath;
 //# sourceMappingURL=definition.d.ts.map

package/build/lib/graphql-path/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/lib/graphql-path/definition.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAEzF;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GAAI,MAAM,cAAc,KAAG,MAS7C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,YAAY,MAAM,KAAG,cAAc,GAAG,IAwB5D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,cAAc,KAAG,MAE9C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,mBAAmB,GAAG,sBAAsB,KAAG,MAE7E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,sBAAsB,KAAG,MAE1D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG;IAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CAYjG,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,mBAAmB,GACnB,sBAAsB,CAAA;AAE1B;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,WAAW,CAAC,CAAA;AAE9C;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,WAAW,EAAE,YAAY,CAAC,CAAA;AAE7D;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,WAAW,EAAE,YAAY,EAAE,eAAe,CAAC,CAAA;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,cAAc,KAAG,IAAI,IAAI,kBAEnE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM,cAAc,KAAG,IAAI,IAAI,mBAEpE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,cAAc,KAAG,IAAI,IAAI,sBAEvE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,MAAM,KAAG,kBAEvD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,mBAEvE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GACvC,MAAM,MAAM,EACZ,OAAO,MAAM,EACb,UAAU,MAAM,KACf,sBAEF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,SAxC8B,MAAM,KAAG,kBAwCZ,CAAA;AAE5C;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,SAtC8B,MAAM,SAAS,MAAM,KAAG,mBAsC1B,CAAA;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,SAnCb,MAAM,SACL,MAAM,YACH,MAAM,KACf,sBAgCiD,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/lib/graphql-path/definition.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAgBxC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;YAe7B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;WAmB9B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;YAoBjC,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;cAOzB,CAAA;AAMF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACzE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC3E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACjF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,cAAc,CAAC,CAAA;AAMjE;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;EAAsC,CAAA;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;wEAA+B,CAAA;AAMtD;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,cAAc,KAAG,MAE9C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,mBAAmB,GAAG,sBAAsB,KAAG,MAE7E,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,sBAAsB,KAAG,MAE1D,CAAA;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,cAAc,KAAG,IAAI,IAAI,kBAEnE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM,cAAc,KAAG,IAAI,IAAI,mBAEpE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,cAAc,KAAG,IAAI,IAAI,sBAOvE,CAAA;AAMD;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,UAAU,MAAM,KAAG,kBAEvC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAU,MAAM,EAAE,WAAW,MAAM,KAAG,mBAE3D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAU,MAAM,EAAE,WAAW,MAAM,EAAE,cAAc,MAAM,KAAG,sBAMpF,CAAA"}