}),

      }),

    }),

  }).nullable(),

  state: union([literal("running"), literal("stopped")]),

});

    open: number(),

    closed: number(),

  }),

});

const projectsSchema = array(projectSchema);

  export let baseUrl: BaseUrl;

  export let commit: Commit;

  export let project: Project;

  $: header = commit.commit;

</script>

  }

</style>

  <div class="header">

    <div class="summary">

      <div class="txt-medium txt-bold">

  export let revision: string | undefined;

  export let totalCommitCount: number;

  export let tree: Tree;

  const api = new HttpdClient(baseUrl);

  }

</style>

  <svelte:fragment slot="subheader">

    <div style:margin-top="1rem">

      <Header

  export let issue: Issue;

  export let project: Project;

  export let rawPath: (commit?: string) => string;

  const api = new HttpdClient(baseUrl);

  }

</style>

  <div class="issue">

    <div style="display: flex; flex-direction: column; gap: 1.5rem;">

      <CobHeader id={issue.id}>

  export let baseUrl: BaseUrl;

  export let project: Project;

  export let rawPath: (commit?: string) => string;

  let preview: boolean = false;

  let selectionStart = 0;

  }

</style>

  <main>

    {#if session}

      <div class="form">

  export let issues: Issue[];

  export let project: Project;

  export let state: IssueState["status"];

  let loading = false;

  let page = 0;

  }

</style>

  <div class="issues">

    <List items={allIssues}>

      <div slot="header" style="display: flex;">

  import CopyableId from "@app/components/CopyableId.svelte";

  import Header from "@app/views/projects/Header.svelte";

  import Link from "@app/components/Link.svelte";

  export let activeTab: ActiveTab = undefined;

  export let baseUrl: BaseUrl;

  export let project: Project;

  const render = (content: string): string =>

    dompurify.sanitize(markdown.parse(content) as string);

    <div

      class="layout-desktop-flex"

      style="margin-left: auto; display: flex; gap: 0.5rem;">

        projectId={project.id} />

      <CloneButton {baseUrl} id={project.id} name={project.name} />

    </div>

  export let rawPath: (commit?: string) => string;

  export let project: Project;

  export let view: PatchView;

  $: api = new HttpdClient(baseUrl);

  }

</style>

  <div class="patch">

    <div>

      <CobHeader id={patch.id}>

  export let patches: Patch[];

  export let project: Project;

  export let state: PatchState["status"];

  let loading = false;

  let page = 0;

  }

</style>

  <div class="patches">

    <List items={allPatches}>

      <div slot="header" style="display: flex;">

  export let project: Project;

  export let revision: string | undefined;

  export let tree: Tree;

  // Whether the mobile file tree is visible.

  let mobileFileTree = false;

  }

</style>

  <svelte:fragment slot="subheader">

    <div style:margin-top="1rem">

      <Header

    const nodeId = formatNodeId(p.id);

    return p.delegate

      ? `${nodeId} is a delegate of this project`

  }

