danielbodart

Here's the synthesis — and I'm going to be straight with you, including where the evidence says don't just crank the dial to "always big."

The verdict: the pattern is real, and it's one-directional

Across ~340 transcripts, roughly 7–8 distinct bold structural bets (list-value substrate, Carried extraction, full q-kernel sweep, edge 3-concern split, typed-property model, GraphBinary streaming, path-tracking). Every one landed on trunk, CI-green, and was kept. Zero completed bold change was rolled back in regret. The only time you said something negative about scope was "why did you revert?" — you were angry I'd abandoned a bold experiment, not that I went bold.

danielbodart

#!/bin/bash

# Whisper Push-to-Talk Dictation Tool
# Runs whisper.cpp continuously, only processes output when key is held

set -euo pipefail

# Get script directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

danielbodart

// Function to fetch paginated GitHub API responses
async function fetchPaginatedGitHubData(url: string, headers: Headers): Promise<any[]> {
    let results: any[] = [];
    let nextPageUrl: string | null = url;

    while (nextPageUrl) {
        const response: Response = await fetch(nextPageUrl, { headers });
        const data = await response.json();
        results = results.concat(data);

danielbodart

/**
 * A transducer that can be applied synchronously
 */
export interface Transducer<A, B>  {
    /**
     * Applies the transducer to the given iterable
     */
    (iterable: Iterable<A>): Iterable<B>;

    /**

danielbodart

interface Constructor<T = object> {
    new(...args: any[]): T;
}

interface Disposable {
    dispose(): void;
}

function Disposable<T extends Constructor>(Base: T): T & Constructor<Disposable> {
    return class extends Base implements Disposable {

danielbodart

/*
* Usage:
* const message: IncomingMessage = ...
* const iterator = new AsyncIteratorHandler<string>();
* message.on("data", chunk => {
*   iterator.handle({value: chunk.toString(), done: false});
* });
* this.message.on("end", () => {
*   iterator.handle({value: null as any, done: true})
* });

danielbodart

<div class="application root">
  <style src="../generated/bundle.css"></style>
  <include src="../generated/bundle.svg" selector="svg"></include>
  <decorator src="../header/header.html" selector=".header" content=".controls">
    <svg class="close-logo">
      <use xlink:href="#close-logo"></use>
    </svg>
  </decorator>
  <include src="../popup/popup.html" selector=".popup"></include>
  <decorator src="../footer/footer.html" selector=".footer">

danielbodart

package fun;

import com.googlecode.totallylazy.Streams;
import com.googlecode.totallylazy.io.Uri;
import com.googlecode.utterlyidle.HttpHandler;
import com.googlecode.utterlyidle.Request;
import com.googlecode.utterlyidle.Response;
import com.googlecode.utterlyidle.handlers.ClientHttpHandler;
import com.googlecode.utterlyidle.html.RelativeUrlHandler;
import jodd.lagarto.dom.*;

danielbodart

#[derive(PartialEq, Debug)]
pub enum StartLine<'a> {
    RequestLine (RequestLine<'a>),
    StatusLine (StatusLine<'a>),
}

impl <'a> fmt::Display for StartLine<'a> {
    fn fmt(&self, format: &mut fmt::Formatter) -> fmt::Result {
        match self {
            StartLine::RequestLine(rl) => rl.fmt(format),

danielbodart

fn get<'a>(headers: &'a Vec<(&str, String)>, name:&str) -> Option<&'a str> {
    headers.into_iter().find(|&&(key,_)| name.eq_ignore_ascii_case(key)).map(|&(_,&value)|value)
} //                                                                              ^^^^^^ expected struct `std::string::String`, found reference