@jinn-network/plugin 0.1.0

package/dist/testing/in-memory-contribution.js

@@ -0,0 +1,104 @@
+import { deriveContributionStatus } from '../ports/contribution-port.js';
+import { ok, unavailable } from '../outcome.js';
+import { ContributionCandidateV1Schema, } from '../schemas/contribution-candidate.js';
+function snapshot(state) {
+    return { ...state, status: deriveContributionStatus(state) };
+}
+export class InMemoryContributionPort {
+    records = new Map();
+    counter = 0;
+    async recordMineable(candidate, options) {
+        const parsed = ContributionCandidateV1Schema.safeParse(candidate);
+        if (!parsed.success)
+            return unavailable('invalid contribution candidate');
+        this.counter += 1;
+        const recordId = `record-${this.counter}`;
+        this.records.set(recordId, {
+            candidate: parsed.data,
+            state: {
+                localState: 'recorded',
+                publicationState: options?.publicationState ??
+                    (parsed.data.publishMinedTasksConsent ? 'preview-required' : 'disabled'),
+            },
+        });
+        return ok({ recordId });
+    }
+    async ledger() {
+        return ok([...this.records.entries()].map(([recordId, record]) => ({
+            recordId,
+            sourceId: record.candidate.sourceId,
+            createdAt: record.candidate.createdAt,
+            verifiabilityTier: record.candidate.testRuns.some((run) => run.exitCode === 0)
+                ? 'tests-passed'
+                : 'user-accepted',
+            repositorySlug: record.candidate.repositorySlug,
+            baseCommit: record.candidate.baseCommit,
+            ...snapshot(record.state),
+        })));
+    }
+    async mintStatus(recordId) {
+        const record = this.records.get(recordId);
+        if (!record)
+            return unavailable(`no such record: ${recordId}`);
+        return ok(snapshot(record.state));
+    }
+    async authorize(recordId) {
+        const record = this.records.get(recordId);
+        if (!record)
+            return unavailable(`no such record: ${recordId}`);
+        if (record.state.publicationState === 'disabled') {
+            return unavailable(`publication disabled by consent: ${recordId}`);
+        }
+        if (record.state.publicationState === 'vetoed') {
+            return unavailable(`publication vetoed: ${recordId}`);
+        }
+        record.state.publicationState = 'queued';
+        return ok({ recordId, publicationState: 'queued', status: 'queued' });
+    }
+    async veto(recordId) {
+        const record = this.records.get(recordId);
+        if (!record)
+            return unavailable(`no such record: ${recordId}`);
+        record.state.publicationState = 'vetoed';
+        return ok({ recordId, publicationState: 'vetoed', status: 'vetoed' });
+    }
+    async disableUnpublished() {
+        const recordIds = [];
+        for (const [recordId, record] of this.records) {
+            if (record.state.publicationState === 'preview-required' || record.state.publicationState === 'queued') {
+                record.state.publicationState = 'disabled';
+                recordIds.push(recordId);
+            }
+        }
+        return ok({ recordIds });
+    }
+    /** Testing control for the sidecar-owned forward state. */
+    markMinted(recordId, mintRef) {
+        const record = this.records.get(recordId);
+        if (!record)
+            return;
+        record.state.localState = 'minted';
+        record.state.mintRef = mintRef;
+    }
+    /** Testing control for the sidecar-owned terminal local state. */
+    markRejected(recordId) {
+        const record = this.records.get(recordId);
+        if (!record)
+            return;
+        record.state.localState = 'rejected';
+        delete record.state.mintRef;
+        if (record.state.publicationState !== 'vetoed')
+            record.state.publicationState = 'disabled';
+    }
+    /** Testing control for the sidecar-owned outbound state. */
+    markPublished(recordId, publicationRef) {
+        const record = this.records.get(recordId);
+        if (!record)
+            return;
+        record.state.publicationState = 'published';
+        record.state.publicationRef = publicationRef;
+    }
+    getCandidate(recordId) {
+        return this.records.get(recordId)?.candidate;
+    }
+}

package/dist/testing/in-memory-corpus.d.ts

