@agentxm/extension-model 0.28.4-bootstrap.0

package/dist/src/unstable/sources/types.d.ts

@@ -0,0 +1,262 @@
+/**
+ * Core types for source parsing and identification.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import type { ExtensionName, ExtensionType } from "../extensions/common.js";
+import type { Handle } from "../extensions/handle.js";
+/**
+ * Source type discriminator for extension origins.
+ *
+ * - `"github"` - GitHub repository source
+ * - `"gitlab"` - GitLab repository source
+ * - `"bitbucket"` - Bitbucket repository source
+ * - `"azurerepos"` - Azure Repos repository source
+ * - `"git"` - Generic git repository source
+ * - `"registry"` - Package registry source
+ * - `"local"` - Local filesystem path source
+ * - `"inline"` - Inline workspace configuration
+ * - `"workspace"` - Intrinsic source in the selected scope's managed extension tree
+ *
+ * @experimental
+ */
+export declare const SourceTypeSchema: Schema.Literals<readonly ["github", "gitlab", "bitbucket", "azurerepos", "git", "registry", "local", "inline", "workspace"]>;
+/**
+ * Inferred type for SourceTypeSchema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SourceType = Schema.Schema.Type<typeof SourceTypeSchema>;
+/**
+ * Ref type discriminator for extension ref hosting categories.
+ *
+ * - `"git-hosted"` - Git-based sources (GitHub, GitLab, Bitbucket, AzureRepos, Git)
+ * - `"registry"` - Package registry source
+ * - `"local"` - Local filesystem path source
+ * - `"workspace"` - Intrinsic managed workspace package
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const RefTypeSchema: Schema.Literals<readonly ["git-hosted", "registry", "local", "workspace"]>;
+/**
+ * Inferred type for RefTypeSchema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type RefType = Schema.Schema.Type<typeof RefTypeSchema>;
+export declare const SourceSegmentSchema: Schema.NonEmptyString;
+export declare const SourceRefSchema: Schema.NonEmptyString;
+export declare const SourceNamespaceSchema: Schema.NonEmptyString;
+export declare const SourceSubPathSchema: Schema.NonEmptyString;
+export declare const GitHostedSourceParamPartsSchema: Schema.Struct<{
+    sourceName: Schema.optional<Schema.String>;
+    owner: Schema.NonEmptyString;
+    repo: Schema.NonEmptyString;
+    ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+}>;
+export type GitHostedSourceParamParts = Schema.Schema.Type<typeof GitHostedSourceParamPartsSchema>;
+export declare const AzureReposSourceParamPartsSchema: Schema.Struct<{
+    sourceName: Schema.optional<Schema.String>;
+    organization: Schema.NonEmptyString;
+    project: Schema.NonEmptyString;
+    repo: Schema.NonEmptyString;
+    ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+}>;
+export type AzureReposSourceParamParts = Schema.Schema.Type<typeof AzureReposSourceParamPartsSchema>;
+export declare const GitHubSourceParamsSchema: Schema.Struct<{
+    readonly sourceName: Schema.optional<Schema.String>;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly type: Schema.Literal<"github">;
+}>;
+export declare const GitLabSourceParamsSchema: Schema.Struct<{
+    readonly sourceName: Schema.optional<Schema.String>;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly type: Schema.Literal<"gitlab">;
+}>;
+export declare const BitbucketSourceParamsSchema: Schema.Struct<{
+    readonly sourceName: Schema.optional<Schema.String>;
+    readonly owner: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly type: Schema.Literal<"bitbucket">;
+}>;
+export declare const AzureReposSourceParamsSchema: Schema.Struct<{
+    readonly sourceName: Schema.optional<Schema.String>;
+    readonly organization: Schema.NonEmptyString;
+    readonly project: Schema.NonEmptyString;
+    readonly repo: Schema.NonEmptyString;
+    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
+    readonly type: Schema.Literal<"azurerepos">;
+}>;
+/** @experimental */
+export interface GitHubSourceHost {
+    readonly type: "github";
+    readonly name: string;
+    readonly url: URL;
+}
+/** @experimental */
+export interface GitLabSourceHost {
+    readonly type: "gitlab";
+    readonly name: string;
+    readonly url: URL;
+}
+/** @experimental */
+export interface BitbucketSourceHost {
+    readonly type: "bitbucket";
+    readonly name: string;
+    readonly url: URL;
+}
+/** @experimental */
+export interface AzureReposSourceHost {
+    readonly type: "azurerepos";
+    readonly name: string;
+    readonly url: URL;
+}
+/** Self-describing — the git URL lives in SourceParams. @experimental */
+export interface GitSourceHost {
+    readonly type: "git";
+}
+/**
+ * Registry source host with URL.
+ * @experimental
+ */
+export interface RegistrySourceHost {
+    readonly type: "registry";
+    readonly name: string;
+    readonly location: URL;
+}
+/** Self-describing — the filesystem path lives in SourceParams. @experimental */
+export interface LocalSourceHost {
+    readonly type: "local";
+}
+/** Self-describing — inline transport details live in SourceParams. @experimental */
+export interface InlineSourceHost {
+    readonly type: "inline";
+}
+/** Intrinsic managed-tree source whose scope is bound by its settings document. @experimental */
+export interface WorkspaceSourceHost {
+    readonly type: "workspace";
+}
+/** @experimental */
+export type SourceHost = GitHubSourceHost | GitLabSourceHost | BitbucketSourceHost | AzureReposSourceHost | GitSourceHost | RegistrySourceHost | LocalSourceHost | InlineSourceHost | WorkspaceSourceHost;
+/** @experimental */
+export interface GitHubSourceParams {
+    readonly type: "github";
+    readonly sourceName?: string | undefined;
+    readonly owner: string;
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly cloneUrl?: Option.Option<string>;
+}
+/** @experimental */
+export interface GitLabSourceParams {
+    readonly type: "gitlab";
+    readonly sourceName?: string | undefined;
+    readonly owner: string;
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly cloneUrl?: Option.Option<string>;
+}
+/** @experimental */
+export interface BitbucketSourceParams {
+    readonly type: "bitbucket";
+    readonly sourceName?: string | undefined;
+    readonly owner: string;
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly cloneUrl?: Option.Option<string>;
+}
+/** @experimental */
+export interface AzureReposSourceParams {
+    readonly type: "azurerepos";
+    readonly sourceName?: string | undefined;
+    readonly organization: string;
+    readonly project: string;
+    readonly repo: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+    readonly cloneUrl?: Option.Option<string>;
+}
+/** @experimental */
+export interface GitSourceParams {
+    readonly type: "git";
+    readonly url: URL;
+    readonly ref: Option.Option<string>;
+}
+/** @experimental */
+export interface RegistrySourceParams {
+    readonly type: "registry";
+    readonly sourceName?: string | undefined;
+    readonly owner: Option.Option<Handle>;
+}
+/** @experimental */
+export interface LocalSourceParams {
+    readonly type: "local";
+    readonly path: string;
+}
+/** @experimental */
+export interface InlineSourceParams {
+    readonly type: "inline";
+    readonly command: Option.Option<string>;
+    readonly args: ReadonlyArray<string>;
+    readonly url: Option.Option<string>;
+    readonly headers: Readonly<Record<string, string>>;
+}
+/** @experimental */
+export interface WorkspaceSourceParams {
+    readonly type: "workspace";
+    readonly owner: Handle;
+    readonly extensionType: ExtensionType;
+    readonly name: ExtensionName;
+}
+/** @experimental */
+export type SourceParams = GitHubSourceParams | GitLabSourceParams | BitbucketSourceParams | AzureReposSourceParams | GitSourceParams | RegistrySourceParams | LocalSourceParams | InlineSourceParams | WorkspaceSourceParams;
+/** @experimental */
+export type GitHubSource = GitHubSourceHost & GitHubSourceParams;
+/** @experimental */
+export type GitLabSource = GitLabSourceHost & GitLabSourceParams;
+/** @experimental */
+export type BitbucketSource = BitbucketSourceHost & BitbucketSourceParams;
+/** @experimental */
+export type AzureReposSource = AzureReposSourceHost & AzureReposSourceParams;
+/** @experimental */
+export type InlineSource = InlineSourceHost & InlineSourceParams;
+/** @experimental */
+export type GitSource = GitSourceHost & GitSourceParams;
+/** @experimental */
+export type RegistrySource = RegistrySourceHost & RegistrySourceParams;
+/** @experimental */
+export type LocalSource = LocalSourceHost & LocalSourceParams;
+/** @experimental */
+export type WorkspaceSource = WorkspaceSourceHost & WorkspaceSourceParams;
+/** @experimental */
+export type Source = GitHubSource | GitLabSource | BitbucketSource | AzureReposSource | GitSource | RegistrySource | LocalSource | WorkspaceSource;
+/** Git hosting providers that require a configured URL. @experimental */
+export type GitHostingSourceHost = GitHubSourceHost | GitLabSourceHost | BitbucketSourceHost | AzureReposSourceHost;
+/** @experimental */
+export type GitHostingSourceParams = GitHubSourceParams | GitLabSourceParams | BitbucketSourceParams | AzureReposSourceParams;
+/** @experimental */
+export type GitHostingSource = GitHubSource | GitLabSource | BitbucketSource | AzureReposSource;
+/** All git-based sources (hosting providers + generic git). @experimental */
+export type GitBasedSource = GitHostingSource | GitSource;
+/** Sources that require host configuration from settings. @experimental */
+export type ConfiguredSourceHost = GitHostingSourceHost | RegistrySourceHost;
+/** Sources that are self-describing (no settings config needed). @experimental */
+export type SelfDescribingSourceHost = GitSourceHost | LocalSourceHost;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/unstable/sources/types.js

