polen 0.11.0-next.23 → 0.11.0-next.25

package/build/api/schema/augmentations/config.d.ts

@@ -0,0 +1,24 @@
+import { S } from '#lib/kit-temp/effect';
+export declare const AugmentationConfig: S.Struct<{
+    on: 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>]>;
+    placement: S.Enums<{
+        readonly before: "before";
+        readonly after: "after";
+        readonly over: "over";
+    }>;
+    content: typeof S.String;
+}>;
+export type AugmentationConfig = S.Schema.Type<typeof AugmentationConfig>;
+//# sourceMappingURL=config.d.ts.map

package/build/api/schema/augmentations/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/api/schema/augmentations/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAExC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;EAI7B,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/build/api/schema/augmentations/config.js

@@ -0,0 +1,9 @@
+import { Placement } from '#api/schema/augmentations/placement';
+import { GraphQLPath } from '#lib/graphql-path';
+import { S } from '#lib/kit-temp/effect';
+export const AugmentationConfig = S.Struct({
+    on: GraphQLPath.Definition.DefinitionPath,
+    placement: Placement,
+    content: S.String,
+});
+//# sourceMappingURL=config.js.map

package/build/api/schema/augmentations/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../src/api/schema/augmentations/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAExC,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,EAAE,EAAE,WAAW,CAAC,UAAU,CAAC,cAAc;IACzC,SAAS,EAAE,SAAS;IACpB,OAAO,EAAE,CAAC,CAAC,MAAM;CAClB,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/diagnostic.d.ts

@@ -0,0 +1,67 @@
+import { S } from '#lib/kit-temp/effect';
+export * from './duplicate-version.js';
+export * from './invalid-path.js';
+export * from './version-mismatch.js';
+export declare const Diagnostic: S.Union<[S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["invalid-path"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    path: typeof S.String;
+    version: S.optional<S.Union<[S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof import("../../../../lib/version/integer.js").Integer, typeof import("../../../../lib/version/semver.js").Semver, typeof import("../../../../lib/version/date.js").Date, typeof import("../../../../lib/version/custom.js").Custom]>, never>, typeof S.Null]>>;
+    error: typeof S.String;
+}>, S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["version-mismatch"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    path: typeof S.String;
+    requestedVersion: S.transformOrFail<S.Union<[typeof S.String, typeof S.Number]>, S.Union<[typeof import("../../../../lib/version/integer.js").Integer, typeof import("../../../../lib/version/semver.js").Semver, typeof import("../../../../lib/version/date.js").Date, typeof import("../../../../lib/version/custom.js").Custom]>, never>;
+    availableVersions: S.Array$<typeof S.String>;
+}>, S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["duplicate-version"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    version: typeof S.String;
+    firstPath: typeof S.String;
+    duplicatePath: typeof S.String;
+}>]>;
+export type Diagnostic = S.Schema.Type<typeof Diagnostic>;
+//# sourceMappingURL=diagnostic.d.ts.map

package/build/api/schema/augmentations/diagnostics/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/diagnostic.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAGxC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AAErC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/diagnostic.js

@@ -0,0 +1,13 @@
+import { DiagnosticDuplicateVersion } from '#api/schema/augmentations/diagnostics/duplicate-version';
+import { DiagnosticInvalidPath } from '#api/schema/augmentations/diagnostics/invalid-path';
+import { DiagnosticVersionMismatch } from '#api/schema/augmentations/diagnostics/version-mismatch';
+import { S } from '#lib/kit-temp/effect';
+// Re-export all individual diagnostics
+export * from './duplicate-version.js';
+export * from './invalid-path.js';
+export * from './version-mismatch.js';
+export const Diagnostic = S.Union(DiagnosticInvalidPath, DiagnosticVersionMismatch, DiagnosticDuplicateVersion).annotations({
+    identifier: 'AugmentationsDiagnostic',
+    description: 'All diagnostics that can be generated for schema augmentations',
+});
+//# sourceMappingURL=diagnostic.js.map

package/build/api/schema/augmentations/diagnostics/diagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,yDAAyD,CAAA;AACpG,OAAO,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAA;AAC1F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wDAAwD,CAAA;AAClG,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAExC,uCAAuC;AACvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AAErC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAC/B,qBAAqB,EACrB,yBAAyB,EACzB,0BAA0B,CAC3B,CAAC,WAAW,CAAC;IACZ,UAAU,EAAE,yBAAyB;IACrC,WAAW,EAAE,gEAAgE;CAC9E,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/duplicate-version.d.ts

