@agentxm/extension-content 0.28.14-preview.1789139351.5cd4595aa

package/dist/src/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/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/lint/catalog/rule.js

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

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

@@ -0,0 +1,88 @@
+/**
+ * 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.
+ *
+ * @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/lint/catalog/shared/envelope-rules.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ * @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/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/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/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

package/dist/src/lint/catalog/shared/manifest-present.js

@@ -0,0 +1,37 @@
+/**
+ * Shared factory for `manifest-present` advisory rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+export const makeManifestPresentRule = (args) => {
+    const severity = args.severity ?? "error";
+    const getFiles = args.getFiles ?? ((context) => context.files);
+    const applies = args.applies ?? (() => true);
+    return {
+        id: args.ruleId,
+        description: args.description,
+        kind: "advisory",
+        severity,
+        check: (context) => {
+            if (!applies(context)) {
+                return Effect.succeed([]);
+            }
+            return Effect.map(getFiles(context).exists(args.manifestFile), (present) => {
+                if (present) {
+                    return [];
+                }
+                return [
+                    {
+                        kind: "advisory",
+                        ruleId: args.ruleId,
+                        severity,
+                        message: args.missingMessage,
+                        location: { file: args.manifestFile },
+                    },
+                ];
+            });
+        },
+    };
+};
+//# sourceMappingURL=manifest-present.js.map

package/dist/src/lint/catalog/shared/recommended-packs-rules.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Shared factories for the `standalone` / `recommendedPacks` coherence rules.
+ *
+ * Both fields come from `NonPackManifestFields` in
+ * `extensions/common.ts`, so every non-pack catalog (`skill`, `subagent`,
+ * `mcp-server`, `rule`, `hook`, `knowledge`) enforces the same two invariants
+ * against its own manifest. Rather than copy twelve near-identical rule
+ * bodies, each catalog registers a rule produced here and parameterized by
+ * namespace and manifest accessor — the same shape `shared/schema-rule.ts`
+ * establishes for the `-schema-valid` rules.
+ *
+ * Both rules ship at `warning`. They would otherwise retroactively reject
+ * manifests published before the rules existed, which the rule-authoring
+ * guide's "new rules start soft" clause forbids.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { AdvisoryRule } from "../../rule.js";
+/**
+ * Per-catalog parameters for the shared non-pack manifest rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface RecommendedPacksRuleOptions<C> {
+    /** Rule-id namespace; matches the context kind (`skill`, `hook`, ...). */
+    readonly namespace: string;
+    /** Accessor-relative manifest filename stamped on `location.file`. */
+    readonly manifestFile: string;
+    /** Reads the caller-decoded manifest JSON off the rule context. */
+    readonly manifestJson: (context: C) => unknown;
+}
+/**
+ * Split a `recommendedPacks` entry into its FQN and optional version range.
+ *
+ * Mirrors the separator search in `PackSpecSchema`: the range delimiter is the
+ * first `@` after the last `/`, since the owner segment also starts with `@`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const splitPackSpec: (spec: string) => {
+    readonly fqn: string;
+    readonly range: string | undefined;
+};
+/**
+ * Build the `<namespace>/standalone-declaration-valid` rule for one catalog.
+ *
+ * A manifest with `standalone: false` declares that it is meaningless without
+ * one of its recommended packs. With `recommendedPacks` absent or empty that
+ * declaration is self-contradictory and nothing downstream — registry, Library
+ * UI, or `workspace/recommended-packs-retained` — can act on it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeStandaloneDeclarationValidRule: <C>(options: RecommendedPacksRuleOptions<C>) => AdvisoryRule<C>;
+/**
+ * Build the `<namespace>/recommended-packs-valid` rule for one catalog.
+ *
+ * `recommendedPacks` is typed `PackSpecSchema`, which permits a trailing
+ * version range, but nothing consumes one — recommendations are matched by
+ * name — and `axm help packs` tells authors to use the bare reference. One
+ * finding per offending entry.
+ *
+ * When published manifests have drained, the field can move to
+ * `PackFqnSchema` and this rule retires: decoding takes over.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const makeRecommendedPacksValidRule: <C>(options: RecommendedPacksRuleOptions<C>) => AdvisoryRule<C>;
+//# sourceMappingURL=recommended-packs-rules.d.ts.map

package/dist/src/lint/catalog/shared/recommended-packs-rules.js

@@ -0,0 +1,139 @@
+/**
+ * Shared factories for the `standalone` / `recommendedPacks` coherence rules.
+ *
+ * Both fields come from `NonPackManifestFields` in
+ * `extensions/common.ts`, so every non-pack catalog (`skill`, `subagent`,
+ * `mcp-server`, `rule`, `hook`, `knowledge`) enforces the same two invariants
+ * against its own manifest. Rather than copy twelve near-identical rule
+ * bodies, each catalog registers a rule produced here and parameterized by
+ * namespace and manifest accessor — the same shape `shared/schema-rule.ts`
+ * establishes for the `-schema-valid` rules.
+ *
+ * Both rules ship at `warning`. They would otherwise retroactively reject
+ * manifests published before the rules existed, which the rule-authoring
+ * guide's "new rules start soft" clause forbids.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { isManifestJsonParseFailure } from "./manifest-json.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * Narrow a caller-decoded manifest value to a plain record, or `undefined`
+ * when there is nothing for these rules to read. Absent manifests are the
+ * `-present` rule's problem; unparseable ones are the `-schema-valid` rule's.
+ */
+const manifestRecord = (input) => {
+    if (input === undefined || isManifestJsonParseFailure(input) || !isRecord(input)) {
+        return undefined;
+    }
+    return input;
+};
+const stringEntries = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+/**
+ * Split a `recommendedPacks` entry into its FQN and optional version range.
+ *
+ * Mirrors the separator search in `PackSpecSchema`: the range delimiter is the
+ * first `@` after the last `/`, since the owner segment also starts with `@`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const splitPackSpec = (spec) => {
+    const lastSlash = spec.lastIndexOf("/");
+    const rangeAt = lastSlash > 0 ? spec.indexOf("@", lastSlash + 1) : -1;
+    if (rangeAt <= 0) {
+        return { fqn: spec, range: undefined };
+    }
+    return { fqn: spec.slice(0, rangeAt), range: spec.slice(rangeAt + 1) };
+};
+// -----------------------------------------------------------------------------
+// <namespace>/standalone-declaration-valid
+// -----------------------------------------------------------------------------
+/**
+ * Build the `<namespace>/standalone-declaration-valid` rule for one catalog.
+ *
+ * A manifest with `standalone: false` declares that it is meaningless without
+ * one of its recommended packs. With `recommendedPacks` absent or empty that
+ * declaration is self-contradictory and nothing downstream — registry, Library
+ * UI, or `workspace/recommended-packs-retained` — can act on it.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makeStandaloneDeclarationValidRule = (options) => {
+    const ruleId = `${options.namespace}/standalone-declaration-valid`;
+    return {
+        id: ruleId,
+        description: "Extensions that are not standalone recommend at least one pack.",
+        kind: "advisory",
+        severity: "warning",
+        check: (context) => {
+            const manifest = manifestRecord(options.manifestJson(context));
+            if (manifest === undefined || manifest["standalone"] !== false) {
+                return Effect.succeed([]);
+            }
+            if (stringEntries(manifest["recommendedPacks"]).length > 0) {
+                return Effect.succeed([]);
+            }
+            return Effect.succeed([
+                {
+                    kind: "advisory",
+                    ruleId,
+                    severity: "warning",
+                    message: "`standalone` is set to false, which says this extension only works alongside one of its recommended packs, but no `recommendedPacks` are declared. " +
+                        `To keep the restriction, add each pack's fully qualified name (\`@owner/packs/<name>\`) under \`recommendedPacks\` in \`${options.manifestFile}\`. ` +
+                        `If the extension does work on its own, remove the \`standalone\` key from \`${options.manifestFile}\`.`,
+                    location: { file: options.manifestFile },
+                },
+            ]);
+        },
+    };
+};
+// -----------------------------------------------------------------------------
+// <namespace>/recommended-packs-valid
+// -----------------------------------------------------------------------------
+/**
+ * Build the `<namespace>/recommended-packs-valid` rule for one catalog.
+ *
+ * `recommendedPacks` is typed `PackSpecSchema`, which permits a trailing
+ * version range, but nothing consumes one — recommendations are matched by
+ * name — and `axm help packs` tells authors to use the bare reference. One
+ * finding per offending entry.
+ *
+ * When published manifests have drained, the field can move to
+ * `PackFqnSchema` and this rule retires: decoding takes over.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const makeRecommendedPacksValidRule = (options) => {
+    const ruleId = `${options.namespace}/recommended-packs-valid`;
+    return {
+        id: ruleId,
+        description: "Recommended packs are referenced by name without a version range.",
+        kind: "advisory",
+        severity: "warning",
+        check: (context) => {
+            const manifest = manifestRecord(options.manifestJson(context));
+            if (manifest === undefined) {
+                return Effect.succeed([]);
+            }
+            const findings = [];
+            for (const entry of stringEntries(manifest["recommendedPacks"])) {
+                const { fqn, range } = splitPackSpec(entry);
+                if (range === undefined) {
+                    continue;
+                }
+                findings.push({
+                    kind: "advisory",
+                    ruleId,
+                    severity: "warning",
+                    message: `\`recommendedPacks\` entry '${entry}' pins a version range, but recommended packs are matched by name only, so the range is ignored. ` +
+                        `Replace it with the bare pack reference '${fqn}' under \`recommendedPacks\` in \`${options.manifestFile}\`.`,
+                    location: { file: options.manifestFile },
+                });
+            }
+            return Effect.succeed(findings);
+        },
+    };
+};
+//# sourceMappingURL=recommended-packs-rules.js.map

package/dist/src/lint/catalog/shared/schema-rule.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared schema-delegation plumbing for `-schema-valid` rules.
+ *
+ * Every rule whose id ends in `-schema-valid` implements `check` by
+ * running the canonical schema through `Schema.decodeUnknownResult` with
+ * `onExcessProperty: "ignore"` and `errors: "all"`, then mapping the issues
+ * through `issuesToFindings`.
+ *
+ * The helper is intentionally narrow — only the surface the `-schema-valid`
+ * rules need.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { AdvisoryFinding, Severity } from "../../rule.js";
+/**
+ * Decode `input` against `schema` (excess keys ignored, all issues collected)
+ * and return one advisory finding per leaf issue. Success produces `[]`.
+ *
+ * `input` of `undefined` short-circuits to `[]` — the caller is expected to
+ * have already guarded on "manifest exists" via the complementary
+ * `-present` rule.
+ *
+ * @param ruleId   - `<namespace>/<name>` id of the calling rule.
+ * @param severity - Severity to stamp on each emitted finding.
+ * @param file     - Accessor-relative file path to stamp on `location.file`.
+ * @param schema   - Canonical Effect schema; `Schema.decodeUnknownResult`
+ *                   runs with `onExcessProperty: "ignore"` and `errors: "all"`.
+ * @param input    - Raw decoded JSON value to check (typically `subject.*Json`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const schemaDecodeFindings: <A, I>(ruleId: string, severity: Severity, file: string, schema: Schema.Codec<A, I>, input: unknown) => Effect.Effect<ReadonlyArray<AdvisoryFinding>>;
+/**
+ * Read the top-level field names of a `Schema.Struct` value.
+ *
+ * Callers produce an `allowedKeys` set in one place, driven by the schema
+ * itself — no copy-paste of field names into rule bodies. If the schema
+ * gains a field the allowed-keys set grows by construction.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const structFieldKeys: (struct: {
+    readonly fields: Readonly<Record<string, unknown>>;
+}) => ReadonlySet<string>;
+/**
+ * Enumerate top-level keys present on `input` that are not declared by
+ * `allowedKeys`. Returns one advisory finding per unknown key.
+ *
+ * `input` of `undefined` or non-object short-circuits to `[]`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const enumerateUnknownTopLevelKeys: (ruleId: string, severity: Severity, file: string, allowedKeys: ReadonlySet<string>, input: unknown) => ReadonlyArray<AdvisoryFinding>;
+//# sourceMappingURL=schema-rule.d.ts.map