@agentxm/extension-publish 0.28.4-bootstrap.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2025-2026 AgentXM, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/archive.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Build a deterministic zip archive of a directory.
+ *
+ * Uses fflate (pure JS) so publish works on platforms without a system
+ * `zip` binary (notably Windows). Entries are walked via the platform
+ * FileSystem service, sorted by relative path, and stamped with a fixed
+ * mtime so the byte output is reproducible.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { PublishFailed } from "./errors.js";
+/** @experimental This API is unstable and may change without notice. */
+export interface BuildZipArchiveOptions {
+    /**
+     * Glob patterns matched against archive-relative POSIX paths. Absent or
+     * empty leaves the archive exactly as it would have been built without this
+     * option — the default path is unchanged, so already-published integrity
+     * digests stay reproducible.
+     */
+    readonly ignore?: ReadonlyArray<string> | undefined;
+}
+/** One file in the deterministic Registry archive plan. */
+export interface ArchivePlanFile {
+    readonly path: string;
+    readonly size: number;
+    readonly matchedPatterns: ReadonlyArray<string>;
+}
+/** Match accounting for one declared ignore pattern. */
+export interface ArchivePlanPattern {
+    readonly pattern: string;
+    readonly matchCount: number;
+}
+/** The effective Registry-only distribution boundary before ZIP construction. */
+export interface ArchivePlan {
+    readonly included: ReadonlyArray<ArchivePlanFile>;
+    readonly excluded: ReadonlyArray<ArchivePlanFile>;
+    readonly patterns: ReadonlyArray<ArchivePlanPattern>;
+    readonly warnings: ReadonlyArray<string>;
+    readonly includedCount: number;
+    readonly excludedCount: number;
+    readonly uncompressedBytes: number;
+}
+/** Deterministic archive bytes paired with the exact plan that produced them. */
+export interface PlannedZipArchive {
+    readonly archive: Uint8Array;
+    readonly plan: ArchivePlan;
+}
+/**
+ * Build a zip archive of a directory.
+ * Files are stored at the root of the zip (no enclosing directory).
+ * Directory entries are not emitted.
+ */
+export declare const planZipArchive: (dir: string, options?: BuildZipArchiveOptions) => Effect.Effect<{
+    archive: Uint8Array<ArrayBuffer>;
+    plan: {
+        included: ArchivePlanFile[];
+        excluded: ArchivePlanFile[];
+        patterns: {
+            pattern: string;
+            matchCount: number;
+        }[];
+        warnings: string[];
+        includedCount: number;
+        excludedCount: number;
+        uncompressedBytes: number;
+    };
+}, PublishFailed, FileSystem.FileSystem | Path.Path>;
+export declare const buildZipArchive: (dir: string, options?: BuildZipArchiveOptions) => Effect.Effect<Uint8Array<ArrayBuffer>, PublishFailed, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=archive.d.ts.map

package/dist/src/archive.js