@@ -0,0 +1,45 @@
+import { S } from '#lib/kit-temp/effect';
+export declare const DiagnosticDuplicateVersion: S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["duplicate-version"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    version: typeof S.String;
+    firstPath: typeof S.String;
+    duplicatePath: typeof S.String;
+}>;
+export declare const makeDiagnosticDuplicateVersion: import("#lib/kit-temp/effect").EffectKit.Schema.ConstructorUsingOmitLiteral1Algo<S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["duplicate-version"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    version: typeof S.String;
+    firstPath: typeof S.String;
+    duplicatePath: typeof S.String;
+}>>;
+export type DiagnosticDuplicateVersion = S.Schema.Type<typeof DiagnosticDuplicateVersion>;
+//# sourceMappingURL=duplicate-version.d.ts.map

package/build/api/schema/augmentations/diagnostics/duplicate-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-version.d.ts","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/duplicate-version.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAExC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;EAYrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;GAAoD,CAAA;AAE/F,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/duplicate-version.js

@@ -0,0 +1,17 @@
+import { Diagnostic } from '#lib/diagnostic/$';
+import { S } from '#lib/kit-temp/effect';
+export const DiagnosticDuplicateVersion = Diagnostic.create({
+    source: 'schema-augmentations',
+    name: 'duplicate-version',
+    severity: 'error',
+    context: {
+        version: S.String,
+        firstPath: S.String,
+        duplicatePath: S.String,
+    },
+}).annotations({
+    identifier: 'DiagnosticDuplicateVersion',
+    description: 'Same version is specified multiple times in augmentation configuration',
+});
+export const makeDiagnosticDuplicateVersion = Diagnostic.createMake(DiagnosticDuplicateVersion);
+//# sourceMappingURL=duplicate-version.js.map

package/build/api/schema/augmentations/diagnostics/duplicate-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-version.js","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/duplicate-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAExC,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAAC,MAAM,CAAC;IAC1D,MAAM,EAAE,sBAAsB;IAC9B,IAAI,EAAE,mBAAmB;IACzB,QAAQ,EAAE,OAAO;IACjB,OAAO,EAAE;QACP,OAAO,EAAE,CAAC,CAAC,MAAM;QACjB,SAAS,EAAE,CAAC,CAAC,MAAM;QACnB,aAAa,EAAE,CAAC,CAAC,MAAM;KACxB;CACF,CAAC,CAAC,WAAW,CAAC;IACb,UAAU,EAAE,4BAA4B;IACxC,WAAW,EAAE,wEAAwE;CACtF,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC,UAAU,CAAC,0BAA0B,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/invalid-path.d.ts

@@ -0,0 +1,46 @@
+import { S } from '#lib/kit-temp/effect';
+import { Version } from '#lib/version/$';
+export declare const DiagnosticInvalidPath: S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["invalid-path"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    path: typeof S.String;
+    version: S.optional<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>, typeof S.Null]>>;
+    error: typeof S.String;
+}>;
+export declare const makeDiagnosticInvalidPath: import("#lib/kit-temp/effect").EffectKit.Schema.ConstructorUsingOmitLiteral1Algo<S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["invalid-path"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    path: typeof S.String;
+    version: S.optional<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>, typeof S.Null]>>;
+    error: typeof S.String;
+}>>;
+export type DiagnosticInvalidPath = S.Schema.Type<typeof DiagnosticInvalidPath>;
+//# sourceMappingURL=invalid-path.d.ts.map

package/build/api/schema/augmentations/diagnostics/invalid-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-path.d.ts","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/invalid-path.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAExC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;EAYhC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;GAA+C,CAAA;AAErF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/invalid-path.js

@@ -0,0 +1,18 @@
+import { Diagnostic } from '#lib/diagnostic/$';
+import { S } from '#lib/kit-temp/effect';
+import { Version } from '#lib/version/$';
+export const DiagnosticInvalidPath = Diagnostic.create({
+    source: 'schema-augmentations',
+    name: 'invalid-path',
+    severity: 'error',
+    context: {
+        path: S.String,
+        version: S.optional(S.Union(Version.Version, S.Null)),
+        error: S.String,
+    },
+}).annotations({
+    identifier: 'DiagnosticInvalidPath',
+    description: 'Augmentation references a non-existent type or field in the schema',
+});
+export const makeDiagnosticInvalidPath = Diagnostic.createMake(DiagnosticInvalidPath);
+//# sourceMappingURL=invalid-path.js.map

