```ts
/**
 * Finds the smallest number of edges in a walk from start to goal that follows the cadence.
 * @param edges - A list of directed edges, each a [from, to, label] triple of non-empty strings.
 * @param cadence - A list of non-empty strings representing the required label sequence.
 * @param start - The starting node as a non-empty string.
 * @param goal - The goal node as a non-empty string.
 * @returns The smallest number of edges in the walk, or -1 if no such walk exists.
 */
export function labelCadenceWalk(edges: string[][], cadence: string[], start: string, goal: string): number {
    if (cadence.length === 0) {
        throw new Error("Cadence list cannot be empty.");
    }
    if (!cadence.every(label => typeof label === 'string' && label.length > 0)) {
        throw new Error("All cadence entries must be non-empty strings.");
    }
    if (!edges.every(edge => Array.isArray(edge) && edge.length === 3 && edge.every(nodeOrLabel => typeof nodeOrLabel === 'string' && nodeOrLabel.length > 0))) {
        throw new Error("Each edge must be a triple of non-empty strings.");
    }

    const nodes = new Set<string>();
    edges.forEach(([from, to]) => {
        nodes.add(from);
        nodes.add(to);
    });

    if (!nodes.has(start) || !nodes.has(goal)) {
        return -1;
    }

    const cadenceLength = cadence.length;
    let minSteps = Infinity;

    function dfs(current: string, steps: number, currentCadenceIndex: number): void {
        if (current === goal) {
            minSteps = Math.min(minSteps, steps);
            return;
        }
        edges.forEach(([from, to, label]) => {
            if (from === current && label === cadence[currentCadenceIndex % cadenceLength]) {
                dfs(to, steps + 1, (currentCadenceIndex + 1) % cadenceLength);
            }
        });
    }

    dfs(start, 0, 0);

    return minSteps === Infinity ? -1 : minSteps;
}
```