@@ -0,0 +1,106 @@
+// @effect-diagnostics globalDate:off — ZIP's driver API requires one fixed Date value and never reads the ambient clock
+/**
+ * Build a deterministic zip archive of a directory.
+ *
+ * Uses fflate (pure JS) so publish works on platforms without a system
+ * `zip` binary (notably Windows). Entries are walked via the platform
+ * FileSystem service, sorted by relative path, and stamped with a fixed
+ * mtime so the byte output is reproducible.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { zipSync } from "fflate";
+import { PublishFailed } from "./errors.js";
+import { expandGlob } from "./internal/glob.js";
+// ZIP timestamps have no timezone. fflate serializes Date's local calendar
+// fields, so construct those fields locally to keep the encoded bytes stable
+// across host timezones.
+// eslint-disable-next-line no-restricted-syntax -- ZIP's driver API requires Date; this fixed value never reads the ambient clock.
+const DETERMINISTIC_MTIME = new Date(2020, 0, 1, 0, 0, 0, 0);
+const READ_CONCURRENCY = 16;
+/**
+ * Build a zip archive of a directory.
+ * Files are stored at the root of the zip (no enclosing directory).
+ * Directory entries are not emitted.
+ */
+export const planZipArchive = (dir, options) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const files = yield* Effect.gen(function* () {
+        const rawEntries = yield* fs.readDirectory(dir, { recursive: true });
+        const toZipPath = path.sep === "/" ? (s) => s : (s) => s.split(path.sep).join("/");
+        const candidates = yield* Effect.forEach(rawEntries, (relRaw) => Effect.gen(function* () {
+            const abs = path.join(dir, relRaw);
+            const info = yield* fs.stat(abs);
+            return {
+                rel: toZipPath(relRaw),
+                abs,
+                isFile: info.type === "File",
+                size: Number(info.size),
+            };
+        }), { concurrency: READ_CONCURRENCY });
+        const onlyFiles = candidates.filter((c) => c.isFile);
+        onlyFiles.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));
+        return onlyFiles;
+    }).pipe(Effect.mapError((cause) => new PublishFailed({
+        category: "internal",
+        detail: "Failed to read source directory for zip archive",
+        cause,
+    })));
+    const patterns = options?.ignore ?? [];
+    const paths = files.map((file) => file.rel);
+    const matchesByPattern = patterns.map((pattern) => ({
+        pattern,
+        matches: new Set(expandGlob(pattern, paths)),
+    }));
+    const planned = files.map((file) => ({
+        path: file.rel,
+        size: file.size,
+        matchedPatterns: matchesByPattern
+            .filter(({ matches }) => matches.has(file.rel))
+            .map(({ pattern }) => pattern),
+    }));
+    const included = planned.filter((file) => file.matchedPatterns.length === 0);
+    const excluded = planned.filter((file) => file.matchedPatterns.length > 0);
+    const includedPaths = new Set(included.map((file) => file.path));
+    const contents = yield* Effect.forEach(files.filter((file) => includedPaths.has(file.rel)), ({ rel, abs }) => fs.readFile(abs).pipe(Effect.map((bytes) => [rel, bytes])), { concurrency: READ_CONCURRENCY }).pipe(Effect.mapError((cause) => new PublishFailed({
+        category: "internal",
+        detail: "Failed to read file for zip archive",
+        cause,
+    })));
+    const zippable = {};
+    for (const [rel, bytes] of contents) {
+        zippable[rel] = [bytes, { mtime: DETERMINISTIC_MTIME }];
+    }
+    const archive = yield* Effect.try({
+        try: () => zipSync(zippable, { mtime: DETERMINISTIC_MTIME }),
+        catch: (cause) => new PublishFailed({
+            category: "internal",
+            detail: "Failed to build zip archive",
+            cause,
+        }),
+    });
+    const patternPlans = matchesByPattern.map(({ pattern, matches }) => ({
+        pattern,
+        matchCount: matches.size,
+    }));
+    return {
+        archive,
+        plan: {
+            included,
+            excluded,
+            patterns: patternPlans,
+            warnings: patternPlans
+                .filter(({ matchCount }) => matchCount === 0)
+                .map(({ pattern }) => `publish.ignore pattern "${pattern}" matched no files.`),
+            includedCount: included.length,
+            excludedCount: excluded.length,
+            uncompressedBytes: included.reduce((total, file) => total + file.size, 0),
+        },
+    };
+});
+export const buildZipArchive = (dir, options) => planZipArchive(dir, options).pipe(Effect.map(({ archive }) => archive));
+//# sourceMappingURL=archive.js.map

package/dist/src/authorization.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Authentication requirements and grant bindings for exact publication.
+ *
+ * The feature never invokes authentication itself: it expresses the
+ * requirement as typed precondition data and consumes the authorization
+ * RESULT as a structural grant value. The application sequences the
+ * registry-auth feature to satisfy the requirement and passes each issued
+ * grant into the upload binding as data.
+ */
+import type { OperationPrecondition } from "@agentxm/workspace-operations";
+import type { PublishVisibility } from "@agentxm/registry-protocol/unstable/publish";
+import type { PublicationVisibilityInput, Sha256Hex } from "@agentxm/registry-protocol/unstable/registry";
+import type { PublishExtensionArgs } from "@agentxm/registry-client";
+/**
+ * One exact publish capability the application obtained from the Registry
+ * authorization flow. Structurally satisfied by the auth feature's issued
+ * capability; this package never depends on that feature.
+ */
+export interface PublishGrant {
+    readonly accessToken: string;
+    readonly visibility: PublishVisibility;
+    readonly condition: string;
+    readonly publicationSetDigest: Sha256Hex;
+    readonly publicationDescriptorDigest: Sha256Hex;
+}
+/** The authoritative preview facts one upload binds to. */
+export interface ResolvedPublishPreview {
+    readonly visibility: PublishVisibility;
+    readonly visibilityInput: PublicationVisibilityInput;
+    readonly condition?: string;
+    readonly publicationSetDigest: string;
+    readonly publicationDescriptorDigest: string;
+}
+export declare const publishAuthenticationPreconditions: (options: {
+    readonly preview: boolean;
+    readonly remoteRegistry: boolean;
+    readonly authenticated: boolean;
+    readonly hasPublishCandidates: boolean;
+}) => ReadonlyArray<OperationPrecondition>;
+export declare const exactPublishUploadBinding: (capability: PublishGrant, visibilityInput: PublicationVisibilityInput) => Pick<PublishExtensionArgs, "accessToken" | "condition" | "visibility" | "visibilityInput" | "publicationSetDigest" | "publicationDescriptorDigest">;
+export declare const previewPublishUploadBinding: (preview: ResolvedPublishPreview) => Pick<PublishExtensionArgs, "condition" | "visibility" | "visibilityInput" | "publicationSetDigest" | "publicationDescriptorDigest">;
+//# sourceMappingURL=authorization.d.ts.map

