@agentxm/extension-model 0.28.5 → 0.28.7-preview.1788522540.63ba4b89a

package/dist/src/unstable/release-channel.d.ts

@@ -0,0 +1,156 @@
+import * as Schema from "effect/Schema";
+/** @experimental This API is unstable and may change without notice. */
+export declare const STABLE_CHANNEL_SCHEMA = "axm.release-channel/v1";
+/** @experimental This API is unstable and may change without notice. */
+export declare const STABLE_CHANNEL_URL = "https://releases.axm.sh/v1/channels/stable.json";
+/** @experimental This API is unstable and may change without notice. */
+export declare const STABLE_CHANNEL_REPOSITORY = "agentxm/axm";
+/**
+ * Public stable-channel document. Exact-version artifacts remain hosted by the
+ * immutable GitHub Release coordinate contained in this validated document.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const StableChannelDocumentV1Schema: Schema.Struct<{
+    readonly schema: Schema.Literal<"axm.release-channel/v1">;
+    readonly channel: Schema.Literal<"stable">;
+    readonly revision: Schema.Int;
+    readonly version: Schema.String;
+    readonly release: Schema.Struct<{
+        readonly repository: Schema.Literal<"agentxm/axm">;
+        readonly tag: Schema.String;
+        readonly commit: Schema.String;
+        readonly publishedAt: Schema.String;
+    }>;
+    readonly artifacts: Schema.Struct<{
+        readonly checksumManifest: Schema.Struct<{
+            readonly name: Schema.Literal<"SHA256SUMS">;
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+        }>;
+        readonly binaries: Schema.Tuple<readonly [Schema.Struct<{
+            readonly target: Schema.Literal<"darwin-arm64">;
+            readonly name: Schema.Literal<"axm-darwin-arm64">;
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+        }>, Schema.Struct<{
+            readonly target: Schema.Literal<"darwin-x64">;
+            readonly name: Schema.Literal<"axm-darwin-x64">;
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+        }>, Schema.Struct<{
+            readonly target: Schema.Literal<"linux-arm64">;
+            readonly name: Schema.Literal<"axm-linux-arm64">;
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+        }>, Schema.Struct<{
+            readonly target: Schema.Literal<"linux-x64">;
+            readonly name: Schema.Literal<"axm-linux-x64">;
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+        }>, Schema.Struct<{
+            readonly target: Schema.Literal<"windows-x64">;
+            readonly name: Schema.Literal<"axm-windows-x64.exe">;
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+        }>]>;
+    }>;
+    readonly promotedAt: Schema.String;
+}>;
+/** @experimental This API is unstable and may change without notice. */
+export type StableChannelDocumentV1 = typeof StableChannelDocumentV1Schema.Type;
+/** @experimental This API is unstable and may change without notice. */
+export declare const decodeStableChannelDocument: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly schema: "axm.release-channel/v1";
+    readonly channel: "stable";
+    readonly revision: number;
+    readonly version: string;
+    readonly release: {
+        readonly repository: "agentxm/axm";
+        readonly tag: string;
+        readonly commit: string;
+        readonly publishedAt: string;
+    };
+    readonly artifacts: {
+        readonly checksumManifest: {
+            readonly name: "SHA256SUMS";
+            readonly url: string;
+            readonly sha256: string;
+        };
+        readonly binaries: readonly [{
+            readonly target: "darwin-arm64";
+            readonly name: "axm-darwin-arm64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "darwin-x64";
+            readonly name: "axm-darwin-x64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "linux-arm64";
+            readonly name: "axm-linux-arm64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "linux-x64";
+            readonly name: "axm-linux-x64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "windows-x64";
+            readonly name: "axm-windows-x64.exe";
+            readonly url: string;
+            readonly sha256: string;
+        }];
+    };
+    readonly promotedAt: string;
+}, Schema.SchemaError, never>;
+/** @experimental This API is unstable and may change without notice. */
+export declare const decodeStableChannelDocumentSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly schema: "axm.release-channel/v1";
+    readonly channel: "stable";
+    readonly revision: number;
+    readonly version: string;
+    readonly release: {
+        readonly repository: "agentxm/axm";
+        readonly tag: string;
+        readonly commit: string;
+        readonly publishedAt: string;
+    };
+    readonly artifacts: {
+        readonly checksumManifest: {
+            readonly name: "SHA256SUMS";
+            readonly url: string;
+            readonly sha256: string;
+        };
+        readonly binaries: readonly [{
+            readonly target: "darwin-arm64";
+            readonly name: "axm-darwin-arm64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "darwin-x64";
+            readonly name: "axm-darwin-x64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "linux-arm64";
+            readonly name: "axm-linux-arm64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "linux-x64";
+            readonly name: "axm-linux-x64";
+            readonly url: string;
+            readonly sha256: string;
+        }, {
+            readonly target: "windows-x64";
+            readonly name: "axm-windows-x64.exe";
+            readonly url: string;
+            readonly sha256: string;
+        }];
+    };
+    readonly promotedAt: string;
+};
+//# sourceMappingURL=release-channel.d.ts.map

