@agentxm/registry-protocol 0.28.12 → 0.28.13

package/dist/src/unstable/lint/evaluate.js

@@ -1,73 +0,0 @@
-/**
- * Pure evaluator for the lint engine.
- *
- * `evaluateContexts(rules, contexts, config)` pairs each rule with each context,
- * invokes `rule.check`, applies severity overrides from `config.rules`, and
- * drops findings from rules configured `"off"`.
- *
- * Both functions are plain `Effect` values; neither requires a Layer or an
- * ambient service. See the `lint-engine` design doc §3 for the rationale
- * behind library primitives over a central engine service.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-import * as Effect from "effect/Effect";
-// -----------------------------------------------------------------------------
-// Severity override
-// -----------------------------------------------------------------------------
-/**
- * Translate a `LintRuleSeverity` config value into an effective `Severity`
- * or the `"off"` sentinel. `"warn"` maps to `"warning"` so downstream code
- * sees the canonical three-severity alphabet.
- *
- * `config.rules` keys are exact rule ids with no wildcard / glob support in v1;
- * see `./config.ts` for the schema.
- */
-const translateConfigValue = (value) => {
-    switch (value) {
-        case "warn":
-            return "warning";
-        case "off":
-        case "info":
-        case "error":
-            return value;
-    }
-};
-const resolveEffectiveSeverity = (defaultSeverity, override) => (override === undefined ? defaultSeverity : translateConfigValue(override));
-const withSeverity = (finding, severity) => ({
-    ...finding,
-    severity,
-});
-// -----------------------------------------------------------------------------
-// evaluateContexts
-// -----------------------------------------------------------------------------
-/**
- * Pair each rule with each context, run `rule.check`, apply severity overrides
- * from `config.rules`, and return one `Evaluated<C>` per pair.
- *
- * Findings whose configured severity is `"off"` are suppressed entirely; the
- * `Evaluated` entry still ships (with an empty `findings` array) so consumers
- * that group by rule still see the rule ran.
- *
- * Rules are evaluated in catalog order; contexts are evaluated in caller
- * order. Rule-context invocation is sequential within a single
- * `evaluateContexts` call so tests can observe deterministic ordering.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const evaluateContexts = (rules, contexts, config) => Effect.forEach(rules.flatMap((rule) => contexts.map((context) => ({ rule, context }))), ({ rule, context }) => evaluateOne(rule, context, config), { concurrency: 1 });
-const evaluateOne = (rule, context, config) => Effect.map(rule.check(context), (rawFindings) => ({
-    rule,
-    context,
-    findings: applySeverityConfig(rule, rawFindings, config),
-}));
-const applySeverityConfig = (rule, findings, config) => {
-    const override = config.rules?.[rule.id];
-    const effective = resolveEffectiveSeverity(rule.severity, override);
-    if (effective === "off") {
-        return [];
-    }
-    return findings.map((finding) => withSeverity(finding, effective));
-};
-//# sourceMappingURL=evaluate.js.map

package/dist/src/unstable/lint/issues-to-findings.d.ts

@@ -1,35 +0,0 @@
-/**
- * `issuesToFindings` — shared schema-delegation helper.
- *
- * `-schema-valid` rules delegate their `check` to Effect Schema via
- * `Schema.decodeUnknownResult(schema, { onExcessProperty: "ignore" })` (or the
- * Effect/Exit equivalents) and map the resulting `Issue` tree 1:1 to
- * `AdvisoryFinding`s through this helper. Rules never re-implement schema
- * checks inline; the paired `-keys-recognized` rule owns unknown-key hygiene
- * at warning severity.
- *
- * The helper walks the recursive `SchemaIssue.Issue` tree, accumulating a
- * path at each `Pointer` node and emitting one finding per leaf issue.
- * Composite nodes recurse into their children. Each finding's `message`
- * is branch-specific and guide-conformant: invariant failure first, raw
- * schema detail second when needed, remediation last. `location.file` is the
- * caller-supplied file (the manifest file); v1 does not parse byte positions
- * out of `Issue` values.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-import * as SchemaIssue from "effect/SchemaIssue";
-import type { AdvisoryFinding, Severity } from "./rule.js";
-/**
- * Walk an `Issue` tree and produce one finding per leaf issue.
- *
- * @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 issue     - Root `Issue` produced by `Schema.decodeUnknown*`.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export declare const issuesToFindings: (ruleId: string, severity: Severity, file: string, issue: SchemaIssue.Issue) => ReadonlyArray<AdvisoryFinding>;
-//# sourceMappingURL=issues-to-findings.d.ts.map

package/dist/src/unstable/lint/issues-to-findings.js

@@ -1,149 +0,0 @@
-/**
- * `issuesToFindings` — shared schema-delegation helper.
- *
- * `-schema-valid` rules delegate their `check` to Effect Schema via
- * `Schema.decodeUnknownResult(schema, { onExcessProperty: "ignore" })` (or the
- * Effect/Exit equivalents) and map the resulting `Issue` tree 1:1 to
- * `AdvisoryFinding`s through this helper. Rules never re-implement schema
- * checks inline; the paired `-keys-recognized` rule owns unknown-key hygiene
- * at warning severity.
- *
- * The helper walks the recursive `SchemaIssue.Issue` tree, accumulating a
- * path at each `Pointer` node and emitting one finding per leaf issue.
- * Composite nodes recurse into their children. Each finding's `message`
- * is branch-specific and guide-conformant: invariant failure first, raw
- * schema detail second when needed, remediation last. `location.file` is the
- * caller-supplied file (the manifest file); v1 does not parse byte positions
- * out of `Issue` values.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-import * as SchemaIssue from "effect/SchemaIssue";
-import { describeSchemaDocument } from "./describe-document.js";
-// -----------------------------------------------------------------------------
-// Public helper
-// -----------------------------------------------------------------------------
-/**
- * Walk an `Issue` tree and produce one finding per leaf issue.
- *
- * @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 issue     - Root `Issue` produced by `Schema.decodeUnknown*`.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const issuesToFindings = (ruleId, severity, file, issue) => {
-    const findings = [];
-    walkIssue(issue, [], (leaf, path) => {
-        findings.push(toFinding(ruleId, severity, file, leaf, path));
-    });
-    return findings;
-};
-const walkIssue = (issue, path, visit) => {
-    switch (issue._tag) {
-        case "Pointer": {
-            walkIssue(issue.issue, [...path, ...issue.path], visit);
-            return;
-        }
-        case "Composite":
-        case "AnyOf": {
-            if (issue.issues.length === 0) {
-                // No union member matched / no nested issues — treat as a leaf so
-                // the caller sees at least one finding for the covering diagnostic.
-                visit(issue, path);
-                return;
-            }
-            for (const child of issue.issues) {
-                walkIssue(child, path, visit);
-            }
-            return;
-        }
-        case "Filter":
-        case "Encoding": {
-            walkIssue(issue.issue, path, visit);
-            return;
-        }
-        case "InvalidType":
-        case "InvalidValue":
-        case "MissingKey":
-        case "UnexpectedKey":
-        case "Forbidden":
-        case "OneOf": {
-            visit(issue, path);
-            return;
-        }
-    }
-};
-const toFinding = (ruleId, severity, file, issue, path) => {
-    return {
-        kind: "advisory",
-        ruleId,
-        severity,
-        message: formatIssueMessage(describeSchemaDocument(file), file, issue, path),
-        location: { file },
-    };
-};
-const formatIssueMessage = (documentLabel, file, issue, path) => {
-    const pathStr = formatPath(path);
-    const valueRef = describeValueReference(documentLabel, pathStr);
-    switch (issue._tag) {
-        case "MissingKey":
-            return formatMissingKeyMessage(documentLabel, file, path, pathStr);
-        case "UnexpectedKey":
-            return formatUnexpectedKeyMessage(documentLabel, file, pathStr);
-        case "InvalidType":
-            return `${valueRef} has the wrong type. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "replace it with a value of the expected type")}`;
-        case "InvalidValue":
-            return `${valueRef} is invalid. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "update it so it satisfies the schema constraint")}`;
-        case "Forbidden":
-            return `${valueRef} uses a value or operation the schema does not allow. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "update it so the document satisfies the schema")}`;
-        case "OneOf":
-            return `${valueRef} matches more than one allowed shape. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "rewrite it so exactly one allowed shape matches")}`;
-        case "AnyOf":
-            return `${valueRef} does not match any allowed shape. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "rewrite it so it matches one of the allowed shapes")}`;
-        case "Filter":
-            return `${valueRef} fails a schema constraint. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "update it so it satisfies the constraint")}`;
-        case "Encoding":
-            return `${valueRef} cannot be encoded or decoded as required by the schema. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "update it to the shape the schema expects")}`;
-        case "Pointer":
-            return `${documentLabel} has a schema problem${pathStr === "" ? "" : ` at ${pathStr}`}. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "fix the value at that path so the document satisfies the schema")}`;
-        case "Composite":
-            return `${valueRef} has multiple schema problems. Detail: ${formatSchemaIssue(issue)}. ${formatRemediation(file, "fix the referenced values so the document satisfies the schema")}`;
-    }
-};
-const formatSchemaIssue = SchemaIssue.makeFormatterDefault();
-const formatMissingKeyMessage = (documentLabel, file, path, pathStr) => {
-    const lastSegment = path[path.length - 1];
-    const parentPath = formatPath(path.slice(0, -1));
-    if (typeof lastSegment === "string" && pathStr !== "") {
-        return parentPath === ""
-            ? `${documentLabel} is missing required field \`${pathStr}\`. ${formatRemediation(file, `add \`${lastSegment}\``)}`
-            : `${documentLabel} is missing required field \`${pathStr}\`. ${formatRemediation(file, `add \`${lastSegment}\` under \`${parentPath}\``)}`;
-    }
-    if (lastSegment !== undefined && pathStr !== "") {
-        return `${documentLabel} is missing a required item at \`${pathStr}\`. ${formatRemediation(file, "add the missing item at that path")}`;
-    }
-    return `${documentLabel} is missing a required value. ${formatRemediation(file, "add the required value")}`;
-};
-const formatUnexpectedKeyMessage = (documentLabel, file, pathStr) => pathStr === ""
-    ? `${documentLabel} has an unrecognized field. ${formatRemediation(file, "remove it or rename it to the intended field name")}`
-    : `${documentLabel} has unrecognized field \`${pathStr}\`. ${formatRemediation(file, "remove it or rename it to the intended field name")}`;
-const describeValueReference = (documentLabel, pathStr) => pathStr === "" ? documentLabel : `${documentLabel} field \`${pathStr}\``;
-const formatRemediation = (file, manualAction) => isLockfile(file)
-    ? "Regenerate the workspace lockfile from workspace settings by reinstalling the declared extensions."
-    : `Edit \`${file}\` and ${manualAction}.`;
-const formatPath = (path) => path.reduce((acc, segment) => {
-    if (typeof segment === "number") {
-        return `${acc}[${String(segment)}]`;
-    }
-    return acc === "" ? String(segment) : `${acc}.${String(segment)}`;
-}, "");
-const basename = (file) => {
-    const normalized = file.replace(/\\/g, "/");
-    const parts = normalized.split("/");
-    return parts[parts.length - 1] ?? normalized;
-};
-const isLockfile = (file) => basename(file) === "axm-lock.yaml";
-//# sourceMappingURL=issues-to-findings.js.map

package/dist/src/unstable/lint/publish.d.ts

@@ -1,49 +0,0 @@
-/**
- * Registry-publish lint surface.
- *
- * This entry point intentionally exports only the primitives the registry
- * publish gate needs. It avoids the full lint barrel because that surface also
- * constructs workspace-settings schemas and workspace catalogs for `axm lint`.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-import type { HookRuleContext, KnowledgeRuleContext, McpServerRuleContext, PackRuleContext, RuleRuleContext, SkillRuleContext, SubagentRuleContext } from "./context.js";
-import type { LintRule } from "./rule.js";
-export { composePath } from "./compose-path.js";
-export { evaluateContexts, type Evaluated } from "./evaluate.js";
-export type { LintConfig } from "./config.js";
-export type { FileAccessError, HookContent, HookFileAccessor, HookRuleContext, KnowledgeContent, KnowledgeFileAccessor, KnowledgeRuleContext, RuleContent, RuleFileAccessor, RuleRuleContext, McpServerContent, McpServerFileAccessor, McpServerRuleContext, PackContent, PackFileAccessor, PackRuleContext, SkillContent, SkillFileAccessor, SkillRuleContext, SubagentContent, SubagentFileAccessor, SubagentRuleContext, } from "./context.js";
-export type { LintFinding, LintRule } from "./rule.js";
-export { makeVftPackFileAccessor, type PackVFTNode } from "./catalog/pack-accessor/vft.js";
-export { makeVftSkillFileAccessor, makeVftSkillFileAccessorScoped, type VFTNode, } from "./catalog/skill-accessor/vft.js";
-/**
- * Ordered publish-safe `pack/*` rule catalog.
- *
- * This intentionally avoids `./catalog/pack.js`, whose module-load rule-id
- * registration imports the workspace lint config schema.
- */
-export declare const packRules: ReadonlyArray<LintRule<PackRuleContext>>;
-/**
- * Ordered publish-safe `skill/*` rule catalog.
- *
- * This intentionally avoids `./catalog/skill.js`, whose module-load rule-id
- * registration imports the workspace lint config schema.
- */
-export declare const skillRules: ReadonlyArray<LintRule<SkillRuleContext>>;
-export declare const subagentRules: ReadonlyArray<LintRule<SubagentRuleContext>>;
-export declare const mcpServerRules: ReadonlyArray<LintRule<McpServerRuleContext>>;
-/**
- * Ordered publish-safe `hook//*` rule catalog.
- *
- * Identical to `catalog/hook.ts`: `hook/matcher-raw-portability` used to be
- * omitted here, which meant `axm publish` and `axm lint` disagreed about the
- * same `hook.json`. It is a pure-manifest advisory at `warning` severity, and
- * the publish gate fails only on `error` findings, so running it at publish
- * time surfaces the portability advice to the author without gating the
- * publish.
- */
-export declare const hookRules: ReadonlyArray<LintRule<HookRuleContext>>;
-export declare const ruleRules: ReadonlyArray<LintRule<RuleRuleContext>>;
-export declare const knowledgeRules: ReadonlyArray<LintRule<KnowledgeRuleContext>>;
-//# sourceMappingURL=publish.d.ts.map

