@agentxm/extension-model 0.28.4-bootstrap.0

package/dist/src/unstable/extensions/deprecation.js

@@ -0,0 +1,46 @@
+/**
+ * Identity deprecation vocabulary carried by resolved extension references.
+ *
+ * A registry-resolved ref commits to the deprecation evidence captured at
+ * resolution time, so the view lives with the extension identity vocabulary.
+ * Publisher-management composites (transitions, management views) stay in
+ * `@agentxm/registry-protocol`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import { DateTimeUtcSchema } from "../date-time.js";
+import { ExtensionFqnSchema } from "./common.js";
+const DeprecationMessageSchema = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(500)).annotate({
+    identifier: "DeprecationMessage",
+    description: "Concise publisher guidance for consumers of a deprecated extension.",
+});
+export const DeprecationReplacementSchema = Schema.Union([
+    Schema.Struct({
+        status: Schema.Literal("available"),
+        fqn: ExtensionFqnSchema,
+    }),
+    Schema.Struct({
+        status: Schema.Literal("unavailable"),
+        fqn: Schema.optional(ExtensionFqnSchema),
+    }),
+]).annotate({
+    identifier: "DeprecationReplacement",
+    description: "Authorization-safe current availability of a recorded replacement identity.",
+});
+export const DeprecationViewSchema = Schema.Union([
+    Schema.Struct({
+        deprecatedAt: DateTimeUtcSchema,
+        message: DeprecationMessageSchema,
+        replacement: Schema.optional(DeprecationReplacementSchema),
+    }),
+    Schema.Struct({
+        deprecatedAt: DateTimeUtcSchema,
+        message: Schema.optional(DeprecationMessageSchema),
+        replacement: DeprecationReplacementSchema,
+    }),
+]).annotate({
+    identifier: "DeprecationView",
+    description: "Canonical authorization-safe identity deprecation guidance.",
+});
+//# sourceMappingURL=deprecation.js.map

package/dist/src/unstable/extensions/fqn-pattern.d.ts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+import { type ExtensionFqnParts } from "./common.js";
+declare const ReleaseAgeExcludePatternPartsSchema: Schema.Struct<{
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly type: Schema.Union<readonly [Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>, Schema.Literal<"*">]>;
+    readonly name: Schema.Union<readonly [Schema.brand<Schema.NonEmptyString, "ExtensionName">, Schema.Literal<"*">]>;
+}>;
+export type ReleaseAgeExcludePattern = typeof ReleaseAgeExcludePatternPartsSchema.Type;
+/** A validated publisher, type, or exact-extension release-age exemption. */
+export declare const ReleaseAgeExcludePatternSchema: Schema.decodeTo<Schema.toType<Schema.Struct<{
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly type: Schema.Union<readonly [Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>, Schema.Literal<"*">]>;
+    readonly name: Schema.Union<readonly [Schema.brand<Schema.NonEmptyString, "ExtensionName">, Schema.Literal<"*">]>;
+}>>, Schema.String, never, never>;
+export declare const matchesReleaseAgeExcludePattern: (pattern: ReleaseAgeExcludePattern, identity: ExtensionFqnParts) => boolean;
+export {};
+//# sourceMappingURL=fqn-pattern.d.ts.map

package/dist/src/unstable/extensions/fqn-pattern.js