package/dist/src/unstable/release-channel.js

@@ -0,0 +1,92 @@
+import * as Schema from "effect/Schema";
+import * as semver from "semver";
+/** @experimental This API is unstable and may change without notice. */
+export const STABLE_CHANNEL_SCHEMA = "axm.release-channel/v1";
+/** @experimental This API is unstable and may change without notice. */
+export const STABLE_CHANNEL_URL = "https://releases.axm.sh/v1/channels/stable.json";
+/** @experimental This API is unstable and may change without notice. */
+export const STABLE_CHANNEL_REPOSITORY = "agentxm/axm";
+const Sha256Schema = Schema.String.pipe(Schema.check(Schema.isPattern(/^[0-9a-f]{64}$/u, {
+    message: "Expected a lowercase SHA-256 digest",
+})));
+const UtcInstantSchema = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => {
+    if (!value.endsWith("Z") || Number.isNaN(Date.parse(value))) {
+        return "Expected a valid UTC RFC 3339 instant";
+    }
+    return undefined;
+})));
+const StableVersionSchema = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => {
+    const normalized = semver.valid(value);
+    return normalized === value && semver.prerelease(value) === null
+        ? undefined
+        : "Expected a normalized stable semantic version without a leading v";
+})));
+const ReleaseBinarySchema = (target, name) => Schema.Struct({
+    target: Schema.Literal(target),
+    name: Schema.Literal(name),
+    url: Schema.String,
+    sha256: Sha256Schema,
+});
+const StableChannelDocumentShape = Schema.Struct({
+    schema: Schema.Literal(STABLE_CHANNEL_SCHEMA),
+    channel: Schema.Literal("stable"),
+    revision: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1, { message: "Expected a positive revision" }))),
+    version: StableVersionSchema,
+    release: Schema.Struct({
+        repository: Schema.Literal(STABLE_CHANNEL_REPOSITORY),
+        tag: Schema.String,
+        commit: Schema.String.pipe(Schema.check(Schema.isPattern(/^[0-9a-f]{40}$/u, {
+            message: "Expected a lowercase 40-character Git object ID",
+        }))),
+        publishedAt: UtcInstantSchema,
+    }),
+    artifacts: Schema.Struct({
+        checksumManifest: Schema.Struct({
+            name: Schema.Literal("SHA256SUMS"),
+            url: Schema.String,
+            sha256: Sha256Schema,
+        }),
+        binaries: Schema.Tuple([
+            ReleaseBinarySchema("darwin-arm64", "axm-darwin-arm64"),
+            ReleaseBinarySchema("darwin-x64", "axm-darwin-x64"),
+            ReleaseBinarySchema("linux-arm64", "axm-linux-arm64"),
+            ReleaseBinarySchema("linux-x64", "axm-linux-x64"),
+            ReleaseBinarySchema("windows-x64", "axm-windows-x64.exe"),
+        ]),
+    }),
+    promotedAt: UtcInstantSchema,
+});
+const expectedAssetUrl = (tag, name) => `https://github.com/${STABLE_CHANNEL_REPOSITORY}/releases/download/${tag}/${name}`;
+const validateStableChannelDocument = (document) => {
+    const issues = [];
+    const expectedTag = `cli-v${document.version}`;
+    if (document.release.tag !== expectedTag) {
+        issues.push(`release.tag must equal ${expectedTag}`);
+    }
+    const checksumUrl = expectedAssetUrl(expectedTag, document.artifacts.checksumManifest.name);
+    if (document.artifacts.checksumManifest.url !== checksumUrl) {
+        issues.push(`artifacts.checksumManifest.url must equal ${checksumUrl}`);
+    }
+    for (const binary of document.artifacts.binaries) {
+        const url = expectedAssetUrl(expectedTag, binary.name);
+        if (binary.url !== url) {
+            issues.push(`artifact URL for ${binary.name} must equal ${url}`);
+        }
+    }
+    if (Date.parse(document.promotedAt) < Date.parse(document.release.publishedAt)) {
+        issues.push("promotedAt must not be earlier than release.publishedAt");
+    }
+    return issues;
+};
+/**
+ * Public stable-channel document. Exact-version artifacts remain hosted by the
+ * immutable GitHub Release coordinate contained in this validated document.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const StableChannelDocumentV1Schema = StableChannelDocumentShape.pipe(Schema.check(Schema.makeFilter(validateStableChannelDocument)));
+/** @experimental This API is unstable and may change without notice. */
+export const decodeStableChannelDocument = Schema.decodeUnknownEffect(StableChannelDocumentV1Schema);
+/** @experimental This API is unstable and may change without notice. */
+export const decodeStableChannelDocumentSync = Schema.decodeUnknownSync(StableChannelDocumentV1Schema);
+//# sourceMappingURL=release-channel.js.map