package/dist/src/unstable/lint/publish.js

@@ -1,86 +0,0 @@
-/**
- * Registry-publish lint surface.
- *
- * This entry point intentionally exports only the primitives the registry
- * publish gate needs. It avoids the full lint barrel because that surface also
- * constructs workspace-settings schemas and workspace catalogs for `axm lint`.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-import { manifestKeysRecognizedRule as packManifestKeysRecognizedRule } from "./catalog/pack/manifest-keys-recognized.js";
-import { manifestPresentRule as packManifestPresentRule } from "./catalog/pack/manifest-present.js";
-import { manifestSchemaValidRule as packManifestSchemaValidRule } from "./catalog/pack/manifest-schema-valid.js";
-import { subagentEnvelopeRules } from "./catalog/subagent/envelope.js";
-import { mcpServerEnvelopeRules } from "./catalog/mcp-server/envelope.js";
-import { hookEnvelopeRules } from "./catalog/hook/envelope.js";
-import { ruleEnvelopeRules } from "./catalog/rule/envelope.js";
-import { knowledgeEnvelopeRules } from "./catalog/knowledge/envelope.js";
-import { orderedEnvelopeRules } from "./catalog/shared/envelope-rules.js";
-import { entrypointExistsRule as hookEntrypointExistsRule } from "./catalog/hook/entrypoint-exists.js";
-import { matcherRawPortabilityRule as hookMatcherRawPortabilityRule } from "./catalog/hook/matcher-raw-portability.js";
-import { decisionPortabilityRule as hookDecisionPortabilityRule } from "./catalog/hook/decision-portability.js";
-import { frontmatterParseableRule as skillFrontmatterParseableRule } from "./catalog/skill/frontmatter-parseable.js";
-import { frontmatterStandardValidRule as skillFrontmatterStandardValidRule } from "./catalog/skill/frontmatter-standard-valid.js";
-import { manifestKeysRecognizedRule as skillManifestKeysRecognizedRule } from "./catalog/skill/manifest-keys-recognized.js";
-import { manifestPresentRule as skillManifestPresentRule } from "./catalog/skill/manifest-present.js";
-import { manifestSchemaValidRule as skillManifestSchemaValidRule } from "./catalog/skill/manifest-schema-valid.js";
-import { skillMdPresentRule } from "./catalog/skill/skill-md-present.js";
-import { recommendedPacksValidRule as skillRecommendedPacksValidRule } from "./catalog/skill/recommended-packs-valid.js";
-import { standaloneDeclarationValidRule as skillStandaloneDeclarationValidRule } from "./catalog/skill/standalone-declaration-valid.js";
-export { composePath } from "./compose-path.js";
-export { evaluateContexts } from "./evaluate.js";
-export { makeVftPackFileAccessor } from "./catalog/pack-accessor/vft.js";
-export { makeVftSkillFileAccessor, makeVftSkillFileAccessorScoped, } from "./catalog/skill-accessor/vft.js";
-/**
- * Ordered publish-safe `pack/*` rule catalog.
- *
- * This intentionally avoids `./catalog/pack.js`, whose module-load rule-id
- * registration imports the workspace lint config schema.
- */
-export const packRules = [
-    packManifestPresentRule,
-    packManifestSchemaValidRule,
-    packManifestKeysRecognizedRule,
-];
-/**
- * Ordered publish-safe `skill/*` rule catalog.
- *
- * This intentionally avoids `./catalog/skill.js`, whose module-load rule-id
- * registration imports the workspace lint config schema.
- */
-export const skillRules = [
-    skillMdPresentRule,
-    skillManifestPresentRule,
-    skillFrontmatterParseableRule,
-    skillFrontmatterStandardValidRule,
-    skillManifestSchemaValidRule,
-    skillManifestKeysRecognizedRule,
-    skillStandaloneDeclarationValidRule,
-    skillRecommendedPacksValidRule,
-];
-export const subagentRules = orderedEnvelopeRules(subagentEnvelopeRules);
-export const mcpServerRules = orderedEnvelopeRules(mcpServerEnvelopeRules);
-/**
- * Ordered publish-safe `hook//*` rule catalog.
- *
- * Identical to `catalog/hook.ts`: `hook/matcher-raw-portability` used to be
- * omitted here, which meant `axm publish` and `axm lint` disagreed about the
- * same `hook.json`. It is a pure-manifest advisory at `warning` severity, and
- * the publish gate fails only on `error` findings, so running it at publish
- * time surfaces the portability advice to the author without gating the
- * publish.
- */
-export const hookRules = [
-    hookEnvelopeRules.manifestPresent,
-    hookEnvelopeRules.manifestSchemaValid,
-    hookEnvelopeRules.manifestKeysRecognized,
-    hookDecisionPortabilityRule,
-    hookMatcherRawPortabilityRule,
-    hookEntrypointExistsRule,
-    hookEnvelopeRules.standaloneDeclarationValid,
-    hookEnvelopeRules.recommendedPacksValid,
-];
-export const ruleRules = orderedEnvelopeRules(ruleEnvelopeRules);
-export const knowledgeRules = orderedEnvelopeRules(knowledgeEnvelopeRules);
-//# sourceMappingURL=publish.js.map

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