@@ -0,0 +1,47 @@
+import type { CorpusPort, CorpusRecord } from '../ports/corpus-port.js';
+import type { KnowledgeHit } from '../schemas/knowledge-hit.js';
+/**
+ * A seed record for `InMemoryCorpusPort`: a full content-bearing
+ * `CorpusRecord` plus the lightweight `KnowledgeHit` metadata a real corpus
+ * search would return for it (kind/title/tier/payloadKind/publishedAt — the
+ * fields not derivable from `CorpusRecord` alone).
+ */
+export type InMemoryCorpusSeed = CorpusRecord & Pick<KnowledgeHit, 'kind'> & Partial<Pick<KnowledgeHit, 'title' | 'tier' | 'payloadKind' | 'publishedAt'>>;
+/** Map/array-backed, seedable — architecture spec §8. Seeds carry full
+ *  content (`CorpusRecord`) so `get()` can return it directly; `search()`
+ *  derives the lightweight `KnowledgeHit` view. */
+export declare class InMemoryCorpusPort implements CorpusPort {
+    private readonly seed;
+    constructor(seed?: InMemoryCorpusSeed[]);
+    search(query: string): Promise<import("../outcome.js").PortResult<{
+        ref: string;
+        kind: "seed" | "trace" | "skill";
+        tags: string[];
+        title?: string | undefined;
+        snippet?: string | undefined;
+        score?: number | undefined;
+        tier?: "user-accepted" | "tests-passed" | "evaluator-verified" | undefined;
+        payloadKind?: "unknown" | "skill" | undefined;
+        origin?: string | undefined;
+        publishedAt?: number | undefined;
+        retrievalVisible?: boolean | undefined;
+    }[]>>;
+    get(ref: string): Promise<{
+        status: "unavailable";
+        reason: string;
+    } | {
+        status: "ok";
+        value: null;
+    } | {
+        status: "degraded";
+        reason: string;
+        value?: null | undefined;
+    } | {
+        status: "ok";
+        value: CorpusRecord;
+    } | {
+        status: "degraded";
+        reason: string;
+        value?: CorpusRecord | undefined;
+    }>;
+}

package/dist/testing/in-memory-corpus.js

@@ -0,0 +1,54 @@
+import { ok } from '../outcome.js';
+function toKnowledgeHit(seed) {
+    return {
+        ref: seed.ref,
+        kind: seed.kind,
+        ...(seed.title !== undefined ? { title: seed.title } : {}),
+        snippet: seed.task.summary,
+        ...(seed.tier !== undefined ? { tier: seed.tier } : {}),
+        ...(seed.payloadKind !== undefined ? { payloadKind: seed.payloadKind } : {}),
+        tags: seed.tags,
+        origin: seed.origin,
+        ...(seed.publishedAt !== undefined ? { publishedAt: seed.publishedAt } : {}),
+        retrievalVisible: seed.retrievalVisible,
+    };
+}
+/** Map/array-backed, seedable — architecture spec §8. Seeds carry full
+ *  content (`CorpusRecord`) so `get()` can return it directly; `search()`
+ *  derives the lightweight `KnowledgeHit` view. */
+export class InMemoryCorpusPort {
+    seed;
+    constructor(seed = []) {
+        // Seeds default to retrieval-visible (#1824) so pre-allowlist scenarios
+        // keep exercising their own concern; a test proving exclusion sets
+        // `retrievalVisible: false` explicitly. Normalized once here so the
+        // search() and get() views cannot disagree about the default.
+        this.seed = seed.map((s) => ({ ...s, retrievalVisible: s.retrievalVisible ?? true }));
+    }
+    async search(query) {
+        // Naive token-overlap match, no ranking — a stand-in for the real
+        // corpus's capture-meta / manifest-scan search. Words under 4 chars are
+        // dropped so stopwords ("how", "do", "fix") don't cause spurious matches.
+        const words = query
+            .toLowerCase()
+            .split(/[^\p{L}\p{N}]+/u)
+            .filter((word) => word.length >= 4);
+        const hits = this.seed.filter((record) => {
+            const haystack = [record.ref, record.task.summary, ...record.tags]
+                .join(' ')
+                .toLowerCase();
+            return words.length === 0
+                ? haystack.includes(query.toLowerCase())
+                : words.some((word) => haystack.includes(word));
+        });
+        return ok(hits.map(toKnowledgeHit));
+    }
+    async get(ref) {
+        const record = this.seed.find((r) => r.ref === ref);
+        if (!record)
+            return ok(null);
+        // Strip the KnowledgeHit-only fields — get() returns the CorpusRecord shape.
+        const { kind: _kind, title: _title, tier: _tier, payloadKind: _payloadKind, publishedAt: _publishedAt, ...corpusRecord } = record;
+        return ok(corpusRecord);
+    }
+}