package/dist/src/unstable/specifications/contract.d.ts

@@ -44,14 +44,6 @@ export declare const SPECIFICATION_CLASSES: readonly SpecificationClass[];
  */
 export type SpecificationRole = "experience" | "interface" | "supporting";
 export declare const SPECIFICATION_ROLES: readonly SpecificationRole[];
-/**
- * Whether the obligation is normative. A `candidate` records a proposed
- * obligation with its sources and is never authority; `accepted` records an
- * obligation the declared acceptance authority has explicitly accepted.
- * Execution evidence never changes status.
- */
-export type SpecificationStatus = "candidate" | "accepted";
-export declare const SPECIFICATION_STATUSES: readonly SpecificationStatus[];
 /**
  * Where the specification's default execution observes the system.
  * Additional boundary-specific executions bind their own evidence to the
@@ -124,8 +116,6 @@ export interface SpecificationMetadata {
      * local registry.
      */
     readonly goals: readonly [string, ...string[]];
-    /** Whether the obligation is a candidate or accepted authority. */
-    readonly status: SpecificationStatus;
     /** Observation boundary of the default execution. Defaults to `memory`. */
     readonly boundary?: ExecutionBoundary;
     /**
@@ -147,7 +137,7 @@ export interface SpecificationMetadata {
     readonly derivedFrom: readonly string[];
     /**
      * Identities this specification replaces as authority. A superseded
-     * identity is retired in the same change that accepts its successor and
+     * identity is retired in the same change that lands its successor and
      * must not remain present in the corpus.
      */
     readonly supersedes: readonly string[];

package/dist/src/unstable/specifications/contract.js

@@ -28,7 +28,6 @@ export const SPECIFICATION_ROLES = [
     "interface",
     "supporting",
 ];