@@ -1,97 +0,0 @@
-/**
- * Lint rule and finding primitives.
- *
- * Library-style discriminated unions for the lint engine. Rules are plain
- * values generic over a caller-built `RuleContext` — no Layer wiring and no
- * ambient service bag. Findings are produced by `rule.check`; rules do not
- * carry mutation or workflow guidance.
- *
- * Rule ids follow `<namespace>/<subject>-<predicate>` with lowercase letters,
- * digits, and hyphens; ids leak into settings files, CI logs, and agent
- * transcripts, so changing one is an explicit product-contract change.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-import type * as Effect from "effect/Effect";
-/**
- * Platform-canonical finding severity.
- *
- * WorkspaceMutations `lint.rules` overrides can raise or lower the severity at
- * evaluation time; the catalog pins the platform default.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type Severity = "error" | "warning" | "info";
-/**
- * Accessor-relative location of a finding.
- *
- * `file` is posix and relative to the rule context's accessor root (skill or
- * pack manifest directory for per-extension rules, workspace root for workspace
- * rules). Rules MUST NOT embed absolute paths, `displayRoot`-qualified paths,
- * or source coordinates in `message`; the display path is composed from
- * `context.displayRoot` and `location.file` at format time via `composePath`.
- *
- * `file: ""` targets the context root itself (e.g., a missing `SKILL.md` on a
- * skill context).
- *
- * @experimental This API is unstable and may change without notice.
- */
-export interface FindingLocation {
-    readonly file: string;
-    readonly line?: number;
-    readonly column?: number;
-    readonly byteOffset?: number;
-    readonly byteLength?: number;
-}
-/**
- * Fields common to all lint findings.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export interface FindingBase {
-    readonly ruleId: string;
-    readonly severity: Severity;
-    readonly message: string;
-    readonly location?: FindingLocation;
-}
-/**
- * Intrinsic fact produced by a lint rule.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export interface AdvisoryFinding extends FindingBase {
-    readonly kind: "advisory";
-}
-/**
- * Discriminated union of lint findings on `kind`.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type LintFinding = AdvisoryFinding;
-/**
- * Fields common to all lint rules.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export interface RuleBase {
-    readonly id: string;
-    readonly description: string;
-    readonly severity: Severity;
-}
-/**
- * Rule that only surfaces findings; never autofixes.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export interface AdvisoryRule<C> extends RuleBase {
-    readonly kind: "advisory";
-    readonly check: (context: C) => Effect.Effect<ReadonlyArray<AdvisoryFinding>>;
-}
-/**
- * Discriminated union of lint rules over a caller-built rule-context type `C`.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export type LintRule<C> = AdvisoryRule<C>;
-//# sourceMappingURL=rule.d.ts.map

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

@@ -1,17 +0,0 @@
-/**
- * Lint rule and finding primitives.
- *
- * Library-style discriminated unions for the lint engine. Rules are plain
- * values generic over a caller-built `RuleContext` — no Layer wiring and no
- * ambient service bag. Findings are produced by `rule.check`; rules do not
- * carry mutation or workflow guidance.
- *
- * Rule ids follow `<namespace>/<subject>-<predicate>` with lowercase letters,
- * digits, and hyphens; ids leak into settings files, CI logs, and agent
- * transcripts, so changing one is an explicit product-contract change.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-export {};
-//# sourceMappingURL=rule.js.map

package/dist/src/unstable/publish/archive-guardrails.d.ts

@@ -1,39 +0,0 @@
-import * as Effect from "effect/Effect";
-declare const ArchiveGuardrailError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ArchiveGuardrailError";
-} & Readonly<A>;
-export declare class ArchiveGuardrailError extends ArchiveGuardrailError_base<{
-    readonly code: "path_traversal" | "absolute_path" | "duplicate_entry" | "symlink_entry" | "unsupported_compression" | "malformed_archive" | "decompression_limit_exceeded" | "compression_ratio_exceeded" | "entry_count_exceeded" | "forbidden_entry";
-    readonly message: string;
-    readonly entry?: string;
-}> {
-}
-export declare const ZIP_LOCAL_SIGNATURE = 67324752;
-export interface ZipEntry {
-    readonly fileName: string;
-    readonly compressedSize: number;
-    readonly uncompressedSize: number;
-    readonly compressionMethod: number;
-    readonly externalAttributes: number;
-    readonly localHeaderOffset: number;
-}
-export interface ArchiveGuardrailLimits {
-    readonly maxEntries?: number;
-    readonly maxDecompressedBytes?: number;
-    readonly maxCompressionRatio?: number;
-}
-export declare const parseZipCentralDirectory: (buf: Uint8Array) => Effect.Effect<readonly ZipEntry[], ArchiveGuardrailError>;
-/**
- * Reject archives carrying build or secret leftovers: any `node_modules` or
- * `.git` path segment, and `.env` / `.env.*` files. Kept out of
- * {@link validateArchive} on purpose — that function is the registry ingest
- * contract, and archives accepted by earlier clients must keep ingesting.
- *
- * `.env*` matches the basename exactly (`.env`) or by dotted prefix
- * (`.env.local`, `.env.production`, and also `.env.example`), so sibling names
- * like `.envrc` and `environment.md` are unaffected.
- */
-export declare const checkForbiddenSourceEntries: (entries: readonly ZipEntry[]) => Effect.Effect<void, ArchiveGuardrailError>;
-export declare const validateArchive: (archiveBytes: Uint8Array, limits?: ArchiveGuardrailLimits) => Effect.Effect<readonly ZipEntry[], ArchiveGuardrailError>;
-export {};
-//# sourceMappingURL=archive-guardrails.d.ts.map