@savvy-web/silk-effects 0.6.1 → 1.0.1

package/changesets/schemas/git.js

@@ -0,0 +1,69 @@
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/git.ts
+/**
+* Git-related Effect schemas for commit hashes and version bump types.
+*
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/**
+* Schema for a git commit hash (at least 7 lowercase hex characters).
+*
+* @remarks
+* Accepts both abbreviated (7-character) and full (40-character) SHA-1 hashes.
+* Only lowercase hexadecimal characters are allowed; uppercase letters will
+* fail validation. This matches the output of `git rev-parse --short` and
+* `git log --format=%h`.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { CommitHashSchema } from "@savvy-web/changesets";
+*
+* // Succeeds — abbreviated hash
+* const short = Schema.decodeUnknownSync(CommitHashSchema)("a1b2c3d");
+*
+* // Succeeds — full 40-character SHA
+* const full = Schema.decodeUnknownSync(CommitHashSchema)(
+* 	"a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2"
+* );
+*
+* // Throws ParseError — too short
+* Schema.decodeUnknownSync(CommitHashSchema)("a1b2c3");
+*
+* // Throws ParseError — uppercase not allowed
+* Schema.decodeUnknownSync(CommitHashSchema)("A1B2C3D");
+* ```
+*
+* @see {@link ChangesetSchema} which uses this for the optional `commit` field
+*
+* @public
+*/
+const CommitHashSchema = Schema.String.pipe(Schema.pattern(/^[a-f0-9]{7,}$/, { message: () => "Commit hash must be 7 or more lowercase hexadecimal characters (0-9, a-f). Example: \"a1b2c3d\" or a full 40-character SHA like \"a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2\". Uppercase letters are not allowed" }));
+/**
+* Semantic version bump type.
+*
+* @remarks
+* Represents the four possible version bump levels used by Changesets:
+* - `"major"` -- breaking changes (e.g., 1.x.x to 2.0.0)
+* - `"minor"` -- new features (e.g., 1.1.x to 1.2.0)
+* - `"patch"` -- bug fixes (e.g., 1.1.1 to 1.1.2)
+* - `"none"` -- no version bump (internal changes only)
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { VersionTypeSchema } from "@savvy-web/changesets";
+* import type { VersionType } from "@savvy-web/changesets";
+*
+* const bump: VersionType = Schema.decodeUnknownSync(VersionTypeSchema)("minor");
+* ```
+*
+* @public
+*/
+const VersionTypeSchema = Schema.Literal("major", "minor", "patch", "none");
+
+//#endregion
+export { CommitHashSchema, VersionTypeSchema };

package/changesets/schemas/github.js

