@agentxm/registry-protocol 0.28.4-bootstrap.0

package/dist/src/unstable/lint/catalog/pack/manifest-schema-valid.js

@@ -0,0 +1,33 @@
+/**
+ * `pack/manifest-schema-valid` — `pack.json` conforms to
+ * `PackManifestSchema`.
+ *
+ * Delegates to Effect Schema. Issues map 1:1 to findings via
+ * `issuesToFindings`.
+ *
+ * Early-return arm (no findings):
+ *
+ * - `subject.packJson === undefined` — manifest is absent (covered by
+ *   `pack/manifest-present`).
+ *
+ * Dependency-map FQN grammar and `VersionRange` decode arms are owned by
+ * `PackManifestSchema` itself — the dependency sections are typed
+ * `Record<FQN, VersionRange>` so unknown FQNs, malformed grammar, and
+ * bad semver ranges surface as normal schema issues through the shared
+ * `schemaDecodeFindings` plumbing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { PackManifestSchema } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { schemaDecodeFindings } from "../shared/schema-rule.js";
+const RULE_ID = "pack/manifest-schema-valid";
+const PACK_JSON = "pack.json";
+export const manifestSchemaValidRule = {
+    id: RULE_ID,
+    description: "pack.json defines a valid pack manifest.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => schemaDecodeFindings(RULE_ID, "error", PACK_JSON, PackManifestSchema, context.subject.packJson),
+};
+//# sourceMappingURL=manifest-schema-valid.js.map

package/dist/src/unstable/lint/catalog/pack-accessor/contexts.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `buildPackRuleContexts` — build `PackRuleContext[]` from a structural
+ * `installedPacks` input. The full lint workspace view
+ * (`LintWorkspaceView`) satisfies this by construction.
+ *
+ * The minimal shape is **exactly** the set of fields the function reads per
+ * installed pack:
+ *
+ * - `packJson` — pre-decoded `pack.json` when present (caller
+ *   decodes once per pack, so rules don't re-read + re-parse).
+ * - `displayRoot` — posix-relative root used by the renderer; the caller
+ *   picks per provenance (see the table below).
+ * - `files` — the pre-bound `PackFileAccessor`. The caller chooses VFT or
+ *   platform-backed.
+ *
+ * Provenance → `displayRoot` table:
+ *
+ * | Surface                            | `displayRoot`                             |
+ * | ---------------------------------- | ----------------------------------------- |
+ * | Publish                            | `""`                                      |
+ * | Registry-installed pack            | `agent_extensions/<@owner>/packs/<name>`   |
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackFileAccessor, PackRuleContext } from "../../context.js";
+/**
+ * Minimal structural shape `buildPackRuleContexts` needs per installed
+ * pack. The full lint workspace view exposes
+ * `installedPacks: ReadonlyArray<InstalledPackInfo>`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface InstalledPackInfo {
+    readonly packJson: unknown;
+    readonly displayRoot: string;
+    readonly files: PackFileAccessor;
+}
+/**
+ * Project an input's `installedPacks` into `PackRuleContext`s with their
+ * `displayRoot` and `subject` fields pre-populated.
+ *
+ * Publish callers bypass this helper and construct a single context directly
+ * — they have exactly one pack in play and no workspace.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const buildPackRuleContexts: (input: {
+    readonly installedPacks: ReadonlyArray<InstalledPackInfo>;
+}) => ReadonlyArray<PackRuleContext>;
+//# sourceMappingURL=contexts.d.ts.map

package/dist/src/unstable/lint/catalog/pack-accessor/contexts.js

@@ -0,0 +1,45 @@
+/**
+ * `buildPackRuleContexts` — build `PackRuleContext[]` from a structural
+ * `installedPacks` input. The full lint workspace view
+ * (`LintWorkspaceView`) satisfies this by construction.
+ *
+ * The minimal shape is **exactly** the set of fields the function reads per
+ * installed pack:
+ *
+ * - `packJson` — pre-decoded `pack.json` when present (caller
+ *   decodes once per pack, so rules don't re-read + re-parse).
+ * - `displayRoot` — posix-relative root used by the renderer; the caller
+ *   picks per provenance (see the table below).
+ * - `files` — the pre-bound `PackFileAccessor`. The caller chooses VFT or
+ *   platform-backed.
+ *
+ * Provenance → `displayRoot` table:
+ *
+ * | Surface                            | `displayRoot`                             |
+ * | ---------------------------------- | ----------------------------------------- |
+ * | Publish                            | `""`                                      |
+ * | Registry-installed pack            | `agent_extensions/<@owner>/packs/<name>`   |
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// -----------------------------------------------------------------------------
+// buildPackRuleContexts
+// -----------------------------------------------------------------------------
+/**
+ * Project an input's `installedPacks` into `PackRuleContext`s with their
+ * `displayRoot` and `subject` fields pre-populated.
+ *
+ * Publish callers bypass this helper and construct a single context directly
+ * — they have exactly one pack in play and no workspace.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const buildPackRuleContexts = (input) => input.installedPacks.map((info) => ({
+    subject: {
+        packJson: info.packJson,
+    },
+    files: info.files,
+    displayRoot: info.displayRoot,
+}));
+//# sourceMappingURL=contexts.js.map

package/dist/src/unstable/lint/catalog/pack-accessor/vft.d.ts

@@ -0,0 +1,60 @@
+/**
+ * VFT-backed `PackFileAccessor` for publish callers.
+ *
+ * A Virtual File Tree (VFT) is an in-memory representation of an extracted
+ * archive — the registry publish pipeline extracts an upload into a VFT, then
+ * passes that tree into Phase 4 decode/lint. The VFT's schema and bounds
+ * (max size, file count, path depth) are owned by the registry extract phase
+ * (Phase 4 concern); this accessor treats the tree as a read-only
+ * `path -> Uint8Array` map and enforces its own rooted-read + no-`..`-escape
+ * invariants at the rule boundary.
+ *
+ * Bounds enforcement here:
+ *
+ * - Paths are normalized to posix, `./` prefixes are stripped.
+ * - Empty path resolves to the accessor root itself.
+ * - Any path containing a `..` segment raises `FileAccessError {
+ *   reason: "path-escape" }` from `readBytes` and resolves to `false` from
+ *   `exists`.
+ * - Absolute paths (starting with `/` or a Windows drive letter) are
+ *   treated as escape attempts.
+ *
+ * Mirrors the skill VFT accessor (`../skill-accessor/vft.ts`). The VFTNode
+ * interface is intentionally the same so a publish caller can extract a
+ * single archive once and pass the same tree to either accessor factory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { PackFileAccessor } from "../../context.js";
+/**
+ * Minimal shape of a Virtual File Tree consumed by the accessor.
+ *
+ * Shape-compatible with `../skill-accessor/vft.ts#VFTNode`; kept as a local
+ * declaration to avoid a cross-subfolder import and to document what this
+ * accessor uses.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface PackVFTNode {
+    /**
+     * Whether the given posix path points to a file within the tree.
+     */
+    readonly hasFile: (posixPath: string) => boolean;
+    /**
+     * Return the bytes for the given posix path, or `undefined` when the path
+     * does not resolve to a file (missing, directory, or outside the tree).
+     */
+    readonly getFile: (posixPath: string) => Uint8Array | undefined;
+}
+/**
+ * Build a VFT-backed `PackFileAccessor` rooted at the tree's root.
+ *
+ * Callers that root the pack at a sub-path of the archive should pre-strip
+ * that sub-path before constructing the tree — the accessor enforces no
+ * `..` escape above the root it was given.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeVftPackFileAccessor: (tree: PackVFTNode) => PackFileAccessor;
+//# sourceMappingURL=vft.d.ts.map

package/dist/src/unstable/lint/catalog/pack-accessor/vft.js

@@ -0,0 +1,85 @@
+/**
+ * VFT-backed `PackFileAccessor` for publish callers.
+ *
+ * A Virtual File Tree (VFT) is an in-memory representation of an extracted
+ * archive — the registry publish pipeline extracts an upload into a VFT, then
+ * passes that tree into Phase 4 decode/lint. The VFT's schema and bounds
+ * (max size, file count, path depth) are owned by the registry extract phase
+ * (Phase 4 concern); this accessor treats the tree as a read-only
+ * `path -> Uint8Array` map and enforces its own rooted-read + no-`..`-escape
+ * invariants at the rule boundary.
+ *
+ * Bounds enforcement here:
+ *
+ * - Paths are normalized to posix, `./` prefixes are stripped.
+ * - Empty path resolves to the accessor root itself.
+ * - Any path containing a `..` segment raises `FileAccessError {
+ *   reason: "path-escape" }` from `readBytes` and resolves to `false` from
+ *   `exists`.
+ * - Absolute paths (starting with `/` or a Windows drive letter) are
+ *   treated as escape attempts.
+ *
+ * Mirrors the skill VFT accessor (`../skill-accessor/vft.ts`). The VFTNode
+ * interface is intentionally the same so a publish caller can extract a
+ * single archive once and pass the same tree to either accessor factory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+/**
+ * Build a VFT-backed `PackFileAccessor` rooted at the tree's root.
+ *
+ * Callers that root the pack at a sub-path of the archive should pre-strip
+ * that sub-path before constructing the tree — the accessor enforces no
+ * `..` escape above the root it was given.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makeVftPackFileAccessor = (tree) => {
+    return {
+        exists: (path) => {
+            const normalized = normalizeAndCheck(path);
+            if (normalized.kind !== "ok") {
+                return Effect.succeed(false);
+            }
+            return Effect.succeed(tree.hasFile(normalized.path));
+        },
+        readBytes: (path) => {
+            const normalized = normalizeAndCheck(path);
+            if (normalized.kind === "escape") {
+                return failFileAccess(path, "path-escape", `path escapes the accessor root: ${path}`);
+            }
+            const bytes = tree.getFile(normalized.path);
+            if (bytes === undefined) {
+                return failFileAccess(path, "read-error", `file not found at ${path}`);
+            }
+            return Effect.succeed(bytes);
+        },
+    };
+};
+const normalizeAndCheck = (path) => {
+    if (path === "" || path === "." || path === "./") {
+        return { kind: "ok", path: "" };
+    }
+    // Windows drive letters (`C:/`) and absolute posix paths both count as
+    // escape attempts at a pack-rooted accessor.
+    if (/^[a-z]:[\\/]/i.test(path) || path.startsWith("/") || path.startsWith("\\")) {
+        return { kind: "escape" };
+    }
+    const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
+    const segments = normalized.split("/");
+    for (const segment of segments) {
+        if (segment === "..") {
+            return { kind: "escape" };
+        }
+    }
+    return { kind: "ok", path: normalized };
+};
+const failFileAccess = (path, reason, message) => Effect.fail({
+    _tag: "FileAccessError",
+    path,
+    reason,
+    message,
+});
+//# sourceMappingURL=vft.js.map

package/dist/src/unstable/lint/catalog/pack.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `pack/*` rule catalog — the v1 three-rule set.
+ *
+ * Per the lint design, registry publish and `axm lint`
+ * run exactly these rules against each pack context:
+ *
+ * | ID                              | Severity | Autofix |
+ * | ------------------------------- | -------- | ------- |
+ * | `pack/manifest-present`         | error    | —       |
+ * | `pack/manifest-schema-valid`    | error    | —       |
+ * | `pack/manifest-keys-recognized` | error    | —       |
+ *
+ * All three ship `kind: "advisory"`. Packs are registry-only at v1 (no
+ * non-native arm), so there is no applicability discriminator — every pack
+ * context runs every rule and the `check` body's early-return arms handle
+ * manifest-absent cases.
+ *
+ * Rule ids are **registered with the lint config allowlist at module-load
+ * time**, so importing this catalog extends the set of accepted
+ * `axm.json` `lint.rules` keys. Consumers that never import the
+ * catalog (the registry Worker bundle for `skill`-only routes, e.g.) don't
+ * pay the registration cost.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { LintRule } from "../rule.js";
+import type { PackRuleContext } from "../context.js";
+/**
+ * Ordered v1 `pack/*` rule catalog. Declaration order is the evaluation
+ * order within a single `evaluateContexts` call (deterministic ordering is
+ * test-observable; see `evaluate.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const packRules: ReadonlyArray<LintRule<PackRuleContext>>;
+//# sourceMappingURL=pack.d.ts.map

package/dist/src/unstable/lint/catalog/pack.js

@@ -0,0 +1,47 @@
+/**
+ * `pack/*` rule catalog — the v1 three-rule set.
+ *
+ * Per the lint design, registry publish and `axm lint`
+ * run exactly these rules against each pack context:
+ *
+ * | ID                              | Severity | Autofix |
+ * | ------------------------------- | -------- | ------- |
+ * | `pack/manifest-present`         | error    | —       |
+ * | `pack/manifest-schema-valid`    | error    | —       |
+ * | `pack/manifest-keys-recognized` | error    | —       |
+ *
+ * All three ship `kind: "advisory"`. Packs are registry-only at v1 (no
+ * non-native arm), so there is no applicability discriminator — every pack
+ * context runs every rule and the `check` body's early-return arms handle
+ * manifest-absent cases.
+ *
+ * Rule ids are **registered with the lint config allowlist at module-load
+ * time**, so importing this catalog extends the set of accepted
+ * `axm.json` `lint.rules` keys. Consumers that never import the
+ * catalog (the registry Worker bundle for `skill`-only routes, e.g.) don't
+ * pay the registration cost.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { registerLintRuleIds } from "../config.js";
+import { manifestPresentRule } from "./pack/manifest-present.js";
+import { manifestSchemaValidRule } from "./pack/manifest-schema-valid.js";
+import { manifestKeysRecognizedRule } from "./pack/manifest-keys-recognized.js";
+/**
+ * Ordered v1 `pack/*` rule catalog. Declaration order is the evaluation
+ * order within a single `evaluateContexts` call (deterministic ordering is
+ * test-observable; see `evaluate.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const packRules = [
+    manifestPresentRule,
+    manifestSchemaValidRule,
+    manifestKeysRecognizedRule,
+];
+// Register ids into the `LintConfig.rules` allowlist. Module-load side effect:
+// a consumer that imports this catalog (or the `catalog/index` barrel) enables
+// `axm.json` `lint.rules` to reference any of the above rule ids.
+registerLintRuleIds(packRules.map((r) => r.id));
+//# sourceMappingURL=pack.js.map

package/dist/src/unstable/lint/catalog/rule/envelope.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `rule/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import type { RuleRuleContext } from "../../context.js";
+export declare const ruleEnvelopeRules: import("../shared/envelope-rules.js").ManifestEnvelopeRules<RuleRuleContext<import("../../context.js").RuleContent>>;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/src/unstable/lint/catalog/rule/envelope.js

@@ -0,0 +1,15 @@
+/**
+ * `rule/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import { RuleManifestSchema, RULE_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/rules/manifest-schema";
+import { makeManifestEnvelopeRules } from "../shared/envelope-rules.js";
+export const ruleEnvelopeRules = makeManifestEnvelopeRules({
+    namespace: "rule",
+    manifestFile: RULE_MANIFEST_FILENAME,
+    schema: RuleManifestSchema,
+    manifestJson: (context) => context.subject.ruleJson,
+    presentDescription: "Rules include a root rule.json manifest.",
+    presentMissingMessage: "rule.json is missing. Create rule.json with the required manifest fields (`owner`, `type`, `name`, `version`).",
+    schemaDescription: "rule.json defines a valid rule manifest.",
+});
+//# sourceMappingURL=envelope.js.map

package/dist/src/unstable/lint/catalog/rule.d.ts

@@ -0,0 +1,4 @@
+import type { RuleRuleContext } from "../context.js";
+import type { LintRule } from "../rule.js";
+export declare const ruleRules: ReadonlyArray<LintRule<RuleRuleContext>>;
+//# sourceMappingURL=rule.d.ts.map

package/dist/src/unstable/lint/catalog/rule.js

@@ -0,0 +1,6 @@
+import { registerLintRuleIds } from "../config.js";
+import { ruleEnvelopeRules } from "./rule/envelope.js";
+import { orderedEnvelopeRules } from "./shared/envelope-rules.js";
+export const ruleRules = orderedEnvelopeRules(ruleEnvelopeRules);
+registerLintRuleIds(ruleRules.map((r) => r.id));
+//# sourceMappingURL=rule.js.map

package/dist/src/unstable/lint/catalog/shared/envelope-rules.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The five-rule manifest envelope every non-pack per-extension catalog ships.
+ *
+ * `skill`, `subagent`, `mcp-server`, `hook`, `rule`, and `knowledge` each
+ * enforce the same five invariants against their own
+ * manifest:
+ *
+ * 1. `<ns>/manifest-present`             — the manifest file exists.
+ * 2. `<ns>/manifest-schema-valid`        — it decodes against the canonical schema.
+ * 3. `<ns>/manifest-keys-recognized`     — it carries no unknown top-level keys.
+ * 4. `<ns>/standalone-declaration-valid` — `standalone: false` names its packs.
+ * 5. `<ns>/recommended-packs-valid`      — recommended packs are bare FQNs.
+ *
+ * Rules 1, 4, and 5 already had factories; rules 2 and 3 were hand-copied per
+ * type. This module composes all five so a new extension type's envelope is
+ * one call, and so the publish-safe barrel (`lint/publish.ts`) and the
+ * `axm lint` catalog (`catalog/<type>.ts`) build from the same definitions.
+ *
+ * The factory is deliberately free of `registerLintRuleIds` — that module-load
+ * side effect stays in `catalog/<type>.ts`, because it imports the workspace
+ * lint config schema that `lint/publish.ts` exists to keep out of the registry
+ * Worker bundle.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import type * as Schema from "effect/Schema";
+import type { AdvisoryRule } from "../../rule.js";
+/**
+ * A manifest schema usable by the envelope: decodable, and introspectable for
+ * its declared top-level field names.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type ManifestEnvelopeSchema<A, I> = Schema.Codec<A, I> & {
+    readonly fields: Readonly<Record<string, unknown>>;
+};
+/**
+ * Per-catalog parameters for {@link makeManifestEnvelopeRules}.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface ManifestEnvelopeOptions<C, A, I> {
+    /** Rule-id namespace; matches the context kind (`skill`, `hook`, ...). */
+    readonly namespace: string;
+    /** Accessor-relative manifest filename stamped on `location.file`. */
+    readonly manifestFile: string;
+    /** Canonical manifest schema for this type. */
+    readonly schema: ManifestEnvelopeSchema<A, I>;
+    /** Reads the caller-decoded manifest JSON off the rule context. */
+    readonly manifestJson: (context: C) => unknown;
+    /** `description` for `<ns>/manifest-present`. */
+    readonly presentDescription: string;
+    /** Finding message emitted when the manifest file is absent. */
+    readonly presentMissingMessage: string;
+    /** `description` for `<ns>/manifest-schema-valid`. */
+    readonly schemaDescription: string;
+}
+/**
+ * The five envelope rules, named so callers can order them alongside their own
+ * bespoke rules rather than splicing an opaque array.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface ManifestEnvelopeRules<C> {
+    readonly manifestPresent: AdvisoryRule<C>;
+    readonly manifestSchemaValid: AdvisoryRule<C>;
+    readonly manifestKeysRecognized: AdvisoryRule<C>;
+    readonly standaloneDeclarationValid: AdvisoryRule<C>;
+    readonly recommendedPacksValid: AdvisoryRule<C>;
+}
+/**
+ * Build one catalog's five manifest envelope rules.
+ *
+ * The context only has to expose a `files` accessor with `exists`; the
+ * manifest value itself is read through `options.manifestJson`, so the factory
+ * never assumes a subject field name.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeManifestEnvelopeRules: <C extends {
+    readonly files: {
+        readonly exists: (path: string) => Effect.Effect<boolean>;
+    };
+}, A, I>(options: ManifestEnvelopeOptions<C, A, I>) => ManifestEnvelopeRules<C>;
+/**
+ * The envelope rules in canonical catalog order.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const orderedEnvelopeRules: <C>(rules: ManifestEnvelopeRules<C>) => ReadonlyArray<AdvisoryRule<C>>;
+//# sourceMappingURL=envelope-rules.d.ts.map

package/dist/src/unstable/lint/catalog/shared/envelope-rules.js

@@ -0,0 +1,89 @@
+/**
+ * The five-rule manifest envelope every non-pack per-extension catalog ships.
+ *
+ * `skill`, `subagent`, `mcp-server`, `hook`, `rule`, and `knowledge` each
+ * enforce the same five invariants against their own
+ * manifest:
+ *
+ * 1. `<ns>/manifest-present`             — the manifest file exists.
+ * 2. `<ns>/manifest-schema-valid`        — it decodes against the canonical schema.
+ * 3. `<ns>/manifest-keys-recognized`     — it carries no unknown top-level keys.
+ * 4. `<ns>/standalone-declaration-valid` — `standalone: false` names its packs.
+ * 5. `<ns>/recommended-packs-valid`      — recommended packs are bare FQNs.
+ *
+ * Rules 1, 4, and 5 already had factories; rules 2 and 3 were hand-copied per
+ * type. This module composes all five so a new extension type's envelope is
+ * one call, and so the publish-safe barrel (`lint/publish.ts`) and the
+ * `axm lint` catalog (`catalog/<type>.ts`) build from the same definitions.
+ *
+ * The factory is deliberately free of `registerLintRuleIds` — that module-load
+ * side effect stays in `catalog/<type>.ts`, because it imports the workspace
+ * lint config schema that `lint/publish.ts` exists to keep out of the registry
+ * Worker bundle.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { makeManifestPresentRule } from "./manifest-present.js";
+import { makeRecommendedPacksValidRule, makeStandaloneDeclarationValidRule, } from "./recommended-packs-rules.js";
+import { enumerateUnknownTopLevelKeys, schemaDecodeFindings, structFieldKeys, } from "./schema-rule.js";
+/**
+ * Build one catalog's five manifest envelope rules.
+ *
+ * The context only has to expose a `files` accessor with `exists`; the
+ * manifest value itself is read through `options.manifestJson`, so the factory
+ * never assumes a subject field name.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makeManifestEnvelopeRules = (options) => {
+    const schemaValidRuleId = `${options.namespace}/manifest-schema-valid`;
+    const keysRecognizedRuleId = `${options.namespace}/manifest-keys-recognized`;
+    const allowedKeys = structFieldKeys(options.schema);
+    return {
+        manifestPresent: makeManifestPresentRule({
+            ruleId: `${options.namespace}/manifest-present`,
+            description: options.presentDescription,
+            manifestFile: options.manifestFile,
+            missingMessage: options.presentMissingMessage,
+        }),
+        manifestSchemaValid: {
+            id: schemaValidRuleId,
+            description: options.schemaDescription,
+            kind: "advisory",
+            severity: "error",
+            check: (context) => schemaDecodeFindings(schemaValidRuleId, "error", options.manifestFile, options.schema, options.manifestJson(context)),
+        },
+        manifestKeysRecognized: {
+            id: keysRecognizedRuleId,
+            description: `${options.manifestFile} uses only supported top-level fields.`,
+            kind: "advisory",
+            severity: "error",
+            check: (context) => Effect.succeed(enumerateUnknownTopLevelKeys(keysRecognizedRuleId, "error", options.manifestFile, allowedKeys, options.manifestJson(context))),
+        },
+        standaloneDeclarationValid: makeStandaloneDeclarationValidRule({
+            namespace: options.namespace,
+            manifestFile: options.manifestFile,
+            manifestJson: options.manifestJson,
+        }),
+        recommendedPacksValid: makeRecommendedPacksValidRule({
+            namespace: options.namespace,
+            manifestFile: options.manifestFile,
+            manifestJson: options.manifestJson,
+        }),
+    };
+};
+/**
+ * The envelope rules in canonical catalog order.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const orderedEnvelopeRules = (rules) => [
+    rules.manifestPresent,
+    rules.manifestSchemaValid,
+    rules.manifestKeysRecognized,
+    rules.standaloneDeclarationValid,
+    rules.recommendedPacksValid,
+];
+//# sourceMappingURL=envelope-rules.js.map

package/dist/src/unstable/lint/catalog/shared/manifest-json.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared loose-manifest JSON helpers.
+ *
+ * Workspace lint parses installed manifests before per-extension rules run.
+ * The parsed value must stay raw JSON, not a schema-decoded manifest, so
+ * `*-keys-recognized` rules can still see excess top-level fields.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { AdvisoryFinding, Severity } from "../../rule.js";
+export interface ManifestJsonParseFailure {
+    readonly _tag: "ManifestJsonParseFailure";
+    readonly file: string;
+}
+export declare const makeManifestJsonParseFailure: (file: string) => ManifestJsonParseFailure;
+export declare const isManifestJsonParseFailure: (value: unknown) => value is ManifestJsonParseFailure;
+export declare const manifestJsonParseFailureToFinding: (ruleId: string, severity: Severity, file: string, input: ManifestJsonParseFailure) => AdvisoryFinding;
+//# sourceMappingURL=manifest-json.d.ts.map

package/dist/src/unstable/lint/catalog/shared/manifest-json.js

@@ -0,0 +1,28 @@
+/**
+ * Shared loose-manifest JSON helpers.
+ *
+ * Workspace lint parses installed manifests before per-extension rules run.
+ * The parsed value must stay raw JSON, not a schema-decoded manifest, so
+ * `*-keys-recognized` rules can still see excess top-level fields.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { describeSchemaDocument } from "../../describe-document.js";
+export const makeManifestJsonParseFailure = (file) => ({
+    _tag: "ManifestJsonParseFailure",
+    file,
+});
+export const isManifestJsonParseFailure = (value) => {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    return "_tag" in value && value._tag === "ManifestJsonParseFailure";
+};
+export const manifestJsonParseFailureToFinding = (ruleId, severity, file, input) => ({
+    kind: "advisory",
+    ruleId,
+    severity,
+    message: `${describeSchemaDocument(file)} contains invalid JSON. Edit \`${input.file}\` and fix the JSON syntax.`,
+    location: { file },
+});
+//# sourceMappingURL=manifest-json.js.map

package/dist/src/unstable/lint/catalog/shared/manifest-present.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared factory for `manifest-present` advisory rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type { AdvisoryRule, Severity } from "../../rule.js";
+interface ManifestFileAccessor {
+    readonly exists: (path: string) => Effect.Effect<boolean>;
+}
+interface ManifestPresentRuleContext {
+    readonly files: ManifestFileAccessor;
+}
+interface ManifestPresentRuleArgs<C> {
+    readonly ruleId: string;
+    readonly description: string;
+    readonly manifestFile: string;
+    readonly missingMessage: string;
+    readonly severity?: Severity;
+    readonly getFiles?: (context: C) => ManifestFileAccessor;
+    readonly applies?: (context: C) => boolean;
+}
+export declare const makeManifestPresentRule: <C extends ManifestPresentRuleContext>(args: ManifestPresentRuleArgs<C>) => AdvisoryRule<C>;
+export {};
+//# sourceMappingURL=manifest-present.d.ts.map