package/dist/src/authorization.js

@@ -0,0 +1,42 @@
+/**
+ * Authentication requirements and grant bindings for exact publication.
+ *
+ * The feature never invokes authentication itself: it expresses the
+ * requirement as typed precondition data and consumes the authorization
+ * RESULT as a structural grant value. The application sequences the
+ * registry-auth feature to satisfy the requirement and passes each issued
+ * grant into the upload binding as data.
+ */
+export const publishAuthenticationPreconditions = (options) => options.preview &&
+    options.remoteRegistry &&
+    !options.authenticated &&
+    options.hasPublishCandidates
+    ? [
+        {
+            id: "authentication",
+            label: "Registry authentication",
+            status: "unmet",
+            detail: "Publishing requires human authorization before apply; authenticate before preparing a release workflow.",
+            blockedOn: "human",
+            command: "axm login --device-code --json",
+        },
+    ]
+    : [];
+export const exactPublishUploadBinding = (capability, visibilityInput) => ({
+    accessToken: capability.accessToken,
+    condition: capability.condition,
+    publicationSetDigest: capability.publicationSetDigest,
+    publicationDescriptorDigest: capability.publicationDescriptorDigest,
+    visibilityInput,
+    ...(capability.visibility.disposition === "establish"
+        ? { visibility: capability.visibility }
+        : {}),
+});
+export const previewPublishUploadBinding = (preview) => ({
+    ...(preview.condition === undefined ? {} : { condition: preview.condition }),
+    publicationSetDigest: preview.publicationSetDigest,
+    publicationDescriptorDigest: preview.publicationDescriptorDigest,
+    visibilityInput: preview.visibilityInput,
+    ...(preview.visibility.disposition === "establish" ? { visibility: preview.visibility } : {}),
+});
+//# sourceMappingURL=authorization.js.map