@@ -0,0 +1,63 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import { ExtensionNameSchema, ExtensionTypeSchema, isExtensionTypePlural, toExtensionType, toExtensionTypePlural, } from "./common.js";
+import { HandleSchema } from "./handle.js";
+const INVALID_RELEASE_AGE_EXCLUDE_PATTERN_MESSAGE = "Expected @owner/<type>s/name, @owner/<type>s/*, or @owner/*";
+const ReleaseAgeExcludePatternPartsSchema = Schema.Struct({
+    owner: HandleSchema,
+    type: Schema.Union([ExtensionTypeSchema, Schema.Literal("*")]),
+    name: Schema.Union([ExtensionNameSchema, Schema.Literal("*")]),
+});
+const decodeReleaseAgeExcludePatternParts = Schema.decodeUnknownResult(ReleaseAgeExcludePatternPartsSchema);
+const parseReleaseAgeExcludePattern = (input) => {
+    const segments = input.split("/");
+    if (segments.length === 2) {
+        const [owner, wildcard] = segments;
+        if (owner === undefined || wildcard !== "*")
+            return undefined;
+        const decoded = decodeReleaseAgeExcludePatternParts({ owner, type: "*", name: "*" });
+        return Result.isSuccess(decoded) ? decoded.success : undefined;
+    }
+    if (segments.length !== 3)
+        return undefined;
+    const [owner, typeSegment, name] = segments;
+    if (owner === undefined ||
+        typeSegment === undefined ||
+        name === undefined ||
+        !isExtensionTypePlural(typeSegment)) {
+        return undefined;
+    }
+    const decoded = decodeReleaseAgeExcludePatternParts({
+        owner,
+        type: toExtensionType(typeSegment),
+        name,
+    });
+    return Result.isSuccess(decoded) ? decoded.success : undefined;
+};
+const formatReleaseAgeExcludePattern = (pattern) => pattern.type === "*"
+    ? `${pattern.owner}/*`
+    : `${pattern.owner}/${toExtensionTypePlural(pattern.type)}/${pattern.name}`;
+/** A validated publisher, type, or exact-extension release-age exemption. */
+export const ReleaseAgeExcludePatternSchema = Schema.String.pipe(Schema.decodeTo(Schema.toType(ReleaseAgeExcludePatternPartsSchema), SchemaTransformation.transformOrFail({
+    decode: (input) => {
+        const parsed = parseReleaseAgeExcludePattern(input);
+        return parsed === undefined
+            ? Effect.fail(new SchemaIssue.Forbidden({ message: INVALID_RELEASE_AGE_EXCLUDE_PATTERN_MESSAGE }, input))
+            : Effect.succeed(parsed);
+    },
+    encode: (pattern) => Effect.succeed(formatReleaseAgeExcludePattern(pattern)),
+})), Schema.annotate({
+    identifier: "ReleaseAgeExcludePattern",
+    title: "Minimum Release Age Exclude Pattern",
+    description: "A registry extension exemption matching one exact FQN, one owner and extension type, or one owner.",
+    message: INVALID_RELEASE_AGE_EXCLUDE_PATTERN_MESSAGE,
+}), Schema.annotateEncoded({
+    examples: ["@acme/skills/code-review", "@acme/skills/*", "@acme/*"],
+}));
+export const matchesReleaseAgeExcludePattern = (pattern, identity) => pattern.owner === identity.owner &&
+    (pattern.type === "*" || pattern.type === identity.type) &&
+    (pattern.name === "*" || pattern.name === identity.name);
+//# sourceMappingURL=fqn-pattern.js.map

