```ts
export function labelCadenceWalk(edges: string[][], cadence: string[], start: string, goal: string): number {
    if (cadence.length === 0) throw new Error("Empty cadence list");
    if (!cadence.every(label => typeof label === 'string' && label !== '')) throw new Error("Cadence entry must be a non-empty string");
    if (!edges.every(([from, to, label]) => from !== '' && to !== '' && label !== '')) throw new Error("Edge must be a triple of non-empty strings");
    if (!edges.some(edge => edge[0] === start) || !edges.some(edge => edge[1] === goal)) throw new Error("Start or goal not in any edge");

    const graph: { [node: string]: { [label: string]: string[] } } = {};
    edges.forEach(([from, to, label]) => {
        if (!graph[from]) graph[from] = {};
        if (!graph[from][label]) graph[from][label] = [];
        graph[from][label].push(to);
    });

    const cadenceLength = cadence.length;
    const queue: { node: string; labelIndex: number; edgesUsed: number }[] = [{ node: start, labelIndex: 0, edgesUsed: 1 }];
    const visited: Set<string> = new Set();

    while (queue.length > 0) {
        const { node, labelIndex, edgesUsed } = queue.shift()!;
        if (node === goal) return edgesUsed;
        if (!graph[node] || !graph[node][cadence[labelIndex]]) continue;

        graph[node][cadence[labelIndex]].forEach(nextNode => {
            if (!visited.has(`${nextNode}-${labelIndex}`)) {
                visited.add(`${nextNode}-${labelIndex}`);
                queue.push({ node: nextNode, labelIndex: (labelIndex + 1) % cadenceLength, edgesUsed: edgesUsed + 1 });
            }
        });
    }

    return -1;
}
```