package/dist/src/errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Typed failures for the extension-publish feature. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+declare const PublishFailed_base: Schema.Class<PublishFailed, Schema.TaggedStruct<"PublishFailed", {
+    readonly category: Schema.Literals<readonly ["conflict", "internal", "not_found", "usage", "validation"]>;
+    readonly detail: Schema.String;
+    readonly recover: Schema.optional<Schema.String>;
+    readonly cmd: Schema.optional<Schema.String>;
+    readonly suggestions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly cmd: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A publish policy step could not proceed. The carried fields mirror the
+ * application error envelope's inputs 1:1: `category` selects the code,
+ * `recover` folds into the leading suggested action, and `detail`,
+ * `suggestions`, and `cause` carry over verbatim.
+ */
+export declare class PublishFailed extends PublishFailed_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,29 @@
+/**
+ * Typed failures for the extension-publish feature. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+const CarriedSuggestedActionSchema = Schema.Struct({
+    description: Schema.String,
+    cmd: Schema.optional(Schema.String),
+    url: Schema.optional(Schema.String),
+});
+/**
+ * A publish policy step could not proceed. The carried fields mirror the
+ * application error envelope's inputs 1:1: `category` selects the code,
+ * `recover` folds into the leading suggested action, and `detail`,
+ * `suggestions`, and `cause` carry over verbatim.
+ */
+export class PublishFailed extends Schema.TaggedError()("PublishFailed", {
+    category: Schema.Literals(["conflict", "internal", "not_found", "usage", "validation"]),
+    detail: Schema.String,
+    recover: Schema.optional(Schema.String),
+    cmd: Schema.optional(Schema.String),
+    suggestions: Schema.optional(Schema.Array(CarriedSuggestedActionSchema)),
+    cause: Schema.optional(Schema.Unknown),
+}) {
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Extension-publish feature: publish selection policy, publication
+ * validation, archive planning, authentication requirements, upload
+ * settlement, and recovery. Authentication is expressed as typed
+ * precondition data and consumed as structural grant values; the application
+ * sequences the registry-auth feature to satisfy it.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { PublishFailed } from "./errors.js";
+export { PUBLISHABLE_TYPES, isPublishableType, type PublishableType } from "./publishable-types.js";
+export { runPublishLintGate, type PublishLintArgs } from "./lint-gate.js";
+export { PublishIgnoreError, protectedPublishPaths, publishArchiveOptions, resolvePublishIgnore, } from "./publish-ignore.js";
+export { buildZipArchive, planZipArchive, type ArchivePlan, type ArchivePlanFile, type ArchivePlanPattern, type BuildZipArchiveOptions, type PlannedZipArchive, } from "./archive.js";
+export { settlePublish, type PublishSettlement, type PublishSettlementFailure, type SettledPublish, } from "./settlement.js";
+export { exactPublishUploadBinding, previewPublishUploadBinding, publishAuthenticationPreconditions, type PublishGrant, type ResolvedPublishPreview, } from "./authorization.js";
+export { buildPublishJobs, type PublishPlanCandidate } from "./jobs.js";
+export { publishRecoverySelection, type PublishRecoveryItem } from "./recovery.js";
+export { alreadyPublishedVersionConflict, findPackPublishDivergenceFindings, localPackConstraintFailures, nonMonotonicVersionConflict, validatePublishOwners, type LocalPackConstraintCandidate, type PublishAdvisoryFinding, type PublishAdvisorySuggestion, } from "./preflight.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,21 @@
+/**
+ * Extension-publish feature: publish selection policy, publication
+ * validation, archive planning, authentication requirements, upload
+ * settlement, and recovery. Authentication is expressed as typed
+ * precondition data and consumed as structural grant values; the application
+ * sequences the registry-auth feature to satisfy it.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { PublishFailed } from "./errors.js";
+export { PUBLISHABLE_TYPES, isPublishableType } from "./publishable-types.js";
+export { runPublishLintGate } from "./lint-gate.js";
+export { PublishIgnoreError, protectedPublishPaths, publishArchiveOptions, resolvePublishIgnore, } from "./publish-ignore.js";
+export { buildZipArchive, planZipArchive, } from "./archive.js";
+export { settlePublish, } from "./settlement.js";
+export { exactPublishUploadBinding, previewPublishUploadBinding, publishAuthenticationPreconditions, } from "./authorization.js";
+export { buildPublishJobs } from "./jobs.js";
+export { publishRecoverySelection } from "./recovery.js";
+export { alreadyPublishedVersionConflict, findPackPublishDivergenceFindings, localPackConstraintFailures, nonMonotonicVersionConflict, validatePublishOwners, } from "./preflight.js";
+//# sourceMappingURL=index.js.map

package/dist/src/internal/glob.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Glob expansion for extension names.
+ *
+ * Deliberately duplicated from the CLI-destined glob module: the feature may
+ * not depend on application utilities, and this helper is within the
+ * sanctioned duplication budget for small pure functions.
+ *
+ * Expands `*` wildcards against a list of names. Only `*` is supported
+ * as a wildcard — all other characters are treated as literals.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Expand a glob pattern against a list of names.
+ *
+ * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
+ * are treated as literals. Matching is case-sensitive.
+ *
+ * @param pattern - The pattern to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order
+ */
+export declare const expandGlob: (pattern: string, names: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Expand multiple glob patterns against a list of skill names.
+ *
+ * Returns the union of all matches, deduplicated, preserving the original
+ * order of `names`.
+ *
+ * @param patterns - Patterns to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order, deduplicated
+ */
+export declare const expandGlobs: (patterns: ReadonlyArray<string>, names: ReadonlyArray<string>) => ReadonlyArray<string>;
+/**
+ * Returns true when an input should be treated as a glob pattern.
+ */
+export declare const isGlobPattern: (input: string) => boolean;
+//# sourceMappingURL=glob.d.ts.map

package/dist/src/internal/glob.js

@@ -0,0 +1,79 @@
+/**
+ * Glob expansion for extension names.
+ *
+ * Deliberately duplicated from the CLI-destined glob module: the feature may
+ * not depend on application utilities, and this helper is within the
+ * sanctioned duplication budget for small pure functions.
+ *
+ * Expands `*` wildcards against a list of names. Only `*` is supported
+ * as a wildcard — all other characters are treated as literals.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/**
+ * Expand a glob pattern against a list of names.
+ *
+ * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
+ * are treated as literals. Matching is case-sensitive.
+ *
+ * @param pattern - The pattern to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order
+ */
+export const expandGlob = (pattern, names) => {
+    const matches = (name) => {
+        let patternIndex = 0;
+        let nameIndex = 0;
+        let wildcardIndex = -1;
+        let wildcardNameIndex = 0;
+        while (nameIndex < name.length) {
+            const token = pattern[patternIndex];
+            if (token !== undefined && token !== "*" && token === name[nameIndex]) {
+                patternIndex += 1;
+                nameIndex += 1;
+            }
+            else if (token === "*") {
+                wildcardIndex = patternIndex;
+                wildcardNameIndex = nameIndex;
+                patternIndex += 1;
+            }
+            else if (wildcardIndex >= 0) {
+                patternIndex = wildcardIndex + 1;
+                wildcardNameIndex += 1;
+                nameIndex = wildcardNameIndex;
+            }
+            else {
+                return false;
+            }
+        }
+        while (pattern[patternIndex] === "*") {
+            patternIndex += 1;
+        }
+        return patternIndex === pattern.length;
+    };
+    return names.filter(matches);
+};
+/**
+ * Expand multiple glob patterns against a list of skill names.
+ *
+ * Returns the union of all matches, deduplicated, preserving the original
+ * order of `names`.
+ *
+ * @param patterns - Patterns to match (may contain `*`)
+ * @param names - Available names to match against
+ * @returns Matching names in their original order, deduplicated
+ */
+export const expandGlobs = (patterns, names) => {
+    const matched = new Set();
+    for (const pattern of patterns) {
+        for (const name of expandGlob(pattern, names)) {
+            matched.add(name);
+        }
+    }
+    return names.filter((n) => matched.has(n));
+};
+/**
+ * Returns true when an input should be treated as a glob pattern.
+ */
+export const isGlobPattern = (input) => input.includes("*");
+//# sourceMappingURL=glob.js.map

package/dist/src/jobs.d.ts

@@ -0,0 +1,12 @@
+import type { Job, PlannedJobStep } from "@agentxm/workspace-operations";
+import type { PublishableType } from "./publishable-types.js";
+/** The selection facts one publish candidate contributes to job planning. */
+export interface PublishPlanCandidate {
+    readonly fqn: string;
+    readonly type: PublishableType;
+    readonly dependencies?: Readonly<Record<string, unknown>>;
+    readonly includedDependency?: true;
+}
+/** Creates dependency edges without expanding the user's selection. */
+export declare const buildPublishJobs: <Candidate extends PublishPlanCandidate, Requirements = never, Output = never>(candidates: ReadonlyArray<Candidate>, candidateStep: (candidate: Candidate) => PlannedJobStep<Requirements, Output>) => ReadonlyArray<Job<Requirements, Output>>;
+//# sourceMappingURL=jobs.d.ts.map

package/dist/src/jobs.js

@@ -0,0 +1,20 @@
+/** Creates dependency edges without expanding the user's selection. */
+export const buildPublishJobs = (candidates, candidateStep) => {
+    const selectedFqns = new Set(candidates.map((candidate) => candidate.fqn));
+    return [
+        {
+            concurrency: 4,
+            executionPolicy: "best-effort",
+            steps: candidates.map((candidate) => ({
+                ...candidateStep(candidate),
+                key: candidate.fqn,
+                ...(candidate.type !== "pack"
+                    ? {}
+                    : {
+                        dependsOn: Object.keys(candidate.dependencies ?? {}).filter((fqn) => selectedFqns.has(fqn)),
+                    }),
+            })),
+        },
+    ];
+};
+//# sourceMappingURL=jobs.js.map