package/dist/testing/in-memory-evidence.d.ts

@@ -0,0 +1,335 @@
+import type { EvidenceListQuery, EvidencePort, EvidenceRetentionPolicy } from '../ports/evidence-port.js';
+import type { EpisodeV1 } from '../schemas/episode.js';
+export declare class InMemoryEvidencePort implements EvidencePort {
+    private readonly retentionPolicy;
+    private readonly episodes;
+    constructor(retentionPolicy?: EvidenceRetentionPolicy);
+    put(episode: EpisodeV1): Promise<import("../outcome.js").PortResult<{
+        episodeId: string;
+    }>>;
+    get(episodeId: string): Promise<import("../outcome.js").PortResult<{
+        [x: string]: unknown;
+        schemaVersion: "jinn.episode.v1";
+        episodeId: string;
+        retrievalVisible: boolean;
+        session: {
+            [x: string]: unknown;
+            sessionId: string;
+            capturedAt: string;
+            kind: "user" | "host-internal";
+            parentSessionId?: string | undefined;
+        };
+        origin: "legacy-unstamped" | {
+            [x: string]: unknown;
+            writer: string;
+            build: string;
+        };
+        task: {
+            [x: string]: unknown;
+            summary: string;
+            distributionTags: string[];
+            repositorySlug?: string | undefined;
+            baseCommit?: string | undefined;
+            createdAt?: number | undefined;
+            instanceId?: string | undefined;
+        };
+        trajectory: {
+            [x: string]: unknown;
+            spanId: string;
+            parentSpanId: string | null;
+            kind: "jinn.agent_turn" | "jinn.tool_call";
+            name: string;
+            startTimeUnixNano: string;
+            endTimeUnixNano: string;
+            attributes: Record<string, unknown>;
+            redactedKeys: string[];
+            truncatedKeys?: string[] | undefined;
+            events?: {
+                timeUnixNano: string;
+                name: string;
+                attributes?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            status?: {
+                code: "UNSET" | "OK" | "ERROR";
+                message?: string | undefined;
+            } | undefined;
+        }[];
+        environment: {
+            [x: string]: unknown;
+            harness: {
+                [x: string]: unknown;
+                name: string;
+                version: string;
+            };
+            model: string;
+            tools: string[];
+            skillsLoadout: string[];
+            generatorModel?: {
+                [x: string]: unknown;
+                id: string;
+                source: "stream" | "config";
+                provider?: string | undefined;
+                openWeights?: boolean | undefined;
+            } | undefined;
+            distributionClass?: "unknown" | "open" | "restricted-tos" | undefined;
+            verifier?: {
+                [x: string]: unknown;
+                type: "f2p-p2p";
+                failToPass: string[];
+                passToPass: string[];
+                evalSemanticsVersion: string;
+            } | {
+                [x: string]: unknown;
+                type: "command" | "none";
+                failToPass: string[];
+                passToPass: string[];
+                evalSemanticsVersion?: string | undefined;
+            } | undefined;
+        };
+        outcome: {
+            [x: string]: unknown;
+            status: "completed" | "failed" | "abandoned";
+            verificationStrength: "user-accepted" | "tests-passed" | "evaluator-verified";
+            testRuns?: {
+                [x: string]: unknown;
+                passed: number;
+                failed: number;
+            } | undefined;
+            summary?: string | undefined;
+            acceptedDiff?: boolean | undefined;
+        };
+        cost: {
+            [x: string]: unknown;
+            durationMs: number;
+            tokens?: {
+                [x: string]: unknown;
+                input: number;
+                output: number;
+            } | undefined;
+            usdEstimate?: string | undefined;
+        };
+        retention: {
+            [x: string]: unknown;
+            policy: "local-private" | "contribution-eligible";
+        };
+        provenance: "contributed" | "imported" | "derived-from-history";
+        lineage?: {
+            [x: string]: unknown;
+            episodeId: string;
+            mintRef?: string | undefined;
+        } | undefined;
+        attemptGroup?: {
+            [x: string]: unknown;
+            groupId: string;
+            attemptId: string;
+            relatedAttemptRefs: string[];
+            groupSize?: number | undefined;
+            nPass?: number | undefined;
+            nFail?: number | undefined;
+        } | undefined;
+        activity?: {
+            [x: string]: unknown;
+            retrievalFired: boolean;
+            eligibleRefs: string[];
+            deliveredRefs: string[];
+            deliveryMode: "degraded" | "disabled" | "delivered" | "withheld";
+            searchedTerms: string[];
+            providedRefs: string[];
+            surfacedRefs: string[];
+            fetchedRefs: string[];
+            installedSkillRefs: string[];
+            deliveredContentHash?: string | undefined;
+        } | undefined;
+        eligibility?: {
+            [x: string]: unknown;
+            eligible: boolean;
+            reason: string;
+            checkedAt: string;
+        } | undefined;
+        contributionCandidate?: {
+            [x: string]: unknown;
+            testRuns: {
+                [x: string]: unknown;
+                command: string;
+                exitCode: number;
+                at: string;
+            }[];
+            skillEvents: {
+                [x: string]: unknown;
+                skillRef: string;
+                action: "loaded" | "invoked";
+            }[];
+            schemaVersion: "jinn.contribution-candidate.v1";
+            sourceId: string;
+            repositorySlug: string;
+            baseCommit: string;
+            acceptedDiff: string;
+            intermediateFailureDiffs: string[];
+            publishMinedTasksConsent: boolean;
+            createdAt: string;
+        } | undefined;
+    } | null>>;
+    list(query?: EvidenceListQuery): Promise<import("../outcome.js").PortResult<{
+        [x: string]: unknown;
+        schemaVersion: "jinn.episode.v1";
+        episodeId: string;
+        retrievalVisible: boolean;
+        session: {
+            [x: string]: unknown;
+            sessionId: string;
+            capturedAt: string;
+            kind: "user" | "host-internal";
+            parentSessionId?: string | undefined;
+        };
+        origin: "legacy-unstamped" | {
+            [x: string]: unknown;
+            writer: string;
+            build: string;
+        };
+        task: {
+            [x: string]: unknown;
+            summary: string;
+            distributionTags: string[];
+            repositorySlug?: string | undefined;
+            baseCommit?: string | undefined;
+            createdAt?: number | undefined;
+            instanceId?: string | undefined;
+        };
+        trajectory: {
+            [x: string]: unknown;
+            spanId: string;
+            parentSpanId: string | null;
+            kind: "jinn.agent_turn" | "jinn.tool_call";
+            name: string;
+            startTimeUnixNano: string;
+            endTimeUnixNano: string;
+            attributes: Record<string, unknown>;
+            redactedKeys: string[];
+            truncatedKeys?: string[] | undefined;
+            events?: {
+                timeUnixNano: string;
+                name: string;
+                attributes?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            status?: {
+                code: "UNSET" | "OK" | "ERROR";
+                message?: string | undefined;
+            } | undefined;
+        }[];
+        environment: {
+            [x: string]: unknown;
+            harness: {
+                [x: string]: unknown;
+                name: string;
+                version: string;
+            };
+            model: string;
+            tools: string[];
+            skillsLoadout: string[];
+            generatorModel?: {
+                [x: string]: unknown;
+                id: string;
+                source: "stream" | "config";
+                provider?: string | undefined;
+                openWeights?: boolean | undefined;
+            } | undefined;
+            distributionClass?: "unknown" | "open" | "restricted-tos" | undefined;
+            verifier?: {
+                [x: string]: unknown;
+                type: "f2p-p2p";
+                failToPass: string[];
+                passToPass: string[];
+                evalSemanticsVersion: string;
+            } | {
+                [x: string]: unknown;
+                type: "command" | "none";
+                failToPass: string[];
+                passToPass: string[];
+                evalSemanticsVersion?: string | undefined;
+            } | undefined;
+        };
+        outcome: {
+            [x: string]: unknown;
+            status: "completed" | "failed" | "abandoned";
+            verificationStrength: "user-accepted" | "tests-passed" | "evaluator-verified";
+            testRuns?: {
+                [x: string]: unknown;
+                passed: number;
+                failed: number;
+            } | undefined;
+            summary?: string | undefined;
+            acceptedDiff?: boolean | undefined;
+        };
+        cost: {
+            [x: string]: unknown;
+            durationMs: number;
+            tokens?: {
+                [x: string]: unknown;
+                input: number;
+                output: number;
+            } | undefined;
+            usdEstimate?: string | undefined;
+        };
+        retention: {
+            [x: string]: unknown;
+            policy: "local-private" | "contribution-eligible";
+        };
+        provenance: "contributed" | "imported" | "derived-from-history";
+        lineage?: {
+            [x: string]: unknown;
+            episodeId: string;
+            mintRef?: string | undefined;
+        } | undefined;
+        attemptGroup?: {
+            [x: string]: unknown;
+            groupId: string;
+            attemptId: string;
+            relatedAttemptRefs: string[];
+            groupSize?: number | undefined;
+            nPass?: number | undefined;
+            nFail?: number | undefined;
+        } | undefined;
+        activity?: {
+            [x: string]: unknown;
+            retrievalFired: boolean;
+            eligibleRefs: string[];
+            deliveredRefs: string[];
+            deliveryMode: "degraded" | "disabled" | "delivered" | "withheld";
+            searchedTerms: string[];
+            providedRefs: string[];
+            surfacedRefs: string[];
+            fetchedRefs: string[];
+            installedSkillRefs: string[];
+            deliveredContentHash?: string | undefined;
+        } | undefined;
+        eligibility?: {
+            [x: string]: unknown;
+            eligible: boolean;
+            reason: string;
+            checkedAt: string;
+        } | undefined;
+        contributionCandidate?: {
+            [x: string]: unknown;
+            testRuns: {
+                [x: string]: unknown;
+                command: string;
+                exitCode: number;
+                at: string;
+            }[];
+            skillEvents: {
+                [x: string]: unknown;
+                skillRef: string;
+                action: "loaded" | "invoked";
+            }[];
+            schemaVersion: "jinn.contribution-candidate.v1";
+            sourceId: string;
+            repositorySlug: string;
+            baseCommit: string;
+            acceptedDiff: string;
+            intermediateFailureDiffs: string[];
+            publishMinedTasksConsent: boolean;
+            createdAt: string;
+        } | undefined;
+    }[]>>;
+    retention(): Promise<import("../outcome.js").PortResult<EvidenceRetentionPolicy>>;
+}

package/dist/testing/in-memory-evidence.js

@@ -0,0 +1,23 @@
+import { ok } from '../outcome.js';
+const DEFAULT_RETENTION = { policy: 'local-private', maxEpisodes: 200 };
+export class InMemoryEvidencePort {
+    retentionPolicy;
+    episodes = new Map();
+    constructor(retentionPolicy = DEFAULT_RETENTION) {
+        this.retentionPolicy = retentionPolicy;
+    }
+    async put(episode) {
+        this.episodes.set(episode.episodeId, episode);
+        return ok({ episodeId: episode.episodeId });
+    }
+    async get(episodeId) {
+        return ok(this.episodes.get(episodeId) ?? null);
+    }
+    async list(query = {}) {
+        const all = [...this.episodes.values()];
+        return ok(query.limit ? all.slice(0, query.limit) : all);
+    }
+    async retention() {
+        return ok(this.retentionPolicy);
+    }
+}

package/dist/testing/in-memory-local-learning.d.ts

@@ -0,0 +1,25 @@
+import type { LocalLearningPort, LocalLearningRun, LocalLearningSkill } from '../ports/local-learning-port.js';
+export declare class InMemoryLocalLearningPort implements LocalLearningPort {
+    private readonly runs;
+    private readonly learnedSkills;
+    private counter;
+    run(_input: {
+        episodeIds: string[];
+    }): Promise<import("../outcome.js").PortResult<{
+        runId: string;
+    }>>;
+    status(runId: string): Promise<{
+        status: "unavailable";
+        reason: string;
+    } | {
+        status: "ok";
+        value: LocalLearningRun;
+    } | {
+        status: "degraded";
+        reason: string;
+        value?: LocalLearningRun | undefined;
+    }>;
+    list(): Promise<import("../outcome.js").PortResult<LocalLearningRun[]>>;
+    recordSkill(skill: LocalLearningSkill): void;
+    skills(): Promise<import("../outcome.js").PortResult<LocalLearningSkill[]>>;
+}

package/dist/testing/in-memory-local-learning.js

@@ -0,0 +1,30 @@
+import { ok, unavailable } from '../outcome.js';
+export class InMemoryLocalLearningPort {
+    runs = new Map();
+    learnedSkills = new Map();
+    counter = 0;
+    async run(_input) {
+        this.counter += 1;
+        const runId = `run-${this.counter}`;
+        this.runs.set(runId, { runId, state: 'pending' });
+        return ok({ runId });
+    }
+    async status(runId) {
+        const run = this.runs.get(runId);
+        if (!run)
+            return unavailable(`no such run: ${runId}`);
+        return ok(run);
+    }
+    async list() {
+        return ok([...this.runs.values()]);
+    }
+    recordSkill(skill) {
+        this.learnedSkills.set(skill.ref, {
+            ...skill,
+            sourceSessionIds: [...skill.sourceSessionIds],
+        });
+    }
+    async skills() {
+        return ok([...this.learnedSkills.values()]);
+    }
+}

package/dist/testing/in-memory-skills.d.ts

@@ -0,0 +1,9 @@
+import type { SkillRecord, SkillsPort } from '../ports/skills-port.js';
+export declare class InMemorySkillsPort implements SkillsPort {
+    private readonly installed;
+    install(ref: string): Promise<import("../outcome.js").PortResult<SkillRecord>>;
+    list(): Promise<import("../outcome.js").PortResult<SkillRecord[]>>;
+    uninstall(ref: string): Promise<import("../outcome.js").PortResult<{
+        ref: string;
+    }>>;
+}

package/dist/testing/in-memory-skills.js

@@ -0,0 +1,16 @@
+import { ok } from '../outcome.js';
+export class InMemorySkillsPort {
+    installed = new Map();
+    async install(ref) {
+        const record = { ref, installedAt: new Date().toISOString() };
+        this.installed.set(ref, record);
+        return ok(record);
+    }
+    async list() {
+        return ok([...this.installed.values()]);
+    }
+    async uninstall(ref) {
+        this.installed.delete(ref);
+        return ok({ ref });
+    }
+}

package/dist/testing.d.ts

@@ -0,0 +1,6 @@
+export { InMemoryCorpusPort } from './testing/in-memory-corpus.js';
+export { InMemoryEvidencePort } from './testing/in-memory-evidence.js';
+export { InMemoryContributionPort } from './testing/in-memory-contribution.js';
+export { InMemoryLocalLearningPort } from './testing/in-memory-local-learning.js';
+export { InMemorySkillsPort } from './testing/in-memory-skills.js';
+export { describeCorpusPortContract, describeEvidencePortContract, describeContributionPortContract, describeLocalLearningPortContract, describeSkillsPortContract, } from './testing/contract-kits.js';

package/dist/testing.js

@@ -0,0 +1,8 @@
+// packages/plugin/src/testing.ts
+// ./testing subpath entry — in-memory adapters + contract kits (S1-F1).
+export { InMemoryCorpusPort } from './testing/in-memory-corpus.js';
+export { InMemoryEvidencePort } from './testing/in-memory-evidence.js';
+export { InMemoryContributionPort } from './testing/in-memory-contribution.js';
+export { InMemoryLocalLearningPort } from './testing/in-memory-local-learning.js';
+export { InMemorySkillsPort } from './testing/in-memory-skills.js';
+export { describeCorpusPortContract, describeEvidencePortContract, describeContributionPortContract, describeLocalLearningPortContract, describeSkillsPortContract, } from './testing/contract-kits.js';

package/dist/visibility.d.ts

@@ -0,0 +1,7 @@
+/** Retrieval-visibility mark (issue #1824, corpus-supply-design §5 W2): a
+ *  reserved, deterministic distribution tag carried inside the signed
+ *  jinn.trace-envelope.v0 content (task.distributionTags). Presence is the
+ *  sole allowlist signal pickup enforcement keys on — absence excludes,
+ *  fail-closed (opposite of the fail-open skill-detection guards). */
+export declare const RETRIEVAL_VISIBLE_TAG: "retrieval:visible.v1";
+export declare function hasRetrievalMark(tags: readonly string[]): boolean;