@tenova/swt3-ai 0.5.3 → 0.5.5

package/dist/witness.js

@@ -21,7 +21,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { sha256Truncated, mintFingerprint, timestampMs } from "./fingerprint.js";
-import { extractPayloads, extractGatekeeperPayload, extractRevocationPayload, REVOCATION_REASONS } from "./clearing.js";
+import { extractPayloads, extractGatekeeperPayload, extractRevocationPayload, extractChainTrustDegradationPayload, REVOCATION_REASONS } from "./clearing.js";
 import { signPayload } from "./signing.js";
 import { WitnessBuffer } from "./buffer.js";
 import { WriteAheadLog } from "./wal.js";
@@ -34,7 +34,7 @@ import { queryHardware as queryHw, topologyCode as topoCode, queryTPM as queryTp
 import { queryEnvironment as queryEnv } from "./environment.js";
 import { TrustRegistry, verifyCredential, signCredential, TRUST_LEVEL_NAMES, } from "./trust.js";
 import { createVercelOnFinish } from "./adapters/vercel-ai.js";
-import { QUANTIZATION_CODES, POLICY_CATEGORIES, BINDING_METHODS, APPROVAL_STATUS, PII_EVENT_TYPES } from "./types.js";
+import { QUANTIZATION_CODES, POLICY_CATEGORIES, BINDING_METHODS, APPROVAL_STATUS, PII_EVENT_TYPES, CONTENT_TYPE_CODES, BASELINE_MODE_CODES } from "./types.js";
 import { loadFullConfig, validatePolicy } from "./config.js";
 import { MerkleAccumulator } from "./merkle.js";
 // ── Chain Density Enforcement ──────────────────────────────────────────
@@ -194,12 +194,25 @@ export class GatekeeperError extends Error {
         this.missingNames = missingNames;
     }
 }
+export class ChainTrustError extends Error {
+    effectiveTrustLevel;
+    minimumRequired;
+    constructor(effective, minimum) {
+        super(`Chain trust blocked: effective level ${effective} below minimum ${minimum}`);
+        this.name = "ChainTrustError";
+        this.effectiveTrustLevel = effective;
+        this.minimumRequired = minimum;
+    }
+}
 export class Witness {
     config;
     buffer;
     handoffWarned = false;
     _strict;
     _gatewayMode;
+    _chainTrustLevels = [];
+    _onViolation;
+    _walPath;
     /** True if the SDK is deferring witnessing to an SWT3 Gateway. */
     get gatewayMode() {
         return this._gatewayMode;
@@ -239,6 +252,14 @@ export class Witness {
             if (loaded.hardware.requireAttestation) {
                 witness.witnessHardware();
             }
+            if (loaded.hardware.runtimeProfile && witness._lastHwSnapshot) {
+                witness._validateRuntimeProfile(loaded.hardware.runtimeProfile, witness._lastHwSnapshot);
+            }
+        }
+        if (loaded.skillCard && loaded.skillCard.skills.length > 0) {
+            witness.witnessSkillManifest(loaded.skillCard.skills, {
+                expectedManifestHash: loaded.skillCard.expectedManifestHash,
+            });
         }
         if (loaded.densityPolicy) {
             witness._densityPolicy = loaded.densityPolicy;
@@ -260,15 +281,22 @@ export class Witness {
                 });
             }
         }
+        // Fire-and-forget sentinel auto-detection (patent pending).
+        // Non-blocking: <10ms probe. If daemon is running, wrapTool/record
+        // will delegate to it. If not, SDK operates standalone as before.
+        witness._detectSentinelAsync();
         return witness;
     }
     _configHash;
     _hardwareConfig;
+    _lastHwSnapshot;
     _densityPolicy;
     _mcpPolicy;
     _merkleConfig;
     _merkleAccumulator;
     _chainEnforcer;
+    _sentinel;
+    _sentinelDetecting = false;
     get configHash() {
         return this._configHash;
     }