package/dist/src/unstable/extensions/fqn.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Fully qualified name (FQN) parsing and formatting for 3-segment extension names.
+ *
+ * FQN format: `@owner/type-plural/name` (e.g., `@acme/skills/code-review`)
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Result from "effect/Result";
+import { type ExtensionFqnParts } from "./common.js";
+declare const FqnInvalidError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FqnInvalidError";
+} & Readonly<A>;
+/**
+ * Failure produced when an FQN string does not match the canonical
+ * `@owner/type-plural/name` shape.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare class FqnInvalidError extends FqnInvalidError_base<{
+    readonly input: string;
+}> {
+}
+/**
+ * Parse a 3-segment FQN string into its parts.
+ *
+ * Pure synchronous validation — yield the Result in `Effect.gen` to bridge
+ * failures into the surrounding error channel, or pattern-match on it directly
+ * for synchronous callers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const parseFqn: (input: string) => Result.Result<ExtensionFqnParts, FqnInvalidError>;
+/**
+ * Parse a schema-validated FQN, throwing as a defect on failure.
+ *
+ * Use only at call sites where the input has already been validated against
+ * an FQN schema (e.g., manifest dependency keys, lockfile resolved maps).
+ * A failure here is an invariant violation, not a user error — inside
+ * `Effect.gen`, the synchronous throw surfaces as `Cause.Die`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const parseFqnOrThrow: (input: string) => ExtensionFqnParts;
+/**
+ * Format a parsed FQN back into a string.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const formatFqn: (fqn: ExtensionFqnParts) => string;
+export {};
+//# sourceMappingURL=fqn.d.ts.map

package/dist/src/unstable/extensions/fqn.js

@@ -0,0 +1,51 @@
+/**
+ * Fully qualified name (FQN) parsing and formatting for 3-segment extension names.
+ *
+ * FQN format: `@owner/type-plural/name` (e.g., `@acme/skills/code-review`)
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+import * as Result from "effect/Result";
+import { parseExtensionFqnParts, toExtensionTypePlural } from "./common.js";
+/**
+ * Failure produced when an FQN string does not match the canonical
+ * `@owner/type-plural/name` shape.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export class FqnInvalidError extends Data.TaggedError("FqnInvalidError") {
+}
+/**
+ * Parse a 3-segment FQN string into its parts.
+ *
+ * Pure synchronous validation — yield the Result in `Effect.gen` to bridge
+ * failures into the surrounding error channel, or pattern-match on it directly
+ * for synchronous callers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const parseFqn = (input) => {
+    const parsed = parseExtensionFqnParts(input);
+    return parsed === undefined
+        ? Result.fail(new FqnInvalidError({ input }))
+        : Result.succeed(parsed);
+};
+/**
+ * Parse a schema-validated FQN, throwing as a defect on failure.
+ *
+ * Use only at call sites where the input has already been validated against
+ * an FQN schema (e.g., manifest dependency keys, lockfile resolved maps).
+ * A failure here is an invariant violation, not a user error — inside
+ * `Effect.gen`, the synchronous throw surfaces as `Cause.Die`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const parseFqnOrThrow = (input) => Result.getOrThrowWith(parseFqn(input), (error) => error);
+/**
+ * Format a parsed FQN back into a string.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const formatFqn = (fqn) => `${fqn.owner}/${toExtensionTypePlural(fqn.type)}/${fqn.name}`;
+//# sourceMappingURL=fqn.js.map

package/dist/src/unstable/extensions/handle.d.ts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+export declare const SLUG_PATTERN_SOURCE = "[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?";
+export declare const HANDLE_PATTERN_SOURCE = "@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?";
+export declare const SLUG_PATTERN: RegExp;
+export declare const HANDLE_PATTERN: RegExp;
+export declare const SlugSchema: Schema.brand<Schema.String, "Slug">;
+export type Slug = Schema.Schema.Type<typeof SlugSchema>;
+export declare const HandleSchema: Schema.brand<Schema.String, "Handle">;
+export type Handle = Schema.Schema.Type<typeof HandleSchema>;
+export declare const decodeHandleSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Handle">;
+export declare const decodeSlugSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Slug">;
+export declare const handleFromSlug: (slug: Slug) => Handle;
+export declare const slugFromHandle: (handle: Handle) => Slug;
+export declare const normalizeSlug: (slug: string) => Slug;
+export declare const normalizeHandle: (handle: string) => Handle;
+//# sourceMappingURL=handle.d.ts.map

package/dist/src/unstable/extensions/handle.js

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+export const SLUG_PATTERN_SOURCE = "[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?";
+export const HANDLE_PATTERN_SOURCE = `@${SLUG_PATTERN_SOURCE}`;
+export const SLUG_PATTERN = new RegExp(`^${SLUG_PATTERN_SOURCE}$`);
+export const HANDLE_PATTERN = new RegExp(`^${HANDLE_PATTERN_SOURCE}$`);
+export const SlugSchema = Schema.String.pipe(Schema.check(Schema.isPattern(SLUG_PATTERN, {
+    message: "Expected a valid slug (lowercase alphanumeric, hyphens, and underscores)",
+})), Schema.annotate({
+    identifier: "Slug",
+    title: "Slug",
+    description: "A short name using lowercase letters, numbers, hyphens, and underscores.",
+    examples: ["my-org", "user_name"],
+    message: "Expected a valid slug (e.g., my-org)",
+}), Schema.brand("Slug"));
+export const HandleSchema = Schema.String.pipe(Schema.check(Schema.isPattern(HANDLE_PATTERN, {
+    message: "Expected a valid handle starting with @ (e.g., @my-org)",
+})), Schema.annotate({
+    identifier: "Handle",
+    title: "Handle",
+    description: "A unique username or organization name starting with @, like @my-org.",
+    examples: ["@my-org", "@username"],
+    message: "Expected a valid handle (e.g., @my-org)",
+}), Schema.brand("Handle"));
+export const decodeHandleSync = Schema.decodeUnknownSync(HandleSchema);
+export const decodeSlugSync = Schema.decodeUnknownSync(SlugSchema);
+export const handleFromSlug = (slug) => decodeHandleSync(`@${slug}`);
+export const slugFromHandle = (handle) => decodeSlugSync(handle.slice(1));
+export const normalizeSlug = (slug) => decodeSlugSync(slug.trim().toLowerCase());
+export const normalizeHandle = (handle) => decodeHandleSync(handle.trim().toLowerCase());
+//# sourceMappingURL=handle.js.map

package/dist/src/unstable/extensions/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Area barrel for the package public surface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { AgentIdSchema, type Author, AuthorSchema, CONTAINER_EXTENSION_TYPES, CommonManifestBaseFields, type ConfigurableAgentId, ConfigurableAgentIdSchema, type ContainerType, EXTENSION_NAME_PATTERN, EXTENSION_ONLY_TYPES, type ExtensionDependencyConstraintMap, ExtensionDependencyConstraintMapSchema, type ExtensionFqn, type ExtensionFqnParts, ExtensionFqnPartsSchema, ExtensionFqnSchema, type ExtensionName, ExtensionNameSchema, type ExtensionSpec, ExtensionSpecSchema, type ExtensionType, type ExtensionTypePlural, ExtensionTypePluralSchema, ExtensionTypeSchema, type ExtensionVisibility, ExtensionVisibilitySchema, FQN_PATTERN, LicenseSchema, NON_PACK_FQN_PATTERN, type NonPackExtensionDependencyConstraintMap, NonPackExtensionDependencyConstraintMapSchema, type NonPackExtensionFqn, NonPackExtensionFqnSchema, type NonPackExtensionTypePlural, NonPackManifestFields, PACK_FQN_PATTERN, PER_AGENT_EXTENSION_TYPES, type PackFqn, PackFqnSchema, type PackSpec, PackSpecSchema, type PerAgentType, type PublishOptions, PublishOptionsSchema, WORKSPACE_CAPABILITY_EXTENSION_TYPES, type WorkspaceCapabilityType, decodeExtensionNameSync, extensionTypeFromPlural, extensionTypeLabels, extensionTypePluralLabels, extensionTypePluralSegments, extensionTypePluralSentenceLabels, extensionTypeSentenceLabels, extensionTypeToPlural, extensionTypes, isExtensionType, isExtensionTypePlural, nonPackExtensionTypePluralSegments, parseExtensionFqnParts, parseExtensionSpecParts, toAuthor, toExtensionType, toExtensionTypePlural, } from "./common.js";
+export { type ReleaseAgeExcludePattern, ReleaseAgeExcludePatternSchema, matchesReleaseAgeExcludePattern, } from "./fqn-pattern.js";
+export { FqnInvalidError, formatFqn, parseFqn, parseFqnOrThrow } from "./fqn.js";
+export { HANDLE_PATTERN, HANDLE_PATTERN_SOURCE, type Handle, HandleSchema, SLUG_PATTERN, SLUG_PATTERN_SOURCE, type Slug, SlugSchema, decodeHandleSync, decodeSlugSync, handleFromSlug, normalizeHandle, normalizeSlug, slugFromHandle, } from "./handle.js";
+export { parseLicenseExpression } from "./license.js";
+export { EXTENSION_METADATA_MAX_BYTES, EXTENSION_METADATA_MAX_DEPTH, type ExtensionMetadata, ExtensionMetadataSchema, extensionMetadataCompactByteLength, extensionMetadataContainerDepth, } from "./manifest-metadata.js";
+export { type RegistrySourcePatternParts, RegistrySourcePatternPartsSchema, RegistrySourcePatternSchema, type RegistrySourceRefParts, RegistrySourceRefPartsSchema, RegistrySourceRefSchema, type SourceQualifiedRegistrySourcePatternParts, formatRegistrySourcePatternParts, formatRegistrySourceRef, parseRegistrySourcePatternParts, parseRegistrySourceRef, parseSourceQualifiedRegistrySourcePatternParts, } from "./registry-source.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/unstable/extensions/index.js

@@ -0,0 +1,13 @@
+/**
+ * Area barrel for the package public surface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { AgentIdSchema, AuthorSchema, CONTAINER_EXTENSION_TYPES, CommonManifestBaseFields, ConfigurableAgentIdSchema, EXTENSION_NAME_PATTERN, EXTENSION_ONLY_TYPES, ExtensionDependencyConstraintMapSchema, ExtensionFqnPartsSchema, ExtensionFqnSchema, ExtensionNameSchema, ExtensionSpecSchema, ExtensionTypePluralSchema, ExtensionTypeSchema, ExtensionVisibilitySchema, FQN_PATTERN, LicenseSchema, NON_PACK_FQN_PATTERN, NonPackExtensionDependencyConstraintMapSchema, NonPackExtensionFqnSchema, NonPackManifestFields, PACK_FQN_PATTERN, PER_AGENT_EXTENSION_TYPES, PackFqnSchema, PackSpecSchema, PublishOptionsSchema, WORKSPACE_CAPABILITY_EXTENSION_TYPES, decodeExtensionNameSync, extensionTypeFromPlural, extensionTypeLabels, extensionTypePluralLabels, extensionTypePluralSegments, extensionTypePluralSentenceLabels, extensionTypeSentenceLabels, extensionTypeToPlural, extensionTypes, isExtensionType, isExtensionTypePlural, nonPackExtensionTypePluralSegments, parseExtensionFqnParts, parseExtensionSpecParts, toAuthor, toExtensionType, toExtensionTypePlural, } from "./common.js";
+export { ReleaseAgeExcludePatternSchema, matchesReleaseAgeExcludePattern, } from "./fqn-pattern.js";
+export { FqnInvalidError, formatFqn, parseFqn, parseFqnOrThrow } from "./fqn.js";
+export { HANDLE_PATTERN, HANDLE_PATTERN_SOURCE, HandleSchema, SLUG_PATTERN, SLUG_PATTERN_SOURCE, SlugSchema, decodeHandleSync, decodeSlugSync, handleFromSlug, normalizeHandle, normalizeSlug, slugFromHandle, } from "./handle.js";
+export { parseLicenseExpression } from "./license.js";
+export { EXTENSION_METADATA_MAX_BYTES, EXTENSION_METADATA_MAX_DEPTH, ExtensionMetadataSchema, extensionMetadataCompactByteLength, extensionMetadataContainerDepth, } from "./manifest-metadata.js";
+export { RegistrySourcePatternPartsSchema, RegistrySourcePatternSchema, RegistrySourceRefPartsSchema, RegistrySourceRefSchema, formatRegistrySourcePatternParts, formatRegistrySourceRef, parseRegistrySourcePatternParts, parseRegistrySourceRef, parseSourceQualifiedRegistrySourcePatternParts, } from "./registry-source.js";
+//# sourceMappingURL=index.js.map

package/dist/src/unstable/extensions/installable-types.d.ts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+export declare const installableExtensionTypes: readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[];
+export type InstallableExtensionType = (typeof installableExtensionTypes)[number];
+export declare const isInstallableExtensionType: (value: string | undefined) => value is InstallableExtensionType;
+export declare const installableExtensionTypePluralSegments: readonly ("skills" | "mcps" | "subagents" | "rules" | "hooks" | "knowledge" | "packs")[];
+export type InstallableExtensionTypePlural = (typeof installableExtensionTypePluralSegments)[number];
+export declare const isInstallableExtensionTypePlural: (value: string | undefined) => value is InstallableExtensionTypePlural;
+export declare const toInstallableExtensionType: (segment: InstallableExtensionTypePlural) => InstallableExtensionType;
+export declare const toInstallableExtensionTypePlural: (type: InstallableExtensionType) => InstallableExtensionTypePlural;
+export declare const InstallableExtensionTypeSchema: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+export declare const InstallableExtensionTypePluralSchema: Schema.Literals<readonly ("skills" | "mcps" | "subagents" | "rules" | "hooks" | "knowledge" | "packs")[]>;
+//# sourceMappingURL=installable-types.d.ts.map

package/dist/src/unstable/extensions/installable-types.js

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+import { extensionTypeFromPlural, extensionTypePluralSegments, extensionTypes, extensionTypeToPlural, isExtensionType, isExtensionTypePlural, } from "./common.js";
+export const installableExtensionTypes = extensionTypes;
+export const isInstallableExtensionType = (value) => isExtensionType(value);
+export const installableExtensionTypePluralSegments = extensionTypePluralSegments;
+export const isInstallableExtensionTypePlural = (value) => isExtensionTypePlural(value);
+const installableExtensionTypeFromPlural = extensionTypeFromPlural;
+const installableExtensionTypeToPlural = extensionTypeToPlural;
+export const toInstallableExtensionType = (segment) => installableExtensionTypeFromPlural[segment];
+export const toInstallableExtensionTypePlural = (type) => installableExtensionTypeToPlural[type];
+export const InstallableExtensionTypeSchema = Schema.Literals(installableExtensionTypes).annotate({
+    identifier: "InstallableExtensionType",
+    title: "Installable Extension Type",
+    description: "Extension types supported by install-oriented CLI and registry flows.",
+});
+export const InstallableExtensionTypePluralSchema = Schema.Literals(installableExtensionTypePluralSegments).annotate({
+    identifier: "InstallableExtensionTypePlural",
+    title: "Installable Extension Type (Plural)",
+    description: "Plural extension type segments supported by install-oriented CLI and registry flows.",
+});
+//# sourceMappingURL=installable-types.js.map

package/dist/src/unstable/extensions/license.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SPDX license expression validation for extension manifests.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Result from "effect/Result";
+/**
+ * Parse and validate an extension manifest license string.
+ *
+ * Accepts SPDX license expressions plus the npm-compatible `UNLICENSED`
+ * escape hatch for proprietary code.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const parseLicenseExpression: (input: string) => Result.Result<void, string>;
+//# sourceMappingURL=license.d.ts.map

package/dist/src/unstable/extensions/license.js

@@ -0,0 +1,29 @@
+/**
+ * SPDX license expression validation for extension manifests.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Result from "effect/Result";
+import parseSpdxExpression from "spdx-expression-parse";
+const UNLICENSED = "UNLICENSED";
+const parseErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+/**
+ * Parse and validate an extension manifest license string.
+ *
+ * Accepts SPDX license expressions plus the npm-compatible `UNLICENSED`
+ * escape hatch for proprietary code.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const parseLicenseExpression = (input) => {
+    if (input === UNLICENSED)
+        return Result.void;
+    try {
+        parseSpdxExpression(input);
+        return Result.void;
+    }
+    catch (error) {
+        return Result.fail(parseErrorMessage(error));
+    }
+};
+//# sourceMappingURL=license.js.map

package/dist/src/unstable/extensions/manifest-metadata.d.ts

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+/** @experimental This API is unstable and may change without notice. */
+export declare const EXTENSION_METADATA_MAX_BYTES = 65536;
+/** @experimental This API is unstable and may change without notice. */
+export declare const EXTENSION_METADATA_MAX_DEPTH = 16;
+/** @experimental This API is unstable and may change without notice. */
+export declare const extensionMetadataCompactByteLength: (metadata: Schema.JsonObject) => number;
+/** @experimental This API is unstable and may change without notice. */
+export declare const extensionMetadataContainerDepth: (metadata: Schema.JsonObject) => number;
+/**
+ * Bounded, opaque consumer-defined metadata carried by an extension manifest.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const ExtensionMetadataSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+/** @experimental This API is unstable and may change without notice. */
+export type ExtensionMetadata = typeof ExtensionMetadataSchema.Type;
+//# sourceMappingURL=manifest-metadata.d.ts.map