@@ -0,0 +1,127 @@
+/**
+ * Core types for source parsing and identification.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Schema from "effect/Schema";
+// -----------------------------------------------------------------------------
+// Source Type Schema
+// -----------------------------------------------------------------------------
+/**
+ * Source type discriminator for extension origins.
+ *
+ * - `"github"` - GitHub repository source
+ * - `"gitlab"` - GitLab repository source
+ * - `"bitbucket"` - Bitbucket repository source
+ * - `"azurerepos"` - Azure Repos repository source
+ * - `"git"` - Generic git repository source
+ * - `"registry"` - Package registry source
+ * - `"local"` - Local filesystem path source
+ * - `"inline"` - Inline workspace configuration
+ * - `"workspace"` - Intrinsic source in the selected scope's managed extension tree
+ *
+ * @experimental
+ */
+export const SourceTypeSchema = Schema.Literals([
+    "github",
+    "gitlab",
+    "bitbucket",
+    "azurerepos",
+    "git",
+    "registry",
+    "local",
+    "inline",
+    "workspace",
+]).annotate({
+    identifier: "SourceType",
+    title: "Source Type",
+    description: "Source type discriminator: github, gitlab, bitbucket, azurerepos, git, registry, local, inline, or workspace.",
+});
+// -----------------------------------------------------------------------------
+// Ref Type Schema
+// -----------------------------------------------------------------------------
+/**
+ * Ref type discriminator for extension ref hosting categories.
+ *
+ * - `"git-hosted"` - Git-based sources (GitHub, GitLab, Bitbucket, AzureRepos, Git)
+ * - `"registry"` - Package registry source
+ * - `"local"` - Local filesystem path source
+ * - `"workspace"` - Intrinsic managed workspace package
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const RefTypeSchema = Schema.Literals([
+    "git-hosted",
+    "registry",
+    "local",
+    "workspace",
+]).annotate({
+    identifier: "RefType",
+    title: "Ref Type",
+    description: "Ref type category: git-hosted, registry, local, or workspace.",
+});
+const noSlashSegmentMessage = "Expected non-empty segment without '/' characters";
+const noTraversalSegmentMessage = "Expected subpath without '..' traversal segments";
+export const SourceSegmentSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.makeFilter((value) => (value.includes("/") ? noSlashSegmentMessage : undefined)))).annotate({
+    identifier: "SourceSegment",
+    title: "Source Segment",
+    description: "A non-empty path segment without slash characters, used for owner/repo identifiers.",
+});
+export const SourceRefSchema = Schema.NonEmptyString;
+export const SourceNamespaceSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.makeFilter((value) => value.split("/").some((segment) => segment.length === 0 || segment === "..")
+    ? "Expected non-empty namespace path segments without '..' traversal"
+    : undefined))).annotate({
+    identifier: "SourceNamespace",
+    title: "Source Namespace",
+    description: "A non-empty repository namespace path. GitLab subgroup paths may contain slash-separated segments.",
+});
+export const SourceSubPathSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.makeFilter((value) => value.split("/").some((segment) => segment.length === 0 || segment === "..")
+    ? noTraversalSegmentMessage
+    : undefined))).annotate({
+    identifier: "SourceSubPath",
+    title: "Source Subpath",
+    description: "A non-empty repository subpath without empty or '..' traversal segments.",
+});
+const GitHostedSourceParamFields = {
+    sourceName: Schema.optional(Schema.String),
+    owner: SourceNamespaceSchema,
+    repo: SourceSegmentSchema,
+    ref: Schema.OptionFromOptionalKey(SourceRefSchema),
+    subPath: Schema.OptionFromOptionalKey(SourceSubPathSchema),
+};
+export const GitHostedSourceParamPartsSchema = Schema.Struct(GitHostedSourceParamFields).annotate({
+    identifier: "GitHostedSourceParamParts",
+    title: "Git Hosted Source Params",
+    description: "Parameters for a git-hosted source: owner, repo, optional ref and sub-path.",
+});
+const AzureReposSourceParamFields = {
+    sourceName: Schema.optional(Schema.String),
+    organization: SourceSegmentSchema,
+    project: SourceSegmentSchema,
+    repo: SourceSegmentSchema,
+    ref: Schema.OptionFromOptionalKey(SourceRefSchema),
+    subPath: Schema.OptionFromOptionalKey(SourceSubPathSchema),
+};
+export const AzureReposSourceParamPartsSchema = Schema.Struct(AzureReposSourceParamFields).annotate({
+    identifier: "AzureReposSourceParamParts",
+    title: "Azure Repos Source Params",
+    description: "Parameters for an Azure Repos source: organization, project, repo, optional ref and sub-path.",
+});
+export const GitHubSourceParamsSchema = Schema.Struct({
+    type: Schema.Literal("github"),
+    ...GitHostedSourceParamFields,
+});
+export const GitLabSourceParamsSchema = Schema.Struct({
+    type: Schema.Literal("gitlab"),
+    ...GitHostedSourceParamFields,
+});
+export const BitbucketSourceParamsSchema = Schema.Struct({
+    type: Schema.Literal("bitbucket"),
+    ...GitHostedSourceParamFields,
+});
+export const AzureReposSourceParamsSchema = Schema.Struct({
+    type: Schema.Literal("azurerepos"),
+    ...AzureReposSourceParamFields,
+});
+//# sourceMappingURL=types.js.map

package/dist/src/unstable/sources/workspace.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return whether a configured source string declares intrinsic workspace
+ * authority.
+ *
+ * This is the single classification predicate lifecycle guards use. Parsing
+ * and identity validation remain separate so malformed workspace locators are
+ * still classified as workspace-owned and cannot fall through to a remote
+ * source.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const isWorkspaceSourceLocator: (source: string) => boolean;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/src/unstable/sources/workspace.js

@@ -0,0 +1,13 @@
+/**
+ * Return whether a configured source string declares intrinsic workspace
+ * authority.
+ *
+ * This is the single classification predicate lifecycle guards use. Parsing
+ * and identity validation remain separate so malformed workspace locators are
+ * still classified as workspace-owned and cannot fall through to a remote
+ * source.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const isWorkspaceSourceLocator = (source) => source === "workspace";
+//# sourceMappingURL=workspace.js.map

package/dist/src/unstable/subagents/manifest-schema.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Subagent manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Filename for subagent manifest files.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const MANIFEST_FILENAME = "subagent.json";
+/**
+ * URL for the subagent manifest JSON Schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/subagent.schema.json";
+/**
+ * Schema for subagent manifest files (subagent.json).
+ *
+ * The manifest carries registry-facing identity and metadata. Fields like
+ * `model`, `toolAccess`, and `background` live (if at all) in the content
+ * file's frontmatter and are passed through to agent-native files verbatim;
+ * the manifest does not mirror them.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SubagentManifestSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"subagent">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
+    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+    readonly standalone: Schema.optional<Schema.Boolean>;
+    readonly publish: Schema.optional<Schema.Struct<{
+        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly version: Schema.brand<Schema.String, "Version">;
+    readonly description: Schema.optional<Schema.String>;
+    readonly keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly type: Schema.optional<Schema.NonEmptyString>;
+        readonly url: Schema.NonEmptyString;
+        readonly directory: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly homepage: Schema.optional<Schema.String>;
+    readonly license: Schema.optional<Schema.String>;
+    readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly url: Schema.optional<Schema.NonEmptyString>;
+        readonly email: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly email: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+            readonly raw: Schema.NonEmptyString;
+            readonly scheme: Schema.NonEmptyString;
+            readonly constraints: Schema.$Array<Schema.Struct<{
+                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                readonly version: Schema.NonEmptyString;
+            }>>;
+        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+    }>>>;
+    readonly $schema: Schema.optional<Schema.String>;
+}>;
+/**
+ * Inferred type for SubagentManifest schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SubagentManifest = Schema.Schema.Type<typeof SubagentManifestSchema>;
+//# sourceMappingURL=manifest-schema.d.ts.map

package/dist/src/unstable/subagents/manifest-schema.js

@@ -0,0 +1,43 @@
+/**
+ * Subagent manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import { CommonManifestBaseFields, ExtensionNameSchema, NonPackManifestFields, } from "../extensions/common.js";
+/**
+ * Filename for subagent manifest files.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const MANIFEST_FILENAME = "subagent.json";
+/**
+ * URL for the subagent manifest JSON Schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/subagent.schema.json";
+/**
+ * Schema for subagent manifest files (subagent.json).
+ *
+ * The manifest carries registry-facing identity and metadata. Fields like
+ * `model`, `toolAccess`, and `background` live (if at all) in the content
+ * file's frontmatter and are passed through to agent-native files verbatim;
+ * the manifest does not mirror them.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const SubagentManifestSchema = Schema.Struct({
+    $schema: Schema.optional(Schema.String),
+    ...CommonManifestBaseFields,
+    ...NonPackManifestFields,
+    type: Schema.Literal("subagent"),
+    name: ExtensionNameSchema.pipe(Schema.annotateKey({ messageMissingKey: "subagent name is required" }), Schema.annotate({
+        description: "Short name for this subagent within its owner namespace. Combined with owner, forms the FQN @owner/subagents/<name>.",
+    })),
+}).annotate({
+    identifier: "SubagentManifest",
+    title: "Subagent Manifest",
+    description: "Extension manifest file for subagent. Carries the registry-facing identity, version, and metadata.",
+});
+//# sourceMappingURL=manifest-schema.js.map

package/dist/src/unstable/version-constraints/version-constraints.d.ts

@@ -0,0 +1,71 @@
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+/**
+ * Minimal version entry shape used for range resolution.
+ * Compatible with the full VersionEntry from the registry module.
+ */
+export interface VersionEntryLike {
+    readonly version: Version;
+}
+/**
+ * Canonical strict semver pattern from semver.org.
+ *
+ * Equivalent to `semver.valid(value) === value`: rejects leading `v`,
+ * whitespace, partial versions, and leading-zero numeric identifiers.
+ */
+export declare const SEMVER_PATTERN: RegExp;
+/**
+ * Schema for an exact semver version (no ranges).
+ */
+export declare const VersionSchema: Schema.brand<Schema.String, "Version">;
+/**
+ * Inferred type for an exact semver version.
+ */
+export type Version = Schema.Schema.Type<typeof VersionSchema>;
+/**
+ * Schema for a semver version range, including exact versions and range expressions.
+ */
+export declare const VersionRangeSchema: Schema.brand<Schema.NonEmptyString, "VersionRange">;
+/**
+ * Inferred type for a semver version range.
+ */
+export type VersionRange = Schema.Schema.Type<typeof VersionRangeSchema>;
+/**
+ * Decode a value as an exact semver version.
+ */
+export declare const decodeVersionSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Version">;
+/**
+ * Decode a value as a semver version range.
+ */
+export declare const decodeVersionRangeSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"VersionRange">;
+/**
+ * Extract a version range suffix from a source string.
+ *
+ * Handles both namespaced (`@handle/name@^1.0.0`) and non-namespaced (`name@^1.0.0`) names.
+ * Returns `Option.none()` when no version suffix is present.
+ */
+export declare const parseVersionRange: (sourceString: string) => Option.Option<VersionRange>;
+/**
+ * Check whether a string is a valid semver version range.
+ */
+export declare const isValidVersionRange: (range: string) => boolean;
+/** Return one range representing the complete intersection, or undefined when unsatisfiable. */
+export declare const intersectVersionConstraints: (constraints: ReadonlyArray<string>) => string | undefined;
+/**
+ * Check whether moving from `previousVersion` to `currentVersion` includes at
+ * least a minor version bump.
+ */
+export declare const hasMinorOrMajorVersionBump: (previousVersion: string, currentVersion: string) => boolean;
+/**
+ * Check whether a version satisfies a semver version range.
+ */
+export declare const versionSatisfiesRange: (version: Version, range: VersionRange) => boolean;
+/**
+ * Select the maximum version that satisfies the range, independent of input
+ * order.
+ *
+ * - `Option.none()` range or `"*"` matches any version.
+ * - Invalid ranges match nothing.
+ */
+export declare const resolveVersionInRange: <T extends VersionEntryLike>(versions: ReadonlyArray<T>, range: Option.Option<string>) => Option.Option<T>;
+//# sourceMappingURL=version-constraints.d.ts.map