@iamem/amem 0.1.0

package/dist/proposal.js

@@ -0,0 +1,376 @@
+import { readFileSync } from "node:fs";
+import { listClaims, listComponents, listEdges, listFlows, nowIso, openDb, reindexClaimsSearch, } from "./db.js";
+import { compiledDenyPatterns } from "./policy.js";
+import { newId } from "./repo-identity.js";
+import { parseAnchors } from "./freshness.js";
+import { tokenJaccard } from "./search.js";
+const OBJECT_TYPES = new Set(["claim", "flow", "component"]);
+const CONFLICT_JACCARD = 0.45;
+export function parseProposalJson(raw) {
+    const data = JSON.parse(raw);
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        throw new Error("Proposal must be a JSON object");
+    }
+    return data;
+}
+function normalizeSupersedes(claim) {
+    if (!claim.supersedes)
+        return [];
+    return [...new Set(claim.supersedes.filter((id) => typeof id === "string" && id.trim()))];
+}
+/** Collect explicit supersede targets from claims + supersedes edges. */
+export function collectSupersedeTargets(proposal) {
+    // oldId -> newId
+    const map = new Map();
+    for (const claim of proposal.claims ?? []) {
+        for (const oldId of normalizeSupersedes(claim)) {
+            if (oldId !== claim.id)
+                map.set(oldId, claim.id);
+        }
+    }
+    for (const edge of proposal.edges ?? []) {
+        if (edge.kind === "supersedes" && edge.from_type === "claim" && edge.to_type === "claim") {
+            if (edge.from_id && edge.to_id && edge.from_id !== edge.to_id) {
+                map.set(edge.to_id, edge.from_id);
+            }
+        }
+    }
+    return map;
+}
+function shareAnchor(a, b) {
+    const set = new Set(a);
+    return b.some((x) => set.has(x));
+}
+/**
+ * Likely conflict: share ≥1 code_anchor and high text overlap, different ids,
+ * and the older claim is not explicitly superseded by this proposal.
+ */
+export function findClaimConflicts(proposal, existingActive) {
+    const conflicts = [];
+    const supersedeTargets = collectSupersedeTargets(proposal);
+    const incomingIds = new Set((proposal.claims ?? []).map((c) => c.id));
+    for (const claim of proposal.claims ?? []) {
+        const anchors = claim.code_anchors ?? [];
+        if (anchors.length === 0 || !claim.text)
+            continue;
+        for (const other of existingActive) {
+            if (other.id === claim.id)
+                continue;
+            if (incomingIds.has(other.id) && (proposal.claims ?? []).some((c) => c.id === other.id)) {
+                continue;
+            }
+            if (supersedeTargets.get(other.id) === claim.id)
+                continue;
+            if (supersedeTargets.has(other.id))
+                continue;
+            const otherAnchors = parseAnchors(other.code_anchors);
+            if (!shareAnchor(anchors, otherAnchors))
+                continue;
+            const sim = tokenJaccard(claim.text, other.text);
+            if (sim >= CONFLICT_JACCARD) {
+                conflicts.push({
+                    claimId: claim.id,
+                    otherId: other.id,
+                    otherText: other.text,
+                    similarity: sim,
+                    sharedAnchors: anchors.filter((a) => otherAnchors.includes(a)),
+                    withinProposal: false,
+                });
+            }
+        }
+        for (const peer of proposal.claims ?? []) {
+            if (peer.id <= claim.id)
+                continue;
+            const peerAnchors = peer.code_anchors ?? [];
+            if (!shareAnchor(anchors, peerAnchors))
+                continue;
+            if (normalizeSupersedes(claim).includes(peer.id) || normalizeSupersedes(peer).includes(claim.id)) {
+                continue;
+            }
+            const sim = tokenJaccard(claim.text, peer.text ?? "");
+            if (sim >= CONFLICT_JACCARD) {
+                conflicts.push({
+                    claimId: claim.id,
+                    otherId: peer.id,
+                    otherText: peer.text ?? "",
+                    similarity: sim,
+                    sharedAnchors: anchors.filter((a) => peerAnchors.includes(a)),
+                    withinProposal: true,
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+export function findConflictWarnings(proposal, existingActive) {
+    return findClaimConflicts(proposal, existingActive).map((c) => c.withinProposal
+        ? `claims ${c.claimId} and ${c.otherId} look conflicting in the same proposal — set supersedes on the winner.`
+        : `claim ${c.claimId} may conflict with active ${c.otherId} (shared anchors, text similarity ${(c.similarity * 100).toFixed(0)}%). Add "supersedes": ["${c.otherId}"] if this replaces it.`);
+}
+/** Attach supersede targets to the first claim (Memory “replace older facts”). */
+export function applySupersedes(proposal, otherIds) {
+    const extra = [...new Set(otherIds.filter((id) => id.trim()))];
+    if (extra.length === 0)
+        return proposal;
+    const claims = (proposal.claims ?? []).map((claim, index) => {
+        if (index !== 0)
+            return claim;
+        return {
+            ...claim,
+            supersedes: [...new Set([...normalizeSupersedes(claim), ...extra.filter((id) => id !== claim.id)])],
+        };
+    });
+    return { ...proposal, claims };
+}
+export function validateProposal(proposal, policy, opts = {}) {
+    const errors = [];
+    const warnings = [];
+    const componentIds = new Set();
+    const flowIds = new Set();
+    const claimIds = new Set();
+    for (const c of proposal.components ?? []) {
+        if (!c.id || !c.name)
+            errors.push("component requires id and name");
+        else
+            componentIds.add(c.id);
+    }
+    for (const f of proposal.flows ?? []) {
+        if (!f.id || !f.name)
+            errors.push("flow requires id and name");
+        else
+            flowIds.add(f.id);
+    }
+    for (const claim of proposal.claims ?? []) {
+        if (!claim.id || !claim.kind || !claim.text) {
+            errors.push(`claim ${claim.id ?? "(missing id)"} requires id, kind, and text`);
+        }
+        else {
+            claimIds.add(claim.id);
+            if (!claim.code_anchors || claim.code_anchors.length === 0) {
+                errors.push(`claim ${claim.id} should include at least one code_anchor`);
+            }
+            for (const oldId of normalizeSupersedes(claim)) {
+                if (oldId === claim.id) {
+                    errors.push(`claim ${claim.id} cannot supersede itself`);
+                }
+            }
+        }
+    }
+    for (const edge of proposal.edges ?? []) {
+        if (!OBJECT_TYPES.has(edge.from_type) || !OBJECT_TYPES.has(edge.to_type)) {
+            errors.push(`edge has invalid types: ${edge.from_type} -> ${edge.to_type}`);
+            continue;
+        }
+        if (!edge.from_id || !edge.to_id || !edge.kind) {
+            errors.push("edge requires from_id, to_id, and kind");
+        }
+    }
+    if ((proposal.components?.length ?? 0) === 0 &&
+        (proposal.flows?.length ?? 0) === 0 &&
+        (proposal.claims?.length ?? 0) === 0 &&
+        (proposal.edges?.length ?? 0) === 0) {
+        errors.push("proposal is empty");
+    }
+    errors.push(...checkProposalAgainstPolicy(proposal, policy));
+    const existing = opts.existingClaims ?? [];
+    const activeExisting = existing.filter((c) => (c.status ?? "active") === "active");
+    warnings.push(...findConflictWarnings(proposal, activeExisting));
+    // dangling supersedes targets (informational)
+    const existingIds = new Set(existing.map((c) => c.id));
+    for (const claim of proposal.claims ?? []) {
+        for (const oldId of normalizeSupersedes(claim)) {
+            if (!existingIds.has(oldId) && !claimIds.has(oldId)) {
+                warnings.push(`claim ${claim.id} supersedes unknown id ${oldId} (will no-op if missing at apply)`);
+            }
+        }
+    }
+    return { ok: errors.length === 0, errors, warnings, proposal };
+}
+/** Block claims that look like secrets / credentials (builtin + policy patterns). */
+export function checkProposalAgainstPolicy(proposal, policy) {
+    const errors = [];
+    let patterns;
+    try {
+        patterns = compiledDenyPatterns(policy);
+    }
+    catch (err) {
+        return [err instanceof Error ? err.message : String(err)];
+    }
+    for (const claim of proposal.claims ?? []) {
+        const haystacks = [
+            claim.id ?? "",
+            claim.text ?? "",
+            claim.source_ref ?? "",
+            ...(claim.code_anchors ?? []),
+        ];
+        for (const re of patterns) {
+            for (const text of haystacks) {
+                if (text && re.test(text)) {
+                    errors.push(`claim ${claim.id ?? "(missing id)"} blocked by deny_claim_patterns /${re.source}/i`);
+                    break;
+                }
+            }
+        }
+    }
+    return errors;
+}
+export function loadProposalFile(path) {
+    return parseProposalJson(readFileSync(path, "utf8"));
+}
+function anchorsEqual(a, b) {
+    let left = [];
+    try {
+        left = a ? JSON.parse(a) : [];
+    }
+    catch {
+        left = [];
+    }
+    const right = b ?? [];
+    if (left.length !== right.length)
+        return false;
+    const s = new Set(left);
+    return right.every((x) => s.has(x));
+}
+/** Preview what apply would change against current active (+ superseded targets). */
+export function diffProposal(repoId, proposal) {
+    const existing = listClaims(repoId, { includeSuperseded: true });
+    const byId = new Map(existing.map((c) => [c.id, c]));
+    const components = listComponents(repoId);
+    const flows = listFlows(repoId);
+    const componentIds = new Set(components.map((c) => c.id));
+    const flowIds = new Set(flows.map((f) => f.id));
+    const claimsAdded = [];
+    const claimsUpdated = [];
+    const claimsUnchanged = [];
+    for (const claim of proposal.claims ?? []) {
+        const prior = byId.get(claim.id);
+        if (!prior) {
+            claimsAdded.push(claim.id);
+            continue;
+        }
+        const same = prior.text === claim.text &&
+            prior.kind === claim.kind &&
+            anchorsEqual(prior.code_anchors, claim.code_anchors) &&
+            (prior.status ?? "active") === "active";
+        if (same)
+            claimsUnchanged.push(claim.id);
+        else
+            claimsUpdated.push(claim.id);
+    }
+    const willSupersede = [...collectSupersedeTargets(proposal).keys()].filter((id) => {
+        const row = byId.get(id);
+        return row && (row.status ?? "active") === "active";
+    });
+    return {
+        claimsAdded,
+        claimsUpdated,
+        claimsUnchanged,
+        willSupersede,
+        componentsAdded: (proposal.components ?? [])
+            .map((c) => c.id)
+            .filter((id) => !componentIds.has(id)),
+        flowsAdded: (proposal.flows ?? []).map((f) => f.id).filter((id) => !flowIds.has(id)),
+    };
+}
+export function formatProposalDiff(diff) {
+    const lines = ["Diff:"];
+    const push = (label, ids) => {
+        if (!ids.length)
+            return;
+        lines.push(`- ${label}: ${ids.map((id) => `\`${id}\``).join(", ")}`);
+    };
+    push("add claims", diff.claimsAdded);
+    push("update claims", diff.claimsUpdated);
+    push("unchanged claims", diff.claimsUnchanged);
+    push("supersede", diff.willSupersede);
+    push("add components", diff.componentsAdded);
+    push("add flows", diff.flowsAdded);
+    if (lines.length === 1)
+        lines.push("- (no claim/component/flow changes detected)");
+    return lines.join("\n");
+}
+export function applyProposal(repoId, proposal, policy) {
+    const existing = listClaims(repoId, { includeSuperseded: true });
+    const validated = validateProposal(proposal, policy, { existingClaims: existing });
+    if (!validated.ok) {
+        throw new Error(`Invalid proposal:\n- ${validated.errors.join("\n- ")}`);
+    }
+    const db = openDb();
+    const ts = nowIso();
+    let components = 0;
+    let flows = 0;
+    let claims = 0;
+    let edges = 0;
+    let superseded = 0;
+    const upsertComponent = db.prepare(`INSERT INTO components (repo_id, id, name, code_anchor)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(repo_id, id) DO UPDATE SET
+       name = excluded.name,
+       code_anchor = excluded.code_anchor`);
+    const upsertFlow = db.prepare(`INSERT INTO flows (repo_id, id, name)
+     VALUES (?, ?, ?)
+     ON CONFLICT(repo_id, id) DO UPDATE SET name = excluded.name`);
+    const upsertClaim = db.prepare(`INSERT INTO claims (repo_id, id, kind, text, code_anchors, source_ref, created_at, updated_at, status, superseded_by, pinned)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', NULL, 0)
+     ON CONFLICT(repo_id, id) DO UPDATE SET
+       kind = excluded.kind,
+       text = excluded.text,
+       code_anchors = excluded.code_anchors,
+       source_ref = COALESCE(excluded.source_ref, claims.source_ref),
+       updated_at = excluded.updated_at,
+       status = 'active',
+       superseded_by = NULL`);
+    const markSuperseded = db.prepare(`UPDATE claims SET status = 'superseded', superseded_by = ?, updated_at = ?
+     WHERE repo_id = ? AND id = ? AND id != ?`);
+    const upsertEdge = db.prepare(`INSERT INTO edges (repo_id, id, from_id, from_type, to_id, to_type, kind)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo_id, id) DO UPDATE SET
+       from_id = excluded.from_id,
+       from_type = excluded.from_type,
+       to_id = excluded.to_id,
+       to_type = excluded.to_type,
+       kind = excluded.kind`);
+    const supersedeMap = collectSupersedeTargets(proposal);
+    db.exec("BEGIN");
+    try {
+        for (const c of proposal.components ?? []) {
+            upsertComponent.run(repoId, c.id, c.name, c.code_anchor ?? null);
+            components += 1;
+        }
+        for (const f of proposal.flows ?? []) {
+            upsertFlow.run(repoId, f.id, f.name);
+            flows += 1;
+        }
+        for (const claim of proposal.claims ?? []) {
+            const prior = db
+                .prepare("SELECT created_at FROM claims WHERE repo_id = ? AND id = ?")
+                .get(repoId, claim.id);
+            upsertClaim.run(repoId, claim.id, claim.kind, claim.text, JSON.stringify(claim.code_anchors ?? []), claim.source_ref ?? null, prior?.created_at ?? ts, ts);
+            claims += 1;
+        }
+        for (const [oldId, newId] of supersedeMap) {
+            const result = markSuperseded.run(newId, ts, repoId, oldId, newId);
+            superseded += Number(result.changes ?? 0);
+        }
+        for (const edge of proposal.edges ?? []) {
+            const id = edge.id ?? newId("edge");
+            upsertEdge.run(repoId, id, edge.from_id, edge.from_type, edge.to_id, edge.to_type, edge.kind);
+            edges += 1;
+        }
+        db.exec("COMMIT");
+    }
+    catch (err) {
+        db.exec("ROLLBACK");
+        throw err;
+    }
+    reindexClaimsSearch(repoId);
+    return { components, flows, claims, edges, superseded };
+}
+export function exportRepoMemory(repoId) {
+    return {
+        components: listComponents(repoId),
+        flows: listFlows(repoId),
+        claims: listClaims(repoId, { includeSuperseded: true }),
+        edges: listEdges(repoId),
+    };
+}

package/dist/publish.d.ts

@@ -0,0 +1,28 @@
+/** Paths that must be inside the published tarball for `npx @iamem/amem setup`. */
+export declare const REQUIRED_PACK_PATHS: readonly ["dist/cli.js", "dist/mcp.js", "dist/remember-contract.js", "ui-static/index.html", "ui-static/app.js", "ui-static/styles.css", "docs/remember-contract.md", "docs/agent-install-prompt.md", "docs/npm-release.md", "skills/amem-update-working-memory/SKILL.md", "scripts/mdm-offboard.sh"];
+export declare const PUBLISH_PACKAGE_NAME = "@iamem/amem";
+export type PublishReady = {
+    root: string;
+    name: string;
+    version: string;
+    bin: string;
+    engines: string;
+    filesField: string[];
+    missing: string[];
+    ok: boolean;
+};
+export declare function packageRoot(): string;
+export declare function readPackageJson(root?: string): {
+    name?: string;
+    version?: string;
+    bin?: Record<string, string> | string;
+    engines?: {
+        node?: string;
+    };
+    files?: string[];
+    publishConfig?: {
+        access?: string;
+    };
+};
+export declare function inspectPublishReady(root?: string): PublishReady;
+export declare function assertPublishReady(root?: string): PublishReady;

package/dist/publish.js

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Paths that must be inside the published tarball for `npx @iamem/amem setup`. */
+export const REQUIRED_PACK_PATHS = [
+    "dist/cli.js",
+    "dist/mcp.js",
+    "dist/remember-contract.js",
+    "ui-static/index.html",
+    "ui-static/app.js",
+    "ui-static/styles.css",
+    "docs/remember-contract.md",
+    "docs/agent-install-prompt.md",
+    "docs/npm-release.md",
+    "skills/amem-update-working-memory/SKILL.md",
+    "scripts/mdm-offboard.sh",
+];
+export const PUBLISH_PACKAGE_NAME = "@iamem/amem";
+export function packageRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+export function readPackageJson(root = packageRoot()) {
+    return JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+}
+export function inspectPublishReady(root = packageRoot()) {
+    const pkg = readPackageJson(root);
+    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.amem ?? "";
+    const missing = REQUIRED_PACK_PATHS.filter((rel) => !existsSync(join(root, rel)));
+    if (!bin)
+        missing.push("package.json#bin.amem");
+    if (pkg.publishConfig?.access !== "public")
+        missing.push("package.json#publishConfig.access=public");
+    if (!pkg.engines?.node)
+        missing.push("package.json#engines.node");
+    const filesField = pkg.files ?? [];
+    for (const required of ["dist", "ui-static", "docs", "skills"]) {
+        if (!filesField.includes(required))
+            missing.push(`package.json#files missing ${required}`);
+    }
+    return {
+        root,
+        name: pkg.name ?? "",
+        version: pkg.version ?? "",
+        bin,
+        engines: pkg.engines?.node ?? "",
+        filesField,
+        missing,
+        ok: missing.length === 0 && pkg.name === PUBLISH_PACKAGE_NAME && Boolean(bin),
+    };
+}
+export function assertPublishReady(root = packageRoot()) {
+    const info = inspectPublishReady(root);
+    if (!info.ok) {
+        throw new Error(`Package is not npx-ready:\n${info.missing.map((m) => `  - ${m}`).join("\n")}`);
+    }
+    return info;
+}

package/dist/remember-contract.d.ts

@@ -0,0 +1,23 @@
+/** Generic host recipe: read then write. Not tied to any one MCP client. */
+export declare const REMEMBER_CONTRACT_VERSION = "1";
+export declare const MCP_URL_TEMPLATE = "http://127.0.0.1:7843/mcp?workspace=<slug>";
+export type RememberRule = {
+    id: string;
+    must: boolean;
+    text: string;
+};
+export type RememberContract = {
+    version: string;
+    title: string;
+    mcpUrlTemplate: string;
+    tools: {
+        name: string;
+        role: "read" | "write" | "meta";
+        when: string;
+    }[];
+    rules: RememberRule[];
+    markdown: string;
+    paste: string;
+};
+export declare function rememberContract(): RememberContract;
+export declare function rememberContractMustIds(): string[];

package/dist/remember-contract.js

@@ -0,0 +1,117 @@
+/** Generic host recipe: read then write. Not tied to any one MCP client. */
+export const REMEMBER_CONTRACT_VERSION = "1";
+export const MCP_URL_TEMPLATE = "http://127.0.0.1:7843/mcp?workspace=<slug>";
+const TOOLS = [
+    {
+        name: "amem_context",
+        role: "read",
+        when: "Before exploring files or sending a large prompt. Pass workspace=<slug>.",
+    },
+    {
+        name: "amem_remember",
+        role: "write",
+        when: "After a durable outcome: a decision, constraint, owner, or gotcha that should survive this chat.",
+    },
+    {
+        name: "amem_recipe",
+        role: "meta",
+        when: "If you are unsure when to read or write — fetch this contract.",
+    },
+];
+const RULES = [
+    {
+        id: "read-first",
+        must: true,
+        text: "Call amem_context at the start of a task. Do not treat a successful read as a substitute for writing later.",
+    },
+    {
+        id: "write-outcomes",
+        must: true,
+        text: "Call amem_remember when the user confirms a durable fact, or when you discover a constraint that the next session will need.",
+    },
+    {
+        id: "local-only",
+        must: true,
+        text: "Memory stays on this machine under ~/.amem. Do not upload claims, paste them into shared docs, or commit them to product git.",
+    },
+    {
+        id: "no-secrets",
+        must: true,
+        text: "Never remember passwords, API keys, tokens, or private key material.",
+    },
+    {
+        id: "no-prompt-strategy",
+        must: true,
+        text: "Store repo or workspace facts with file anchors — not proprietary prompting strategy.",
+    },
+    {
+        id: "durable-kinds",
+        must: true,
+        text: "Prefer kinds constraint, gotcha, structure, howto, or owner. Use kind=session only for short-lived chat takeaways — session spam drowns retrieval.",
+    },
+    {
+        id: "workspace",
+        must: true,
+        text: "Named workspaces are not git repos. Always pass the workspace slug on context and remember.",
+    },
+];
+function renderMarkdown() {
+    const toolLines = TOOLS.map((t) => `- \`${t.name}\` (${t.role}) — ${t.when}`).join("\n");
+    const ruleLines = RULES.map((r) => `- ${r.must ? "Must:" : "Should:"} ${r.text}`).join("\n");
+    return `# amem remember contract (v${REMEMBER_CONTRACT_VERSION})
+
+Generic MCP host recipe. Same tools for every client — do not fork per product.
+
+## Connect
+
+Keep \`amem ui\` running, then attach:
+
+\`${MCP_URL_TEMPLATE}\`
+
+GUI hosts often cannot see Homebrew on PATH. Prefer the HTTP URL over a bare \`amem\` command.
+
+## Tools
+
+${toolLines}
+
+## Rules
+
+${ruleLines}
+
+## Example
+
+1. \`amem_context\` query="What should I know before changing auth?" workspace=my-app
+2. Do the work, verify files.
+3. \`amem_remember\` text="Auth mode is checked in src/auth.ts before Drive sync" workspace=my-app kind=constraint anchors=["src/auth.ts"]
+`;
+}
+function renderPaste() {
+    return `amem remember contract v${REMEMBER_CONTRACT_VERSION}
+
+Connect (any MCP host): ${MCP_URL_TEMPLATE}
+Keep amem ui running. Do not use a bare amem command from GUI apps.
+
+Every task:
+1. amem_context — read local memory first (pass workspace=<slug>)
+2. Do the work
+3. amem_remember — write durable outcomes (decisions, constraints, owners, gotchas)
+
+Never: upload memory, commit claims to product git, store secrets, or store prompting strategy.
+Facts stay in ~/.amem on this machine.
+
+If unsure, call amem_recipe.`;
+}
+export function rememberContract() {
+    return {
+        version: REMEMBER_CONTRACT_VERSION,
+        title: "amem remember contract",
+        mcpUrlTemplate: MCP_URL_TEMPLATE,
+        tools: TOOLS,
+        rules: RULES,
+        markdown: renderMarkdown(),
+        paste: renderPaste(),
+    };
+}
+export function rememberContractMustIds() {
+    return RULES.filter((r) => r.must).map((r) => r.id);
+}

package/dist/repo-identity.d.ts

@@ -0,0 +1,15 @@
+export type RepoIdentity = {
+    rootPath: string;
+    remoteUrl: string | null;
+    repoKey: string;
+    repoName: string;
+    defaultBranch: string;
+};
+export declare function findGitRoot(startPath?: string): string | null;
+/** Normalize remotes so ssh/https clones of the same repo share a key. */
+export declare function normalizeRemoteUrl(url: string): string;
+export declare function detectRepoIdentity(cwd?: string): RepoIdentity;
+export declare function slugifyWorkspace(name: string): string;
+export declare function workspaceIdentity(name: string, rootPath: string): RepoIdentity;
+export declare function parseWorkspaceSlug(remoteUrl: string | null | undefined): string | null;
+export declare function newId(prefix?: string): string;