@@ -292,11 +320,72 @@ export class Witness {
     get chainEnforcer() {
         return this._chainEnforcer;
     }
+    /** Connected sentinel daemon client (null if no daemon detected). */
+    get sentinel() {
+        return this._sentinel;
+    }
+    /**
+     * Connect to a running swt3-sentinel daemon.
+     *
+     * When connected, chain enforcement, signing, and WAL operations are
+     * delegated to the isolated daemon process. If the daemon is not running,
+     * returns false and the SDK continues with local enforcement.
+     *
+     * This method is called automatically by fromConfig() in fire-and-forget
+     * mode. You only need to call it explicitly if you want to await the
+     * connection or use a custom socket path.
+     */
+    async connectSentinel(socketPath) {
+        try {
+            const { SentinelClient } = await import("./sentinel-client.js");
+            const client = await SentinelClient.detect(socketPath);
+            if (client) {
+                this._sentinel = client;
+                return true;
+            }
+        }
+        catch {
+            // Sentinel not available -- silent fallback
+        }
+        return false;
+    }
+    /**
+     * Fire-and-forget sentinel detection. Called from fromConfig().
+     * Non-blocking: takes <10ms, resolves in background.
+     */
+    _detectSentinelAsync() {
+        if (this._sentinelDetecting)
+            return;
+        this._sentinelDetecting = true;
+        this.connectSentinel().finally(() => {
+            this._sentinelDetecting = false;
+        });
+    }
     /** Record token usage against the chain enforcer's session budget. */
     recordSessionTokens(count) {
         if (this._chainEnforcer) {
             this._chainEnforcer.recordTokens(count);
         }
+        // Mirror to sentinel for cross-process shared budget
+        if (this._sentinel?.connected) {
+            this._sentinel.recordTokens(count).catch(() => { });
+        }
+    }
+    /** Set or replace the violation callback at runtime. */
+    set onViolation(cb) {
+        this._onViolation = cb;
+    }
+    _fireViolation(violation) {
+        if (this._onViolation) {
+            try {
+                this._onViolation(violation);
+            }
+            catch (e) {
+                if (typeof process !== "undefined" && process.env.SWT3_DEBUG) {
+                    console.error("SWT3: onViolation callback threw:", e);
+                }
+            }
+        }
     }
     _recordChainViolation(violation) {
         const record = {
@@ -315,6 +404,7 @@ export class Witness {
             toolCallId: `chain-${violation.timestamp}`,
         };
         this.record(record);
+        this._fireViolation(violation);
     }
     _configureTrustMesh(mesh) {
         const registry = this.trustRegistry;
@@ -381,9 +471,12 @@ export class Witness {
             legalBasis: options.legalBasis,
             purposeClass: options.purposeClass,
             tokenBudget: options.tokenBudget,
+            chainMinTrustLevel: options.chainMinTrustLevel,
             onFlush: options.onFlush,
         };
         this._strict = options.strict ?? false;
+        this._onViolation = options.onViolation;
+        this._walPath = options.walPath;
         // WAL: crash-resilient buffer persistence + replay protection (patent pending)
         let wal;
         if (options.walPath) {
@@ -457,7 +550,7 @@ export class Witness {
         const policyHash = this.config.policyVersion
             ? sha256Truncated(this.config.policyVersion, 12)
             : undefined;
-        const payload = extractGatekeeperPayload(this.config.tenantId, required, active, gatePassed, this.config.clearingLevel, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, this.config.cycleId, policyHash, this.config.jurisdiction, this.config.legalBasis, this.config.purposeClass);
+        const payload = extractGatekeeperPayload(this.config.tenantId, required, active, gatePassed, this.config.clearingLevel, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, this.config.cycleId, policyHash, this.config.jurisdiction, this.config.legalBasis, this.config.purposeClass, this.config.signingAlgorithm);
         this.buffer.enqueueMany([payload]);
         if (!gatePassed) {
             throw new GatekeeperError(required, active);
@@ -480,16 +573,23 @@ export class Witness {
         const name = toolName ?? fn.name ?? "anonymous";
         const self = this;
         const wrapper = function (...args) {
-            // Chain density enforcement -- BEFORE execution
+            // Chain density enforcement -- BEFORE execution.
+            // Local enforcer runs synchronously (fast path).
+            // Sentinel (if connected) mirrors the check for cross-process shared state.
             if (self._chainEnforcer) {
                 const violation = self._chainEnforcer.check(name);
                 if (violation) {
                     if (violation.action === "blocked") {
+                        self._fireViolation(violation);
                         throw new PolicyViolationError(violation);
                     }
                     self._recordChainViolation(violation);
                 }
             }
+            // Mirror to sentinel for cross-process state (fire-and-forget).
+            if (self._sentinel?.connected) {
+                self._sentinel.check(name).catch(() => { });
+            }
             const callId = randomUUID().replace(/-/g, "").slice(0, 12);
             const start = performance.now();
             let succeeded = true;
@@ -661,7 +761,9 @@ export class Witness {
             payload.policy_version_hash = sha256Truncated(this.config.policyVersion, 12);
         }
         if (this.config.signingKey) {
-            payload.payload_signature = signPayload(this.config.signingKey, fp, this.config.agentId);
+            const algo = this.config.signingAlgorithm ?? "hmac-sha256";
+            payload.payload_signature = signPayload(this.config.signingKey, fp, this.config.agentId, algo);
+            payload.signing_algorithm = algo;
             if (this.config.signingKeyId)
                 payload.signing_key_id = this.config.signingKeyId;
             if (this.config.signingKeyVersion !== undefined)
@@ -716,7 +818,9 @@ export class Witness {
             payload.policy_version_hash = sha256Truncated(this.config.policyVersion, 12);
         }
         if (this.config.signingKey) {
-            payload.payload_signature = signPayload(this.config.signingKey, fp, this.config.agentId);
+            const algo = this.config.signingAlgorithm ?? "hmac-sha256";
+            payload.payload_signature = signPayload(this.config.signingKey, fp, this.config.agentId, algo);
+            payload.signing_algorithm = algo;
             if (this.config.signingKeyId)
                 payload.signing_key_id = this.config.signingKeyId;
             if (this.config.signingKeyVersion !== undefined)
@@ -1078,13 +1182,37 @@ export class Witness {
         if (policyHash)
             payload.policy_version_hash = policyHash;
         if (this.config.signingKey) {
-            payload.payload_signature = signPayload(this.config.signingKey, payload.anchor_fingerprint, this.config.agentId);
+            const alg = this.config.signingAlgorithm ?? "hmac-sha256";
+            payload.payload_signature = signPayload(this.config.signingKey, payload.anchor_fingerprint, this.config.agentId, alg);
+            payload.signing_algorithm = alg;
             if (this.config.signingKeyId)
                 payload.signing_key_id = this.config.signingKeyId;
             if (this.config.signingKeyVersion !== undefined)
                 payload.signing_key_version = this.config.signingKeyVersion;
         }
     }
+    /**
+     * Validate hardware snapshot against a runtime profile. Logs warnings
+     * on mismatch but never blocks -- we are a witness, not enforcement.
+     */
+    _validateRuntimeProfile(profile, snapshot) {
+        const warn = (msg) => console.warn(`[swt3] runtime profile: ${msg}`);
+        if (profile.expectedTopology && snapshot.topology !== profile.expectedTopology) {
+            warn(`expected topology "${profile.expectedTopology}", got "${snapshot.topology}"`);
+        }
+        if (profile.minGpuCount != null && snapshot.gpus.length < profile.minGpuCount) {
+            warn(`expected min_gpu_count=${profile.minGpuCount}, got ${snapshot.gpus.length}`);
+        }
+        if (profile.minMemoryMb != null && snapshot.totalMemoryMb < profile.minMemoryMb) {
+            warn(`expected min_memory_mb=${profile.minMemoryMb}, got ${snapshot.totalMemoryMb}`);
+        }
+        if (profile.expectedAccelerator) {
+            const match = snapshot.gpus.some((g) => g.name.toUpperCase().includes(profile.expectedAccelerator.toUpperCase()));
+            if (!match) {
+                warn(`expected accelerator containing "${profile.expectedAccelerator}", none found`);
+            }
+        }
+    }
     /**
      * Revoke a previously-issued witness anchor (AI-REV.1).
      *
@@ -1111,6 +1239,7 @@ export class Witness {
      */
     witnessHardware(options) {
         const snapshot = options?.snapshot ?? queryHw();
+        this._lastHwSnapshot = snapshot;
         const gpuCount = snapshot.gpus.length;
         let allHealthy = gpuCount > 0;
         if (options?.expectedTopology && snapshot.topology !== options.expectedTopology) {
@@ -1315,6 +1444,110 @@ export class Witness {
         this.buffer.enqueueMany([payload]);
         return payload;
     }
+    // ── Content Provenance (AI-MARK.1) ────────────────────────────
+    /**
+     * Witness content provenance marking (AI-MARK.1).
+     *
+     * Records when AI-generated content is labelled for machine
+     * detectability per EU AI Act Art. 50(2) and GPAI Code of Practice.
+     *
+     * @param options.contentCount - Number of content items marked.
+     * @param options.contentType - Content type key (text, image, audio, video, multimodal, code, structured_data).
+     * @param options.markingMethod - Marking method (c2pa, watermark, metadata_tag, steganographic, manifest).
+     * @param options.hasMetadata - True if C2PA/watermark metadata was attached.
+     * @param options.content - Raw content string (auto-hashed to contentHash).
+     * @param options.contentHash - Pre-computed SHA-256 of content.
+     * @param options.manifestHash - SHA-256 of C2PA manifest.
+     * @param options.standard - Standard identifier (e.g., "C2PA-1.4", "IPTC", "XMP").
+     */
+    witnessContentMark(options) {
+        const fa = options.contentCount;
+        const fb = options.hasMetadata ? 1 : 0;
+        const fc = CONTENT_TYPE_CODES[options.contentType] ?? 0;
+        const [ts, epoch] = timestampMs();
+        const fp = mintFingerprint(this.config.tenantId, "AI-MARK.1", fa, fb, fc, ts);
+        const contentHash = options.contentHash
+            ?? (options.content ? sha256Truncated(options.content) : undefined);
+        const payload = {
+            procedure_id: "AI-MARK.1",
+            factor_a: fa, factor_b: fb, factor_c: fc,
+            clearing_level: this.config.clearingLevel,
+            anchor_fingerprint: fp, anchor_epoch: epoch, fingerprint_timestamp_ms: ts,
+        };
+        if (this.config.clearingLevel <= 1) {
+            payload.ai_model_id = `mark-${options.contentType}`;
+            const ctx = {
+                provider: "content-provenance",
+                content_type: options.contentType,
+                marking_method: options.markingMethod,
+            };
+            if (contentHash)
+                ctx.content_hash = contentHash;
+            if (options.manifestHash)
+                ctx.manifest_hash = options.manifestHash;
+            if (options.standard)
+                ctx.standard = options.standard;
+            payload.ai_context = ctx;
+        }
+        const policyHash = this.config.policyVersion
+            ? sha256Truncated(this.config.policyVersion, 12) : undefined;
+        this._applyOperationalMetadata(payload, policyHash);
+        this.buffer.enqueueMany([payload]);
+        return payload;
+    }
+    // ── Agent Behavioral Baseline (AI-BASE.1) ───────────────────
+    /**
+     * Witness an agent behavioral baseline (AI-BASE.1).
+     *
+     * Records the establishment or monitoring of an agent's behavior
+     * envelope and detects drift from baseline.
+     *
+     * @param options.dimensions - Number of behavioral dimensions measured.
+     * @param options.withinEnvelope - True if behavior is within baseline.
+     * @param options.mode - Baseline mode (establishing, monitoring, drift_detected, baseline_reset).
+     * @param options.driftScore - Normalized distance from baseline center (0.0-1.0).
+     * @param options.baselineHash - SHA-256 of the baseline vector.
+     * @param options.currentHash - SHA-256 of current observation vector.
+     * @param options.driftThreshold - Threshold above which drift is flagged (default 0.5).
+     * @param options.baselineWindowHours - Hours of data the baseline covers.
+     */
+    witnessAgentBaseline(options) {
+        const fa = options.dimensions;
+        const fb = options.withinEnvelope ? 1 : 0;
+        const fc = BASELINE_MODE_CODES[options.mode] ?? 0;
+        const [ts, epoch] = timestampMs();
+        const fp = mintFingerprint(this.config.tenantId, "AI-BASE.1", fa, fb, fc, ts);
+        const agentIdHash = this.config.agentId
+            ? sha256Truncated(this.config.agentId)
+            : undefined;
+        const payload = {
+            procedure_id: "AI-BASE.1",
+            factor_a: fa, factor_b: fb, factor_c: fc,
+            clearing_level: this.config.clearingLevel,
+            anchor_fingerprint: fp, anchor_epoch: epoch, fingerprint_timestamp_ms: ts,
+        };
+        if (this.config.clearingLevel <= 1) {
+            payload.ai_model_id = `baseline-${options.mode}`;
+            const ctx = {
+                provider: "agent-baseline",
+                dimensions: options.dimensions,
+                drift_score: options.driftScore,
+                baseline_hash: options.baselineHash,
+                current_hash: options.currentHash,
+                drift_threshold: options.driftThreshold ?? 0.5,
+            };
+            if (options.baselineWindowHours != null)
+                ctx.baseline_window_hours = options.baselineWindowHours;
+            if (agentIdHash)
+                ctx.agent_id_hash = agentIdHash;
+            payload.ai_context = ctx;
+        }
+        const policyHash = this.config.policyVersion
+            ? sha256Truncated(this.config.policyVersion, 12) : undefined;
+        this._applyOperationalMetadata(payload, policyHash);
+        this.buffer.enqueueMany([payload]);
+        return payload;
+    }
     // ── Chain, Violation, Charter, Registry, Reviewer, Safe State ───
     /**
      * Witness a multi-agent chain handoff (AI-CHAIN.1).
@@ -1342,6 +1575,78 @@ export class Witness {
         this.buffer.enqueueMany([payload]);
         return payload;
     }
+    /**
+     * Witness a trust-level-aware chain handoff (AI-CHAIN.1 + optional AI-CHAIN.2).
+     *
+     * Tracks the effective trust level across all agents in the chain.
+     * If chainMinTrustLevel is configured and strict mode is active,
+     * throws ChainTrustError when the effective level drops below the minimum.
+     *
+     * Auto-mints AI-CHAIN.2 (trust degradation) when the effective trust
+     * level drops compared to the previous handoff.
+     */
+    witnessChainTrustHandoff(targetAgentId, targetTrustLevel, options) {
+        const accepted = options?.accepted ?? true;
+        const prevEffective = this._chainTrustLevels.length > 0
+            ? Math.min(...this._chainTrustLevels)
+            : targetTrustLevel;
+        this._chainTrustLevels.push(targetTrustLevel);
+        const effectiveTrustLevel = Math.min(...this._chainTrustLevels);
+        // Enforce minimum if configured
+        const minLevel = this.config.chainMinTrustLevel;
+        if (minLevel !== undefined && effectiveTrustLevel < minLevel && this._strict) {
+            throw new ChainTrustError(effectiveTrustLevel, minLevel);
+        }
+        const [ts, epoch] = timestampMs();
+        const fa = this._chainTrustLevels.length;
+        const fb = targetTrustLevel;
+        const fc = effectiveTrustLevel;
+        const fp = mintFingerprint(this.config.tenantId, "AI-CHAIN.1", fa, fb, fc, ts);
+        const payload = {
+            procedure_id: "AI-CHAIN.1", factor_a: fa, factor_b: fb, factor_c: fc,
+            clearing_level: this.config.clearingLevel,
+            anchor_fingerprint: fp, anchor_epoch: epoch, fingerprint_timestamp_ms: ts,
+        };
+        if (this.config.clearingLevel <= 1) {
+            payload.ai_model_id = targetAgentId;
+            payload.ai_context = {
+                provider: "chain-trust",
+                target_agent: targetAgentId,
+                target_trust_level: targetTrustLevel,
+                effective_trust_level: effectiveTrustLevel,
+                chain_depth: this._chainTrustLevels.length,
+            };
+        }
+        const cycleId = options?.cycleId ?? this.config.cycleId;
+        const policyHash = this.config.policyVersion ? sha256Truncated(this.config.policyVersion, 12) : undefined;
+        this._applyOperationalMetadata(payload, policyHash);
+        if (cycleId)
+            payload.cycle_id = cycleId;
+        const payloads = [payload];
+        // Auto-mint AI-CHAIN.2 if trust degraded
+        if (this._chainTrustLevels.length > 1 && effectiveTrustLevel < prevEffective) {
+            const degradation = extractChainTrustDegradationPayload(this.config.tenantId, prevEffective, effectiveTrustLevel, this.config.clearingLevel, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, cycleId, policyHash, this.config.signingAlgorithm);
+            if (this.config.clearingLevel <= 1) {
+                degradation.ai_context = {
+                    provider: "chain-trust-degradation",
+                    previous_effective: prevEffective,
+                    new_effective: effectiveTrustLevel,
+                    target_agent: targetAgentId,
+                };
+            }
+            payloads.push(degradation);
+        }
+        this.buffer.enqueueMany(payloads);
+        return payload;
+    }
+    /** The effective (minimum) trust level across all chain handoffs. Returns 4 if no handoffs yet. */
+    get chainEffectiveTrustLevel() {
+        return this._chainTrustLevels.length === 0 ? 4 : Math.min(...this._chainTrustLevels);
+    }
+    /** The trust levels recorded at each chain handoff. */
+    get chainTrustLevels() {
+        return this._chainTrustLevels;
+    }
     /**
      * Witness a policy violation (AI-VIO.1).
      */
@@ -1684,7 +1989,7 @@ export class Witness {
         const policyHash = this.config.policyVersion
             ? sha256Truncated(this.config.policyVersion, 12)
             : undefined;
-        const payload = extractRevocationPayload(this.config.tenantId, fingerprint.trim(), reason, this.config.clearingLevel, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, this.config.cycleId, policyHash, this.config.jurisdiction, this.config.legalBasis, this.config.purposeClass);
+        const payload = extractRevocationPayload(this.config.tenantId, fingerprint.trim(), reason, this.config.clearingLevel, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, this.config.cycleId, policyHash, this.config.jurisdiction, this.config.legalBasis, this.config.purposeClass, this.config.signingAlgorithm);
         this.buffer.enqueueMany([payload]);
         return payload.anchor_fingerprint;
     }
@@ -1745,7 +2050,7 @@ export class Witness {
         const policyHash = this.config.policyVersion
             ? sha256Truncated(this.config.policyVersion, 12)
             : undefined;
-        const payloads = extractPayloads(inference, this.config.tenantId, this.config.clearingLevel, this.config.latencyThresholdMs, this.config.guardrailsRequired, this.config.procedures, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, this.config.cycleId, policyHash, this.config.jurisdiction, this.config.legalBasis, this.config.purposeClass, authorizationId);
+        const payloads = extractPayloads(inference, this.config.tenantId, this.config.clearingLevel, this.config.latencyThresholdMs, this.config.guardrailsRequired, this.config.procedures, this.config.agentId, this.config.signingKey, this.config.signingKeyId, this.config.signingKeyVersion, this.config.cycleId, policyHash, this.config.jurisdiction, this.config.legalBasis, this.config.purposeClass, authorizationId, this.config.signingAlgorithm);
         // Factor handoff: write full (uncleared) data to custody destination
         // BEFORE enqueuing the cleared payload for transmission.
         // If this fails, we do NOT proceed.
@@ -1773,6 +2078,26 @@ export class Witness {
     vercelOnFinish(options) {
         return createVercelOnFinish(this, options);
     }
+    /**
+     * Export a self-contained evidence bundle from the local WAL.
+     *
+     * Returns an EvidenceExporter pre-configured with the witness's
+     * tenant, agent, clearing level, and credential state.
+     */
+    exportEvidence() {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { EvidenceExporter } = require("./exporters/evidence.js");
+        return new EvidenceExporter({
+            walDir: this._walPath,
+            tenantId: this.config.tenantId,
+            agentId: this.config.agentId,
+            clearingLevel: this.config.clearingLevel,
+            apiKey: this.config.apiKey,
+            signingKey: this.config.signingKey,
+            hasHardwareAttestation: !!this._hardwareConfig?.requireAttestation,
+            merkleRoots: this._merkleAccumulator?.roots,
+        });
+    }
     /** Force-flush all buffered payloads. */
     async flush() {
         return this.buffer.flush();