package/dist/src/unstable/extensions/manifest-metadata.js

@@ -0,0 +1,61 @@
+import * as Schema from "effect/Schema";
+/** @experimental This API is unstable and may change without notice. */
+export const EXTENSION_METADATA_MAX_BYTES = 65_536;
+/** @experimental This API is unstable and may change without notice. */
+export const EXTENSION_METADATA_MAX_DEPTH = 16;
+const textEncoder = new TextEncoder();
+/** @experimental This API is unstable and may change without notice. */
+export const extensionMetadataCompactByteLength = (metadata) => {
+    const compact = JSON.stringify(metadata);
+    return compact === undefined ? 0 : textEncoder.encode(compact).length;
+};
+/** @experimental This API is unstable and may change without notice. */
+export const extensionMetadataContainerDepth = (metadata) => {
+    let maximum = 1;
+    const pending = [
+        { value: metadata, depth: 1 },
+    ];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            continue;
+        if (Array.isArray(current.value)) {
+            maximum = Math.max(maximum, current.depth);
+            for (const value of current.value) {
+                pending.push({ value, depth: current.depth + 1 });
+            }
+        }
+        else if (typeof current.value === "object" && current.value !== null) {
+            maximum = Math.max(maximum, current.depth);
+            for (const value of Object.values(current.value)) {
+                pending.push({ value, depth: current.depth + 1 });
+            }
+        }
+    }
+    return maximum;
+};
+const validateExtensionMetadata = (metadata) => {
+    const issues = [];
+    const bytes = extensionMetadataCompactByteLength(metadata);
+    if (bytes > EXTENSION_METADATA_MAX_BYTES) {
+        issues.push(`metadata must use at most 65,536 compact UTF-8 JSON bytes; received ${bytes.toLocaleString("en-US")}`);
+    }
+    const depth = extensionMetadataContainerDepth(metadata);
+    if (depth > EXTENSION_METADATA_MAX_DEPTH) {
+        issues.push(`metadata must have container depth at most 16; received ${depth}`);
+    }
+    return issues;
+};
+/**
+ * Bounded, opaque consumer-defined metadata carried by an extension manifest.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const ExtensionMetadataSchema = Schema.Record(Schema.String, Schema.Json)
+    .annotate({
+    identifier: "ExtensionMetadata",
+    title: "Extension Metadata",
+    description: "Opaque consumer-defined JSON metadata. The compact UTF-8 JSON representation is limited to 65,536 bytes and container depth 16.",
+})
+    .check(Schema.makeFilter(validateExtensionMetadata));
+//# sourceMappingURL=manifest-metadata.js.map

package/dist/src/unstable/extensions/refs/extension-ref.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Extension ref union assembler.
+ *
+ * Imports per-type concrete refs from feature folders and defines the
+ * unified `ExtensionRef` union. This file is a leaf — feature folders
+ * import only from `ref-base.ts`, never from this file.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { SkillExtensionRef } from "./skill.js";
+import type { McpServerExtensionRef } from "./mcp-server.js";
+import type { SubagentExtensionRef } from "./subagent.js";
+import type { RuleExtensionRef } from "./rule.js";
+import type { HookExtensionRef } from "./hook.js";
+import type { KnowledgeExtensionRef } from "./knowledge.js";
+import type { PackRef } from "./pack.js";
+/** @experimental */
+export type ExtensionRef = SkillExtensionRef | McpServerExtensionRef | SubagentExtensionRef | RuleExtensionRef | HookExtensionRef | KnowledgeExtensionRef | PackRef;
+//# sourceMappingURL=extension-ref.d.ts.map