package/build/api/schema/augmentations/diagnostics/invalid-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-path.js","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/invalid-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAExC,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC,MAAM,CAAC;IACrD,MAAM,EAAE,sBAAsB;IAC9B,IAAI,EAAE,cAAc;IACpB,QAAQ,EAAE,OAAO;IACjB,OAAO,EAAE;QACP,IAAI,EAAE,CAAC,CAAC,MAAM;QACd,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;QACrD,KAAK,EAAE,CAAC,CAAC,MAAM;KAChB;CACF,CAAC,CAAC,WAAW,CAAC;IACb,UAAU,EAAE,uBAAuB;IACnC,WAAW,EAAE,oEAAoE;CAClF,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/version-mismatch.d.ts

@@ -0,0 +1,46 @@
+import { S } from '#lib/kit-temp/effect';
+import { Version } from '#lib/version/$';
+export declare const DiagnosticVersionMismatch: S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["version-mismatch"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    path: typeof S.String;
+    requestedVersion: 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>;
+    availableVersions: S.Array$<typeof S.String>;
+}>;
+export declare const makeDiagnosticVersionMismatch: import("#lib/kit-temp/effect").EffectKit.Schema.ConstructorUsingOmitLiteral1Algo<S.Struct<{
+    _tag: S.tag<"Diagnostic">;
+} & Omit<{
+    _tag: S.Literal<["Diagnostic"]>;
+    source: typeof S.String;
+    name: typeof S.String;
+    severity: S.Enums<{
+        readonly error: "error";
+        readonly warning: "warning";
+        readonly info: "info";
+    }>;
+    message: typeof S.String;
+}, "_tag" | "name" | "source" | "severity"> & {
+    name: S.Literal<["version-mismatch"]>;
+    source: S.Literal<["schema-augmentations"]>;
+    severity: S.Literal<["error"]>;
+} & {
+    path: typeof S.String;
+    requestedVersion: 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>;
+    availableVersions: S.Array$<typeof S.String>;
+}>>;
+export type DiagnosticVersionMismatch = S.Schema.Type<typeof DiagnosticVersionMismatch>;
+//# sourceMappingURL=version-mismatch.d.ts.map

package/build/api/schema/augmentations/diagnostics/version-mismatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-mismatch.d.ts","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/version-mismatch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAExC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;EAYpC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;GAAmD,CAAA;AAE7F,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAA"}

package/build/api/schema/augmentations/diagnostics/version-mismatch.js

@@ -0,0 +1,18 @@
+import { Diagnostic } from '#lib/diagnostic/$';
+import { S } from '#lib/kit-temp/effect';
+import { Version } from '#lib/version/$';
+export const DiagnosticVersionMismatch = Diagnostic.create({
+    source: 'schema-augmentations',
+    name: 'version-mismatch',
+    severity: 'error',
+    context: {
+        path: S.String,
+        requestedVersion: Version.Version,
+        availableVersions: S.Array(S.String),
+    },
+}).annotations({
+    identifier: 'DiagnosticVersionMismatch',
+    description: 'Augmentation specifies a version that does not match any schema version',
+});
+export const makeDiagnosticVersionMismatch = Diagnostic.createMake(DiagnosticVersionMismatch);
+//# sourceMappingURL=version-mismatch.js.map

package/build/api/schema/augmentations/diagnostics/version-mismatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-mismatch.js","sourceRoot":"","sources":["../../../../../src/api/schema/augmentations/diagnostics/version-mismatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAExC,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC,MAAM,CAAC;IACzD,MAAM,EAAE,sBAAsB;IAC9B,IAAI,EAAE,kBAAkB;IACxB,QAAQ,EAAE,OAAO;IACjB,OAAO,EAAE;QACP,IAAI,EAAE,CAAC,CAAC,MAAM;QACd,gBAAgB,EAAE,OAAO,CAAC,OAAO;QACjC,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;KACrC;CACF,CAAC,CAAC,WAAW,CAAC;IACb,UAAU,EAAE,2BAA2B;IACvC,WAAW,EAAE,yEAAyE;CACvF,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,6BAA6B,GAAG,UAAU,CAAC,UAAU,CAAC,yBAAyB,CAAC,CAAA"}

package/build/api/schema/augmentations/input.d.ts