@@ -0,0 +1,175 @@
+import { PositiveInteger } from "./primitives.js";
+import { MARKDOWN_LINK_PATTERN } from "../utils/markdown-link.js";
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/github.ts
+/**
+* GitHub-related Effect schemas for usernames, issue numbers, and API responses.
+*
+* @remarks
+* These schemas validate data returned by the `\@changesets/get-github-info`
+* vendor module and enforce GitHub's naming conventions for usernames and
+* issue references.
+*
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/**
+* Test whether a string is a valid URL.
+*
+* @internal
+*/
+function isValidUrl(value) {
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Schema for a GitHub username.
+*
+* @remarks
+* Validates against GitHub's username rules: alphanumeric characters and
+* hyphens only, cannot start or end with a hyphen. Does not enforce the
+* 39-character maximum length since GitHub may change that limit.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { UsernameSchema } from "@savvy-web/changesets";
+*
+* // Succeeds
+* Schema.decodeUnknownSync(UsernameSchema)("octocat");
+* Schema.decodeUnknownSync(UsernameSchema)("my-user-123");
+*
+* // Throws ParseError — starts with hyphen
+* Schema.decodeUnknownSync(UsernameSchema)("-invalid");
+* ```
+*
+* @see {@link GitHubInfoSchema} which uses this for the `user` field
+*
+* @public
+*/
+const UsernameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/, { message: () => "Invalid GitHub username format. Usernames must contain only alphanumeric characters and hyphens, and cannot start or end with a hyphen. Example: \"octocat\" or \"my-user-123\"" }));
+/**
+* Schema for a GitHub issue or PR number (positive integer).
+*
+* @remarks
+* Built on {@link PositiveInteger}, this schema adds GitHub-specific
+* annotations for documentation tooling. Issue and PR numbers in GitHub
+* are always positive integers starting from 1.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { IssueNumberSchema } from "@savvy-web/changesets";
+*
+* // Succeeds
+* const prNum = Schema.decodeUnknownSync(IssueNumberSchema)(42);
+*
+* // Throws ParseError — zero is not a valid issue number
+* Schema.decodeUnknownSync(IssueNumberSchema)(0);
+* ```
+*
+* @see {@link GitHubInfoSchema} which uses this for the `pull` field
+*
+* @public
+*/
+const IssueNumberSchema = PositiveInteger.annotations({
+	title: "IssueNumber",
+	description: "GitHub issue or pull request number"
+});
+/**
+* Schema accepting either a plain URL or a markdown link `[text](url)`.
+*
+* @remarks
+* The `\@changesets/get-github-info` vendor module returns links in two
+* possible formats depending on context: a bare URL string or a markdown
+* link like `[#42](https://github.com/owner/repo/pull/42)`. This schema
+* accepts both, validating that the URL portion is parseable by the
+* `URL` constructor.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { UrlOrMarkdownLinkSchema } from "@savvy-web/changesets";
+*
+* // Succeeds — plain URL
+* Schema.decodeUnknownSync(UrlOrMarkdownLinkSchema)(
+* 	"https://github.com/owner/repo/pull/42"
+* );
+*
+* // Succeeds — markdown link
+* Schema.decodeUnknownSync(UrlOrMarkdownLinkSchema)(
+* 	"[#42](https://github.com/owner/repo/pull/42)"
+* );
+*
+* // Throws ParseError — not a URL or markdown link
+* Schema.decodeUnknownSync(UrlOrMarkdownLinkSchema)("not-a-url");
+* ```
+*
+* @see {@link GitHubInfoSchema} which uses this for commit, pull, and user links
+*
+* @public
+*/
+const UrlOrMarkdownLinkSchema = Schema.String.pipe(Schema.filter((value) => {
+	if (isValidUrl(value)) return true;
+	const match = MARKDOWN_LINK_PATTERN.exec(value);
+	return match?.[2] ? isValidUrl(match[2]) : false;
+}, { message: () => "Value must be a valid URL or a markdown link. Expected a plain URL (e.g., \"https://github.com/owner/repo/pull/42\") or a markdown link (e.g., \"[#42](https://github.com/owner/repo/pull/42)\")" }));
+/**
+* Schema for a GitHub info response from `\@changesets/get-github-info`.
+*
+* @remarks
+* Represents the structured data returned when querying GitHub for commit
+* metadata. The `user` and `pull` fields are optional because not every
+* commit is associated with a pull request or a known GitHub user (e.g.,
+* bot commits or squash-merged commits without a linked PR).
+*
+* The `links` object contains pre-formatted markdown or URL strings for
+* the commit, pull request, and user profile -- ready for insertion into
+* CHANGELOG entries.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { GitHubInfoSchema } from "@savvy-web/changesets";
+* import type { GitHubInfo } from "@savvy-web/changesets";
+*
+* const info: GitHubInfo = Schema.decodeUnknownSync(GitHubInfoSchema)({
+* 	user: "octocat",
+* 	pull: 42,
+* 	links: {
+* 		commit: "[`a1b2c3d`](https://github.com/owner/repo/commit/a1b2c3d)",
+* 		pull: "[#42](https://github.com/owner/repo/pull/42)",
+* 		user: "[@octocat](https://github.com/octocat)",
+* 	},
+* });
+* ```
+*
+* @see {@link GitHubInfo} for the inferred TypeScript type
+* @see {@link GitHubService} for the Effect service that produces these values
+*
+* @public
+*/
+const GitHubInfoSchema = Schema.Struct({
+	/** GitHub username of the commit author. */
+	user: Schema.optional(UsernameSchema),
+	/** Pull request number associated with the commit. */
+	pull: Schema.optional(IssueNumberSchema),
+	/** Markdown-formatted links. */
+	links: Schema.Struct({
+		/** Link to the commit. */
+		commit: UrlOrMarkdownLinkSchema,
+		/** Link to the associated pull request. */
+		pull: Schema.optional(UrlOrMarkdownLinkSchema),
+		/** Link to the author's GitHub profile. */
+		user: Schema.optional(UrlOrMarkdownLinkSchema)
+	})
+});
+
+//#endregion
+export { GitHubInfoSchema, IssueNumberSchema, UrlOrMarkdownLinkSchema, UsernameSchema };

package/changesets/schemas/options.js

@@ -0,0 +1,182 @@
+import { ConfigurationError } from "../errors.js";
+import { LegacyVersionFilesSchema } from "./version-files.js";
+import { PackagesRecordSchema } from "./package-scope.js";
+import { Effect, Schema } from "effect";
+
+//#region src/changesets/schemas/options.ts
+/**
+* Changeset configuration option schemas and validation.
+*
+* @remarks
+* Defines the schema for the options object passed to the
+* \@savvy-web/changesets changelog formatter in `.changeset/config.json`.
+* The options are specified as the second element of the changelog array:
+*
+* ```json
+* {
+*   "changelog": ["@savvy-web/changesets/changelog", { "repo": "owner/repo" }]
+* }
+* ```
+*
+* @see {@link https://github.com/changesets/changesets/blob/main/docs/config-file-options.md | Changesets config docs}
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/** Regex for `owner/repo` format, shared between schema and validation. */
+const REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
+/**
+* Schema for a GitHub repository in `owner/repo` format.
+*
+* @remarks
+* Validates that the string matches the `owner/repository` format used
+* by GitHub. Both the owner and repository segments accept alphanumeric
+* characters, dots, underscores, and hyphens.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { RepoSchema } from "@savvy-web/changesets";
+*
+* // Succeeds
+* Schema.decodeUnknownSync(RepoSchema)("microsoft/vscode");
+*
+* // Throws ParseError — missing slash
+* Schema.decodeUnknownSync(RepoSchema)("vscode");
+* ```
+*
+* @see {@link ChangesetOptionsSchema} which uses this for the `repo` field
+*
+* @public
+*/
+const RepoSchema = Schema.String.pipe(Schema.pattern(REPO_PATTERN, { message: () => "Repository must be in format \"owner/repository\" (e.g., \"microsoft/vscode\")" }));
+/**
+* Schema for changeset configuration options.
+*
+* @remarks
+* The `repo` field is required; all other fields are optional with sensible
+* defaults applied by the changelog formatter at runtime.
+*
+* Two related fields describe release surfaces:
+*
+* - `packages` (new, recommended) — a record keyed by package name with
+*   per-package `additionalScopes` and `versionFiles`. This is the shape
+*   introduced in 0.9.0 and the only shape that will be accepted in 1.0.0.
+* - `versionFiles` (deprecated) — a flat array of entries each carrying
+*   their own `package` field. Still accepted in 0.9.0 with a deprecation
+*   warning emitted by `ConfigInspector` at config-load time; removed in
+*   1.0.0.
+*
+* A config that declares **both** `packages` and the deprecated
+* `versionFiles` field is rejected — the user must pick one.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { ChangesetOptionsSchema } from "@savvy-web/changesets";
+* import type { ChangesetOptions } from "@savvy-web/changesets";
+*
+* // New per-package shape (recommended)
+* const opts: ChangesetOptions = Schema.decodeUnknownSync(ChangesetOptionsSchema)({
+*   repo: "savvy-web/changesets",
+*   packages: {
+*     "@savvy-web/changesets": {
+*       additionalScopes: ["plugin/**"],
+*       versionFiles: [{ glob: "plugin/.claude-plugin/plugin.json", paths: ["$.version"] }],
+*     },
+*   },
+* });
+* ```
+*
+* @see {@link ChangesetOptions} for the inferred TypeScript type
+* @see {@link validateChangesetOptions} for Effect-idiomatic validation with detailed error messages
+* @see {@link PackagesRecordSchema} for the new `packages` shape
+* @see {@link LegacyVersionFilesSchema} for the deprecated `versionFiles` shape
+*
+* @public
+*/
+const ChangesetOptionsSchema = Schema.Struct({
+	/** GitHub repository in `owner/repo` format. */
+	repo: RepoSchema,
+	/** Whether to include commit hash links in output. */
+	commitLinks: Schema.optional(Schema.Boolean),
+	/** Whether to include pull request links in output. */
+	prLinks: Schema.optional(Schema.Boolean),
+	/** Whether to include issue reference links in output. */
+	issueLinks: Schema.optional(Schema.Boolean),
+	/** Custom issue reference prefixes (e.g., `["#", "GH-"]`). */
+	issuePrefixes: Schema.optional(Schema.Array(Schema.String)),
+	/**
+	* Per-package release surfaces. Each entry declares `additionalScopes`
+	* (globs outside the workspace dir that belong to the package) and
+	* `versionFiles` (files bumped in lockstep with the package's version).
+	*/
+	packages: Schema.optional(PackagesRecordSchema),
+	/**
+	* DEPRECATED. Top-level flat array of version-file entries each with
+	* their own `package` field. Migrate to `packages[<name>].versionFiles`.
+	* Removed in 1.0.0.
+	*
+	* @deprecated 0.9.0 — migrate to `packages`. Removed in 1.0.0.
+	*/
+	versionFiles: Schema.optional(LegacyVersionFilesSchema)
+}).pipe(Schema.filter((opts) => opts.packages === void 0 || opts.versionFiles === void 0, { message: () => "Configuration cannot declare both `packages` and the deprecated top-level `versionFiles` array. Migrate the legacy `versionFiles` entries into `packages[<name>].versionFiles` and remove the top-level field." }));
+/**
+* Validate changeset options with Effect-idiomatic error handling.
+*
+* @remarks
+* Provides detailed, user-friendly error messages that match the prior art
+* from \@savvy-web/changelog. Performs manual pre-validation for `null`,
+* non-object, and missing `repo` before delegating to schema decoding.
+* This layered approach ensures that the most common misconfiguration
+* (missing `repo`) produces a clear, actionable message rather than a
+* generic schema parse error.
+*
+* @example
+* ```typescript
+* import { Effect } from "effect";
+* import { validateChangesetOptions, ConfigurationError } from "@savvy-web/changesets";
+*
+* const program = validateChangesetOptions({ repo: "savvy-web/changesets" }).pipe(
+* 	Effect.catchTag("ConfigurationError", (err) =>
+* 		Effect.logError(`Config invalid: ${err.message}`)
+* 	),
+* );
+*
+* Effect.runPromise(program);
+* ```
+*
+* @param input - Raw configuration input (typically from `.changeset/config.json`)
+* @returns An Effect that succeeds with decoded {@link ChangesetOptions} or fails with a {@link ConfigurationError}
+*
+* @see {@link ChangesetOptionsSchema} for the expected configuration shape
+* @see {@link ConfigurationError} for the error type produced on validation failure
+*
+* @public
+*/
+function validateChangesetOptions(input) {
+	if (input === null || input === void 0) return Effect.fail(new ConfigurationError({
+		field: "options",
+		reason: "Configuration is required. Add options to your changesets config:\n\"changelog\": [\"@savvy-web/changesets\", { \"repo\": \"owner/repository\" }]"
+	}));
+	if (typeof input !== "object") return Effect.fail(new ConfigurationError({
+		field: "options",
+		reason: "Configuration must be an object"
+	}));
+	const obj = input;
+	if (!("repo" in obj) || obj.repo === void 0) return Effect.fail(new ConfigurationError({
+		field: "repo",
+		reason: "Repository name is required. Add the \"repo\" option to your changesets config:\n\"changelog\": [\"@savvy-web/changesets\", { \"repo\": \"owner/repository\" }]"
+	}));
+	if (typeof obj.repo === "string" && !REPO_PATTERN.test(obj.repo)) return Effect.fail(new ConfigurationError({
+		field: "repo",
+		reason: `Invalid repository format: "${obj.repo}". Expected format is "owner/repository" (e.g., "microsoft/vscode")`
+	}));
+	return Schema.decodeUnknown(ChangesetOptionsSchema)(input).pipe(Effect.mapError((parseError) => new ConfigurationError({
+		field: "options",
+		reason: String(parseError)
+	})));
+}
+
+//#endregion
+export { ChangesetOptionsSchema, RepoSchema, validateChangesetOptions };

package/changesets/schemas/package-scope.js

@@ -0,0 +1,128 @@
+import { VersionFileConfigSchema } from "./version-files.js";
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/package-scope.ts
+/**
+* Schemas for the per-package release-surface configuration introduced in
+* \@savvy-web/changesets 0.9.0.
+*
+* @remarks
+* A `PackageScope` is the value side of the `packages` record on the
+* \@savvy-web/changesets changelog options. It tells the formatter which
+* non-workspace paths belong to a package's release surface (via
+* `additionalScopes`) and which files have their version fields bumped in
+* lockstep with the package (via `versionFiles`).
+*
+* ```jsonc
+* "changelog": [
+*   "@savvy-web/changesets/changelog",
+*   {
+*     "repo": "savvy-web/changesets",
+*     "packages": {
+*       "@savvy-web/changesets": {
+*         "additionalScopes": ["plugin/**"],
+*         "versionFiles": [
+*           { "glob": "plugin/.claude-plugin/plugin.json",
+*             "paths": ["$.version"] }
+*         ]
+*       }
+*     }
+*   }
+* ]
+* ```
+*
+* Validation contracts that span multiple packages (no-overlap rules for
+* `additionalScopes`, no glob+path conflicts in `versionFiles`, unknown
+* package keys) are enforced by `ConfigInspector` at load time, not at the
+* schema level — schemas only validate per-entry shape.
+*
+* @see {@link ChangesetOptionsSchema} for the consuming options shape
+* @see {@link VersionFileConfigSchema} for the version-file entry shape
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/**
+* Schema for a single repo-relative glob pattern.
+*
+* @remarks
+* Globs in `additionalScopes` must be repo-relative — absolute paths and
+* parent traversal (`../`) are rejected outright because they cannot be
+* meaningfully resolved against the project workspace. Negation patterns
+* (`!path/**`) are accepted; minimatch handles them at match time.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { GlobSchema } from "@savvy-web/changesets";
+*
+* Schema.decodeUnknownSync(GlobSchema)("plugin/**");          // ok
+* Schema.decodeUnknownSync(GlobSchema)("!plugin/cache/**");   // ok (negation)
+* Schema.decodeUnknownSync(GlobSchema)("/absolute/path");     // throws
+* Schema.decodeUnknownSync(GlobSchema)("../sibling/**");      // throws
+* ```
+*
+* @public
+*/
+const GlobSchema = Schema.String.pipe(Schema.minLength(1), Schema.filter((s) => !s.startsWith("/") && !s.startsWith("../") && !s.includes("/../"), { message: () => "Glob must be repo-relative — absolute paths and parent traversal (../) are not allowed" }));
+/**
+* Schema for a single entry in the `packages` record — the per-package
+* release-surface declaration.
+*
+* @remarks
+* Both fields are optional. An empty object (`{}`) is a valid PackageScope
+* and means "this package uses only its workspace directory as its release
+* surface."
+*
+* - `additionalScopes` — repo-relative globs naming files outside the
+*   package's workspace directory that belong to the package's release
+*   surface. The contract is "a path belongs to exactly one package" — if
+*   two packages declare overlapping additionalScopes, the config is
+*   rejected by `ConfigInspector`.
+* - `versionFiles` — files whose JSON fields are bumped in lockstep with
+*   this package's version. Each entry uses the new {@link VersionFileConfigSchema}
+*   shape (no `package` field; the parent record key names the owner).
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { PackageScopeSchema } from "@savvy-web/changesets";
+*
+* const scope = Schema.decodeUnknownSync(PackageScopeSchema)({
+*   additionalScopes: ["plugin/**", "!plugin/.cache/**"],
+*   versionFiles: [
+*     { glob: "plugin/.claude-plugin/plugin.json", paths: ["$.version"] },
+*   ],
+* });
+* ```
+*
+* @see {@link PackageScope} for the inferred TypeScript type
+* @see {@link GlobSchema} for individual glob validation rules
+* @see {@link VersionFileConfigSchema} for the version-file entry shape
+*
+* @public
+*/
+const PackageScopeSchema = Schema.Struct({
+	/** Repo-relative globs naming files outside the package's workspace directory that belong to its release surface. */
+	additionalScopes: Schema.optional(Schema.Array(GlobSchema)),
+	/** Files whose JSON fields are bumped in lockstep with this package's version. */
+	versionFiles: Schema.optional(Schema.Array(VersionFileConfigSchema))
+});
+/**
+* Schema for the `packages` record on the changelog options.
+*
+* @remarks
+* Keys are package names. The schema itself does not validate that keys
+* resolve to known workspace packages — that check is performed by
+* `ConfigInspector` at config-load time, where `WorkspaceDiscovery` is
+* available to enumerate the workspace.
+*
+* @public
+*/
+const PackagesRecordSchema = Schema.Record({
+	key: Schema.String,
+	value: PackageScopeSchema
+});
+
+//#endregion
+export { GlobSchema, PackageScopeSchema, PackagesRecordSchema };

package/changesets/schemas/primitives.js

@@ -0,0 +1,72 @@
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/primitives.ts
+/**
+* Primitive reusable schemas for common constrained types.
+*
+* @remarks
+* These schemas serve as building blocks for more complex schemas throughout
+* the \@savvy-web/changesets package. They encode common constraints
+* (non-empty strings, positive integers) as Effect Schemas so that validation
+* is enforced at system boundaries.
+*
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/**
+* A non-empty string schema.
+*
+* @remarks
+* Validates that a string has at least one character. Used as the base
+* constraint for package names, dependency identifiers, and other fields
+* that must not be blank.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { NonEmptyString } from "@savvy-web/changesets";
+*
+* // Succeeds — non-empty string
+* const name = Schema.decodeUnknownSync(NonEmptyString)("react");
+*
+* // Throws ParseError — empty string
+* Schema.decodeUnknownSync(NonEmptyString)("");
+* ```
+*
+* @see {@link ChangesetSummarySchema} for a length-bounded variant used for changeset summaries
+*
+* @public
+*/
+const NonEmptyString = Schema.String.pipe(Schema.minLength(1));
+/**
+* A positive integer schema.
+*
+* @remarks
+* Validates that a number is both an integer and strictly greater than zero.
+* Used as the base constraint for GitHub issue numbers and similar
+* identifiers that must be positive whole numbers.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { PositiveInteger } from "@savvy-web/changesets";
+*
+* // Succeeds — positive integer
+* const issueNum = Schema.decodeUnknownSync(PositiveInteger)(42);
+*
+* // Throws ParseError — zero is not positive
+* Schema.decodeUnknownSync(PositiveInteger)(0);
+*
+* // Throws ParseError — floats are not integers
+* Schema.decodeUnknownSync(PositiveInteger)(3.14);
+* ```
+*
+* @see {@link IssueNumberSchema} which builds on this for GitHub issue/PR numbers
+*
+* @public
+*/
+const PositiveInteger = Schema.Number.pipe(Schema.int(), Schema.positive());
+
+//#endregion
+export { NonEmptyString, PositiveInteger };