package/dist/src/unstable/extensions/refs/extension-ref.js

@@ -0,0 +1,12 @@
+/**
+ * Extension ref union assembler.
+ *
+ * Imports per-type concrete refs from feature folders and defines the
+ * unified `ExtensionRef` union. This file is a leaf — feature folders
+ * import only from `ref-base.ts`, never from this file.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=extension-ref.js.map

package/dist/src/unstable/extensions/refs/hook.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Concrete hook ref types.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { ExtensionName } from "../common.js";
+import type { ExtensionRefBase } from "./ref-base.js";
+import type { GitHostedRefDetails, LocalRefDetails, RegistryRefDetails, WorkspaceRefDetails } from "./ref-base.js";
+import type { GitBasedSource, LocalSource, RegistrySource, WorkspaceSource } from "../../sources/types.js";
+type HookExtensionRefBase<TRefType, TSource> = ExtensionRefBase<"hook", Extract<TRefType, "git-hosted" | "registry" | "local" | "workspace">, Extract<TSource, GitBasedSource | RegistrySource | LocalSource | WorkspaceSource>> & {
+    readonly hook: {
+        readonly name: ExtensionName;
+    };
+    /** Override platform capability degradation for this extension. */
+    readonly fallback?: "auto" | "none";
+};
+/** @experimental */
+export type GitHostedHookRef = HookExtensionRefBase<"git-hosted", GitBasedSource> & GitHostedRefDetails;
+/** @experimental */
+export type RegistryHookRef = HookExtensionRefBase<"registry", RegistrySource> & RegistryRefDetails;
+/** @experimental */
+export type LocalHookRef = HookExtensionRefBase<"local", LocalSource> & LocalRefDetails;
+/** @experimental */
+export type WorkspaceHookRef = HookExtensionRefBase<"workspace", WorkspaceSource> & WorkspaceRefDetails;
+/** @experimental */
+export type HookExtensionRef = GitHostedHookRef | RegistryHookRef | LocalHookRef | WorkspaceHookRef;
+export {};
+//# sourceMappingURL=hook.d.ts.map