@@ -0,0 +1,145 @@
+import type { Augmentation } from '#api/schema/augmentations/augmentation';
+import { S } from '#lib/kit-temp/effect';
+/**
+ * Configuration for augmenting GraphQL schema descriptions.
+ *
+ * This schema supports two usage patterns:
+ *
+ * 1. **Unversioned augmentations** - Apply to all schema versions
+ * 2. **Version-specific augmentations** - Apply to specific schema versions with optional defaults
+ *
+ * @example
+ * ```ts
+ * // Unversioned - applies to all versions
+ * {
+ *   on: 'Pokemon',
+ *   placement: 'after',
+ *   content: '**Note:** This type includes battle stats.'
+ * }
+ *
+ * // Version-specific with defaults
+ * {
+ *   on: 'Pokemon',                    // Default for all versions
+ *   placement: 'after',                // Default for all versions
+ *   content: 'Base Pokemon info.',    // Default content
+ *   versions: {
+ *     '2': {
+ *       content: 'Enhanced Pokemon with battle capabilities.' // Override for v2
+ *     },
+ *     '3': {
+ *       on: 'BattlePokemon',          // Different type in v3
+ *       content: 'Battle-ready Pokemon with full stats.'
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * When using version-specific augmentations:
+ * - Top-level fields serve as defaults for all versions
+ * - Version-specific fields override defaults
+ * - A version entry must have complete configuration (after merging with defaults) to be valid
+ * - Invalid paths or missing types will generate build diagnostics rather than crashing
+ */
+export declare const AugmentationInput: S.Struct<{
+    /**
+     * GraphQL path to the type or field to augment.
+     *
+     * @example
+     * - Type path: `'Pokemon'`, `'Query'`, `'User'`
+     * - Field path: `'Pokemon.name'`, `'Query.users'`, `'Mutation.createUser'`
+     *
+     * @remarks
+     * If the specified path doesn't exist in the schema, a diagnostic error will be generated
+     * during the build process rather than causing a crash.
+     */
+    on: S.optional<typeof S.String>;
+    /**
+     * How to apply the augmentation content relative to existing description.
+     *
+     * - `'over'` - Replace the existing description entirely
+     * - `'before'` - Prepend content to the existing description
+     * - `'after'` - Append content to the existing description
+     *
+     * @default 'after'
+     */
+    placement: S.optional<S.Enums<{
+        readonly before: "before";
+        readonly after: "after";
+        readonly over: "over";
+    }>>;
+    /**
+     * The content to add to the description.
+     *
+     * Supports full Markdown syntax including:
+     * - Bold/italic text
+     * - Code blocks and inline code
+     * - Links
+     * - Lists
+     * - Tables
+     *
+     * @example
+     * ```ts
+     * content: `
+     * **Important:** This field requires authentication.
+     *
+     * Example query:
+     * \`\`\`graphql
+     * query {
+     *   users(limit: 10) {
+     *     id
+     *     name
+     *   }
+     * }
+     * \`\`\`
+     * `
+     * ```
+     */
+    content: S.optional<typeof S.String>;
+    /**
+     * Version-specific augmentation overrides.
+     *
+     * Keys are version identifiers (e.g., `'1'`, `'2'`, `'3'`).
+     * Values are partial augmentation configs that override top-level defaults.
+     *
+     * @example
+     * ```ts
+     * versions: {
+     *   '1': { content: 'Legacy API - see migration guide.' },
+     *   '2': { content: 'Current stable API.' },
+     *   '3': {
+     *     on: 'NewTypeName',  // Type renamed in v3
+     *     content: 'Beta API - subject to change.'
+     *   }
+     * }
+     * ```
+     *
+     * @remarks
+     * - Version keys must be valid numeric strings
+     * - Each version inherits top-level defaults
+     * - Invalid version identifiers will generate build diagnostics
+     * - Duplicate version keys will generate build diagnostics
+     */
+    versions: S.optional<S.Record$<typeof S.String, S.Struct<{
+        on: S.optional<typeof S.String>;
+        placement: S.optional<S.Enums<{
+            readonly before: "before";
+            readonly after: "after";
+            readonly over: "over";
+        }>>;
+        content: S.optional<typeof S.String>;
+    }>>>;
+}>;
+export type AugmentationInput = S.Schema.Type<typeof AugmentationInput>;
+/**
+ * Transform user-facing input to normalized internal representation.
+ *
+ * Rules:
+ * 1. If no versions field → create single unversioned entry
+ * 2. If versions field exists:
+ *    - Create version-specific entries for each version
+ *    - If top-level defaults exist, they are used as fallbacks for version entries
+ *    - If a version entry would be incomplete without defaults, skip it
+ */
+export declare const normalizeAugmentationInput: (input: AugmentationInput) => Augmentation | null;
+//# sourceMappingURL=input.d.ts.map

package/build/api/schema/augmentations/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../src/api/schema/augmentations/input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAI1E,OAAO,EAAE,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAKxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;;;;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;;;;;;;;;EAcH,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEvE;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,GAAI,OAAO,iBAAiB,KAAG,YAAY,GAAG,IA2DpF,CAAA"}