</script>

        path: string;

        rawPath: (commit?: string) => string;

        blobResult: BlobResult;

      };

    }

  | {

        tree: Tree;

        commitHeaders: CommitHeader[];

        totalCommitCount: number;

      };

    }

  | {

        baseUrl: BaseUrl;

        project: Project;

        commit: Commit;

      };

    }

  | {

        project: Project;

        rawPath: (commit?: string) => string;

        issue: Issue;

      };

    }

  | {

        project: Project;

        issues: Issue[];

        state: IssueState["status"];

      };

    }

  | {

        baseUrl: BaseUrl;

        project: Project;

        rawPath: (commit?: string) => string;

      };

    }

  | {

        project: Project;

        patches: Patch[];

        state: PatchState["status"];

      };

    }

  | {

        rawPath: (commit?: string) => string;

        patch: Patch;

        view: PatchView;

      };

    };

  }

}

  if (isLocal(route.node.hostname)) {

    return true;

  } else {

    } else if (route.resource === "project.history") {

      return await loadHistoryView(route);

    } else if (route.resource === "project.commit") {

        api.project.getById(route.project),

        api.project.getCommitBySha(route.project, route.commit),

      ]);

      return {

          baseUrl: route.node,

          project,

          commit,

        },

      };

    } else if (route.resource === "project.issue") {

        api.project.getById(route.project),

        api.project.getIssueById(route.project, route.issue),

      ]);

      return {

        resource: "project.issue",

          project,

          rawPath,

          issue,

        },

      };

    } else if (route.resource === "project.patch") {

    } else if (route.resource === "project.issues") {

      return await loadIssuesView(route);

    } else if (route.resource === "project.newIssue") {

        api.project.getById(route.project),

      ]);

      return {

        resource: "project.newIssue",

          baseUrl: route.node,

          project,

          rawPath,

        },

      };

    } else if (route.resource === "project.patches") {

  const searchParams = new URLSearchParams(route.search || "");

  const state = (searchParams.get("state") as PatchState["status"]) || "open";

    api.project.getById(route.project),

    api.project.getAllPatches(route.project, {

      state,

      page: 0,

      perPage: PATCHES_PER_PAGE,

    }),

  ]);

  return {

      patches,

      state,

      project,

    },

  };

}

  const api = new HttpdClient(route.node);

  const state = route.state || "open";

    api.project.getById(route.project),

    api.project.getAllIssues(route.project, {

      state,

      page: 0,

      perPage: ISSUES_PER_PAGE,

    }),

  ]);

  return {

      issues,

      state,

      project,

    },

  };

}

      route.project

    }${commit ? `/${commit}` : ""}`;

    api.project.getById(route.project),

    api.project.getAllRemotes(route.project),

    getPeerBranches(api, route.project, route.peer),

  ]);

  if (route.route) {

      tree,

      path,

      blobResult,

    },

  };

}

    );

  }

    api.project.getTree(route.project, commitId),

    await api.project.getAllCommits(project.id, {

      parent: commitId,

      page: 0,

      perPage: COMMITS_PER_PAGE,

    }),

  ]);

  return {

      tree,

      commitHeaders: commitsResponse.commits.map(c => c.commit),

      totalCommitCount: commitsResponse.stats.commits,

    },

  };

}

    `${route.node.scheme}://${route.node.hostname}:${route.node.port}/raw/${

      route.project

    }${commit ? `/${commit}` : ""}`;

    api.project.getById(route.project),

    api.project.getPatchById(route.project, route.patch),

  ]);

  const latestRevision = patch.revisions[patch.revisions.length - 1];

      rawPath,

      patch,

      view,

    },

  };

}

  });

  await peer.startHttpd();

  await peer.startNode({

    scope: "all",

    alias: "palm",

    externalAddresses: ["seed.radicle.test:8123"],

  // Show rendered README.md contents.

  await expect(page.getByText("Git test repository")).toBeVisible();

});

test("show source tree at specific revision", async ({ page }) => {

}

export async function createCobsFixture(peer: RadiclePeer) {

  await Fs.mkdir(Path.join(tmpDir, "repos", "cobs"));

  const { projectFolder, defaultBranch } = await createProject(peer, {

    name: "cobs",

    },

  );

  await peer.rad(

    createOptions(projectFolder, 1),

  );

  const { stdout: commentIssueOne } = await peer.rad(

    createOptions(projectFolder, 5),

  );

  await peer.rad(

    createOptions(projectFolder, 6),

  );

  await patch.merge(

    { cwd: projectFolder },

  );

  await peer.rad(

    createOptions(projectFolder, 1),

  );

    { cwd: projectFolder },

  );

  await peer.rad(

    createOptions(projectFolder, 1),

  );

  await peer.rad(

    createOptions(projectFolder, 2),

  );

  await Fs.appendFile(

    createOptions(projectFolder, 3),

  );

  await peer.rad(

    createOptions(projectFolder, 2),

  );

    [],

    { cwd: projectFolder },

  );

  await peer.rad(

    ["patch", "archive", patchFour],

    createOptions(projectFolder, 2),

  if (!process.env.SKIP_FIXTURE_CREATION) {

    await palm.startHttpd(defaultHttpdPort);

    try {

      console.log("Creating source-browsing fixture");

      routingMaxAge: number(),

      fetchConcurrency: number(),

      gossipMaxAge: number(),

    }),

  }),

});

        routingMaxAge: 604800,

        fetchConcurrency: 1,

        gossipMaxAge: 1209600,

      },

    });