package/dist/src/unstable/extensions/refs/hook.js

@@ -0,0 +1,8 @@
+/**
+ * Concrete hook ref types.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=hook.js.map

package/dist/src/unstable/extensions/refs/knowledge.d.ts

@@ -0,0 +1,15 @@
+import type { ExtensionName } from "../common.js";
+import type { ExtensionRefBase, GitHostedRefDetails, LocalRefDetails, RegistryRefDetails, WorkspaceRefDetails } from "./ref-base.js";
+import type { GitBasedSource, LocalSource, RegistrySource, WorkspaceSource } from "../../sources/types.js";
+type KnowledgeExtensionRefBase<TRefType, TSource> = ExtensionRefBase<"knowledge", Extract<TRefType, "git-hosted" | "registry" | "local" | "workspace">, Extract<TSource, GitBasedSource | RegistrySource | LocalSource | WorkspaceSource>> & {
+    readonly knowledge: {
+        readonly name: ExtensionName;
+    };
+};
+export type GitHostedKnowledgeRef = KnowledgeExtensionRefBase<"git-hosted", GitBasedSource> & GitHostedRefDetails;
+export type RegistryKnowledgeRef = KnowledgeExtensionRefBase<"registry", RegistrySource> & RegistryRefDetails;
+export type LocalKnowledgeRef = KnowledgeExtensionRefBase<"local", LocalSource> & LocalRefDetails;
+export type WorkspaceKnowledgeRef = KnowledgeExtensionRefBase<"workspace", WorkspaceSource> & WorkspaceRefDetails;
+export type KnowledgeExtensionRef = GitHostedKnowledgeRef | RegistryKnowledgeRef | LocalKnowledgeRef | WorkspaceKnowledgeRef;
+export {};
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/src/unstable/extensions/refs/knowledge.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=knowledge.js.map

package/dist/src/unstable/extensions/refs/mcp-server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Concrete MCP server extension ref types.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { McpServerExtensionRefBase, GitHostedRefDetails, RegistryRefDetails, LocalRefDetails, WorkspaceRefDetails } from "./ref-base.js";
+import type { GitBasedSource, RegistrySource, LocalSource, WorkspaceSource } from "../../sources/types.js";
+/** @experimental */
+export type GitHostedMcpServerRef = McpServerExtensionRefBase<"git-hosted", GitBasedSource> & GitHostedRefDetails;
+/** @experimental */
+export type RegistryMcpServerRef = McpServerExtensionRefBase<"registry", RegistrySource> & RegistryRefDetails;
+/** @experimental */
+export type LocalMcpServerRef = McpServerExtensionRefBase<"local", LocalSource> & LocalRefDetails;
+/** @experimental */
+export type WorkspaceMcpServerRef = McpServerExtensionRefBase<"workspace", WorkspaceSource> & WorkspaceRefDetails;
+/** @experimental */
+export type McpServerExtensionRef = GitHostedMcpServerRef | RegistryMcpServerRef | LocalMcpServerRef | WorkspaceMcpServerRef;
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/src/unstable/extensions/refs/mcp-server.js

@@ -0,0 +1,8 @@
+/**
+ * Concrete MCP server extension ref types.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=mcp-server.js.map

package/dist/src/unstable/extensions/refs/pack.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pack ref types.
+ *
+ * Concrete pack refs built on top of the shared ref base hierarchy.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackRefBase, RegistryRefDetails, WorkspaceRefDetails } from "./ref-base.js";
+import type { RegistrySource, WorkspaceSource } from "../../sources/types.js";
+/** @experimental */
+export type RegistryPackRef = PackRefBase<"registry", RegistrySource> & RegistryRefDetails;
+/** @experimental */
+export type WorkspacePackRef = PackRefBase<"workspace", WorkspaceSource> & WorkspaceRefDetails;
+/** @experimental */
+export type PackRef = RegistryPackRef | WorkspacePackRef;
+//# sourceMappingURL=pack.d.ts.map

package/dist/src/unstable/extensions/refs/pack.js

@@ -0,0 +1,10 @@
+/**
+ * Pack ref types.
+ *
+ * Concrete pack refs built on top of the shared ref base hierarchy.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=pack.js.map