-export const SPECIFICATION_STATUSES = ["candidate", "accepted"];
 export const EXECUTION_BOUNDARIES = [
     "memory",
     "process",

package/dist/src/unstable/specifications/decode.d.ts

@@ -17,7 +17,6 @@ export declare const SpecificationMetadataSchema: Schema.Struct<{
     readonly characteristic: Schema.optionalKey<Schema.String>;
     readonly role: Schema.Literals<import("./contract.js").SpecificationRole[]>;
     readonly goals: Schema.NonEmptyArray<Schema.String>;
-    readonly status: Schema.Literals<import("./contract.js").SpecificationStatus[]>;
     readonly boundary: Schema.optionalKey<Schema.Literals<import("./contract.js").ExecutionBoundary[]>>;
     readonly boundaryRationale: Schema.optionalKey<Schema.NonEmptyString>;
     readonly methods: Schema.NonEmptyArray<Schema.String>;

package/dist/src/unstable/specifications/decode.js

@@ -10,7 +10,7 @@
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import { formatSchemaIssuesToLines } from "../schema-issues.js";
-import { EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, IDENTITY_SEGMENT_PATTERN, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, SPECIFICATION_STATUSES, } from "./contract.js";
+import { EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, IDENTITY_SEGMENT_PATTERN, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, } from "./contract.js";
 const REQUIREMENT_IDENTITY_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*(\/[a-z0-9]+(-[a-z0-9]+)*)+$/;
 const RequirementIdentitySchema = Schema.String.pipe(Schema.check(Schema.isPattern(REQUIREMENT_IDENTITY_PATTERN, {
     title: "Requirement identity",
@@ -30,7 +30,6 @@ const StatedOrUnknownSchema = Schema.Union([
 ]);
 const specificationClasses = SPECIFICATION_CLASSES.map((entry) => entry);
 const specificationRoles = SPECIFICATION_ROLES.map((entry) => entry);
-const specificationStatuses = SPECIFICATION_STATUSES.map((entry) => entry);
 const executionBoundaries = EXECUTION_BOUNDARIES.map((entry) => entry);
 const executionSelections = EXECUTION_SELECTIONS.map((entry) => entry);
 export const SpecificationMetadataSchema = Schema.Struct({
@@ -41,7 +40,6 @@ export const SpecificationMetadataSchema = Schema.Struct({
     characteristic: Schema.optionalKey(IdentifierSchema),
     role: Schema.Literals(specificationRoles),
     goals: Schema.NonEmptyArray(IdentifierSchema),
-    status: Schema.Literals(specificationStatuses),
     boundary: Schema.optionalKey(Schema.Literals(executionBoundaries)),
     boundaryRationale: Schema.optionalKey(Schema.NonEmptyString),
     methods: Schema.NonEmptyArray(IdentifierSchema),
@@ -76,7 +74,13 @@ export const BoundEvidenceSchema = Schema.NonEmptyArray(BoundEvidenceGateSchema)
 const toDecodeResult = (result) => Result.isSuccess(result)
     ? { ok: true, value: result.success }
     : { ok: false, issues: formatSchemaIssuesToLines(result.failure.issue) };
-const decodeMetadata = Schema.decodeUnknownResult(SpecificationMetadataSchema);
+/**
+ * Metadata is a closed literal: a field the contract does not define is a
+ * decoding failure, never ignored.
+ */
+const decodeMetadata = Schema.decodeUnknownResult(SpecificationMetadataSchema, {
+    onExcessProperty: "error",
+});
 const decodeRegistry = Schema.decodeUnknownResult(ProductGoalRegistrySchema);
 const decodeBinding = Schema.decodeUnknownResult(ExecutionBindingSchema);
 const decodeEvidence = Schema.decodeUnknownResult(BoundEvidenceSchema);

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

@@ -3,7 +3,7 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-export { type BoundEvidenceGate, EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, type ExecutionBinding, type ExecutionBoundary, type ExecutionSelection, IDENTITY_SEGMENT_PATTERN, KNOWN_QUALITY_CHARACTERISTICS, KNOWN_SPECIFICATION_METHODS, type KnownQualityCharacteristic, type KnownSpecificationMethod, type ProductGoalDefinition, type ProductGoalRegistry, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, SPECIFICATION_STATUSES, type SpecificationClass, type SpecificationLimitation, type SpecificationMetadata, type SpecificationRole, type SpecificationStatus, UNVERIFIABLE_SPECIFICATION_METHODS, defineBoundEvidence, defineExecutionBinding, defineProductGoals, defineSpecification, } from "./contract.js";
+export { type BoundEvidenceGate, EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, type ExecutionBinding, type ExecutionBoundary, type ExecutionSelection, IDENTITY_SEGMENT_PATTERN, KNOWN_QUALITY_CHARACTERISTICS, KNOWN_SPECIFICATION_METHODS, type KnownQualityCharacteristic, type KnownSpecificationMethod, type ProductGoalDefinition, type ProductGoalRegistry, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, type SpecificationClass, type SpecificationLimitation, type SpecificationMetadata, type SpecificationRole, UNVERIFIABLE_SPECIFICATION_METHODS, defineBoundEvidence, defineExecutionBinding, defineProductGoals, defineSpecification, } from "./contract.js";
 export { BoundEvidenceSchema, ExecutionBindingSchema, ProductGoalRegistrySchema, SpecificationMetadataSchema, decodeBoundEvidence, decodeExecutionBinding, decodeProductGoalRegistry, decodeSpecificationMetadata, type DecodeResult, } from "./decode.js";
 export { type ConformanceIssue, type CorpusExecutionBinding, type CorpusInput, type CorpusSpecification, checkSpecificationCorpus, isExecutableMethodSet, lintProductLanguage, } from "./conformance.js";
 export { type SharedProductGoalId, sharedProductGoals } from "./shared-goals.js";

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

@@ -3,7 +3,7 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-export { EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, IDENTITY_SEGMENT_PATTERN, KNOWN_QUALITY_CHARACTERISTICS, KNOWN_SPECIFICATION_METHODS, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, SPECIFICATION_STATUSES, UNVERIFIABLE_SPECIFICATION_METHODS, defineBoundEvidence, defineExecutionBinding, defineProductGoals, defineSpecification, } from "./contract.js";
+export { EXECUTION_BOUNDARIES, EXECUTION_SELECTIONS, IDENTITY_SEGMENT_PATTERN, KNOWN_QUALITY_CHARACTERISTICS, KNOWN_SPECIFICATION_METHODS, SPECIFICATION_CLASSES, SPECIFICATION_ROLES, UNVERIFIABLE_SPECIFICATION_METHODS, defineBoundEvidence, defineExecutionBinding, defineProductGoals, defineSpecification, } from "./contract.js";
 export { BoundEvidenceSchema, ExecutionBindingSchema, ProductGoalRegistrySchema, SpecificationMetadataSchema, decodeBoundEvidence, decodeExecutionBinding, decodeProductGoalRegistry, decodeSpecificationMetadata, } from "./decode.js";
 export { checkSpecificationCorpus, isExecutableMethodSet, lintProductLanguage, } from "./conformance.js";
 export { sharedProductGoals } from "./shared-goals.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentxm/extension-model",
-  "version": "0.28.5",
+  "version": "0.28.7-preview.1788522540.63ba4b89a",
   "description": "Shared AgentXM extension model: identities, manifests, version constraints, and agent capabilities. Unstable and unsupported — use the axm.sh CLI.",
   "type": "module",
   "license": "FSL-1.1-MIT",
@@ -226,6 +226,11 @@
       "axm-source": "./src/unstable/path-types.ts",
       "default": "./dist/src/unstable/path-types.js"
     },
+    "./unstable/release-channel": {
+      "types": "./dist/src/unstable/release-channel.d.ts",
+      "axm-source": "./src/unstable/release-channel.ts",
+      "default": "./dist/src/unstable/release-channel.js"
+    },
     "./unstable/rules/manifest-schema": {
       "types": "./dist/src/unstable/rules/manifest-schema.d.ts",
       "axm-source": "./src/unstable/rules/manifest-schema.ts",